# Rules for making release tarballs
-VERSION=7.6-devel
+VERSION=7.7-devel
DIRECTORY = Mesa-$(VERSION)
LIB_NAME = MesaLib-$(VERSION)
DEMO_NAME = MesaDemos-$(VERSION)
$(DIRECTORY)/src/gallium/*/*/SConscript \
$(DIRECTORY)/src/gallium/*/*/*.[ch] \
$(DIRECTORY)/src/gallium/*/*/*.py \
+ $(DIRECTORY)/src/gallium/*/*/*.csv \
$(DIRECTORY)/src/gallium/*/*/*/Makefile \
$(DIRECTORY)/src/gallium/*/*/*/SConscript \
$(DIRECTORY)/src/gallium/*/*/*/*.[ch] \
default_machine = _platform.machine()
default_machine = _machine_map.get(default_machine, 'generic')
-if default_platform in ('linux', 'freebsd', 'darwin'):
+if default_platform in ('linux', 'freebsd'):
default_dri = 'yes'
-elif default_platform in ('winddk', 'windows', 'wince'):
+elif default_platform in ('winddk', 'windows', 'wince', 'darwin'):
default_dri = 'no'
else:
default_dri = 'no'
opts.Add(EnumOption('machine', 'use machine-specific assembly code', default_machine,
allowed_values=('generic', 'ppc', 'x86', 'x86_64')))
opts.Add(EnumOption('platform', 'target platform', default_platform,
- allowed_values=('linux', 'cell', 'windows', 'winddk', 'wince')))
+ allowed_values=('linux', 'cell', 'windows', 'winddk', 'wince', 'darwin')))
opts.Add(EnumOption('toolchain', 'compiler toolchain', 'default',
allowed_values=('default', 'crossmingw', 'winsdk', 'winddk')))
opts.Add(BoolOption('llvm', 'use LLVM', 'no'))
# Version info
MESA_MAJOR=7
-MESA_MINOR=6
+MESA_MINOR=7
MESA_TINY=0
MESA_VERSION = $(MESA_MAJOR).$(MESA_MINOR).$(MESA_TINY)
--- /dev/null
+<HTML>
+
+<TITLE>Mesa Release Notes</TITLE>
+
+<head><link rel="stylesheet" type="text/css" href="mesa.css"></head>
+
+<BODY>
+
+<body bgcolor="#eeeeee">
+
+<H1>Mesa 7.5.2 Release Notes, (date tbd)</H1>
+
+<p>
+Mesa 7.5.2 is a bug-fix release fixing issues found since the 7.5.1 release.
+</p>
+<p>
+The main new feature of Mesa 7.5.x is the
+<a href="http://wiki.freedesktop.org/wiki/Software/gallium"
+target="_parent">Gallium3D</a> infrastructure.
+</p>
+<p>
+Mesa 7.5.2 implements the OpenGL 2.1 API, but the version reported by
+glGetString(GL_VERSION) depends on the particular driver being used.
+Some drivers don't support all the features required in OpenGL 2.1.
+</p>
+<p>
+See the <a href="install.html">Compiling/Installing page</a> for prerequisites
+for DRI hardware acceleration.
+</p>
+
+
+<h2>MD5 checksums</h2>
+<pre>
+tbd
+</pre>
+
+
+<h2>New features</h2>
+<ul>
+<li>Detect B43 chipset in Intel driver
+</ul>
+
+
+<h2>Bug fixes</h2>
+<ul>
+<li>Assorted bug fixes for i965/i945 drivers
+<li>Fixed Gallium glDrawPixels(GL_STENCIL_INDEX) failure.
+</ul>
+
+
+</body>
+</html>
--- /dev/null
+<HTML>
+
+<TITLE>Mesa Release Notes</TITLE>
+
+<head><link rel="stylesheet" type="text/css" href="mesa.css"></head>
+
+<BODY>
+
+<body bgcolor="#eeeeee">
+
+<H1>Mesa 7.7 Release Notes / date TBD</H1>
+
+<p>
+Mesa 7.7 is a new development release.
+People who are concerned with stability and reliability should stick
+with a previous release or wait for Mesa 7.7.1.
+</p>
+<p>
+Mesa 7.7 implements the OpenGL 2.1 API, but the version reported by
+glGetString(GL_VERSION) depends on the particular driver being used.
+Some drivers don't support all the features required in OpenGL 2.1.
+</p>
+<p>
+See the <a href="install.html">Compiling/Installing page</a> for prerequisites
+for DRI hardware acceleration.
+</p>
+
+
+<h2>MD5 checksums</h2>
+<pre>
+tbd
+</pre>
+
+
+<h2>New features</h2>
+<ul>
+<li>GL_ARB_draw_elements_base_vertex (supported in Intel i965 and software drivers)</li>
+<li>GL_ARB_depth_clamp (supported in Intel i965 DRI and software drivers)</li>
+<li>GL_NV_depth_clamp (supported in Intel i965 DRI and software drivers)</li>
+</ul>
+
+
+<h2>Bug fixes</h2>
+<ul>
+</ul>
+
+
+<h2>Changes</h2>
+<ul>
+</ul>
+
+</body>
+</html>
</p>
<UL>
+<LI><A HREF="relnotes-7.7.html">7.7 release notes</A>
<LI><A HREF="relnotes-7.6.html">7.6 release notes</A>
+<LI><A HREF="relnotes-7.5.2.html">7.5.2 release notes</A>
<LI><A HREF="relnotes-7.5.1.html">7.5.1 release notes</A>
<LI><A HREF="relnotes-7.5.html">7.5 release notes</A>
<LI><A HREF="relnotes-7.4.4.html">7.4.4 release notes</A>
typedef HBITMAP NativePixmapType;
/** END Added for Windows **/
-#elif defined(__gnu_linux__) || defined(__FreeBSD__) || defined(__sun)
+#elif defined(__gnu_linux__) || defined(__FreeBSD__) || defined(__sun) || defined(__APPLE__)
+
/** BEGIN Added for X (Mesa) **/
#ifndef EGLAPI
static float Xzoom, Yzoom;
static GLboolean DrawFront = GL_FALSE;
static GLboolean Dither = GL_TRUE;
+static GLboolean Invert = GL_FALSE;
static void Reset( void )
if (Scissor)
glEnable(GL_SCISSOR_TEST);
+ if (Invert) {
+ glPixelTransferf(GL_RED_SCALE, -1.0);
+ glPixelTransferf(GL_GREEN_SCALE, -1.0);
+ glPixelTransferf(GL_BLUE_SCALE, -1.0);
+ glPixelTransferf(GL_RED_BIAS, 1.0);
+ glPixelTransferf(GL_GREEN_BIAS, 1.0);
+ glPixelTransferf(GL_BLUE_BIAS, 1.0);
+ }
+
/* draw copy */
glPixelZoom(Xzoom, Yzoom);
glWindowPos2iARB(Xpos, Ypos);
glDisable(GL_SCISSOR_TEST);
+ if (Invert) {
+ glPixelTransferf(GL_RED_SCALE, 1.0);
+ glPixelTransferf(GL_GREEN_SCALE, 1.0);
+ glPixelTransferf(GL_BLUE_SCALE, 1.0);
+ glPixelTransferf(GL_RED_BIAS, 0.0);
+ glPixelTransferf(GL_GREEN_BIAS, 0.0);
+ glPixelTransferf(GL_BLUE_BIAS, 0.0);
+ }
+
if (DrawFront)
glFinish();
else
else
glDisable(GL_DITHER);
break;
+ case 'i':
+ Invert = !Invert;
+ break;
case 's':
Scissor = !Scissor;
break;
--- /dev/null
+!!ARBfp1.0
+TEMP R0;
+MOV R0, fragment.color;
+ADD_SAT R0, R0, R0;
+MUL result.color, {0.5}.x, R0;
+END
--- /dev/null
+!!ARBfp1.0
+TEMP R0;
+MOV R0, fragment.color;
+MOV R0, R0.zyxw;
+MOV result.color, R0;
+END
--- /dev/null
+!!ARBfp1.0
+TEMP R0;
+MOV R0, fragment.color;
+MUL R0, R0.zyxw, fragment.color;
+MOV result.color, R0;
+END
#include <GL/glut.h>
static GLint WinWidth = 500, WinHeight = 500;
+static GLboolean Invert = GL_FALSE;
static void Display(void)
glPixelZoom(4.0, 4.0);
glColor4f(1, 0, 0, 0);
glWindowPos2i(100, 0);
+ if (Invert) {
+ glPixelTransferf(GL_DEPTH_SCALE, -1.0);
+ glPixelTransferf(GL_DEPTH_BIAS, 1.0);
+ }
glDrawPixels(100, 100, GL_DEPTH_COMPONENT, GL_FLOAT, depth);
+ if (Invert) {
+ glPixelTransferf(GL_DEPTH_SCALE, 1.0);
+ glPixelTransferf(GL_DEPTH_BIAS, 0.0);
+ }
glDisable(GL_DEPTH_TEST);
(void) x;
(void) y;
switch (key) {
+ case 'i':
+ Invert = !Invert;
+ break;
case 27:
exit(0);
break;
'-m32',
#'-march=pentium4',
'-mmmx', '-msse', '-msse2', # enable SIMD intrinsics
+ '-mstackrealign', # ensure stack is aligned -- do not enabled -msse without it!
#'-mfpmath=sse',
]
if env['machine'] == 'x86_64':
env.PrependENVPath('PATH', llvm_bin_dir)
if env.Detect('llvm-config'):
- try:
- env['LLVM_VERSION'] = env.backtick('llvm-config --version')
- except AttributeError:
- env['LLVM_VERSION'] = 'X.X'
+ version = env.backtick('llvm-config --version').rstrip()
- env.ParseConfig('llvm-config --cppflags')
- env.ParseConfig('llvm-config --libs jit interpreter nativecodegen bitwriter')
- env.ParseConfig('llvm-config --ldflags')
- env['LINK'] = env['CXX']
+ try:
+ env.ParseConfig('llvm-config --cppflags')
+ env.ParseConfig('llvm-config --libs jit interpreter nativecodegen bitwriter')
+ env.ParseConfig('llvm-config --ldflags')
+ except OSError:
+ print 'llvm-config version %s failed' % version
+ else:
+ env['LINK'] = env['CXX']
+ env['LLVM_VERSION'] = version
def exists(env):
return True
if (mach->ExecMask) {
/* do the call */
- /* push the Cond, Loop, Cont stacks */
+ /* First, record the depths of the execution stacks.
+ * This is important for deeply nested/looped return statements.
+ * We have to unwind the stacks by the correct amount. For a
+ * real code generator, we could determine the number of entries
+ * to pop off each stack with simple static analysis and avoid
+ * implementing this data structure at run time.
+ */
+ mach->CallStack[mach->CallStackTop].CondStackTop = mach->CondStackTop;
+ mach->CallStack[mach->CallStackTop].LoopStackTop = mach->LoopStackTop;
+ mach->CallStack[mach->CallStackTop].ContStackTop = mach->ContStackTop;
+ /* note that PC was already incremented above */
+ mach->CallStack[mach->CallStackTop].ReturnAddr = *pc;
+
+ mach->CallStackTop++;
+
+ /* Second, push the Cond, Loop, Cont, Func stacks */
assert(mach->CondStackTop < TGSI_EXEC_MAX_COND_NESTING);
mach->CondStack[mach->CondStackTop++] = mach->CondMask;
assert(mach->LoopStackTop < TGSI_EXEC_MAX_LOOP_NESTING);
mach->LoopStack[mach->LoopStackTop++] = mach->LoopMask;
assert(mach->ContStackTop < TGSI_EXEC_MAX_LOOP_NESTING);
mach->ContStack[mach->ContStackTop++] = mach->ContMask;
-
assert(mach->FuncStackTop < TGSI_EXEC_MAX_CALL_NESTING);
mach->FuncStack[mach->FuncStackTop++] = mach->FuncMask;
- /* note that PC was already incremented above */
- mach->CallStack[mach->CallStackTop++] = *pc;
+ /* Finally, jump to the subroutine */
*pc = inst->InstructionExtLabel.Label;
}
break;
*pc = -1;
return;
}
- *pc = mach->CallStack[--mach->CallStackTop];
- /* pop the Cond, Loop, Cont stacks */
- assert(mach->CondStackTop > 0);
- mach->CondMask = mach->CondStack[--mach->CondStackTop];
- assert(mach->LoopStackTop > 0);
- mach->LoopMask = mach->LoopStack[--mach->LoopStackTop];
- assert(mach->ContStackTop > 0);
- mach->ContMask = mach->ContStack[--mach->ContStackTop];
+ assert(mach->CallStackTop > 0);
+ mach->CallStackTop--;
+
+ mach->CondStackTop = mach->CallStack[mach->CallStackTop].CondStackTop;
+ mach->CondMask = mach->CondStack[mach->CondStackTop];
+
+ mach->LoopStackTop = mach->CallStack[mach->CallStackTop].LoopStackTop;
+ mach->LoopMask = mach->LoopStack[mach->LoopStackTop];
+
+ mach->ContStackTop = mach->CallStack[mach->CallStackTop].ContStackTop;
+ mach->ContMask = mach->ContStack[mach->ContStackTop];
+
assert(mach->FuncStackTop > 0);
mach->FuncMask = mach->FuncStack[--mach->FuncStackTop];
+ *pc = mach->CallStack[mach->CallStackTop].ReturnAddr;
+
UPDATE_EXEC_MASK(mach);
}
break;
mach->FuncMask = 0xf;
mach->ExecMask = 0xf;
- mach->CondStackTop = 0; /* temporarily subvert this assertion */
assert(mach->CondStackTop == 0);
assert(mach->LoopStackTop == 0);
assert(mach->ContStackTop == 0);
*/
#define TGSI_EXEC_MAX_CONST_BUFFER 4096
+
+/** function call/activation record */
+struct tgsi_call_record
+{
+ uint CondStackTop;
+ uint LoopStackTop;
+ uint ContStackTop;
+ uint ReturnAddr;
+};
+
+
/**
* Run-time virtual machine state for executing TGSI shader.
*/
int FuncStackTop;
/** Function call stack for saving/restoring the program counter */
- uint CallStack[TGSI_EXEC_MAX_CALL_NESTING];
+ struct tgsi_call_record CallStack[TGSI_EXEC_MAX_CALL_NESTING];
int CallStackTop;
struct tgsi_full_instruction *Instructions;
boolean
tgsi_sanity_check(
- struct tgsi_token *tokens )
+ const struct tgsi_token *tokens )
{
struct sanity_check_ctx ctx;
*/
boolean
tgsi_sanity_check(
- struct tgsi_token *tokens );
+ const struct tgsi_token *tokens );
#if defined __cplusplus
}
#include "tgsi/tgsi_info.h"
#include "tgsi/tgsi_parse.h"
#include "tgsi/tgsi_util.h"
-#include "tgsi_exec.h"
-#include "tgsi_sse2.h"
+#include "tgsi/tgsi_dump.h"
+#include "tgsi/tgsi_exec.h"
+#include "tgsi/tgsi_sse2.h"
#include "rtasm/rtasm_x86sse.h"
const struct tgsi_full_instruction *inst,
unsigned chan_index )
{
+ switch( inst->Instruction.Saturate ) {
+ case TGSI_SAT_NONE:
+ break;
+
+ case TGSI_SAT_ZERO_ONE:
+ sse_maxps(
+ func,
+ make_xmm( xmm ),
+ get_temp(
+ TGSI_EXEC_TEMP_00000000_I,
+ TGSI_EXEC_TEMP_00000000_C ) );
+
+ sse_minps(
+ func,
+ make_xmm( xmm ),
+ get_temp(
+ TGSI_EXEC_TEMP_ONE_I,
+ TGSI_EXEC_TEMP_ONE_C ) );
+ break;
+
+ case TGSI_SAT_MINUS_PLUS_ONE:
+ assert( 0 );
+ break;
+ }
+
+
switch( reg->DstRegister.File ) {
case TGSI_FILE_OUTPUT:
emit_output(
default:
assert( 0 );
}
-
- switch( inst->Instruction.Saturate ) {
- case TGSI_SAT_NONE:
- break;
-
- case TGSI_SAT_ZERO_ONE:
- /* assert( 0 ); */
- break;
-
- case TGSI_SAT_MINUS_PLUS_ONE:
- assert( 0 );
- break;
- }
}
#define STORE( FUNC, INST, XMM, INDEX, CHAN )\
if (indirect_temp_reference(inst))
return FALSE;
- /* we don't handle saturation/clamping yet */
- if (inst->Instruction.Saturate != TGSI_SAT_NONE)
- return FALSE;
-
- /* need to use extra temps to fix SOA dependencies : */
- if (tgsi_check_soa_dependencies(inst))
- return FALSE;
-
switch (inst->Instruction.Opcode) {
case TGSI_OPCODE_ARL:
FOR_EACH_DST0_ENABLED_CHANNEL( *inst, chan_index ) {
case TGSI_OPCODE_MOV:
case TGSI_OPCODE_SWZ:
FOR_EACH_DST0_ENABLED_CHANNEL( *inst, chan_index ) {
- FETCH( func, *inst, 0, 0, chan_index );
- STORE( func, *inst, 0, 0, chan_index );
+ FETCH( func, *inst, 4 + chan_index, 0, chan_index );
+ }
+ FOR_EACH_DST0_ENABLED_CHANNEL( *inst, chan_index ) {
+ STORE( func, *inst, 4 + chan_index, 0, chan_index );
}
break;
parse.FullHeader.Processor.Processor == TGSI_PROCESSOR_VERTEX ?
"vertex shader" : "fragment shader");
}
+
+ if (tgsi_check_soa_dependencies(&parse.FullToken.FullInstruction)) {
+ uint opcode = parse.FullToken.FullInstruction.Instruction.Opcode;
+
+ /* XXX: we only handle src/dst aliasing in a few opcodes
+ * currently. Need to use an additional temporay to hold
+ * the result in the cases where the code is too opaque to
+ * fix.
+ */
+ if (opcode != TGSI_OPCODE_MOV &&
+ opcode != TGSI_OPCODE_SWZ) {
+ debug_printf("Warning: src/dst aliasing in instruction"
+ " is not handled:\n");
+ tgsi_dump_instruction(&parse.FullToken.FullInstruction, 1);
+ }
+ }
break;
case TGSI_TOKEN_TYPE_IMMEDIATE:
#include "tgsi/tgsi_ureg.h"
#include "tgsi/tgsi_info.h"
#include "tgsi/tgsi_dump.h"
+#include "tgsi/tgsi_sanity.h"
#include "util/u_memory.h"
#include "util/u_math.h"
#define UREG_MAX_INPUT PIPE_MAX_ATTRIBS
#define UREG_MAX_OUTPUT PIPE_MAX_ATTRIBS
+#define UREG_MAX_CONSTANT_RANGE 32
#define UREG_MAX_IMMEDIATE 32
#define UREG_MAX_TEMP 256
#define UREG_MAX_ADDR 2
unsigned semantic_name;
unsigned semantic_index;
unsigned interp;
- } input[UREG_MAX_INPUT];
- unsigned nr_inputs;
+ } fs_input[UREG_MAX_INPUT];
+ unsigned nr_fs_inputs;
+
+ unsigned vs_inputs[UREG_MAX_INPUT/32];
struct {
unsigned semantic_name;
unsigned temps_active[UREG_MAX_TEMP / 32];
unsigned nr_temps;
- unsigned nr_addrs;
+ struct {
+ unsigned first;
+ unsigned last;
+ } constant_range[UREG_MAX_CONSTANT_RANGE];
+ unsigned nr_constant_ranges;
- unsigned nr_constants;
+ unsigned nr_addrs;
unsigned nr_instructions;
struct ureg_tokens domain[2];
static void tokens_error( struct ureg_tokens *tokens )
{
+ if (tokens->tokens && tokens->tokens != error_tokens)
+ FREE(tokens->tokens);
+
tokens->tokens = error_tokens;
tokens->size = Elements(error_tokens);
tokens->count = 0;
-static struct ureg_src
-ureg_DECL_input( struct ureg_program *ureg,
- unsigned name,
- unsigned index,
- unsigned interp_mode )
+struct ureg_src
+ureg_DECL_fs_input( struct ureg_program *ureg,
+ unsigned name,
+ unsigned index,
+ unsigned interp_mode )
{
unsigned i;
- for (i = 0; i < ureg->nr_inputs; i++) {
- if (ureg->input[i].semantic_name == name &&
- ureg->input[i].semantic_index == index)
+ for (i = 0; i < ureg->nr_fs_inputs; i++) {
+ if (ureg->fs_input[i].semantic_name == name &&
+ ureg->fs_input[i].semantic_index == index)
goto out;
}
- if (ureg->nr_inputs < UREG_MAX_INPUT) {
- ureg->input[i].semantic_name = name;
- ureg->input[i].semantic_index = index;
- ureg->input[i].interp = interp_mode;
- ureg->nr_inputs++;
+ if (ureg->nr_fs_inputs < UREG_MAX_INPUT) {
+ ureg->fs_input[i].semantic_name = name;
+ ureg->fs_input[i].semantic_index = index;
+ ureg->fs_input[i].interp = interp_mode;
+ ureg->nr_fs_inputs++;
}
else {
set_bad( ureg );
}
-
-struct ureg_src
-ureg_DECL_fs_input( struct ureg_program *ureg,
- unsigned name,
- unsigned index,
- unsigned interp )
-{
- assert(ureg->processor == TGSI_PROCESSOR_FRAGMENT);
- return ureg_DECL_input( ureg, name, index, interp );
-}
-
-
struct ureg_src
ureg_DECL_vs_input( struct ureg_program *ureg,
- unsigned name,
unsigned index )
{
assert(ureg->processor == TGSI_PROCESSOR_VERTEX);
- return ureg_DECL_input( ureg, name, index, TGSI_INTERPOLATE_CONSTANT );
+
+ ureg->vs_inputs[index/32] |= 1 << (index % 32);
+ return ureg_src_register( TGSI_FILE_INPUT, index );
}
* value or manage any constant_buffer contents -- that's the
* resposibility of the calling code.
*/
-struct ureg_src ureg_DECL_constant(struct ureg_program *ureg )
+struct ureg_src ureg_DECL_constant(struct ureg_program *ureg,
+ unsigned index )
{
- return ureg_src_register( TGSI_FILE_CONSTANT, ureg->nr_constants++ );
+ unsigned minconst = index, maxconst = index;
+ unsigned i;
+
+ /* Inside existing range?
+ */
+ for (i = 0; i < ureg->nr_constant_ranges; i++) {
+ if (ureg->constant_range[i].first <= index &&
+ ureg->constant_range[i].last >= index)
+ goto out;
+ }
+
+ /* Extend existing range?
+ */
+ for (i = 0; i < ureg->nr_constant_ranges; i++) {
+ if (ureg->constant_range[i].last == index - 1) {
+ ureg->constant_range[i].last = index;
+ goto out;
+ }
+
+ if (ureg->constant_range[i].first == index + 1) {
+ ureg->constant_range[i].first = index;
+ goto out;
+ }
+
+ minconst = MIN2(minconst, ureg->constant_range[i].first);
+ maxconst = MAX2(maxconst, ureg->constant_range[i].last);
+ }
+
+ /* Create new range?
+ */
+ if (ureg->nr_constant_ranges < UREG_MAX_CONSTANT_RANGE) {
+ i = ureg->nr_constant_ranges++;
+ ureg->constant_range[i].first = index;
+ ureg->constant_range[i].last = index;
+ }
+
+ /* Collapse all ranges down to one:
+ */
+ i = 0;
+ ureg->constant_range[0].first = minconst;
+ ureg->constant_range[0].last = maxconst;
+ ureg->nr_constant_ranges = 1;
+
+out:
+ assert(i < ureg->nr_constant_ranges);
+ assert(ureg->constant_range[i].first <= index);
+ assert(ureg->constant_range[i].last >= index);
+ return ureg_src_register( TGSI_FILE_CONSTANT, index );
}
}
+static void validate( unsigned opcode,
+ unsigned nr_dst,
+ unsigned nr_src )
+{
+#ifdef DEBUG
+ const struct tgsi_opcode_info *info = tgsi_get_opcode_info( opcode );
+ assert(info);
+ if(info) {
+ assert(nr_dst == info->num_dst);
+ assert(nr_src == info->num_src);
+ }
+#endif
+}
unsigned
ureg_emit_insn(struct ureg_program *ureg,
{
union tgsi_any_token *out;
+ validate( opcode, num_dst, num_src );
+
out = get_tokens( ureg, DOMAIN_INSN, 1 );
out[0].value = 0;
out[0].insn.Type = TGSI_TOKEN_TYPE_INSTRUCTION;
unsigned insn, i;
boolean saturate;
-#ifdef DEBUG
- {
- const struct tgsi_opcode_info *info = tgsi_get_opcode_info( opcode );
- assert(info);
- if(info) {
- assert(nr_dst == info->num_dst);
- assert(nr_src == info->num_src);
- }
- }
-#endif
-
saturate = nr_dst ? dst[0].Saturate : FALSE;
insn = ureg_emit_insn( ureg, opcode, saturate, nr_dst, nr_src );
ureg_fixup_insn_size( ureg, insn );
}
+void
+ureg_tex_insn(struct ureg_program *ureg,
+ unsigned opcode,
+ const struct ureg_dst *dst,
+ unsigned nr_dst,
+ unsigned target,
+ const struct ureg_src *src,
+ unsigned nr_src )
+{
+ unsigned insn, i;
+ boolean saturate;
+
+ saturate = nr_dst ? dst[0].Saturate : FALSE;
+
+ insn = ureg_emit_insn( ureg, opcode, saturate, nr_dst, nr_src );
+
+ ureg_emit_texture( ureg, insn, target ); \
+
+ for (i = 0; i < nr_dst; i++)
+ ureg_emit_dst( ureg, dst[i] );
+
+ for (i = 0; i < nr_src; i++)
+ ureg_emit_src( ureg, src[i] );
+
+ ureg_fixup_insn_size( ureg, insn );
+}
+
+
+void
+ureg_label_insn(struct ureg_program *ureg,
+ unsigned opcode,
+ const struct ureg_src *src,
+ unsigned nr_src,
+ unsigned *label_token )
+{
+ unsigned insn, i;
+
+ insn = ureg_emit_insn( ureg, opcode, FALSE, 0, nr_src );
+
+ ureg_emit_label( ureg, insn, label_token ); \
+
+ for (i = 0; i < nr_src; i++)
+ ureg_emit_src( ureg, src[i] );
+
+ ureg_fixup_insn_size( ureg, insn );
+}
+
static void emit_decl( struct ureg_program *ureg,
{
unsigned i;
- for (i = 0; i < ureg->nr_inputs; i++) {
- emit_decl( ureg,
- TGSI_FILE_INPUT,
- i,
- ureg->input[i].semantic_name,
- ureg->input[i].semantic_index,
- ureg->input[i].interp );
+ if (ureg->processor == TGSI_PROCESSOR_VERTEX) {
+ for (i = 0; i < UREG_MAX_INPUT; i++) {
+ if (ureg->vs_inputs[i/32] & (1 << (i%32))) {
+ emit_decl_range( ureg, TGSI_FILE_INPUT, i, 1 );
+ }
+ }
+ }
+ else {
+ for (i = 0; i < ureg->nr_fs_inputs; i++) {
+ emit_decl( ureg,
+ TGSI_FILE_INPUT,
+ i,
+ ureg->fs_input[i].semantic_name,
+ ureg->fs_input[i].semantic_index,
+ ureg->fs_input[i].interp );
+ }
}
for (i = 0; i < ureg->nr_outputs; i++) {
ureg->sampler[i].Index, 1 );
}
- if (ureg->nr_constants) {
- emit_decl_range( ureg,
- TGSI_FILE_CONSTANT,
- 0, ureg->nr_constants );
+ if (ureg->nr_constant_ranges) {
+ for (i = 0; i < ureg->nr_constant_ranges; i++)
+ emit_decl_range( ureg,
+ TGSI_FILE_CONSTANT,
+ ureg->constant_range[i].first,
+ (ureg->constant_range[i].last + 1 -
+ ureg->constant_range[i].first) );
}
if (ureg->nr_temps) {
ureg->domain[DOMAIN_DECL].count);
tgsi_dump( tokens, 0 );
}
+
+#if DEBUG
+ if (tokens && !tgsi_sanity_check(tokens)) {
+ debug_printf("tgsi_ureg.c, sanity check failed on generated tokens:\n");
+ tgsi_dump(tokens, 0);
+ assert(0);
+ }
+#endif
+
return tokens;
}
}
+const struct tgsi_token *ureg_get_tokens( struct ureg_program *ureg,
+ unsigned *nr_tokens )
+{
+ const struct tgsi_token *tokens;
+
+ ureg_finalize(ureg);
+
+ tokens = &ureg->domain[DOMAIN_DECL].tokens[0].token;
+
+ if (nr_tokens)
+ *nr_tokens = ureg->domain[DOMAIN_DECL].size;
+
+ ureg->domain[DOMAIN_DECL].tokens = 0;
+ ureg->domain[DOMAIN_DECL].size = 0;
+ ureg->domain[DOMAIN_DECL].order = 0;
+ ureg->domain[DOMAIN_DECL].count = 0;
+
+ return tokens;
+}
struct ureg_program *ureg_create( unsigned processor )
const struct tgsi_token *
ureg_finalize( struct ureg_program * );
+/* Create and return a shader:
+ */
void *
ureg_create_shader( struct ureg_program *,
struct pipe_context *pipe );
+
+/* Alternately, return the built token stream and hand ownership of
+ * that memory to the caller:
+ */
+const struct tgsi_token *
+ureg_get_tokens( struct ureg_program *ureg,
+ unsigned *nr_tokens );
+
+
void
ureg_destroy( struct ureg_program * );
struct ureg_src
ureg_DECL_vs_input( struct ureg_program *,
- unsigned semantic_name,
- unsigned semantic_index );
+ unsigned index );
struct ureg_dst
ureg_DECL_output( struct ureg_program *,
unsigned nr );
struct ureg_src
-ureg_DECL_constant( struct ureg_program * );
+ureg_DECL_constant( struct ureg_program *,
+ unsigned index );
struct ureg_dst
ureg_DECL_temporary( struct ureg_program * );
unsigned nr_src );
+void
+ureg_tex_insn(struct ureg_program *ureg,
+ unsigned opcode,
+ const struct ureg_dst *dst,
+ unsigned nr_dst,
+ unsigned target,
+ const struct ureg_src *src,
+ unsigned nr_src );
+
+
+void
+ureg_label_insn(struct ureg_program *ureg,
+ unsigned opcode,
+ const struct ureg_src *src,
+ unsigned nr_src,
+ unsigned *label);
+
+
/***********************************************************************
* Internal instruction helpers, don't call these directly:
*/
* - avoid outputing large strings (512 bytes is the current maximum length
* that is guaranteed to be printed in all platforms)
*/
+#if !defined(PIPE_OS_HAIKU)
static INLINE void
debug_printf(const char *format, ...)
{
#endif
}
+#endif /* !PIPE_OS_HAIKU */
/*
* ... isn't portable so we need to pass arguments in parentheses.
--- /dev/null
+/**************************************************************************
+ *
+ * Copyright © 2009 Jakob Bornecrantz
+ *
+ * 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 (including the next
+ * paragraph) 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.
+ *
+ **************************************************************************/
+
+#ifndef U_FIFO_H
+#define U_FIFO_H
+
+#include "util/u_memory.h"
+
+struct util_fifo
+{
+ size_t head;
+ size_t tail;
+ size_t num;
+ size_t size;
+};
+
+static INLINE struct util_fifo *
+u_fifo_create(size_t size)
+{
+ struct util_fifo *fifo;
+ fifo = MALLOC(sizeof(*fifo) + size * sizeof(void*));
+
+ fifo->head = 0;
+ fifo->tail = 0;
+ fifo->num = 0;
+ fifo->size = size;
+
+ return fifo;
+}
+
+static INLINE boolean
+u_fifo_add(struct util_fifo *fifo, void *ptr)
+{
+ void **array = (void**)&fifo[1];
+ if (fifo->num >= fifo->size)
+ return FALSE;
+
+ if (++fifo->head >= fifo->size)
+ fifo->head = 0;
+
+ array[fifo->head] = ptr;
+
+ ++fifo->num;
+
+ return TRUE;
+}
+
+static INLINE boolean
+u_fifo_pop(struct util_fifo *fifo, void **ptr)
+{
+ void **array = (void**)&fifo[1];
+
+ if (!fifo->num)
+ return FALSE;
+
+ if (++fifo->tail >= fifo->size)
+ fifo->tail = 0;
+
+ *ptr = array[fifo->tail];
+
+ ++fifo->num;
+
+ return TRUE;
+}
+
+static INLINE void
+u_fifo_destroy(struct util_fifo *fifo)
+{
+ FREE(fifo);
+}
+
+#endif
PIPE_FORMAT_Z16_UNORM , array , 1, 1, un16, , , , x___, zs
PIPE_FORMAT_Z32_UNORM , array , 1, 1, un32, , , , x___, zs
PIPE_FORMAT_Z32_FLOAT , array , 1, 1, f32 , , , , x___, zs
-PIPE_FORMAT_S8Z24_UNORM , arith , 1, 1, un8 , un24, , , yx__, zs
-PIPE_FORMAT_Z24S8_UNORM , arith , 1, 1, un24, un8 , , , xy__, zs
-PIPE_FORMAT_X8Z24_UNORM , arith , 1, 1, un8 , un24, , , y___, zs
-PIPE_FORMAT_Z24X8_UNORM , arith , 1, 1, un24, un8 , , , x___, zs
+PIPE_FORMAT_S8Z24_UNORM , arith , 1, 1, un24, un8 , , , xy__, zs
+PIPE_FORMAT_Z24S8_UNORM , arith , 1, 1, un8 , un24, , , yx__, zs
+PIPE_FORMAT_X8Z24_UNORM , arith , 1, 1, un24, un8 , , , x___, zs
+PIPE_FORMAT_Z24X8_UNORM , arith , 1, 1, un8 , un24, , , y___, zs
PIPE_FORMAT_S8_UNORM , array , 1, 1, un8 , , , , _x__, zs
PIPE_FORMAT_R64_FLOAT , array , 1, 1, f64 , , , , x001, rgb
PIPE_FORMAT_R64G64_FLOAT , array , 1, 1, f64 , f64 , , , xy01, rgb
}
+/**
+ * Test whether x is a power of two.
+ */
+static INLINE boolean
+util_is_pot(unsigned x)
+{
+ return (x & (x - 1)) == 0;
+}
+
+
/**
* Find first bit set in word. Least significant bit is 1.
* Return 0 if no bits set.
#if defined(PIPE_SUBSYSTEM_WINDOWS_USER)
# include <winsock2.h>
# include <windows.h>
-#elif defined(PIPE_OS_LINUX)
+#elif defined(PIPE_OS_LINUX) || defined(PIPE_OS_HAIKU)
# include <sys/socket.h>
# include <netinet/in.h>
# include <unistd.h>
if (s < 0)
return;
-#if defined(PIPE_OS_LINUX)
+#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_HAIKU)
shutdown(s, SHUT_RDWR);
close(s);
#elif defined(PIPE_SUBSYSTEM_WINDOWS_USER)
void
u_socket_block(int s, boolean block)
{
-#if defined(PIPE_OS_LINUX)
+#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_HAIKU)
int old = fcntl(s, F_GETFL, 0);
if (old == -1)
return;
#if defined(PIPE_SUBSYSTEM_WINDOWS_USER)
# define PIPE_HAVE_SOCKETS
-#elif defined(PIPE_OS_LINUX)
+#elif defined(PIPE_OS_LINUX) || defined(PIPE_OS_HAIKU)
# define PIPE_HAVE_SOCKETS
#endif
unsigned bytes)
{
struct pipe_buffer *buffer =
- screen->winsys->user_buffer_create(screen->winsys,
- ptr, bytes);
+ screen->winsys->user_buffer_create(screen->winsys, ptr, bytes);
buffer->screen = screen;
unsigned *stride)
{
struct pipe_buffer *buffer =
- screen->winsys->surface_buffer_create(screen->winsys,
- width, height,
- format, usage, tex_usage, stride);
+ screen->winsys->surface_buffer_create(screen->winsys, width, height,
+ format, usage, tex_usage, stride);
buffer->screen = screen;
struct pipe_buffer *buf,
unsigned usage)
{
- return screen->winsys->buffer_map(screen->winsys,
- buf, usage);
+ return screen->winsys->buffer_map(screen->winsys, buf, usage);
}
static void
struct pipe_surface *surf,
void *context_private)
{
- screen->winsys->flush_frontbuffer(screen->winsys,
- surf, context_private);
+ screen->winsys->flush_frontbuffer(screen->winsys, surf, context_private);
}
static void
struct pipe_fence_handle **ptr,
struct pipe_fence_handle *fence)
{
- screen->winsys->fence_reference(screen->winsys,
- ptr, fence);
+ screen->winsys->fence_reference(screen->winsys, ptr, fence);
}
static int
struct pipe_fence_handle *fence,
unsigned flag)
{
- return screen->winsys->fence_signalled(screen->winsys,
- fence, flag);
+ return screen->winsys->fence_signalled(screen->winsys, fence, flag);
}
static int
struct pipe_fence_handle *fence,
unsigned flag)
{
- return screen->winsys->fence_finish(screen->winsys,
- fence, flag);
+ return screen->winsys->fence_finish(screen->winsys, fence, flag);
}
-void u_simple_screen_init(struct pipe_screen *screen)
+void
+u_simple_screen_init(struct pipe_screen *screen)
{
screen->buffer_create = pass_buffer_create;
screen->user_buffer_create = pass_user_buffer_create;
screen->fence_finish = pass_fence_finish;
}
-const char* u_simple_screen_winsys_name(struct pipe_screen *screen)
+const char *
+u_simple_screen_winsys_name(struct pipe_screen *screen)
{
return screen->winsys->get_name(screen->winsys);
}
#include "pipe/p_context.h"
-#include "util/u_debug.h"
-#include "pipe/p_defines.h"
-#include "pipe/p_screen.h"
#include "pipe/p_shader_tokens.h"
-
-#include "util/u_memory.h"
#include "util/u_simple_shaders.h"
-
#include "tgsi/tgsi_ureg.h"
struct ureg_src src;
struct ureg_dst dst;
- src = ureg_DECL_vs_input( ureg,
- semantic_names[i],
- semantic_indexes[i]);
+ src = ureg_DECL_vs_input( ureg, i );
dst = ureg_DECL_output( ureg,
semantic_names[i],
-
-
/**
* Make simple fragment color pass-through shader.
*/
#include "pipe/p_config.h"
-#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_SUBSYSTEM_WINDOWS_USER) || defined(PIPE_OS_SOLARIS)
+#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_SUBSYSTEM_WINDOWS_USER) || defined(PIPE_OS_SOLARIS) || defined(PIPE_OS_HAIKU)
#include <stdio.h>
pRow[0] = ubyte_to_float((pixel >> 16) & 0xff);
pRow[1] = ubyte_to_float((pixel >> 8) & 0xff);
pRow[2] = ubyte_to_float((pixel >> 0) & 0xff);
- pRow[3] = ubyte_to_float(0xff);
+ pRow[3] = 1.0F;
}
p += dst_stride;
}
+/*** PIPE_FORMAT_R8G8B8_UNORM ***/
+
+static void
+r8g8b8_get_tile_rgba(const ubyte *src,
+ unsigned w, unsigned h,
+ float *p,
+ unsigned dst_stride)
+{
+ unsigned i, j;
+
+ for (i = 0; i < h; i++) {
+ float *pRow = p;
+ for (j = 0; j < w; j++, pRow += 4) {
+ pRow[0] = ubyte_to_float(src[0]);
+ pRow[1] = ubyte_to_float(src[1]);
+ pRow[2] = ubyte_to_float(src[2]);
+ pRow[3] = 1.0f;
+ src += 3;
+ }
+ p += dst_stride;
+ }
+}
+
+
+static void
+r8g8b8_put_tile_rgba(ubyte *dst,
+ unsigned w, unsigned h,
+ const float *p,
+ unsigned src_stride)
+{
+ unsigned i, j;
+
+ for (i = 0; i < h; i++) {
+ const float *pRow = p;
+ for (j = 0; j < w; j++, pRow += 4) {
+ dst[0] = float_to_ubyte(pRow[0]);
+ dst[1] = float_to_ubyte(pRow[1]);
+ dst[2] = float_to_ubyte(pRow[2]);
+ dst += 3;
+ }
+ p += src_stride;
+ }
+}
+
+
+
/*** PIPE_FORMAT_Z16_UNORM ***/
/**
case PIPE_FORMAT_R5G6B5_UNORM:
r5g6b5_get_tile_rgba((ushort *) src, w, h, dst, dst_stride);
break;
+ case PIPE_FORMAT_R8G8B8_UNORM:
+ r8g8b8_get_tile_rgba((ubyte *) src, w, h, dst, dst_stride);
+ break;
case PIPE_FORMAT_L8_UNORM:
l8_get_tile_rgba((ubyte *) src, w, h, dst, dst_stride);
break;
case PIPE_FORMAT_R5G6B5_UNORM:
r5g6b5_put_tile_rgba((ushort *) packed, w, h, p, src_stride);
break;
+ case PIPE_FORMAT_R8G8B8_UNORM:
+ r8g8b8_put_tile_rgba((ubyte *) packed, w, h, p, src_stride);
+ break;
case PIPE_FORMAT_R8G8B8A8_UNORM:
assert(0);
break;
#include "pipe/p_config.h"
-#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS) || defined(PIPE_OS_APPLE)
+#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS) || defined(PIPE_OS_APPLE) || defined(PIPE_OS_HAIKU)
#include <sys/time.h>
#elif defined(PIPE_SUBSYSTEM_WINDOWS_DISPLAY)
#include <windows.h>
void
util_time_get(struct util_time *t)
{
-#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS) || defined(PIPE_OS_APPLE)
+#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS) || defined(PIPE_OS_APPLE) || defined(PIPE_OS_HAIKU)
gettimeofday(&t->tv, NULL);
#elif defined(PIPE_SUBSYSTEM_WINDOWS_DISPLAY)
LONGLONG temp;
int64_t usecs,
struct util_time *t2)
{
-#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS) || defined(PIPE_OS_APPLE)
+#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS) || defined(PIPE_OS_APPLE) || defined(PIPE_OS_HAIKU)
t2->tv.tv_sec = t1->tv.tv_sec + usecs / 1000000;
t2->tv.tv_usec = t1->tv.tv_usec + usecs % 1000000;
#elif defined(PIPE_SUBSYSTEM_WINDOWS_DISPLAY) || defined(PIPE_SUBSYSTEM_WINDOWS_USER) || defined(PIPE_SUBSYSTEM_WINDOWS_CE)
util_time_diff(const struct util_time *t1,
const struct util_time *t2)
{
-#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS) || defined(PIPE_OS_APPLE)
+#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS) || defined(PIPE_OS_APPLE) || defined(PIPE_OS_HAIKU)
return (t2->tv.tv_usec - t1->tv.tv_usec) +
(t2->tv.tv_sec - t1->tv.tv_sec)*1000000;
#elif defined(PIPE_SUBSYSTEM_WINDOWS_DISPLAY) || defined(PIPE_SUBSYSTEM_WINDOWS_USER) || defined(PIPE_SUBSYSTEM_WINDOWS_CE)
util_time_get(&t1);
-#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS) || defined(PIPE_OS_APPLE)
+#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS) || defined(PIPE_OS_APPLE) || defined(PIPE_OS_HAIKU)
return t1.tv.tv_usec + t1.tv.tv_sec*1000000LL;
#elif defined(PIPE_SUBSYSTEM_WINDOWS_DISPLAY) || defined(PIPE_SUBSYSTEM_WINDOWS_USER) || defined(PIPE_SUBSYSTEM_WINDOWS_CE)
util_time_get_frequency();
util_time_compare(const struct util_time *t1,
const struct util_time *t2)
{
-#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS) || defined(PIPE_OS_APPLE)
+#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS) || defined(PIPE_OS_APPLE) || defined(PIPE_OS_HAIKU)
if (t1->tv.tv_sec < t2->tv.tv_sec)
return -1;
else if(t1->tv.tv_sec > t2->tv.tv_sec)
#include <unistd.h> /* usleep */
#endif
+#if defined(PIPE_OS_HAIKU)
+#include <sys/time.h> /* timeval */
+#include <unistd.h>
+#endif
+
#include "pipe/p_compiler.h"
*/
struct util_time
{
-#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS) || defined(PIPE_OS_APPLE)
+#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS) || defined(PIPE_OS_APPLE) || defined(PIPE_OS_HAIKU)
struct timeval tv;
#else
int64_t counter;
const struct util_time *end,
const struct util_time *curr);
-#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS) || defined(PIPE_OS_APPLE)
+#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS) || defined(PIPE_OS_APPLE) || defined(PIPE_OS_HAIKU)
#define util_time_sleep usleep
#else
void
#include "pipe/p_inlines.h"
#include "util/u_math.h"
#include "util/u_memory.h"
+#include "util/u_fifo.h"
#include "i915_context.h"
#include "i915_reg.h"
size_t vbo_size;
size_t vbo_offset;
void *vbo_ptr;
- size_t vbo_alloc_size;
size_t vbo_max_used;
+
+ /* stuff for the pool */
+ struct util_fifo *pool_fifo;
+ unsigned pool_used;
+ unsigned pool_buffer_size;
+ boolean pool_not_used;
};
return &i915->current.vertex_info;
}
+static boolean
+i915_vbuf_render_reserve(struct i915_vbuf_render *i915_render, size_t size)
+{
+ struct i915_context *i915 = i915_render->i915;
+
+ if (i915_render->vbo_size < size + i915_render->vbo_offset)
+ return FALSE;
+
+ if (i915->vbo_flushed)
+ return FALSE;
+
+ return TRUE;
+}
+
+static void
+i915_vbuf_render_new_buf(struct i915_vbuf_render *i915_render, size_t size)
+{
+ struct i915_context *i915 = i915_render->i915;
+ struct intel_winsys *iws = i915->iws;
+
+ if (i915_render->vbo) {
+ if (i915_render->pool_not_used)
+ iws->buffer_destroy(iws, i915_render->vbo);
+ else
+ u_fifo_add(i915_render->pool_fifo, i915_render->vbo);
+ i915_render->vbo = NULL;
+ }
+
+ i915->vbo_flushed = 0;
+
+ i915_render->vbo_size = MAX2(size, i915_render->pool_buffer_size);
+ i915_render->vbo_offset = 0;
+
+ if (i915_render->vbo_size != i915_render->pool_buffer_size) {
+ i915_render->pool_not_used = TRUE;
+ i915_render->vbo = iws->buffer_create(iws, i915_render->vbo_size, 64,
+ INTEL_NEW_VERTEX);
+ } else {
+ i915_render->pool_not_used = FALSE;
+
+ if (i915_render->pool_used >= 2) {
+ FLUSH_BATCH(NULL);
+ i915->vbo_flushed = 0;
+ i915_render->pool_used = 0;
+ }
+ u_fifo_pop(i915_render->pool_fifo, (void**)&i915_render->vbo);
+ }
+}
+
static boolean
i915_vbuf_render_allocate_vertices(struct vbuf_render *render,
ushort vertex_size,
{
struct i915_vbuf_render *i915_render = i915_vbuf_render(render);
struct i915_context *i915 = i915_render->i915;
- struct intel_winsys *iws = i915->iws;
size_t size = (size_t)vertex_size * (size_t)nr_vertices;
/* FIXME: handle failure */
assert(!i915->vbo);
- if (i915_render->vbo_size > size + i915_render->vbo_offset && !i915->vbo_flushed) {
- } else {
- i915->vbo_flushed = 0;
- if (i915_render->vbo) {
- iws->buffer_destroy(iws, i915_render->vbo);
- i915_render->vbo = NULL;
- }
- }
+ if (!i915_vbuf_render_reserve(i915_render, size)) {
- if (!i915_render->vbo) {
- i915_render->vbo_size = MAX2(size, i915_render->vbo_alloc_size);
- i915_render->vbo_offset = 0;
- i915_render->vbo = iws->buffer_create(iws, i915_render->vbo_size, 64,
- INTEL_NEW_VERTEX);
+ if (i915->vbo_flushed)
+ i915_render->pool_used = 0;
+ i915_vbuf_render_new_buf(i915_render, size);
}
i915_render->vertex_size = vertex_size;
{
struct i915_vbuf_render *i915_render = CALLOC_STRUCT(i915_vbuf_render);
struct intel_winsys *iws = i915->iws;
+ int i;
i915_render->i915 = i915;
i915_render->base.release_vertices = i915_vbuf_render_release_vertices;
i915_render->base.destroy = i915_vbuf_render_destroy;
- i915_render->vbo_alloc_size = 128 * 4096;
- i915_render->vbo_size = i915_render->vbo_alloc_size;
+
+ i915_render->vbo = NULL;
+ i915_render->vbo_size = 0;
i915_render->vbo_offset = 0;
- i915_render->vbo = iws->buffer_create(iws, i915_render->vbo_size, 64,
- INTEL_NEW_VERTEX);
+
+ i915_render->pool_used = FALSE;
+ i915_render->pool_buffer_size = 128 * 4096;
+ i915_render->pool_fifo = u_fifo_create(6);
+ for (i = 0; i < 6; i++)
+ u_fifo_add(i915_render->pool_fifo,
+ iws->buffer_create(iws, i915_render->pool_buffer_size, 64,
+ INTEL_NEW_VERTEX));
+
+#if 0
/* TODO JB: is this realy needed? */
i915_render->vbo_ptr = iws->buffer_map(iws, i915_render->vbo, TRUE);
iws->buffer_unmap(iws, i915_render->vbo);
+#endif
return &i915_render->base;
}
void (*buffer_unmap)(struct intel_winsys *iws,
struct intel_buffer *buffer);
+ /**
+ * Write to a buffer.
+ *
+ * Arguments follows pwrite(2)
+ */
+ int (*buffer_write)(struct intel_winsys *iws,
+ struct intel_buffer *dst,
+ const void *src,
+ size_t size,
+ size_t offset);
+
void (*buffer_destroy)(struct intel_winsys *iws,
struct intel_buffer *buffer);
/*@}*/
lp_bld_depth.c \
lp_bld_flow.c \
lp_bld_format_aos.c \
+ lp_bld_format_soa.c \
lp_bld_interp.c \
lp_bld_intr.c \
lp_bld_logic.c \
+ lp_bld_sample_soa.c \
lp_bld_swizzle.c \
lp_bld_struct.c \
lp_bld_tgsi_soa.c \
lp_state_vs.c \
lp_surface.c \
lp_tex_cache.c \
- lp_tex_sample.c \
+ lp_tex_sample_c.c \
+ lp_tex_sample_llvm.c \
lp_texture.c \
lp_tile_cache.c \
lp_tile_soa.c
- the whole fragment pipeline is code generated in a single function
+ - input interpolation
+
- depth testing
+ - texture sampling (not all state/formats are supported)
+
- fragment shader TGSI translation
- same level of support as the TGSI SSE2 exec machine, with the exception
we don't fallback to TGSI interpretation when an unsupported opcode is
found, but just ignore it
- - texture sampling via an intrinsic call
- done in SoA layout
- input interpolation also code generated
any width and length
- not all operations are implemented for these types yet though
-Most mesa/progs/demos/* work. Speed is on par with Keith's softpipe-opt branch,
-which includes hand written fast implementations for common cases.
+Most mesa/progs/demos/* work.
To do (probably by this order):
- code generate stipple and stencil testing
- - code generate texture sampling
+ - translate the remaining bits of texture sampling state
- translate TGSI control flow instructions, and all other remaining opcodes
+
+ - integrate with the draw module for VS code generation
- code generate the triangle setup and rasterization
make linux-llvm
-but the rest of these instructions assume scons is used.
+but the rest of these instructions assume that scons is used.
Using
export LD_LIBRARY_PATH=$PWD/build/linux-x86-debug/lib:$LD_LIBRARY_PATH
+For performance evaluation pass debug=no to scons, and use the corresponding
+lib directory without the "-debug" suffix.
+
Unit testing
============
- lp_test_conv: SIMD vector conversion
- lp_test_format: pixel unpacking/packing
-Some of this tests can output results and benchmarks to a tab-seperated-file
+Some of this tests can output results and benchmarks to a tab-separated-file
for posterior analysis, e.g.:
build/linux-x86_64-debug/gallium/drivers/llvmpipe/lp_test_blend -o blend.tsv
at the top of the lp_bld_*.c functions.
- All lp_bld_*.[ch] are isolated from the rest of the driver, and could/may be
- put in a standalone Gallium state -> LLVM IR translation module.
+ put in a stand-alone Gallium state -> LLVM IR translation module.
- We use LLVM-C bindings for now. They are not documented, but follow the C++
interfaces very closely, and appear to be complete enough for code
generation. See
http://npcontemplation.blogspot.com/2008/06/secret-of-llvm-c-bindings.html
- for a standalone example.
+ for a stand-alone example.
env = env.Clone()
env.Tool('llvm')
-if 'LLVM_VERSION' not in env:
+if env.has_key('LLVM_VERSION') is False:
print 'warning: LLVM not found: not building llvmpipe'
Return()
'lp_bld_depth.c',
'lp_bld_flow.c',
'lp_bld_format_aos.c',
+ 'lp_bld_format_soa.c',
'lp_bld_interp.c',
'lp_bld_intr.c',
+ 'lp_bld_sample_soa.c',
'lp_bld_struct.c',
'lp_bld_logic.c',
'lp_bld_swizzle.c',
'lp_state_vs.c',
'lp_surface.c',
'lp_tex_cache.c',
- 'lp_tex_sample.c',
+ 'lp_tex_sample_c.c',
+ 'lp_tex_sample_llvm.c',
'lp_texture.c',
'lp_tile_cache.c',
'lp_tile_soa.c',
}
+LLVMValueRef
+lp_build_lerp(struct lp_build_context *bld,
+ LLVMValueRef x,
+ LLVMValueRef v0,
+ LLVMValueRef v1)
+{
+ return lp_build_add(bld, v0, lp_build_mul(bld, x, lp_build_sub(bld, v1, v0)));
+}
+
+
+LLVMValueRef
+lp_build_lerp_2d(struct lp_build_context *bld,
+ LLVMValueRef x,
+ LLVMValueRef y,
+ LLVMValueRef v00,
+ LLVMValueRef v01,
+ LLVMValueRef v10,
+ LLVMValueRef v11)
+{
+ LLVMValueRef v0 = lp_build_lerp(bld, x, v00, v01);
+ LLVMValueRef v1 = lp_build_lerp(bld, x, v10, v11);
+ return lp_build_lerp(bld, y, v0, v1);
+}
+
+
/**
* Generate min(a, b)
* Do checks for special cases.
LLVMValueRef a)
{
const union lp_type type = bld->type;
+ LLVMTypeRef vec_type = lp_build_vec_type(type);
if(!type.sign)
return a;
- /* XXX: is this really necessary? */
+ if(type.floating) {
+ /* Mask out the sign bit */
+ LLVMTypeRef int_vec_type = lp_build_int_vec_type(type);
+ LLVMValueRef mask = lp_build_int_const_scalar(type, ((unsigned long long)1 << type.width) - 1);
+ a = LLVMBuildBitCast(bld->builder, a, int_vec_type, "");
+ a = LLVMBuildAnd(bld->builder, a, mask, "");
+ a = LLVMBuildBitCast(bld->builder, a, vec_type, "");
+ return a;
+ }
+
#if defined(PIPE_ARCH_X86) || defined(PIPE_ARCH_X86_64)
- if(!type.floating && type.width*type.length == 128) {
- LLVMTypeRef vec_type = lp_build_vec_type(type);
- if(type.width == 8)
+ if(type.width*type.length == 128) {
+ switch(type.width) {
+ case 8:
return lp_build_intrinsic_unary(bld->builder, "llvm.x86.ssse3.pabs.b.128", vec_type, a);
- if(type.width == 16)
+ case 16:
return lp_build_intrinsic_unary(bld->builder, "llvm.x86.ssse3.pabs.w.128", vec_type, a);
- if(type.width == 32)
+ case 32:
return lp_build_intrinsic_unary(bld->builder, "llvm.x86.ssse3.pabs.d.128", vec_type, a);
+ }
}
#endif
}
+LLVMValueRef
+lp_build_sgn(struct lp_build_context *bld,
+ LLVMValueRef a)
+{
+ const union lp_type type = bld->type;
+ LLVMTypeRef vec_type = lp_build_vec_type(type);
+ LLVMValueRef cond;
+ LLVMValueRef res;
+
+ /* Handle non-zero case */
+ if(!type.sign) {
+ /* if not zero then sign must be positive */
+ res = bld->one;
+ }
+ else if(type.floating) {
+ /* Take the sign bit and add it to 1 constant */
+ LLVMTypeRef int_vec_type = lp_build_int_vec_type(type);
+ LLVMValueRef mask = lp_build_int_const_scalar(type, (unsigned long long)1 << (type.width - 1));
+ LLVMValueRef sign;
+ LLVMValueRef one;
+ sign = LLVMBuildBitCast(bld->builder, a, int_vec_type, "");
+ sign = LLVMBuildAnd(bld->builder, sign, mask, "");
+ one = LLVMConstBitCast(bld->one, int_vec_type);
+ res = LLVMBuildOr(bld->builder, sign, one, "");
+ res = LLVMBuildBitCast(bld->builder, res, vec_type, "");
+ }
+ else
+ {
+ LLVMValueRef minus_one = lp_build_const_scalar(type, -1.0);
+ cond = lp_build_cmp(bld, PIPE_FUNC_GREATER, a, bld->zero);
+ res = lp_build_select(bld, cond, bld->one, minus_one);
+ }
+
+ /* Handle zero */
+ cond = lp_build_cmp(bld, PIPE_FUNC_EQUAL, a, bld->zero);
+ res = lp_build_select(bld, cond, bld->zero, bld->one);
+
+ return res;
+}
+
+
+enum lp_build_round_sse41_mode
+{
+ LP_BUILD_ROUND_SSE41_NEAREST = 0,
+ LP_BUILD_ROUND_SSE41_FLOOR = 1,
+ LP_BUILD_ROUND_SSE41_CEIL = 2,
+ LP_BUILD_ROUND_SSE41_TRUNCATE = 3
+};
+
+
+static INLINE LLVMValueRef
+lp_build_round_sse41(struct lp_build_context *bld,
+ LLVMValueRef a,
+ enum lp_build_round_sse41_mode mode)
+{
+ const union lp_type type = bld->type;
+ LLVMTypeRef vec_type = lp_build_vec_type(type);
+ const char *intrinsic;
+
+ assert(type.floating);
+ assert(type.width*type.length == 128);
+
+ switch(type.width) {
+ case 32:
+ intrinsic = "llvm.x86.sse41.round.ps";
+ break;
+ case 64:
+ intrinsic = "llvm.x86.sse41.round.pd";
+ break;
+ default:
+ assert(0);
+ return bld->undef;
+ }
+
+ return lp_build_intrinsic_binary(bld->builder, intrinsic, vec_type, a,
+ LLVMConstInt(LLVMInt32Type(), mode, 0));
+}
+
+
+LLVMValueRef
+lp_build_round(struct lp_build_context *bld,
+ LLVMValueRef a)
+{
+ const union lp_type type = bld->type;
+
+ assert(type.floating);
+
+#if defined(PIPE_ARCH_X86) || defined(PIPE_ARCH_X86_64)
+ return lp_build_round_sse41(bld, a, LP_BUILD_ROUND_SSE41_NEAREST);
+#endif
+
+ /* FIXME */
+ assert(0);
+ return bld->undef;
+}
+
+
+LLVMValueRef
+lp_build_floor(struct lp_build_context *bld,
+ LLVMValueRef a)
+{
+ const union lp_type type = bld->type;
+
+ assert(type.floating);
+
+#if defined(PIPE_ARCH_X86) || defined(PIPE_ARCH_X86_64)
+ return lp_build_round_sse41(bld, a, LP_BUILD_ROUND_SSE41_FLOOR);
+#endif
+
+ /* FIXME */
+ assert(0);
+ return bld->undef;
+}
+
+
+LLVMValueRef
+lp_build_ceil(struct lp_build_context *bld,
+ LLVMValueRef a)
+{
+ const union lp_type type = bld->type;
+
+ assert(type.floating);
+
+#if defined(PIPE_ARCH_X86) || defined(PIPE_ARCH_X86_64)
+ return lp_build_round_sse41(bld, a, LP_BUILD_ROUND_SSE41_CEIL);
+#endif
+
+ /* FIXME */
+ assert(0);
+ return bld->undef;
+}
+
+
+LLVMValueRef
+lp_build_trunc(struct lp_build_context *bld,
+ LLVMValueRef a)
+{
+ const union lp_type type = bld->type;
+
+ assert(type.floating);
+
+#if defined(PIPE_ARCH_X86) || defined(PIPE_ARCH_X86_64)
+ return lp_build_round_sse41(bld, a, LP_BUILD_ROUND_SSE41_TRUNCATE);
+#endif
+
+ /* FIXME */
+ assert(0);
+ return bld->undef;
+}
+
+
+/**
+ * Convert to integer, through whichever rounding method that's fastest,
+ * typically truncating to zero.
+ */
+LLVMValueRef
+lp_build_int(struct lp_build_context *bld,
+ LLVMValueRef a)
+{
+ const union lp_type type = bld->type;
+ LLVMTypeRef int_vec_type = lp_build_int_vec_type(type);
+
+ assert(type.floating);
+
+ return LLVMBuildFPToSI(bld->builder, a, int_vec_type, "");
+}
+
+
+LLVMValueRef
+lp_build_ifloor(struct lp_build_context *bld,
+ LLVMValueRef a)
+{
+ a = lp_build_floor(bld, a);
+ a = lp_build_int(bld, a);
+ return a;
+}
+
+
LLVMValueRef
lp_build_sqrt(struct lp_build_context *bld,
LLVMValueRef a)
LLVMValueRef a,
LLVMValueRef b);
+LLVMValueRef
+lp_build_lerp(struct lp_build_context *bld,
+ LLVMValueRef x,
+ LLVMValueRef v0,
+ LLVMValueRef v1);
+
+/**
+ * Bilinear interpolation.
+ *
+ * Values indices are in v_{yx}.
+ */
+LLVMValueRef
+lp_build_lerp_2d(struct lp_build_context *bld,
+ LLVMValueRef x,
+ LLVMValueRef y,
+ LLVMValueRef v00,
+ LLVMValueRef v01,
+ LLVMValueRef v10,
+ LLVMValueRef v11);
+
LLVMValueRef
lp_build_min(struct lp_build_context *bld,
LLVMValueRef a,
lp_build_abs(struct lp_build_context *bld,
LLVMValueRef a);
+LLVMValueRef
+lp_build_sgn(struct lp_build_context *bld,
+ LLVMValueRef a);
+
+LLVMValueRef
+lp_build_round(struct lp_build_context *bld,
+ LLVMValueRef a);
+
+LLVMValueRef
+lp_build_floor(struct lp_build_context *bld,
+ LLVMValueRef a);
+
+LLVMValueRef
+lp_build_ceil(struct lp_build_context *bld,
+ LLVMValueRef a);
+
+LLVMValueRef
+lp_build_trunc(struct lp_build_context *bld,
+ LLVMValueRef a);
+
+LLVMValueRef
+lp_build_int(struct lp_build_context *bld,
+ LLVMValueRef a);
+
+LLVMValueRef
+lp_build_ifloor(struct lp_build_context *bld,
+ LLVMValueRef a);
+
LLVMValueRef
lp_build_sqrt(struct lp_build_context *bld,
LLVMValueRef a);
int shift = dst_width - n;
res = LLVMBuildShl(builder, res, lp_build_int_const_scalar(src_type, shift), "");
- /* Fill in the empty lower bits for added precision? */
+ /* TODO: Fill in the empty lower bits for additional precision? */
#if 0
{
LLVMValueRef msb;
* Expand the bit width.
*
* This will only change the number of bits the values are represented, not the
- * values themselved.
+ * values themselves.
*/
static void
lp_build_expand(LLVMBuilderRef builder,
* TODO: Handle saturation consistently.
*/
static LLVMValueRef
-lp_build_trunc(LLVMBuilderRef builder,
- union lp_type src_type,
- union lp_type dst_type,
- boolean clamped,
- const LLVMValueRef *src, unsigned num_srcs)
+lp_build_pack(LLVMBuilderRef builder,
+ union lp_type src_type,
+ union lp_type dst_type,
+ boolean clamped,
+ const LLVMValueRef *src, unsigned num_srcs)
{
LLVMValueRef tmp[LP_MAX_VECTOR_LENGTH];
unsigned i;
if(tmp_type.width > dst_type.width) {
assert(num_dsts == 1);
- tmp[0] = lp_build_trunc(builder, tmp_type, dst_type, TRUE, tmp, num_tmps);
+ tmp[0] = lp_build_pack(builder, tmp_type, dst_type, TRUE, tmp, num_tmps);
tmp_type.width = dst_type.width;
tmp_type.length = dst_type.length;
num_tmps = 1;
if(src_type.width > dst_type.width) {
assert(num_dsts == 1);
- dst[0] = lp_build_trunc(builder, src_type, dst_type, TRUE, src, num_srcs);
+ dst[0] = lp_build_pack(builder, src_type, dst_type, TRUE, src, num_srcs);
}
else if(src_type.width < dst_type.width) {
assert(num_srcs == 1);
#include <udis86.h>
#endif
+#include "util/u_math.h"
#include "util/u_debug.h"
#include "lp_bld_debug.h"
+/**
+ * Check alignment.
+ *
+ * It is important that this check is not implemented as a macro or inlined
+ * function, as the compiler assumptions in respect to alignment of global
+ * and stack variables would often make the check a no op, defeating the
+ * whole purpose of the exercise.
+ */
+boolean
+lp_check_alignment(const void *ptr, unsigned alignment)
+{
+ assert(util_is_pot(alignment));
+ return ((uintptr_t)ptr & (alignment - 1)) == 0;
+}
+
+
void
lp_disassemble(const void* func)
{
}
+boolean
+lp_check_alignment(const void *ptr, unsigned alignment);
+
+
void
lp_disassemble(const void* func);
padding_right = 0;
for(chan = 0; chan < z_swizzle; ++chan)
padding_right += format_desc->channel[chan].size;
- padding_left = format_desc->block.bits - format_desc->channel[z_swizzle].size;
+ padding_left = format_desc->block.bits -
+ (padding_right + format_desc->channel[z_swizzle].size);
if(padding_left || padding_right) {
- const long long mask_left = ((long long)1 << (format_desc->block.bits - padding_left)) - 1;
- const long long mask_right = ((long long)1 << (padding_right)) - 1;
- z_bitmask = lp_build_int_const_scalar(type, mask_left & mask_right);
+ const unsigned long long mask_left = ((unsigned long long)1 << (format_desc->block.bits - padding_left)) - 1;
+ const unsigned long long mask_right = ((unsigned long long)1 << (padding_right)) - 1;
+ z_bitmask = lp_build_int_const_scalar(type, mask_left ^ mask_right);
}
if(padding_left)
LLVMBuildStore(builder, dst, dst_ptr);
}
+ /* FIXME */
assert(!state->occlusion_count);
}
*/
#include "util/u_debug.h"
+#include "util/u_memory.h"
#include "lp_bld_type.h"
#include "lp_bld_flow.h"
+#define LP_BUILD_FLOW_MAX_VARIABLES 32
+#define LP_BUILD_FLOW_MAX_DEPTH 32
+
+
+/**
+ * Enumeration of all possible flow constructs.
+ */
+enum lp_build_flow_construct_kind {
+ lP_BUILD_FLOW_SCOPE,
+ LP_BUILD_FLOW_SKIP,
+};
+
+
+/**
+ * Variable declaration scope.
+ */
+struct lp_build_flow_scope
+{
+ /** Number of variables declared in this scope */
+ unsigned num_variables;
+};
+
+
+/**
+ * Early exit. Useful to skip to the end of a function or block when
+ * the execution mask becomes zero or when there is an error condition.
+ */
+struct lp_build_flow_skip
+{
+ /** Block to skip to */
+ LLVMBasicBlockRef block;
+
+ /** Number of variables declared at the beginning */
+ unsigned num_variables;
+
+ LLVMValueRef *phi;
+};
+
+
+/**
+ * Union of all possible flow constructs' data
+ */
+union lp_build_flow_construct_data
+{
+ struct lp_build_flow_scope scope;
+ struct lp_build_flow_skip skip;
+};
+
+
+/**
+ * Element of the flow construct stack.
+ */
+struct lp_build_flow_construct
+{
+ enum lp_build_flow_construct_kind kind;
+ union lp_build_flow_construct_data data;
+};
+
+
+/**
+ * All necessary data to generate LLVM control flow constructs.
+ *
+ * Besides keeping track of the control flow construct themselves we also
+ * need to keep track of variables in order to generate SSA Phi values.
+ */
+struct lp_build_flow_context
+{
+ LLVMBuilderRef builder;
+
+ /**
+ * Control flow stack.
+ */
+ struct lp_build_flow_construct constructs[LP_BUILD_FLOW_MAX_DEPTH];
+ unsigned num_constructs;
+
+ /**
+ * Variable stack
+ */
+ LLVMValueRef *variables[LP_BUILD_FLOW_MAX_VARIABLES];
+ unsigned num_variables;
+};
+
+
+struct lp_build_flow_context *
+lp_build_flow_create(LLVMBuilderRef builder)
+{
+ struct lp_build_flow_context *flow;
+
+ flow = CALLOC_STRUCT(lp_build_flow_context);
+ if(!flow)
+ return NULL;
+
+ flow->builder = builder;
+
+ return flow;
+}
+
+
void
-lp_build_mask_begin(struct lp_build_mask_context *mask,
- LLVMBuilderRef builder,
- union lp_type type,
- LLVMValueRef value)
+lp_build_flow_destroy(struct lp_build_flow_context *flow)
{
- memset(mask, 0, sizeof *mask);
+ assert(flow->num_constructs == 0);
+ assert(flow->num_variables == 0);
+ FREE(flow);
+}
- mask->builder = builder;
- mask->reg_type = LLVMIntType(type.width * type.length);
- mask->value = value;
+
+static union lp_build_flow_construct_data *
+lp_build_flow_push(struct lp_build_flow_context *flow,
+ enum lp_build_flow_construct_kind kind)
+{
+ assert(flow->num_constructs < LP_BUILD_FLOW_MAX_DEPTH);
+ if(flow->num_constructs >= LP_BUILD_FLOW_MAX_DEPTH)
+ return NULL;
+
+ flow->constructs[flow->num_constructs].kind = kind;
+ return &flow->constructs[flow->num_constructs++].data;
+}
+
+
+static union lp_build_flow_construct_data *
+lp_build_flow_peek(struct lp_build_flow_context *flow,
+ enum lp_build_flow_construct_kind kind)
+{
+ assert(flow->num_constructs);
+ if(!flow->num_constructs)
+ return NULL;
+
+ assert(flow->constructs[flow->num_constructs - 1].kind == kind);
+ if(flow->constructs[flow->num_constructs - 1].kind != kind)
+ return NULL;
+
+ return &flow->constructs[flow->num_constructs - 1].data;
}
+static union lp_build_flow_construct_data *
+lp_build_flow_pop(struct lp_build_flow_context *flow,
+ enum lp_build_flow_construct_kind kind)
+{
+ assert(flow->num_constructs);
+ if(!flow->num_constructs)
+ return NULL;
+
+ assert(flow->constructs[flow->num_constructs - 1].kind == kind);
+ if(flow->constructs[flow->num_constructs - 1].kind != kind)
+ return NULL;
+
+ return &flow->constructs[--flow->num_constructs].data;
+}
+
+
+/**
+ * Begin a variable scope.
+ *
+ *
+ */
void
-lp_build_mask_update(struct lp_build_mask_context *mask,
- LLVMValueRef value)
+lp_build_flow_scope_begin(struct lp_build_flow_context *flow)
{
+ struct lp_build_flow_scope *scope;
- LLVMValueRef cond;
- LLVMBasicBlockRef current_block;
- LLVMBasicBlockRef next_block;
- LLVMBasicBlockRef new_block;
+ scope = &lp_build_flow_push(flow, lP_BUILD_FLOW_SCOPE)->scope;
+ if(!scope)
+ return;
- if(mask->value)
- mask->value = LLVMBuildAnd(mask->builder, mask->value, value, "");
- else
- mask->value = value;
+ scope->num_variables = 0;
+}
- /* FIXME: disabled until we have proper control flow helpers */
-#if 0
- cond = LLVMBuildICmp(mask->builder,
- LLVMIntEQ,
- LLVMBuildBitCast(mask->builder, mask->value, mask->reg_type, ""),
- LLVMConstNull(mask->reg_type),
- "");
- current_block = LLVMGetInsertBlock(mask->builder);
+/**
+ * Declare a variable.
+ *
+ * A variable is a named entity which can have different LLVMValueRef's at
+ * different points of the program. This is relevant for control flow because
+ * when there are mutiple branches to a same location we need to replace
+ * the variable's value with a Phi function as explained in
+ * http://en.wikipedia.org/wiki/Static_single_assignment_form .
+ *
+ * We keep track of variables by keeping around a pointer to where their
+ * current.
+ *
+ * There are a few cautions to observe:
+ *
+ * - Variable's value must not be NULL. If there is no initial value then
+ * LLVMGetUndef() should be used.
+ *
+ * - Variable's value must be kept up-to-date. If the variable is going to be
+ * modified by a function then a pointer should be passed so that its value
+ * is accurate. Failure to do this will cause some of the variables'
+ * transient values to be lost, leading to wrong results.
+ *
+ * - A program should be written from top to bottom, by always appending
+ * instructions to the bottom with a single LLVMBuilderRef. Inserting and/or
+ * modifying existing statements will most likely lead to wrong results.
+ *
+ */
+void
+lp_build_flow_scope_declare(struct lp_build_flow_context *flow,
+ LLVMValueRef *variable)
+{
+ struct lp_build_flow_scope *scope;
+
+ scope = &lp_build_flow_peek(flow, lP_BUILD_FLOW_SCOPE)->scope;
+ if(!scope)
+ return;
- if(!mask->skip_block) {
- LLVMValueRef function = LLVMGetBasicBlockParent(current_block);
- mask->skip_block = LLVMAppendBasicBlock(function, "skip");
+ assert(*variable);
+ if(!*variable)
+ return;
+
+ assert(flow->num_variables < LP_BUILD_FLOW_MAX_VARIABLES);
+ if(flow->num_variables >= LP_BUILD_FLOW_MAX_VARIABLES)
+ return;
+
+ flow->variables[flow->num_variables++] = variable;
+ ++scope->num_variables;
+}
+
+
+void
+lp_build_flow_scope_end(struct lp_build_flow_context *flow)
+{
+ struct lp_build_flow_scope *scope;
+
+ scope = &lp_build_flow_pop(flow, lP_BUILD_FLOW_SCOPE)->scope;
+ if(!scope)
+ return;
- mask->phi = LLVMBuildPhi(mask->builder, LLVMTypeOf(mask->value), "");
+ assert(flow->num_variables >= scope->num_variables);
+ if(flow->num_variables < scope->num_variables) {
+ flow->num_variables = 0;
+ return;
}
+ flow->num_variables -= scope->num_variables;
+}
+
+
+static LLVMBasicBlockRef
+lp_build_flow_insert_block(struct lp_build_flow_context *flow)
+{
+ LLVMBasicBlockRef current_block;
+ LLVMBasicBlockRef next_block;
+ LLVMBasicBlockRef new_block;
+
+ current_block = LLVMGetInsertBlock(flow->builder);
+
next_block = LLVMGetNextBasicBlock(current_block);
- assert(next_block);
if(next_block) {
new_block = LLVMInsertBasicBlock(next_block, "");
}
new_block = LLVMAppendBasicBlock(function, "");
}
- LLVMAddIncoming(mask->phi, &mask->value, ¤t_block, 1);
- LLVMBuildCondBr(mask->builder, cond, mask->skip_block, new_block);
+ return new_block;
+}
+
+void
+lp_build_flow_skip_begin(struct lp_build_flow_context *flow)
+{
+ struct lp_build_flow_skip *skip;
+ LLVMBuilderRef builder;
+ unsigned i;
+
+ skip = &lp_build_flow_push(flow, LP_BUILD_FLOW_SKIP)->skip;
+ if(!skip)
+ return;
+
+ skip->block = lp_build_flow_insert_block(flow);
+ skip->num_variables = flow->num_variables;
+ if(!skip->num_variables) {
+ skip->phi = NULL;
+ return;
+ }
- LLVMPositionBuilderAtEnd(mask->builder, new_block);
-#endif
+ skip->phi = MALLOC(skip->num_variables * sizeof *skip->phi);
+ if(!skip->phi) {
+ skip->num_variables = 0;
+ return;
+ }
+
+ builder = LLVMCreateBuilder();
+ LLVMPositionBuilderAtEnd(builder, skip->block);
+
+ for(i = 0; i < skip->num_variables; ++i)
+ skip->phi[i] = LLVMBuildPhi(builder, LLVMTypeOf(*flow->variables[i]), "");
+
+ LLVMDisposeBuilder(builder);
}
-LLVMValueRef
-lp_build_mask_end(struct lp_build_mask_context *mask)
+void
+lp_build_flow_skip_cond_break(struct lp_build_flow_context *flow,
+ LLVMValueRef cond)
{
- if(mask->skip_block) {
- LLVMBasicBlockRef current_block = LLVMGetInsertBlock(mask->builder);
+ struct lp_build_flow_skip *skip;
+ LLVMBasicBlockRef current_block;
+ LLVMBasicBlockRef new_block;
+ unsigned i;
- LLVMAddIncoming(mask->phi, &mask->value, ¤t_block, 1);
- LLVMBuildBr(mask->builder, mask->skip_block);
+ skip = &lp_build_flow_peek(flow, LP_BUILD_FLOW_SKIP)->skip;
+ if(!skip)
+ return;
- LLVMPositionBuilderAtEnd(mask->builder, mask->skip_block);
+ current_block = LLVMGetInsertBlock(flow->builder);
- mask->value = mask->phi;
- mask->phi = NULL;
- mask->skip_block = NULL;
+ new_block = lp_build_flow_insert_block(flow);
+
+ for(i = 0; i < skip->num_variables; ++i) {
+ assert(*flow->variables[i]);
+ LLVMAddIncoming(skip->phi[i], flow->variables[i], ¤t_block, 1);
}
+ LLVMBuildCondBr(flow->builder, cond, skip->block, new_block);
+
+ LLVMPositionBuilderAtEnd(flow->builder, new_block);
+ }
+
+
+void
+lp_build_flow_skip_end(struct lp_build_flow_context *flow)
+{
+ struct lp_build_flow_skip *skip;
+ LLVMBasicBlockRef current_block;
+ unsigned i;
+
+ skip = &lp_build_flow_pop(flow, LP_BUILD_FLOW_SKIP)->skip;
+ if(!skip)
+ return;
+
+ current_block = LLVMGetInsertBlock(flow->builder);
+
+ for(i = 0; i < skip->num_variables; ++i) {
+ assert(*flow->variables[i]);
+ LLVMAddIncoming(skip->phi[i], flow->variables[i], ¤t_block, 1);
+ *flow->variables[i] = skip->phi[i];
+ }
+
+ LLVMBuildBr(flow->builder, skip->block);
+ LLVMPositionBuilderAtEnd(flow->builder, skip->block);
+
+ FREE(skip->phi);
+}
+
+
+static void
+lp_build_mask_check(struct lp_build_mask_context *mask)
+{
+ LLVMBuilderRef builder = mask->flow->builder;
+ LLVMValueRef cond;
+
+ cond = LLVMBuildICmp(builder,
+ LLVMIntEQ,
+ LLVMBuildBitCast(builder, mask->value, mask->reg_type, ""),
+ LLVMConstNull(mask->reg_type),
+ "");
+
+ lp_build_flow_skip_cond_break(mask->flow, cond);
+}
+
+
+void
+lp_build_mask_begin(struct lp_build_mask_context *mask,
+ struct lp_build_flow_context *flow,
+ union lp_type type,
+ LLVMValueRef value)
+{
+ memset(mask, 0, sizeof *mask);
+
+ mask->flow = flow;
+ mask->reg_type = LLVMIntType(type.width * type.length);
+ mask->value = value;
+
+ lp_build_flow_scope_begin(flow);
+ lp_build_flow_scope_declare(flow, &mask->value);
+ lp_build_flow_skip_begin(flow);
+
+ lp_build_mask_check(mask);
+}
+
+
+void
+lp_build_mask_update(struct lp_build_mask_context *mask,
+ LLVMValueRef value)
+{
+ mask->value = LLVMBuildAnd( mask->flow->builder, mask->value, value, "");
+
+ lp_build_mask_check(mask);
+}
+
+
+LLVMValueRef
+lp_build_mask_end(struct lp_build_mask_context *mask)
+{
+ lp_build_flow_skip_end(mask->flow);
+ lp_build_flow_scope_end(mask->flow);
return mask->value;
}
union lp_type;
+struct lp_build_flow_context;
+
+
+struct lp_build_flow_context *
+lp_build_flow_create(LLVMBuilderRef builder);
+
+void
+lp_build_flow_destroy(struct lp_build_flow_context *flow);
+
+void
+lp_build_flow_scope_begin(struct lp_build_flow_context *flow);
+
+void
+lp_build_flow_scope_declare(struct lp_build_flow_context *flow,
+ LLVMValueRef *variable);
+
+void
+lp_build_flow_scope_end(struct lp_build_flow_context *flow);
+
+void
+lp_build_flow_skip_begin(struct lp_build_flow_context *flow);
+
+void
+lp_build_flow_skip_cond_break(struct lp_build_flow_context *flow,
+ LLVMValueRef cond);
+
+void
+lp_build_flow_skip_end(struct lp_build_flow_context *flow);
+
+
struct lp_build_mask_context
{
- LLVMBuilderRef builder;
+ struct lp_build_flow_context *flow;
LLVMTypeRef reg_type;
LLVMValueRef value;
-
- LLVMValueRef phi;
-
- LLVMBasicBlockRef skip_block;
};
void
lp_build_mask_begin(struct lp_build_mask_context *mask,
- LLVMBuilderRef builder,
+ struct lp_build_flow_context *flow,
union lp_type type,
LLVMValueRef value);
/**
* @file
- * LLVM IR building helpers interfaces.
- *
- * We use LLVM-C bindings for now. They are not documented, but follow the C++
- * interfaces very closely, and appear to be complete enough for code
- * genration. See
- * http://npcontemplation.blogspot.com/2008/06/secret-of-llvm-c-bindings.html
- * for a standalone example.
+ * Pixel format helpers.
*/
#include <llvm-c/Core.h>
-
-#include "pipe/p_format.h"
+#include "pipe/p_format.h"
+struct util_format_description;
union lp_type;
* @return RGBA in a 4 floats vector.
*/
LLVMValueRef
-lp_build_unpack_rgba(LLVMBuilderRef builder,
- enum pipe_format format,
- LLVMValueRef packed);
+lp_build_unpack_rgba_aos(LLVMBuilderRef builder,
+ enum pipe_format format,
+ LLVMValueRef packed);
/**
* @param rgba 4 float vector with the unpacked components.
*/
LLVMValueRef
-lp_build_pack_rgba(LLVMBuilderRef builder,
- enum pipe_format format,
- LLVMValueRef rgba);
+lp_build_pack_rgba_aos(LLVMBuilderRef builder,
+ enum pipe_format format,
+ LLVMValueRef rgba);
/**
* @return RGBA in a 4 floats vector.
*/
LLVMValueRef
-lp_build_load_rgba(LLVMBuilderRef builder,
- enum pipe_format format,
- LLVMValueRef ptr);
+lp_build_load_rgba_aos(LLVMBuilderRef builder,
+ enum pipe_format format,
+ LLVMValueRef ptr);
/**
* @param rgba 4 float vector with the unpacked components.
*/
void
-lp_build_store_rgba(LLVMBuilderRef builder,
- enum pipe_format format,
- LLVMValueRef ptr,
- LLVMValueRef rgba);
+lp_build_store_rgba_aos(LLVMBuilderRef builder,
+ enum pipe_format format,
+ LLVMValueRef ptr,
+ LLVMValueRef rgba);
+LLVMValueRef
+lp_build_gather(LLVMBuilderRef builder,
+ unsigned length,
+ unsigned src_width,
+ unsigned dst_width,
+ LLVMValueRef base_ptr,
+ LLVMValueRef offsets);
+
+
+void
+lp_build_unpack_rgba_soa(LLVMBuilderRef builder,
+ const struct util_format_description *format_desc,
+ union lp_type type,
+ LLVMValueRef packed,
+ LLVMValueRef *rgba);
+
+
+void
+lp_build_load_rgba_soa(LLVMBuilderRef builder,
+ const struct util_format_description *format_desc,
+ union lp_type type,
+ LLVMValueRef base_ptr,
+ LLVMValueRef offsets,
+ LLVMValueRef *rgba);
#endif /* !LP_BLD_H */
LLVMValueRef
-lp_build_unpack_rgba(LLVMBuilderRef builder,
- enum pipe_format format,
- LLVMValueRef packed)
+lp_build_unpack_rgba_aos(LLVMBuilderRef builder,
+ enum pipe_format format,
+ LLVMValueRef packed)
{
const struct util_format_description *desc;
LLVMTypeRef type;
LLVMValueRef
-lp_build_pack_rgba(LLVMBuilderRef builder,
- enum pipe_format format,
- LLVMValueRef rgba)
+lp_build_pack_rgba_aos(LLVMBuilderRef builder,
+ enum pipe_format format,
+ LLVMValueRef rgba)
{
const struct util_format_description *desc;
LLVMTypeRef type;
LLVMValueRef
-lp_build_load_rgba(LLVMBuilderRef builder,
- enum pipe_format format,
- LLVMValueRef ptr)
+lp_build_load_rgba_aos(LLVMBuilderRef builder,
+ enum pipe_format format,
+ LLVMValueRef ptr)
{
const struct util_format_description *desc;
LLVMTypeRef type;
packed = LLVMBuildLoad(builder, ptr, "");
- return lp_build_unpack_rgba(builder, format, packed);
+ return lp_build_unpack_rgba_aos(builder, format, packed);
}
void
-lp_build_store_rgba(LLVMBuilderRef builder,
- enum pipe_format format,
- LLVMValueRef ptr,
- LLVMValueRef rgba)
+lp_build_store_rgba_aos(LLVMBuilderRef builder,
+ enum pipe_format format,
+ LLVMValueRef ptr,
+ LLVMValueRef rgba)
{
const struct util_format_description *desc;
LLVMTypeRef type;
type = LLVMIntType(desc->block.bits);
- packed = lp_build_pack_rgba(builder, format, rgba);
+ packed = lp_build_pack_rgba_aos(builder, format, rgba);
ptr = LLVMBuildBitCast(builder, ptr, LLVMPointerType(type, 0), "");
--- /dev/null
+/**************************************************************************
+ *
+ * Copyright 2009 VMware, Inc.
+ * All Rights Reserved.
+ *
+ * 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, sub license, 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 (including the
+ * next paragraph) 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 NON-INFRINGEMENT.
+ * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS 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.
+ *
+ **************************************************************************/
+
+
+#include "util/u_format.h"
+
+#include "lp_bld_type.h"
+#include "lp_bld_const.h"
+#include "lp_bld_conv.h"
+#include "lp_bld_format.h"
+
+
+/**
+ * Gather elements from scatter positions in memory into a single vector.
+ *
+ * @param src_width src element width
+ * @param dst_width result element width (source will be expanded to fit)
+ * @param length length of the offsets,
+ * @param base_ptr base pointer, should be a i8 pointer type.
+ * @param offsets vector with offsets
+ */
+LLVMValueRef
+lp_build_gather(LLVMBuilderRef builder,
+ unsigned length,
+ unsigned src_width,
+ unsigned dst_width,
+ LLVMValueRef base_ptr,
+ LLVMValueRef offsets)
+{
+ LLVMTypeRef src_type = LLVMIntType(src_width);
+ LLVMTypeRef src_ptr_type = LLVMPointerType(src_type, 0);
+ LLVMTypeRef dst_elem_type = LLVMIntType(dst_width);
+ LLVMTypeRef dst_vec_type = LLVMVectorType(dst_elem_type, length);
+ LLVMValueRef res;
+ unsigned i;
+
+ res = LLVMGetUndef(dst_vec_type);
+ for(i = 0; i < length; ++i) {
+ LLVMValueRef index = LLVMConstInt(LLVMInt32Type(), i, 0);
+ LLVMValueRef elem_offset;
+ LLVMValueRef elem_ptr;
+ LLVMValueRef elem;
+
+ elem_offset = LLVMBuildExtractElement(builder, offsets, index, "");
+ elem_ptr = LLVMBuildGEP(builder, base_ptr, &elem_offset, 1, "");
+ elem_ptr = LLVMBuildBitCast(builder, elem_ptr, src_ptr_type, "");
+ elem = LLVMBuildLoad(builder, elem_ptr, "");
+
+ assert(src_width <= dst_width);
+ if(src_width > dst_width)
+ elem = LLVMBuildTrunc(builder, elem, dst_elem_type, "");
+ if(src_width < dst_width)
+ elem = LLVMBuildZExt(builder, elem, dst_elem_type, "");
+
+ res = LLVMBuildInsertElement(builder, res, elem, index, "");
+ }
+
+ return res;
+}
+
+
+static LLVMValueRef
+lp_build_format_swizzle(union lp_type type,
+ const LLVMValueRef *inputs,
+ enum util_format_swizzle swizzle)
+{
+ switch (swizzle) {
+ case UTIL_FORMAT_SWIZZLE_X:
+ case UTIL_FORMAT_SWIZZLE_Y:
+ case UTIL_FORMAT_SWIZZLE_Z:
+ case UTIL_FORMAT_SWIZZLE_W:
+ return inputs[swizzle];
+ case UTIL_FORMAT_SWIZZLE_0:
+ return lp_build_zero(type);
+ case UTIL_FORMAT_SWIZZLE_1:
+ return lp_build_one(type);
+ case UTIL_FORMAT_SWIZZLE_NONE:
+ return lp_build_undef(type);
+ default:
+ assert(0);
+ return lp_build_undef(type);
+ }
+}
+
+
+void
+lp_build_unpack_rgba_soa(LLVMBuilderRef builder,
+ const struct util_format_description *format_desc,
+ union lp_type type,
+ LLVMValueRef packed,
+ LLVMValueRef *rgba)
+{
+ LLVMValueRef inputs[4];
+ unsigned start;
+ unsigned chan;
+
+ /* FIXME: Support more formats */
+ assert(format_desc->layout == UTIL_FORMAT_LAYOUT_ARITH);
+ assert(format_desc->block.width == 1);
+ assert(format_desc->block.height == 1);
+ assert(format_desc->block.bits <= 32);
+
+ /* Decode the input vector components */
+ start = 0;
+ for (chan = 0; chan < 4; ++chan) {
+ unsigned width = format_desc->channel[chan].size;
+ unsigned stop = start + width;
+ LLVMValueRef input;
+
+ input = packed;
+
+ switch(format_desc->channel[chan].type) {
+ case UTIL_FORMAT_TYPE_VOID:
+ input = NULL;
+ break;
+
+ case UTIL_FORMAT_TYPE_UNSIGNED:
+ if(type.floating) {
+ if(start)
+ input = LLVMBuildLShr(builder, input, lp_build_int_const_scalar(type, start), "");
+ if(stop < format_desc->block.bits) {
+ unsigned mask = ((unsigned long long)1 << width) - 1;
+ input = LLVMBuildAnd(builder, input, lp_build_int_const_scalar(type, mask), "");
+ }
+
+ if(format_desc->channel[chan].normalized)
+ input = lp_build_unsigned_norm_to_float(builder, width, type, input);
+ else
+ input = LLVMBuildFPToSI(builder, input, lp_build_vec_type(type), "");
+ }
+ else {
+ /* FIXME */
+ assert(0);
+ input = lp_build_undef(type);
+ }
+ break;
+
+ default:
+ /* fall through */
+ input = lp_build_undef(type);
+ break;
+ }
+
+ inputs[chan] = input;
+
+ start = stop;
+ }
+
+ if(format_desc->colorspace == UTIL_FORMAT_COLORSPACE_ZS) {
+ enum util_format_swizzle swizzle = format_desc->swizzle[0];
+ LLVMValueRef depth = lp_build_format_swizzle(type, inputs, swizzle);
+ rgba[2] = rgba[1] = rgba[0] = depth;
+ rgba[3] = lp_build_one(type);
+ }
+ else {
+ for (chan = 0; chan < 4; ++chan) {
+ enum util_format_swizzle swizzle = format_desc->swizzle[chan];
+ rgba[chan] = lp_build_format_swizzle(type, inputs, swizzle);
+ }
+ }
+}
+
+
+void
+lp_build_load_rgba_soa(LLVMBuilderRef builder,
+ const struct util_format_description *format_desc,
+ union lp_type type,
+ LLVMValueRef base_ptr,
+ LLVMValueRef offsets,
+ LLVMValueRef *rgba)
+{
+ LLVMValueRef packed;
+
+ assert(format_desc->layout == UTIL_FORMAT_LAYOUT_ARITH);
+ assert(format_desc->block.width == 1);
+ assert(format_desc->block.height == 1);
+ assert(format_desc->block.bits <= 32);
+
+ packed = lp_build_gather(builder,
+ type.length, format_desc->block.bits, type.width,
+ base_ptr, offsets);
+
+ lp_build_unpack_rgba_soa(builder, format_desc, type, packed, rgba);
+}
b = LLVMBuildBitCast(bld->builder, b, int_vec_type, "");
}
- /* TODO: On SSE4 we could do this with a single instruction -- PBLENDVB */
-
a = LLVMBuildAnd(bld->builder, a, mask, "");
/* This often gets translated to PANDN, but sometimes the NOT is
lp_build_select_aos(struct lp_build_context *bld,
LLVMValueRef a,
LLVMValueRef b,
- boolean cond[4])
+ const boolean cond[4])
{
const union lp_type type = bld->type;
const unsigned n = type.length;
return LLVMBuildShuffleVector(bld->builder, a, b, LLVMConstVector(shuffles, n), "");
}
+ else {
#if 0
- else if(0) {
- /* FIXME: Unfortunately select of vectors do not work */
+ /* XXX: Unfortunately select of vectors do not work */
/* Use a select */
LLVMTypeRef elem_type = LLVMInt1Type();
LLVMValueRef cond[LP_MAX_VECTOR_LENGTH];
cond[j + i] = LLVMConstInt(elem_type, cond[i] ? 1 : 0, 0);
return LLVMBuildSelect(bld->builder, LLVMConstVector(cond, n), a, b, "");
- }
-#endif
- else {
+#else
LLVMValueRef mask = lp_build_const_mask_aos(type, cond);
return lp_build_select(bld, mask, a, b);
+#endif
}
}
lp_build_select_aos(struct lp_build_context *bld,
LLVMValueRef a,
LLVMValueRef b,
- boolean cond[4]);
+ const boolean cond[4]);
#endif /* !LP_BLD_LOGIC_H */
--- /dev/null
+/**************************************************************************
+ *
+ * Copyright 2009 VMware, Inc.
+ * All Rights Reserved.
+ *
+ * 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, sub license, 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 (including the
+ * next paragraph) 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 NON-INFRINGEMENT.
+ * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS 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.
+ *
+ **************************************************************************/
+
+/**
+ * @file
+ * Texture sampling.
+ *
+ * @author Jose Fonseca <jfonseca@vmware.com>
+ */
+
+#ifndef LP_BLD_SAMPLE_H
+#define LP_BLD_SAMPLE_H
+
+
+#include <llvm-c/Core.h>
+
+struct pipe_texture;
+struct pipe_sampler_state;
+union lp_type;
+
+
+/**
+ * Sampler static state.
+ *
+ * These are the bits of state from pipe_texture and pipe_sampler_state that
+ * are embedded in the generated code.
+ */
+struct lp_sampler_static_state
+{
+ /* pipe_texture's state */
+ enum pipe_format format;
+ unsigned target:2;
+ unsigned pot_width:1;
+ unsigned pot_height:1;
+ unsigned pot_depth:1;
+
+ /* pipe_sampler_state's state */
+ unsigned wrap_s:3;
+ unsigned wrap_t:3;
+ unsigned wrap_r:3;
+ unsigned min_img_filter:2;
+ unsigned min_mip_filter:2;
+ unsigned mag_img_filter:2;
+ unsigned compare_mode:1;
+ unsigned compare_func:3;
+ unsigned normalized_coords:1;
+ unsigned prefilter:4;
+};
+
+
+/**
+ * Sampler dynamic state.
+ *
+ * These are the bits of state from pipe_texture and pipe_sampler_state that
+ * are computed in runtime.
+ *
+ * There are obtained through callbacks, as we don't want to tie the texture
+ * sampling code generation logic to any particular texture layout or pipe
+ * driver.
+ */
+struct lp_sampler_dynamic_state
+{
+
+ /** Obtain the base texture width. */
+ LLVMValueRef
+ (*width)( struct lp_sampler_dynamic_state *state,
+ LLVMBuilderRef builder,
+ unsigned unit);
+
+ /** Obtain the base texture height. */
+ LLVMValueRef
+ (*height)( struct lp_sampler_dynamic_state *state,
+ LLVMBuilderRef builder,
+ unsigned unit);
+
+ LLVMValueRef
+ (*stride)( struct lp_sampler_dynamic_state *state,
+ LLVMBuilderRef builder,
+ unsigned unit);
+
+ LLVMValueRef
+ (*data_ptr)( struct lp_sampler_dynamic_state *state,
+ LLVMBuilderRef builder,
+ unsigned unit);
+
+};
+
+
+/**
+ * Derive the sampler static state.
+ */
+void
+lp_sampler_static_state(struct lp_sampler_static_state *state,
+ const struct pipe_texture *texture,
+ const struct pipe_sampler_state *sampler);
+
+
+void
+lp_build_sample_soa(LLVMBuilderRef builder,
+ const struct lp_sampler_static_state *static_state,
+ struct lp_sampler_dynamic_state *dynamic_state,
+ union lp_type fp_type,
+ unsigned unit,
+ unsigned num_coords,
+ const LLVMValueRef *coords,
+ LLVMValueRef lodbias,
+ LLVMValueRef *texel);
+
+
+
+#endif /* LP_BLD_SAMPLE_H */
--- /dev/null
+/**************************************************************************
+ *
+ * Copyright 2009 VMware, Inc.
+ * All Rights Reserved.
+ *
+ * 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, sub license, 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 (including the
+ * next paragraph) 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 NON-INFRINGEMENT.
+ * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS 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.
+ *
+ **************************************************************************/
+
+/**
+ * @file
+ * Texture sampling.
+ *
+ * @author Jose Fonseca <jfonseca@vmware.com>
+ */
+
+#include "pipe/p_defines.h"
+#include "pipe/p_state.h"
+#include "util/u_debug.h"
+#include "util/u_memory.h"
+#include "util/u_math.h"
+#include "util/u_format.h"
+#include "lp_bld_debug.h"
+#include "lp_bld_type.h"
+#include "lp_bld_const.h"
+#include "lp_bld_arit.h"
+#include "lp_bld_logic.h"
+#include "lp_bld_swizzle.h"
+#include "lp_bld_format.h"
+#include "lp_bld_sample.h"
+
+
+void
+lp_sampler_static_state(struct lp_sampler_static_state *state,
+ const struct pipe_texture *texture,
+ const struct pipe_sampler_state *sampler)
+{
+ memset(state, 0, sizeof *state);
+
+ if(!texture)
+ return;
+
+ if(!sampler)
+ return;
+
+ state->format = texture->format;
+ state->target = texture->target;
+ state->pot_width = util_is_pot(texture->width[0]);
+ state->pot_height = util_is_pot(texture->height[0]);
+ state->pot_depth = util_is_pot(texture->depth[0]);
+
+ state->wrap_s = sampler->wrap_s;
+ state->wrap_t = sampler->wrap_t;
+ state->wrap_r = sampler->wrap_r;
+ state->min_img_filter = sampler->min_img_filter;
+ state->min_mip_filter = sampler->min_mip_filter;
+ state->mag_img_filter = sampler->mag_img_filter;
+ if(sampler->compare_mode) {
+ state->compare_mode = sampler->compare_mode;
+ state->compare_func = sampler->compare_func;
+ }
+ state->normalized_coords = sampler->normalized_coords;
+ state->prefilter = sampler->prefilter;
+}
+
+
+
+/**
+ * Keep all information for sampling code generation in a single place.
+ */
+struct lp_build_sample_context
+{
+ LLVMBuilderRef builder;
+
+ const struct lp_sampler_static_state *static_state;
+
+ struct lp_sampler_dynamic_state *dynamic_state;
+
+ const struct util_format_description *format_desc;
+
+ /** Incoming coordinates type and build context */
+ union lp_type coord_type;
+ struct lp_build_context coord_bld;
+
+ /** Integer coordinates */
+ union lp_type int_coord_type;
+ struct lp_build_context int_coord_bld;
+
+ /** Output texels type and build context */
+ union lp_type texel_type;
+ struct lp_build_context texel_bld;
+};
+
+
+static void
+lp_build_sample_texel(struct lp_build_sample_context *bld,
+ LLVMValueRef x,
+ LLVMValueRef y,
+ LLVMValueRef y_stride,
+ LLVMValueRef data_ptr,
+ LLVMValueRef *texel)
+{
+ struct lp_build_context *int_coord_bld = &bld->int_coord_bld;
+ LLVMValueRef x_stride;
+ LLVMValueRef offset;
+
+ x_stride = lp_build_const_scalar(bld->int_coord_type, bld->format_desc->block.bits/8);
+
+ if(bld->format_desc->colorspace == UTIL_FORMAT_COLORSPACE_ZS) {
+ LLVMValueRef x_lo, x_hi;
+ LLVMValueRef y_lo, y_hi;
+ LLVMValueRef x_stride_lo, x_stride_hi;
+ LLVMValueRef y_stride_lo, y_stride_hi;
+ LLVMValueRef x_offset_lo, x_offset_hi;
+ LLVMValueRef y_offset_lo, y_offset_hi;
+ LLVMValueRef offset_lo, offset_hi;
+
+ x_lo = LLVMBuildAnd(bld->builder, x, int_coord_bld->one, "");
+ y_lo = LLVMBuildAnd(bld->builder, y, int_coord_bld->one, "");
+
+ x_hi = LLVMBuildLShr(bld->builder, x, int_coord_bld->one, "");
+ y_hi = LLVMBuildLShr(bld->builder, y, int_coord_bld->one, "");
+
+ x_stride_lo = x_stride;
+ y_stride_lo = lp_build_const_scalar(bld->int_coord_type, 2*bld->format_desc->block.bits/8);
+
+ x_stride_hi = lp_build_const_scalar(bld->int_coord_type, 4*bld->format_desc->block.bits/8);
+ y_stride_hi = LLVMBuildShl(bld->builder, y_stride, int_coord_bld->one, "");
+
+ x_offset_lo = lp_build_mul(int_coord_bld, x_lo, x_stride_lo);
+ y_offset_lo = lp_build_mul(int_coord_bld, y_lo, y_stride_lo);
+ offset_lo = lp_build_add(int_coord_bld, x_offset_lo, y_offset_lo);
+
+ x_offset_hi = lp_build_mul(int_coord_bld, x_hi, x_stride_hi);
+ y_offset_hi = lp_build_mul(int_coord_bld, y_hi, y_stride_hi);
+ offset_hi = lp_build_add(int_coord_bld, x_offset_hi, y_offset_hi);
+
+ offset = lp_build_add(int_coord_bld, offset_hi, offset_lo);
+ }
+ else {
+ LLVMValueRef x_offset;
+ LLVMValueRef y_offset;
+
+ x_offset = lp_build_mul(int_coord_bld, x, x_stride);
+ y_offset = lp_build_mul(int_coord_bld, y, y_stride);
+
+ offset = lp_build_add(int_coord_bld, x_offset, y_offset);
+ }
+
+ lp_build_load_rgba_soa(bld->builder,
+ bld->format_desc,
+ bld->texel_type,
+ data_ptr,
+ offset,
+ texel);
+}
+
+
+static LLVMValueRef
+lp_build_sample_wrap(struct lp_build_sample_context *bld,
+ LLVMValueRef coord,
+ LLVMValueRef length,
+ boolean is_pot,
+ unsigned wrap_mode)
+{
+ struct lp_build_context *int_coord_bld = &bld->int_coord_bld;
+ LLVMValueRef length_minus_one;
+
+ length_minus_one = lp_build_sub(int_coord_bld, length, int_coord_bld->one);
+
+ switch(wrap_mode) {
+ case PIPE_TEX_WRAP_REPEAT:
+ if(is_pot)
+ coord = LLVMBuildAnd(bld->builder, coord, length_minus_one, "");
+ else
+ /* Signed remainder won't give the right results for negative
+ * dividends but unsigned remainder does.*/
+ coord = LLVMBuildURem(bld->builder, coord, length, "");
+ break;
+
+ case PIPE_TEX_WRAP_CLAMP:
+ coord = lp_build_max(int_coord_bld, coord, int_coord_bld->zero);
+ coord = lp_build_min(int_coord_bld, coord, length_minus_one);
+ break;
+
+ case PIPE_TEX_WRAP_CLAMP_TO_EDGE:
+ case PIPE_TEX_WRAP_CLAMP_TO_BORDER:
+ case PIPE_TEX_WRAP_MIRROR_REPEAT:
+ case PIPE_TEX_WRAP_MIRROR_CLAMP:
+ case PIPE_TEX_WRAP_MIRROR_CLAMP_TO_EDGE:
+ case PIPE_TEX_WRAP_MIRROR_CLAMP_TO_BORDER:
+ /* FIXME */
+ default:
+ assert(0);
+ }
+
+ return coord;
+}
+
+
+static void
+lp_build_sample_2d_nearest_soa(struct lp_build_sample_context *bld,
+ LLVMValueRef s,
+ LLVMValueRef t,
+ LLVMValueRef width,
+ LLVMValueRef height,
+ LLVMValueRef stride,
+ LLVMValueRef data_ptr,
+ LLVMValueRef *texel)
+{
+ LLVMValueRef x;
+ LLVMValueRef y;
+
+ x = lp_build_ifloor(&bld->coord_bld, s);
+ y = lp_build_ifloor(&bld->coord_bld, t);
+
+ x = lp_build_sample_wrap(bld, x, width, bld->static_state->pot_width, bld->static_state->wrap_s);
+ y = lp_build_sample_wrap(bld, y, height, bld->static_state->pot_height, bld->static_state->wrap_t);
+
+ lp_build_sample_texel(bld, x, y, stride, data_ptr, texel);
+}
+
+
+static void
+lp_build_sample_2d_linear_soa(struct lp_build_sample_context *bld,
+ LLVMValueRef s,
+ LLVMValueRef t,
+ LLVMValueRef width,
+ LLVMValueRef height,
+ LLVMValueRef stride,
+ LLVMValueRef data_ptr,
+ LLVMValueRef *texel)
+{
+ LLVMValueRef half;
+ LLVMValueRef s_ipart;
+ LLVMValueRef t_ipart;
+ LLVMValueRef s_fpart;
+ LLVMValueRef t_fpart;
+ LLVMValueRef x0, x1;
+ LLVMValueRef y0, y1;
+ LLVMValueRef neighbors[2][2][4];
+ unsigned chan;
+
+ half = lp_build_const_scalar(bld->coord_type, 0.5);
+ s = lp_build_sub(&bld->coord_bld, s, half);
+ t = lp_build_sub(&bld->coord_bld, t, half);
+
+ s_ipart = lp_build_floor(&bld->coord_bld, s);
+ t_ipart = lp_build_floor(&bld->coord_bld, t);
+
+ s_fpart = lp_build_sub(&bld->coord_bld, s, s_ipart);
+ t_fpart = lp_build_sub(&bld->coord_bld, t, t_ipart);
+
+ x0 = lp_build_int(&bld->coord_bld, s_ipart);
+ y0 = lp_build_int(&bld->coord_bld, t_ipart);
+
+ x0 = lp_build_sample_wrap(bld, x0, width, bld->static_state->pot_width, bld->static_state->wrap_s);
+ y0 = lp_build_sample_wrap(bld, y0, height, bld->static_state->pot_height, bld->static_state->wrap_t);
+
+ x1 = lp_build_add(&bld->int_coord_bld, x0, bld->int_coord_bld.one);
+ y1 = lp_build_add(&bld->int_coord_bld, y0, bld->int_coord_bld.one);
+
+ x1 = lp_build_sample_wrap(bld, x1, width, bld->static_state->pot_width, bld->static_state->wrap_s);
+ y1 = lp_build_sample_wrap(bld, y1, height, bld->static_state->pot_height, bld->static_state->wrap_t);
+
+ lp_build_sample_texel(bld, x0, y0, stride, data_ptr, neighbors[0][0]);
+ lp_build_sample_texel(bld, x1, y0, stride, data_ptr, neighbors[0][1]);
+ lp_build_sample_texel(bld, x0, y1, stride, data_ptr, neighbors[1][0]);
+ lp_build_sample_texel(bld, x1, y1, stride, data_ptr, neighbors[1][1]);
+
+ /* TODO: Don't interpolate missing channels */
+ for(chan = 0; chan < 4; ++chan) {
+ texel[chan] = lp_build_lerp_2d(&bld->texel_bld,
+ s_fpart, t_fpart,
+ neighbors[0][0][chan],
+ neighbors[0][1][chan],
+ neighbors[1][0][chan],
+ neighbors[1][1][chan]);
+ }
+}
+
+
+static void
+lp_build_sample_compare(struct lp_build_sample_context *bld,
+ LLVMValueRef p,
+ LLVMValueRef *texel)
+{
+ struct lp_build_context *texel_bld = &bld->texel_bld;
+ LLVMValueRef res;
+ unsigned chan;
+
+ if(!bld->static_state->compare_mode)
+ return;
+
+ /* TODO: Compare before swizzling, to avoid redundant computations */
+ res = NULL;
+ for(chan = 0; chan < 4; ++chan) {
+ LLVMValueRef cmp;
+ cmp = lp_build_cmp(texel_bld, bld->static_state->compare_func, p, texel[chan]);
+ cmp = lp_build_select(texel_bld, cmp, texel_bld->one, texel_bld->zero);
+
+ if(res)
+ res = lp_build_add(texel_bld, res, cmp);
+ else
+ res = cmp;
+ }
+
+ assert(res);
+ res = lp_build_mul(texel_bld, res, lp_build_const_scalar(texel_bld->type, 0.25));
+
+ /* XXX returning result for default GL_DEPTH_TEXTURE_MODE = GL_LUMINANCE */
+ for(chan = 0; chan < 3; ++chan)
+ texel[chan] = res;
+ texel[3] = texel_bld->one;
+}
+
+
+void
+lp_build_sample_soa(LLVMBuilderRef builder,
+ const struct lp_sampler_static_state *static_state,
+ struct lp_sampler_dynamic_state *dynamic_state,
+ union lp_type type,
+ unsigned unit,
+ unsigned num_coords,
+ const LLVMValueRef *coords,
+ LLVMValueRef lodbias,
+ LLVMValueRef *texel)
+{
+ struct lp_build_sample_context bld;
+ LLVMValueRef width;
+ LLVMValueRef height;
+ LLVMValueRef stride;
+ LLVMValueRef data_ptr;
+ LLVMValueRef s;
+ LLVMValueRef t;
+ LLVMValueRef p;
+
+ /* Setup our build context */
+ memset(&bld, 0, sizeof bld);
+ bld.builder = builder;
+ bld.static_state = static_state;
+ bld.dynamic_state = dynamic_state;
+ bld.format_desc = util_format_description(static_state->format);
+ bld.coord_type = type;
+ bld.int_coord_type = lp_int_type(type);
+ bld.texel_type = type;
+ lp_build_context_init(&bld.coord_bld, builder, bld.coord_type);
+ lp_build_context_init(&bld.int_coord_bld, builder, bld.int_coord_type);
+ lp_build_context_init(&bld.texel_bld, builder, bld.texel_type);
+
+ /* Get the dynamic state */
+ width = dynamic_state->width(dynamic_state, builder, unit);
+ height = dynamic_state->height(dynamic_state, builder, unit);
+ stride = dynamic_state->stride(dynamic_state, builder, unit);
+ data_ptr = dynamic_state->data_ptr(dynamic_state, builder, unit);
+
+ s = coords[0];
+ t = coords[1];
+ p = coords[2];
+
+ width = lp_build_broadcast_scalar(&bld.int_coord_bld, width);
+ height = lp_build_broadcast_scalar(&bld.int_coord_bld, height);
+ stride = lp_build_broadcast_scalar(&bld.int_coord_bld, stride);
+
+ if(static_state->target == PIPE_TEXTURE_1D)
+ t = bld.coord_bld.zero;
+
+ if(static_state->normalized_coords) {
+ LLVMTypeRef coord_vec_type = lp_build_vec_type(bld.coord_type);
+ LLVMValueRef fp_width = LLVMBuildSIToFP(builder, width, coord_vec_type, "");
+ LLVMValueRef fp_height = LLVMBuildSIToFP(builder, height, coord_vec_type, "");
+ s = lp_build_mul(&bld.coord_bld, s, fp_width);
+ t = lp_build_mul(&bld.coord_bld, t, fp_height);
+ }
+
+ switch (static_state->min_img_filter) {
+ case PIPE_TEX_FILTER_NEAREST:
+ lp_build_sample_2d_nearest_soa(&bld, s, t, width, height, stride, data_ptr, texel);
+ break;
+ case PIPE_TEX_FILTER_LINEAR:
+ case PIPE_TEX_FILTER_ANISO:
+ lp_build_sample_2d_linear_soa(&bld, s, t, width, height, stride, data_ptr, texel);
+ break;
+ default:
+ assert(0);
+ }
+
+ /* FIXME: respect static_state->min_mip_filter */;
+ /* FIXME: respect static_state->mag_img_filter */;
+ /* FIXME: respect static_state->prefilter */;
+
+ lp_build_sample_compare(&bld, p, texel);
+}
#include "lp_bld_struct.h"
+LLVMValueRef
+lp_build_struct_get_ptr(LLVMBuilderRef builder,
+ LLVMValueRef ptr,
+ unsigned member,
+ const char *name)
+{
+ LLVMValueRef indices[2];
+ LLVMValueRef member_ptr;
+ indices[0] = LLVMConstInt(LLVMInt32Type(), 0, 0);
+ indices[1] = LLVMConstInt(LLVMInt32Type(), member, 0);
+ member_ptr = LLVMBuildGEP(builder, ptr, indices, Elements(indices), "");
+ lp_build_name(member_ptr, "%s.%s_ptr", LLVMGetValueName(ptr), name);
+ return member_ptr;
+}
+
+
LLVMValueRef
lp_build_struct_get(LLVMBuilderRef builder,
LLVMValueRef ptr,
unsigned member,
const char *name)
{
- LLVMValueRef indices[2];
LLVMValueRef member_ptr;
LLVMValueRef res;
- indices[0] = LLVMConstInt(LLVMInt32Type(), 0, 0);
- indices[1] = LLVMConstInt(LLVMInt32Type(), member, 0);
- member_ptr = LLVMBuildGEP(builder, ptr, indices, Elements(indices), "");
+ member_ptr = lp_build_struct_get_ptr(builder, ptr, member, name);
res = LLVMBuildLoad(builder, member_ptr, "");
lp_build_name(res, "%s.%s", LLVMGetValueName(ptr), name);
return res;
offsetof(_ctype, _cmember))
+/**
+ * Get value pointer to a structure member.
+ */
+LLVMValueRef
+lp_build_struct_get_ptr(LLVMBuilderRef builder,
+ LLVMValueRef ptr,
+ unsigned member,
+ const char *name);
+
+/**
+ * Get the value of a structure member.
+ */
LLVMValueRef
lp_build_struct_get(LLVMBuilderRef builder,
LLVMValueRef ptr,
LLVMValueRef
lp_build_swizzle1_aos(struct lp_build_context *bld,
LLVMValueRef a,
- unsigned char swizzle[4])
+ const unsigned char swizzle[4])
{
const unsigned n = bld->type.length;
unsigned i, j;
lp_build_swizzle2_aos(struct lp_build_context *bld,
LLVMValueRef a,
LLVMValueRef b,
- unsigned char swizzle[4])
+ const unsigned char swizzle[4])
{
const unsigned n = bld->type.length;
unsigned i, j;
return lp_build_swizzle1_aos(bld, a, swizzle);
if(a == b) {
- swizzle[0] %= 4;
- swizzle[1] %= 4;
- swizzle[2] %= 4;
- swizzle[3] %= 4;
- return lp_build_swizzle1_aos(bld, a, swizzle);
+ unsigned char swizzle1[4];
+ swizzle1[0] = swizzle[0] % 4;
+ swizzle1[1] = swizzle[1] % 4;
+ swizzle1[2] = swizzle[2] % 4;
+ swizzle1[3] = swizzle[3] % 4;
+ return lp_build_swizzle1_aos(bld, a, swizzle1);
}
if(swizzle[0] % 4 == 0 &&
LLVMValueRef
lp_build_swizzle1_aos(struct lp_build_context *bld,
LLVMValueRef a,
- unsigned char swizzle[4]);
+ const unsigned char swizzle[4]);
/**
lp_build_swizzle2_aos(struct lp_build_context *bld,
LLVMValueRef a,
LLVMValueRef b,
- unsigned char swizzle[4]);
+ const unsigned char swizzle[4]);
#endif /* !LP_BLD_SWIZZLE_H */
struct lp_build_mask_context;
-typedef void
-(*lp_emit_fetch_texel_soa_callback)( LLVMBuilderRef builder,
- void *context,
- unsigned unit,
- unsigned num_coords,
- const LLVMValueRef *coords,
- LLVMValueRef lodbias,
- LLVMValueRef *texel);
+/**
+ * Sampler code generation interface.
+ *
+ * Although texture sampling is a requirement for TGSI translation, it is
+ * a very different problem with several different approaches to it. This
+ * structure establishes an interface for texture sampling code generation, so
+ * that we can easily use different texture sampling strategies.
+ */
+struct lp_build_sampler_soa
+{
+ void
+ (*destroy)( struct lp_build_sampler_soa *sampler );
+
+ void
+ (*emit_fetch_texel)( struct lp_build_sampler_soa *sampler,
+ LLVMBuilderRef builder,
+ union lp_type type,
+ unsigned unit,
+ unsigned num_coords,
+ const LLVMValueRef *coords,
+ LLVMValueRef lodbias,
+ LLVMValueRef *texel);
+};
+
void
lp_build_tgsi_soa(LLVMBuilderRef builder,
const LLVMValueRef *pos,
const LLVMValueRef (*inputs)[4],
LLVMValueRef (*outputs)[4],
- lp_emit_fetch_texel_soa_callback emit_fetch_texel,
- void *emit_fetch_texel_context);
+ struct lp_build_sampler_soa *sampler);
#endif /* LP_BLD_TGSI_H */
#define CHAN_Z 2
#define CHAN_W 3
+#define QUAD_TOP_LEFT 0
+#define QUAD_TOP_RIGHT 1
+#define QUAD_BOTTOM_LEFT 2
+#define QUAD_BOTTOM_RIGHT 3
+
struct lp_build_tgsi_soa_context
{
const LLVMValueRef (*inputs)[NUM_CHANNELS];
LLVMValueRef (*outputs)[NUM_CHANNELS];
- lp_emit_fetch_texel_soa_callback emit_fetch_texel;
- void *emit_fetch_texel_context;
+ struct lp_build_sampler_soa *sampler;
LLVMValueRef immediates[LP_MAX_IMMEDIATES][NUM_CHANNELS];
LLVMValueRef temps[LP_MAX_TEMPS][NUM_CHANNELS];
};
+static const unsigned char
+swizzle_left[4] = {
+ QUAD_TOP_LEFT, QUAD_TOP_LEFT,
+ QUAD_BOTTOM_LEFT, QUAD_BOTTOM_LEFT
+};
+
+static const unsigned char
+swizzle_right[4] = {
+ QUAD_TOP_RIGHT, QUAD_TOP_RIGHT,
+ QUAD_BOTTOM_RIGHT, QUAD_BOTTOM_RIGHT
+};
+
+static const unsigned char
+swizzle_top[4] = {
+ QUAD_TOP_LEFT, QUAD_TOP_RIGHT,
+ QUAD_TOP_LEFT, QUAD_TOP_RIGHT
+};
+
+static const unsigned char
+swizzle_bottom[4] = {
+ QUAD_BOTTOM_LEFT, QUAD_BOTTOM_RIGHT,
+ QUAD_BOTTOM_LEFT, QUAD_BOTTOM_RIGHT
+};
+
+
+static LLVMValueRef
+emit_ddx(struct lp_build_tgsi_soa_context *bld,
+ LLVMValueRef src)
+{
+ LLVMValueRef src_left = lp_build_swizzle1_aos(&bld->base, src, swizzle_left);
+ LLVMValueRef src_right = lp_build_swizzle1_aos(&bld->base, src, swizzle_right);
+ return lp_build_sub(&bld->base, src_right, src_left);
+}
+
+
+static LLVMValueRef
+emit_ddy(struct lp_build_tgsi_soa_context *bld,
+ LLVMValueRef src)
+{
+ LLVMValueRef src_top = lp_build_swizzle1_aos(&bld->base, src, swizzle_top);
+ LLVMValueRef src_bottom = lp_build_swizzle1_aos(&bld->base, src, swizzle_bottom);
+ return lp_build_sub(&bld->base, src_top, src_bottom);
+}
+
+
/**
* Register fetch.
*/
break;
case TGSI_UTIL_SIGN_SET:
+ /* TODO: Use bitwese OR for floating point */
res = lp_build_abs( &bld->base, res );
res = LLVMBuildNeg( bld->base.builder, res, "" );
break;
}
+/**
+ * Register fetch with derivatives.
+ */
+static void
+emit_fetch_deriv(
+ struct lp_build_tgsi_soa_context *bld,
+ const struct tgsi_full_instruction *inst,
+ unsigned index,
+ const unsigned chan_index,
+ LLVMValueRef *res,
+ LLVMValueRef *ddx,
+ LLVMValueRef *ddy)
+{
+ LLVMValueRef src;
+
+ src = emit_fetch(bld, inst, index, chan_index);
+
+ if(res)
+ *res = src;
+
+ /* TODO: use interpolation coeffs for inputs */
+
+ if(ddx)
+ *ddx = emit_ddx(bld, src);
+
+ if(ddy)
+ *ddy = emit_ddy(bld, src);
+}
+
+
/**
* Register store.
*/
* High-level instruction translators.
*/
+
static void
emit_tex( struct lp_build_tgsi_soa_context *bld,
const struct tgsi_full_instruction *inst,
boolean apply_lodbias,
- boolean projected)
+ boolean projected,
+ LLVMValueRef *texel)
{
const uint unit = inst->FullSrcRegisters[1].SrcRegister.Index;
LLVMValueRef lodbias;
LLVMValueRef oow;
LLVMValueRef coords[3];
- LLVMValueRef texel[4];
unsigned num_coords;
unsigned i;
coords[i] = lp_build_mul(&bld->base, coords[i], oow);
}
- bld->emit_fetch_texel(bld->base.builder, bld->emit_fetch_texel_context,
- unit, num_coords, coords, lodbias, texel);
-
- FOR_EACH_DST0_ENABLED_CHANNEL( inst, i ) {
- emit_store( bld, inst, 0, i, texel[i] );
- }
+ bld->sampler->emit_fetch_texel(bld->sampler,
+ bld->base.builder,
+ bld->base.type,
+ unit, num_coords, coords, lodbias,
+ texel);
}
}
-static void
-emit_kilp(
- struct lp_build_tgsi_soa_context *bld )
-{
- /* XXX todo / fix me */
-}
-
-
/**
* Check if inst src/dest regs use indirect addressing into temporary
* register file.
static int
emit_instruction(
struct lp_build_tgsi_soa_context *bld,
- struct tgsi_full_instruction *inst )
+ const struct tgsi_full_instruction *inst,
+ const struct tgsi_opcode_info *info)
{
unsigned chan_index;
LLVMValueRef src0, src1, src2;
LLVMValueRef tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
- LLVMValueRef dst0;
+ LLVMValueRef res;
+ LLVMValueRef dst0[NUM_CHANNELS];
/* we can't handle indirect addressing into temp register file yet */
if (indirect_temp_reference(inst))
return FALSE;
+ assert(info->num_dst <= 1);
+ if(info->num_dst) {
+ FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
+ dst0[chan_index] = bld->base.undef;
+ }
+ }
+
switch (inst->Instruction.Opcode) {
#if 0
case TGSI_OPCODE_ARL:
+ /* FIXME */
FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
tmp0 = emit_fetch( bld, inst, 0, chan_index );
emit_flr(bld, 0, 0);
emit_f2it( bld, 0 );
- emit_store( bld, inst, 0, chan_index, tmp0);
+ dst0[chan_index] = tmp0;
}
break;
#endif
case TGSI_OPCODE_MOV:
case TGSI_OPCODE_SWZ:
FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
- tmp0 = emit_fetch( bld, inst, 0, chan_index );
- emit_store( bld, inst, 0, chan_index, tmp0);
+ dst0[chan_index] = emit_fetch( bld, inst, 0, chan_index );
}
break;
case TGSI_OPCODE_LIT:
if( IS_DST0_CHANNEL_ENABLED( inst, CHAN_X ) ) {
- emit_store( bld, inst, 0, CHAN_X, bld->base.one);
+ dst0[CHAN_X] = bld->base.one;
}
if( IS_DST0_CHANNEL_ENABLED( inst, CHAN_Y ) ) {
src0 = emit_fetch( bld, inst, 0, CHAN_X );
- dst0 = lp_build_max( &bld->base, src0, bld->base.zero);
- emit_store( bld, inst, 0, CHAN_Y, dst0);
+ dst0[CHAN_Y] = lp_build_max( &bld->base, src0, bld->base.zero);
}
if( IS_DST0_CHANNEL_ENABLED( inst, CHAN_Z ) ) {
/* XMM[1] = SrcReg[0].yyyy */
tmp1 = lp_build_pow( &bld->base, tmp1, tmp2);
tmp0 = emit_fetch( bld, inst, 0, CHAN_X );
tmp2 = lp_build_cmp(&bld->base, PIPE_FUNC_GREATER, tmp0, bld->base.zero);
- dst0 = lp_build_select(&bld->base, tmp2, tmp1, bld->base.zero);
- emit_store( bld, inst, 0, CHAN_Z, dst0);
+ dst0[CHAN_Z] = lp_build_select(&bld->base, tmp2, tmp1, bld->base.zero);
}
if( IS_DST0_CHANNEL_ENABLED( inst, CHAN_W ) ) {
- emit_store( bld, inst, 0, CHAN_W, bld->base.one);
+ dst0[CHAN_W] = bld->base.one;
}
break;
case TGSI_OPCODE_RCP:
/* TGSI_OPCODE_RECIP */
src0 = emit_fetch( bld, inst, 0, CHAN_X );
- dst0 = lp_build_rcp(&bld->base, src0);
+ res = lp_build_rcp(&bld->base, src0);
FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
- emit_store( bld, inst, 0, chan_index, dst0 );
+ dst0[chan_index] = res;
}
break;
/* TGSI_OPCODE_RECIPSQRT */
src0 = emit_fetch( bld, inst, 0, CHAN_X );
src0 = lp_build_abs(&bld->base, src0);
- dst0 = lp_build_rsqrt(&bld->base, src0);
+ res = lp_build_rsqrt(&bld->base, src0);
FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
- emit_store( bld, inst, 0, chan_index, dst0 );
+ dst0[chan_index] = res;
}
break;
lp_build_exp2_approx(&bld->base, src0, p_exp2_int_part, p_frac_part, p_exp2);
if (IS_DST0_CHANNEL_ENABLED( inst, CHAN_X ))
- emit_store( bld, inst, 0, CHAN_X, tmp0);
+ dst0[CHAN_X] = tmp0;
if (IS_DST0_CHANNEL_ENABLED( inst, CHAN_Y ))
- emit_store( bld, inst, 0, CHAN_Y, tmp1);
+ dst0[CHAN_Y] = tmp1;
if (IS_DST0_CHANNEL_ENABLED( inst, CHAN_Z ))
- emit_store( bld, inst, 0, CHAN_Z, tmp2);
+ dst0[CHAN_Z] = tmp2;
}
/* dst.w = 1.0 */
if (IS_DST0_CHANNEL_ENABLED( inst, CHAN_W )) {
- tmp0 = bld->base.one;
- emit_store( bld, inst, 0, CHAN_W, tmp0);
+ dst0[CHAN_W] = bld->base.one;
}
break;
/* dst.x = floor(lg2(abs(src.x))) */
if (IS_DST0_CHANNEL_ENABLED( inst, CHAN_X ))
- emit_store( bld, inst, 0, CHAN_X, tmp0);
+ dst0[CHAN_X] = tmp0;
/* dst.y = abs(src)/ex2(floor(lg2(abs(src.x)))) */
if (IS_DST0_CHANNEL_ENABLED( inst, CHAN_Y )) {
- tmp1 = lp_build_div( &bld->base, src0, tmp1);
- emit_store( bld, inst, 0, CHAN_Y, tmp1);
+ dst0[CHAN_Y] = lp_build_div( &bld->base, src0, tmp1);
}
/* dst.z = lg2(abs(src.x)) */
if (IS_DST0_CHANNEL_ENABLED( inst, CHAN_Z ))
- emit_store( bld, inst, 0, CHAN_Z, tmp2);
+ dst0[CHAN_Z] = tmp2;
}
/* dst.w = 1.0 */
if (IS_DST0_CHANNEL_ENABLED( inst, CHAN_W )) {
- tmp0 = bld->base.one;
- emit_store( bld, inst, 0, CHAN_W, tmp0);
+ dst0[CHAN_W] = bld->base.one;
}
break;
FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
src0 = emit_fetch( bld, inst, 0, chan_index );
src1 = emit_fetch( bld, inst, 1, chan_index );
- dst0 = lp_build_mul(&bld->base, src0, src1);
- emit_store( bld, inst, 0, chan_index, dst0);
+ dst0[chan_index] = lp_build_mul(&bld->base, src0, src1);
}
break;
FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
src0 = emit_fetch( bld, inst, 0, chan_index );
src1 = emit_fetch( bld, inst, 1, chan_index );
- dst0 = lp_build_add(&bld->base, src0, src1);
- emit_store( bld, inst, 0, chan_index, dst0);
+ dst0[chan_index] = lp_build_add(&bld->base, src0, src1);
}
break;
tmp1 = lp_build_mul( &bld->base, tmp1, tmp2);
tmp0 = lp_build_add( &bld->base, tmp0, tmp1);
FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
- emit_store( bld, inst, 0, chan_index, tmp0);
+ dst0[chan_index] = tmp0;
}
break;
tmp1 = lp_build_mul( &bld->base, tmp1, tmp2);
tmp0 = lp_build_add( &bld->base, tmp0, tmp1);
FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
- emit_store( bld, inst, 0, chan_index, tmp0);
+ dst0[chan_index] = tmp0;
}
break;
case TGSI_OPCODE_DST:
IF_IS_DST0_CHANNEL_ENABLED( inst, CHAN_X ) {
- tmp0 = bld->base.one;
- emit_store( bld, inst, 0, CHAN_X, tmp0);
+ dst0[CHAN_X] = bld->base.one;
}
IF_IS_DST0_CHANNEL_ENABLED( inst, CHAN_Y ) {
tmp0 = emit_fetch( bld, inst, 0, CHAN_Y );
tmp1 = emit_fetch( bld, inst, 1, CHAN_Y );
- tmp0 = lp_build_mul( &bld->base, tmp0, tmp1);
- emit_store( bld, inst, 0, CHAN_Y, tmp0);
+ dst0[CHAN_Y] = lp_build_mul( &bld->base, tmp0, tmp1);
}
IF_IS_DST0_CHANNEL_ENABLED( inst, CHAN_Z ) {
- tmp0 = emit_fetch( bld, inst, 0, CHAN_Z );
- emit_store( bld, inst, 0, CHAN_Z, tmp0);
+ dst0[CHAN_Z] = emit_fetch( bld, inst, 0, CHAN_Z );
}
IF_IS_DST0_CHANNEL_ENABLED( inst, CHAN_W ) {
- tmp0 = emit_fetch( bld, inst, 1, CHAN_W );
- emit_store( bld, inst, 0, CHAN_W, tmp0);
+ dst0[CHAN_W] = emit_fetch( bld, inst, 1, CHAN_W );
}
break;
FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
src0 = emit_fetch( bld, inst, 0, chan_index );
src1 = emit_fetch( bld, inst, 1, chan_index );
- dst0 = lp_build_min( &bld->base, src0, src1 );
- emit_store( bld, inst, 0, chan_index, dst0);
+ dst0[chan_index] = lp_build_min( &bld->base, src0, src1 );
}
break;
FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
src0 = emit_fetch( bld, inst, 0, chan_index );
src1 = emit_fetch( bld, inst, 1, chan_index );
- dst0 = lp_build_max( &bld->base, src0, src1 );
- emit_store( bld, inst, 0, chan_index, dst0);
+ dst0[chan_index] = lp_build_max( &bld->base, src0, src1 );
}
break;
src0 = emit_fetch( bld, inst, 0, chan_index );
src1 = emit_fetch( bld, inst, 1, chan_index );
tmp0 = lp_build_cmp( &bld->base, PIPE_FUNC_LESS, src0, src1 );
- dst0 = lp_build_select( &bld->base, tmp0, bld->base.one, bld->base.zero );
- emit_store( bld, inst, 0, chan_index, dst0);
+ dst0[chan_index] = lp_build_select( &bld->base, tmp0, bld->base.one, bld->base.zero );
}
break;
src0 = emit_fetch( bld, inst, 0, chan_index );
src1 = emit_fetch( bld, inst, 1, chan_index );
tmp0 = lp_build_cmp( &bld->base, PIPE_FUNC_GEQUAL, src0, src1 );
- dst0 = lp_build_select( &bld->base, tmp0, bld->base.one, bld->base.zero );
- emit_store( bld, inst, 0, chan_index, dst0);
+ dst0[chan_index] = lp_build_select( &bld->base, tmp0, bld->base.one, bld->base.zero );
}
break;
tmp2 = emit_fetch( bld, inst, 2, chan_index );
tmp0 = lp_build_mul( &bld->base, tmp0, tmp1);
tmp0 = lp_build_add( &bld->base, tmp0, tmp2);
- emit_store( bld, inst, 0, chan_index, tmp0);
+ dst0[chan_index] = tmp0;
}
break;
FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
tmp0 = emit_fetch( bld, inst, 0, chan_index );
tmp1 = emit_fetch( bld, inst, 1, chan_index );
- tmp0 = lp_build_sub( &bld->base, tmp0, tmp1);
- emit_store( bld, inst, 0, chan_index, tmp0);
+ dst0[chan_index] = lp_build_sub( &bld->base, tmp0, tmp1);
}
break;
src2 = emit_fetch( bld, inst, 2, chan_index );
tmp0 = lp_build_sub( &bld->base, src1, src2 );
tmp0 = lp_build_mul( &bld->base, src0, tmp0 );
- dst0 = lp_build_add( &bld->base, tmp0, src2 );
- emit_store( bld, inst, 0, chan_index, dst0 );
+ dst0[chan_index] = lp_build_add( &bld->base, tmp0, src2 );
}
break;
case TGSI_OPCODE_CND:
- return 0;
+ FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
+ src0 = emit_fetch( bld, inst, 0, chan_index );
+ src1 = emit_fetch( bld, inst, 1, chan_index );
+ src2 = emit_fetch( bld, inst, 2, chan_index );
+ tmp1 = lp_build_const_scalar(bld->base.type, 0.5);
+ tmp0 = lp_build_cmp( &bld->base, PIPE_FUNC_GREATER, src2, tmp1);
+ dst0[chan_index] = lp_build_select( &bld->base, tmp0, src0, src1 );
+ }
break;
case TGSI_OPCODE_DP2A:
tmp1 = emit_fetch( bld, inst, 2, CHAN_X ); /* xmm1 = src[2].x */
tmp0 = lp_build_add( &bld->base, tmp0, tmp1); /* xmm0 = xmm0 + xmm1 */
FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
- emit_store( bld, inst, 0, chan_index, tmp0); /* dest[ch] = xmm0 */
+ dst0[chan_index] = tmp0; /* dest[ch] = xmm0 */
}
break;
-#if 0
case TGSI_OPCODE_FRC:
FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
- tmp0 = emit_fetch( bld, inst, 0, chan_index );
- emit_frc( bld, 0, 0 );
- emit_store( bld, inst, 0, chan_index, tmp0);
+ src0 = emit_fetch( bld, inst, 0, chan_index );
+ tmp0 = lp_build_floor(&bld->base, src0);
+ tmp0 = lp_build_sub(&bld->base, tmp0, src0);
+ dst0[chan_index] = tmp0;
}
break;
case TGSI_OPCODE_CLAMP:
- return 0;
+ FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
+ tmp0 = emit_fetch( bld, inst, 0, chan_index );
+ src1 = emit_fetch( bld, inst, 1, chan_index );
+ src2 = emit_fetch( bld, inst, 2, chan_index );
+ tmp0 = lp_build_max(&bld->base, tmp0, src1);
+ tmp0 = lp_build_min(&bld->base, tmp0, src2);
+ dst0[chan_index] = tmp0;
+ }
break;
case TGSI_OPCODE_FLR:
FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
tmp0 = emit_fetch( bld, inst, 0, chan_index );
- emit_flr( bld, 0, 0 );
- emit_store( bld, inst, 0, chan_index, tmp0);
+ dst0[chan_index] = lp_build_floor(&bld->base, tmp0);
}
break;
case TGSI_OPCODE_ROUND:
FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
tmp0 = emit_fetch( bld, inst, 0, chan_index );
- emit_rnd( bld, 0, 0 );
- emit_store( bld, inst, 0, chan_index, tmp0);
+ dst0[chan_index] = lp_build_round(&bld->base, tmp0);
}
break;
-#endif
case TGSI_OPCODE_EX2: {
tmp0 = emit_fetch( bld, inst, 0, CHAN_X );
tmp0 = lp_build_exp2( &bld->base, tmp0);
FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
- emit_store( bld, inst, 0, chan_index, tmp0);
+ dst0[chan_index] = tmp0;
}
break;
}
tmp0 = emit_fetch( bld, inst, 0, CHAN_X );
tmp0 = lp_build_log2( &bld->base, tmp0);
FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
- emit_store( bld, inst, 0, chan_index, tmp0);
+ dst0[chan_index] = tmp0;
}
break;
case TGSI_OPCODE_POW:
src0 = emit_fetch( bld, inst, 0, CHAN_X );
src1 = emit_fetch( bld, inst, 1, CHAN_X );
- dst0 = lp_build_pow( &bld->base, src0, src1 );
+ res = lp_build_pow( &bld->base, src0, src1 );
FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
- emit_store( bld, inst, 0, chan_index, dst0 );
+ dst0[chan_index] = res;
}
break;
tmp5 = tmp3;
tmp5 = lp_build_mul( &bld->base, tmp5, tmp4);
tmp2 = lp_build_sub( &bld->base, tmp2, tmp5);
- emit_store( bld, inst, 0, CHAN_X, tmp2);
+ dst0[CHAN_X] = tmp2;
}
if( IS_DST0_CHANNEL_ENABLED( inst, CHAN_Y ) ||
IS_DST0_CHANNEL_ENABLED( inst, CHAN_Z ) ) {
tmp3 = lp_build_mul( &bld->base, tmp3, tmp2);
tmp1 = lp_build_mul( &bld->base, tmp1, tmp5);
tmp3 = lp_build_sub( &bld->base, tmp3, tmp1);
- emit_store( bld, inst, 0, CHAN_Y, tmp3);
+ dst0[CHAN_Y] = tmp3;
}
IF_IS_DST0_CHANNEL_ENABLED( inst, CHAN_Z ) {
tmp5 = lp_build_mul( &bld->base, tmp5, tmp4);
tmp0 = lp_build_mul( &bld->base, tmp0, tmp2);
tmp5 = lp_build_sub( &bld->base, tmp5, tmp0);
- emit_store( bld, inst, 0, CHAN_Z, tmp5);
+ dst0[CHAN_Z] = tmp5;
}
IF_IS_DST0_CHANNEL_ENABLED( inst, CHAN_W ) {
- tmp0 = bld->base.one;
- emit_store( bld, inst, 0, CHAN_W, tmp0);
+ dst0[CHAN_W] = bld->base.one;
}
break;
case TGSI_OPCODE_ABS:
FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
tmp0 = emit_fetch( bld, inst, 0, chan_index );
- tmp0 = lp_build_abs( &bld->base, tmp0 ) ;
- emit_store( bld, inst, 0, chan_index, tmp0);
+ dst0[chan_index] = lp_build_abs( &bld->base, tmp0 );
}
break;
case TGSI_OPCODE_RCC:
+ /* deprecated? */
+ assert(0);
return 0;
- break;
case TGSI_OPCODE_DPH:
tmp0 = emit_fetch( bld, inst, 0, CHAN_X );
tmp1 = emit_fetch( bld, inst, 1, CHAN_W );
tmp0 = lp_build_add( &bld->base, tmp0, tmp1);
FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
- emit_store( bld, inst, 0, chan_index, tmp0);
+ dst0[chan_index] = tmp0;
}
break;
tmp0 = emit_fetch( bld, inst, 0, CHAN_X );
tmp0 = lp_build_cos( &bld->base, tmp0 );
FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
- emit_store( bld, inst, 0, chan_index, tmp0);
+ dst0[chan_index] = tmp0;
}
break;
case TGSI_OPCODE_DDX:
- return 0;
+ FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
+ emit_fetch_deriv( bld, inst, 0, chan_index, NULL, &dst0[chan_index], NULL);
+ }
break;
case TGSI_OPCODE_DDY:
- return 0;
+ FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
+ emit_fetch_deriv( bld, inst, 0, chan_index, NULL, NULL, &dst0[chan_index]);
+ }
break;
-#if 0
case TGSI_OPCODE_KILP:
/* predicated kill */
- emit_kilp( bld );
- return 0; /* XXX fix me */
+ /* FIXME */
+ return 0;
break;
-#endif
case TGSI_OPCODE_KIL:
/* conditional kill */
src0 = emit_fetch( bld, inst, 0, chan_index );
src1 = emit_fetch( bld, inst, 1, chan_index );
tmp0 = lp_build_cmp( &bld->base, PIPE_FUNC_EQUAL, src0, src1 );
- dst0 = lp_build_select( &bld->base, tmp0, bld->base.one, bld->base.zero );
- emit_store( bld, inst, 0, chan_index, dst0);
+ dst0[chan_index] = lp_build_select( &bld->base, tmp0, bld->base.one, bld->base.zero );
}
break;
case TGSI_OPCODE_SFL:
- return 0;
+ FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
+ dst0[chan_index] = bld->base.zero;
+ }
break;
case TGSI_OPCODE_SGT:
src0 = emit_fetch( bld, inst, 0, chan_index );
src1 = emit_fetch( bld, inst, 1, chan_index );
tmp0 = lp_build_cmp( &bld->base, PIPE_FUNC_GREATER, src0, src1 );
- dst0 = lp_build_select( &bld->base, tmp0, bld->base.one, bld->base.zero );
- emit_store( bld, inst, 0, chan_index, dst0);
+ dst0[chan_index] = lp_build_select( &bld->base, tmp0, bld->base.one, bld->base.zero );
}
break;
tmp0 = emit_fetch( bld, inst, 0, CHAN_X );
tmp0 = lp_build_sin( &bld->base, tmp0 );
FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
- emit_store( bld, inst, 0, chan_index, tmp0);
+ dst0[chan_index] = tmp0;
}
break;
src0 = emit_fetch( bld, inst, 0, chan_index );
src1 = emit_fetch( bld, inst, 1, chan_index );
tmp0 = lp_build_cmp( &bld->base, PIPE_FUNC_LEQUAL, src0, src1 );
- dst0 = lp_build_select( &bld->base, tmp0, bld->base.one, bld->base.zero );
- emit_store( bld, inst, 0, chan_index, dst0);
+ dst0[chan_index] = lp_build_select( &bld->base, tmp0, bld->base.one, bld->base.zero );
}
break;
src0 = emit_fetch( bld, inst, 0, chan_index );
src1 = emit_fetch( bld, inst, 1, chan_index );
tmp0 = lp_build_cmp( &bld->base, PIPE_FUNC_NOTEQUAL, src0, src1 );
- dst0 = lp_build_select( &bld->base, tmp0, bld->base.one, bld->base.zero );
- emit_store( bld, inst, 0, chan_index, dst0);
+ dst0[chan_index] = lp_build_select( &bld->base, tmp0, bld->base.one, bld->base.zero );
}
break;
case TGSI_OPCODE_STR:
- return 0;
+ FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
+ dst0[chan_index] = bld->base.one;
+ }
break;
case TGSI_OPCODE_TEX:
- emit_tex( bld, inst, FALSE, FALSE );
+ emit_tex( bld, inst, FALSE, FALSE, dst0 );
break;
case TGSI_OPCODE_TXD:
+ /* FIXME */
return 0;
break;
case TGSI_OPCODE_UP2H:
+ /* deprecated */
+ assert (0);
return 0;
break;
case TGSI_OPCODE_UP2US:
+ /* deprecated */
+ assert(0);
return 0;
break;
case TGSI_OPCODE_UP4B:
+ /* deprecated */
+ assert(0);
return 0;
break;
case TGSI_OPCODE_UP4UB:
+ /* deprecated */
+ assert(0);
return 0;
break;
case TGSI_OPCODE_X2D:
+ /* deprecated? */
+ assert(0);
return 0;
break;
case TGSI_OPCODE_ARA:
+ /* deprecated */
+ assert(0);
return 0;
break;
#if 0
case TGSI_OPCODE_ARR:
+ /* FIXME */
FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
tmp0 = emit_fetch( bld, inst, 0, chan_index );
emit_rnd( bld, 0, 0 );
emit_f2it( bld, 0 );
- emit_store( bld, inst, 0, chan_index, tmp0);
+ dst0[chan_index] = tmp0;
}
break;
#endif
case TGSI_OPCODE_BRA:
+ /* deprecated */
+ assert(0);
return 0;
break;
case TGSI_OPCODE_CAL:
+ /* FIXME */
return 0;
break;
-#if 0
case TGSI_OPCODE_RET:
- emit_ret( bld );
+ /* FIXME */
+ return 0;
break;
-#endif
case TGSI_OPCODE_END:
break;
-#if 0
case TGSI_OPCODE_SSG:
/* TGSI_OPCODE_SGN */
FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
tmp0 = emit_fetch( bld, inst, 0, chan_index );
- emit_sgn( bld, 0, 0 );
- emit_store( bld, inst, 0, chan_index, tmp0);
+ dst0[chan_index] = lp_build_sgn( &bld->base, tmp0 );
}
break;
-#endif
case TGSI_OPCODE_CMP:
FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
src1 = emit_fetch( bld, inst, 1, chan_index );
src2 = emit_fetch( bld, inst, 2, chan_index );
tmp0 = lp_build_cmp( &bld->base, PIPE_FUNC_LESS, src0, bld->base.zero );
- dst0 = lp_build_select( &bld->base, tmp0, src1, src2);
- emit_store( bld, inst, 0, chan_index, dst0);
+ dst0[chan_index] = lp_build_select( &bld->base, tmp0, src1, src2);
}
break;
case TGSI_OPCODE_SCS:
IF_IS_DST0_CHANNEL_ENABLED( inst, CHAN_X ) {
tmp0 = emit_fetch( bld, inst, 0, CHAN_X );
- tmp0 = lp_build_cos( &bld->base, tmp0 );
- emit_store( bld, inst, 0, CHAN_X, tmp0);
+ dst0[CHAN_X] = lp_build_cos( &bld->base, tmp0 );
}
IF_IS_DST0_CHANNEL_ENABLED( inst, CHAN_Y ) {
tmp0 = emit_fetch( bld, inst, 0, CHAN_X );
- tmp0 = lp_build_sin( &bld->base, tmp0 );
- emit_store( bld, inst, 0, CHAN_Y, tmp0);
+ dst0[CHAN_Y] = lp_build_sin( &bld->base, tmp0 );
}
IF_IS_DST0_CHANNEL_ENABLED( inst, CHAN_Z ) {
- tmp0 = bld->base.zero;
- emit_store( bld, inst, 0, CHAN_Z, tmp0);
+ dst0[CHAN_Z] = bld->base.zero;
}
IF_IS_DST0_CHANNEL_ENABLED( inst, CHAN_W ) {
- tmp0 = bld->base.one;
- emit_store( bld, inst, 0, CHAN_W, tmp0);
+ dst0[CHAN_W] = bld->base.one;
}
break;
case TGSI_OPCODE_TXB:
- emit_tex( bld, inst, TRUE, FALSE );
+ emit_tex( bld, inst, TRUE, FALSE, dst0 );
break;
case TGSI_OPCODE_NRM:
/* dst.x = xmm1 * src.x */
if (IS_DST0_CHANNEL_ENABLED(inst, CHAN_X)) {
- tmp4 = lp_build_mul( &bld->base, tmp4, tmp1);
- emit_store(bld, inst, 0, CHAN_X, tmp4);
+ dst0[CHAN_X] = lp_build_mul( &bld->base, tmp4, tmp1);
}
/* dst.y = xmm1 * src.y */
if (IS_DST0_CHANNEL_ENABLED(inst, CHAN_Y)) {
- tmp5 = lp_build_mul( &bld->base, tmp5, tmp1);
- emit_store(bld, inst, 0, CHAN_Y, tmp5);
+ dst0[CHAN_Y] = lp_build_mul( &bld->base, tmp5, tmp1);
}
/* dst.z = xmm1 * src.z */
if (IS_DST0_CHANNEL_ENABLED(inst, CHAN_Z)) {
- tmp6 = lp_build_mul( &bld->base, tmp6, tmp1);
- emit_store(bld, inst, 0, CHAN_Z, tmp6);
+ dst0[CHAN_Z] = lp_build_mul( &bld->base, tmp6, tmp1);
}
/* dst.w = xmm1 * src.w */
if (IS_DST0_CHANNEL_ENABLED(inst, CHAN_X) && dims == 4) {
- tmp7 = lp_build_mul( &bld->base, tmp7, tmp1);
- emit_store(bld, inst, 0, CHAN_W, tmp7);
+ dst0[CHAN_W] = lp_build_mul( &bld->base, tmp7, tmp1);
}
}
- /* dst0.w = 1.0 */
+ /* dst.w = 1.0 */
if (IS_DST0_CHANNEL_ENABLED(inst, CHAN_W) && dims == 3) {
- tmp0 = bld->base.one;
- emit_store(bld, inst, 0, CHAN_W, tmp0);
+ dst0[CHAN_W] = bld->base.one;
}
}
break;
case TGSI_OPCODE_DIV:
+ /* deprecated */
+ assert( 0 );
return 0;
break;
tmp1 = lp_build_mul( &bld->base, tmp1, tmp2); /* xmm1 = xmm1 * xmm2 */
tmp0 = lp_build_add( &bld->base, tmp0, tmp1); /* xmm0 = xmm0 + xmm1 */
FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
- emit_store( bld, inst, 0, chan_index, tmp0); /* dest[ch] = xmm0 */
+ dst0[chan_index] = tmp0; /* dest[ch] = xmm0 */
}
break;
case TGSI_OPCODE_TXL:
- emit_tex( bld, inst, TRUE, FALSE );
+ emit_tex( bld, inst, TRUE, FALSE, dst0 );
break;
case TGSI_OPCODE_TXP:
- emit_tex( bld, inst, FALSE, TRUE );
+ emit_tex( bld, inst, FALSE, TRUE, dst0 );
break;
case TGSI_OPCODE_BRK:
+ /* FIXME */
return 0;
break;
case TGSI_OPCODE_IF:
+ /* FIXME */
return 0;
break;
case TGSI_OPCODE_BGNFOR:
+ /* deprecated */
+ assert(0);
return 0;
break;
case TGSI_OPCODE_REP:
+ /* deprecated */
+ assert(0);
return 0;
break;
case TGSI_OPCODE_ELSE:
+ /* FIXME */
return 0;
break;
case TGSI_OPCODE_ENDIF:
+ /* FIXME */
return 0;
break;
case TGSI_OPCODE_ENDFOR:
+ /* deprecated */
+ assert(0);
return 0;
break;
case TGSI_OPCODE_ENDREP:
+ /* deprecated */
+ assert(0);
return 0;
break;
case TGSI_OPCODE_PUSHA:
+ /* deprecated? */
+ assert(0);
return 0;
break;
case TGSI_OPCODE_POPA:
+ /* deprecated? */
+ assert(0);
return 0;
break;
case TGSI_OPCODE_CEIL:
- return 0;
+ FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
+ tmp0 = emit_fetch( bld, inst, 0, chan_index );
+ dst0[chan_index] = lp_build_ceil(&bld->base, tmp0);
+ }
break;
case TGSI_OPCODE_I2F:
+ /* deprecated? */
+ assert(0);
return 0;
break;
case TGSI_OPCODE_NOT:
+ /* deprecated? */
+ assert(0);
return 0;
break;
-#if 0
case TGSI_OPCODE_TRUNC:
FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
tmp0 = emit_fetch( bld, inst, 0, chan_index );
- emit_f2it( bld, 0 );
- emit_i2f( bld, 0 );
- emit_store( bld, inst, 0, chan_index, tmp0);
+ dst0[chan_index] = lp_build_trunc(&bld->base, tmp0);
}
break;
-#endif
case TGSI_OPCODE_SHL:
+ /* deprecated? */
+ assert(0);
return 0;
break;
case TGSI_OPCODE_SHR:
+ /* deprecated? */
+ assert(0);
return 0;
break;
case TGSI_OPCODE_AND:
+ /* deprecated? */
+ assert(0);
return 0;
break;
case TGSI_OPCODE_OR:
+ /* deprecated? */
+ assert(0);
return 0;
break;
case TGSI_OPCODE_MOD:
+ /* deprecated? */
+ assert(0);
return 0;
break;
case TGSI_OPCODE_XOR:
+ /* deprecated? */
+ assert(0);
return 0;
break;
case TGSI_OPCODE_SAD:
+ /* deprecated? */
+ assert(0);
return 0;
break;
case TGSI_OPCODE_TXF:
+ /* deprecated? */
+ assert(0);
return 0;
break;
case TGSI_OPCODE_TXQ:
+ /* deprecated? */
+ assert(0);
return 0;
break;
case TGSI_OPCODE_CONT:
+ /* deprecated? */
+ assert(0);
return 0;
break;
return 0;
break;
+ case TGSI_OPCODE_NOISE1:
+ case TGSI_OPCODE_NOISE2:
+ case TGSI_OPCODE_NOISE3:
+ case TGSI_OPCODE_NOISE4:
+ FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
+ dst0[chan_index] = bld->base.zero;
+ }
+ break;
+
+ case TGSI_OPCODE_NOP:
+ break;
+
default:
return 0;
}
+ if(info->num_dst) {
+ FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
+ emit_store( bld, inst, 0, chan_index, dst0[chan_index]);
+ }
+ }
+
return 1;
}
const LLVMValueRef *pos,
const LLVMValueRef (*inputs)[NUM_CHANNELS],
LLVMValueRef (*outputs)[NUM_CHANNELS],
- lp_emit_fetch_texel_soa_callback emit_fetch_texel,
- void *emit_fetch_texel_context)
+ struct lp_build_sampler_soa *sampler)
{
struct lp_build_tgsi_soa_context bld;
struct tgsi_parse_context parse;
bld.inputs = inputs;
bld.outputs = outputs;
bld.consts_ptr = consts_ptr;
- bld.emit_fetch_texel = emit_fetch_texel;
- bld.emit_fetch_texel_context = emit_fetch_texel_context;
+ bld.sampler = sampler;
tgsi_parse_init( &parse, tokens );
switch( parse.FullToken.Token.Type ) {
case TGSI_TOKEN_TYPE_DECLARATION:
- /* Input already interpolated */
+ /* Inputs already interpolated */
break;
case TGSI_TOKEN_TYPE_INSTRUCTION:
- if (!emit_instruction( &bld, &parse.FullToken.FullInstruction )) {
+ {
unsigned opcode = parse.FullToken.FullInstruction.Instruction.Opcode;
const struct tgsi_opcode_info *info = tgsi_get_opcode_info(opcode);
- _debug_printf("warning: failed to translate tgsi opcode %s to LLVM\n",
- info ? info->mnemonic : "<invalid>");
- }
+ if (!emit_instruction( &bld, &parse.FullToken.FullInstruction, info ))
+ _debug_printf("warning: failed to translate tgsi opcode %s to LLVM\n",
+ info ? info->mnemonic : "<invalid>");
+ }
+
break;
case TGSI_TOKEN_TYPE_IMMEDIATE:
}
+union lp_type
+lp_int_type(union lp_type type)
+{
+ union lp_type int_type;
+ int_type.value = 0;
+ int_type.width = type.width;
+ int_type.length = type.length;
+ return int_type;
+}
+
+
void
lp_build_context_init(struct lp_build_context *bld,
LLVMBuilderRef builder,
lp_build_int_vec_type(union lp_type type);
+union lp_type
+lp_int_type(union lp_type type);
+
+
void
lp_build_context_init(struct lp_build_context *bld,
LLVMBuilderRef builder,
util_pack_color(rgba, ps->format, &cv);
lp_tile_cache_clear(llvmpipe->cbuf_cache[i], rgba, cv);
}
+ llvmpipe->dirty_render_cache = TRUE;
}
if (buffers & PIPE_CLEAR_DEPTHSTENCIL) {
return PIPE_REFERENCED_FOR_WRITE;
}
- /* FIXME: we also need to do the same for the texture cache */
-
return PIPE_UNREFERENCED;
}
static void
lp_jit_init_globals(struct llvmpipe_screen *screen)
{
- /* struct lp_jit_context */
+ LLVMTypeRef texture_type;
+
+ /* struct lp_jit_texture */
{
LLVMTypeRef elem_types[4];
+
+ elem_types[LP_JIT_TEXTURE_WIDTH] = LLVMInt32Type();
+ elem_types[LP_JIT_TEXTURE_HEIGHT] = LLVMInt32Type();
+ elem_types[LP_JIT_TEXTURE_STRIDE] = LLVMInt32Type();
+ elem_types[LP_JIT_TEXTURE_DATA] = LLVMPointerType(LLVMInt8Type(), 0);
+
+ texture_type = LLVMStructType(elem_types, Elements(elem_types), 0);
+
+ LP_CHECK_MEMBER_OFFSET(struct lp_jit_texture, width,
+ screen->target, texture_type,
+ LP_JIT_TEXTURE_WIDTH);
+ LP_CHECK_MEMBER_OFFSET(struct lp_jit_texture, height,
+ screen->target, texture_type,
+ LP_JIT_TEXTURE_HEIGHT);
+ LP_CHECK_MEMBER_OFFSET(struct lp_jit_texture, stride,
+ screen->target, texture_type,
+ LP_JIT_TEXTURE_STRIDE);
+ LP_CHECK_MEMBER_OFFSET(struct lp_jit_texture, data,
+ screen->target, texture_type,
+ LP_JIT_TEXTURE_DATA);
+ LP_CHECK_STRUCT_SIZE(struct lp_jit_texture,
+ screen->target, texture_type);
+
+ LLVMAddTypeName(screen->module, "texture", texture_type);
+ }
+
+ /* struct lp_jit_context */
+ {
+ LLVMTypeRef elem_types[5];
LLVMTypeRef context_type;
elem_types[0] = LLVMPointerType(LLVMFloatType(), 0); /* constants */
elem_types[1] = LLVMPointerType(LLVMInt8Type(), 0); /* samplers */
elem_types[2] = LLVMFloatType(); /* alpha_ref_value */
elem_types[3] = LLVMPointerType(LLVMInt8Type(), 0); /* blend_color */
+ elem_types[4] = LLVMArrayType(texture_type, PIPE_MAX_SAMPLERS); /* textures */
context_type = LLVMStructType(elem_types, Elements(elem_types), 0);
screen->target, context_type, 2);
LP_CHECK_MEMBER_OFFSET(struct lp_jit_context, blend_color,
screen->target, context_type, 3);
+ LP_CHECK_MEMBER_OFFSET(struct lp_jit_context, textures,
+ screen->target, context_type,
+ LP_JIT_CONTEXT_TEXTURES_INDEX);
LP_CHECK_STRUCT_SIZE(struct lp_jit_context,
screen->target, context_type);
#include "lp_bld_struct.h"
+#include "pipe/p_state.h"
+
struct tgsi_sampler;
struct llvmpipe_screen;
+struct lp_jit_texture
+{
+ uint32_t width;
+ uint32_t height;
+ uint32_t stride;
+ const void *data;
+};
+
+
+enum {
+ LP_JIT_TEXTURE_WIDTH = 0,
+ LP_JIT_TEXTURE_HEIGHT,
+ LP_JIT_TEXTURE_STRIDE,
+ LP_JIT_TEXTURE_DATA
+};
+
+
+
/**
* This structure is passed directly to the generated fragment shader.
*
struct tgsi_sampler **samplers;
- /* TODO: alpha reference value */
float alpha_ref_value;
- /* TODO: blend constant color */
+ /* FIXME: store (also?) in floats */
uint8_t *blend_color;
+
+ struct lp_jit_texture textures[PIPE_MAX_SAMPLERS];
};
#define lp_jit_context_blend_color(_builder, _ptr) \
lp_build_struct_get(_builder, _ptr, 3, "blend_color")
+#define LP_JIT_CONTEXT_TEXTURES_INDEX 4
+
+#define lp_jit_context_textures(_builder, _ptr) \
+ lp_build_struct_get_ptr(_builder, _ptr, LP_JIT_CONTEXT_TEXTURES_INDEX, "textures")
+
typedef void
(*lp_jit_frag_func)(struct lp_jit_context *context,
#include "util/u_memory.h"
-#include "util/u_simple_screen.h"
-#include "pipe/internal/p_winsys_screen.h"
#include "pipe/p_defines.h"
#include "pipe/p_screen.h"
llvmpipe_destroy_screen( struct pipe_screen *_screen )
{
struct llvmpipe_screen *screen = llvmpipe_screen(_screen);
-
- struct pipe_winsys *winsys = _screen->winsys;
+ struct llvmpipe_winsys *winsys = screen->winsys;
lp_jit_screen_cleanup(screen);
#include "pipe/p_thread.h"
#include "util/u_math.h"
#include "util/u_memory.h"
+#include "lp_bld_debug.h"
#include "lp_tile_cache.h"
#include "lp_tile_soa.h"
else
depth = NULL;
- /* TODO: blend color */
+ /* XXX: This will most likely fail on 32bit x86 without -mstackrealign */
+ assert(lp_check_alignment(mask, 16));
- assert((((uintptr_t)mask) & 0xf) == 0);
- assert((((uintptr_t)depth) & 0xf) == 0);
- assert((((uintptr_t)color) & 0xf) == 0);
- assert((((uintptr_t)llvmpipe->jit_context.blend_color) & 0xf) == 0);
+ assert(lp_check_alignment(depth, 16));
+ assert(lp_check_alignment(color, 16));
+ assert(lp_check_alignment(llvmpipe->jit_context.blend_color, 16));
/* run shader */
fs->current->jit_function( &llvmpipe->jit_context,
#include "pipe/p_state.h"
#include "tgsi/tgsi_scan.h"
#include "lp_jit.h"
+#include "lp_bld_sample.h" /* for struct lp_sampler_static_state */
#define LP_NEW_VIEWPORT 0x1
struct tgsi_sampler;
struct vertex_info;
-
+struct pipe_context;
+struct llvmpipe_context;
struct lp_fragment_shader;
struct lp_fragment_shader_variant_key
{
+ enum pipe_format zsbuf_format;
struct pipe_depth_state depth;
struct pipe_alpha_state alpha;
struct pipe_blend_state blend;
+
+ struct lp_sampler_static_state sampler[PIPE_MAX_SAMPLERS];
};
if (llvmpipe->dirty & (LP_NEW_FS |
LP_NEW_BLEND |
- LP_NEW_DEPTH_STENCIL_ALPHA))
+ LP_NEW_DEPTH_STENCIL_ALPHA |
+ LP_NEW_SAMPLER |
+ LP_NEW_TEXTURE))
llvmpipe_update_fs( llvmpipe );
#include "lp_context.h"
#include "lp_state.h"
#include "lp_quad.h"
+#include "lp_tex_sample.h"
static const unsigned char quad_offset_x[4] = {0, 1, 0, 1};
* Generate the depth test.
*/
static void
-generate_depth(struct llvmpipe_context *lp,
- LLVMBuilderRef builder,
- const struct pipe_depth_state *state,
+generate_depth(LLVMBuilderRef builder,
+ const struct lp_fragment_shader_variant_key *key,
union lp_type src_type,
struct lp_build_mask_context *mask,
LLVMValueRef src,
const struct util_format_description *format_desc;
union lp_type dst_type;
- if(!lp->framebuffer.zsbuf)
+ if(!key->depth.enabled)
return;
- format_desc = util_format_description(lp->framebuffer.zsbuf->format);
+ format_desc = util_format_description(key->zsbuf_format);
assert(format_desc);
/* Pick the depth type. */
#endif
lp_build_depth_test(builder,
- state,
+ &key->depth,
dst_type,
format_desc,
mask,
}
-struct build_fetch_texel_context
-{
- LLVMValueRef context_ptr;
-
- LLVMValueRef samplers_ptr;
-
- /** Coords/texels store */
- LLVMValueRef store_ptr;
-};
-
-
-void PIPE_CDECL
-lp_fetch_texel_soa( struct tgsi_sampler **samplers,
- uint32_t unit,
- float *store )
-{
- struct tgsi_sampler *sampler = samplers[unit];
-
-#if 0
- uint j;
-
- debug_printf("%s sampler: %p (%p) store: %p\n",
- __FUNCTION__,
- sampler, *sampler,
- store );
-
- debug_printf("lodbias %f\n", store[12]);
-
- for (j = 0; j < 4; j++)
- debug_printf("sample %d texcoord %f %f\n",
- j,
- store[0+j],
- store[4+j]);
-#endif
-
- {
- float rgba[NUM_CHANNELS][QUAD_SIZE];
- sampler->get_samples(sampler,
- &store[0],
- &store[4],
- &store[8],
- 0.0f, /*store[12], lodbias */
- rgba);
- memcpy(store, rgba, sizeof rgba);
- }
-
-#if 0
- for (j = 0; j < 4; j++)
- debug_printf("sample %d result %f %f %f %f\n",
- j,
- store[0+j],
- store[4+j],
- store[8+j],
- store[12+j]);
-#endif
-}
-
-
-static void
-emit_fetch_texel( LLVMBuilderRef builder,
- void *context,
- unsigned unit,
- unsigned num_coords,
- const LLVMValueRef *coords,
- LLVMValueRef lodbias,
- LLVMValueRef *texel)
-{
- struct build_fetch_texel_context *bld = context;
- LLVMTypeRef vec_type = LLVMTypeOf(coords[0]);
- LLVMValueRef args[3];
- unsigned i;
-
- if(!bld->samplers_ptr)
- bld->samplers_ptr = lp_jit_context_samplers(builder, bld->context_ptr);
-
- if(!bld->store_ptr)
- bld->store_ptr = LLVMBuildArrayAlloca(builder,
- vec_type,
- LLVMConstInt(LLVMInt32Type(), 4, 0),
- "texel_store");
-
- for (i = 0; i < num_coords; i++) {
- LLVMValueRef index = LLVMConstInt(LLVMInt32Type(), i, 0);
- LLVMValueRef coord_ptr = LLVMBuildGEP(builder, bld->store_ptr, &index, 1, "");
- LLVMBuildStore(builder, coords[i], coord_ptr);
- }
-
- args[0] = bld->samplers_ptr;
- args[1] = LLVMConstInt(LLVMInt32Type(), unit, 0);
- args[2] = bld->store_ptr;
-
- lp_build_intrinsic(builder, "fetch_texel", LLVMVoidType(), args, 3);
-
- for (i = 0; i < NUM_CHANNELS; ++i) {
- LLVMValueRef index = LLVMConstInt(LLVMInt32Type(), i, 0);
- LLVMValueRef texel_ptr = LLVMBuildGEP(builder, bld->store_ptr, &index, 1, "");
- texel[i] = LLVMBuildLoad(builder, texel_ptr, "");
- }
-}
-
-
/**
* Generate the fragment shader, depth/stencil test, and alpha tests.
*/
LLVMValueRef context_ptr,
unsigned i,
const struct lp_build_interp_soa_context *interp,
- struct build_fetch_texel_context *sampler,
+ struct lp_build_sampler_soa *sampler,
LLVMValueRef *pmask,
LLVMValueRef *color,
LLVMValueRef depth_ptr)
LLVMValueRef consts_ptr;
LLVMValueRef outputs[PIPE_MAX_SHADER_OUTPUTS][NUM_CHANNELS];
LLVMValueRef z = interp->pos[2];
+ struct lp_build_flow_context *flow;
struct lp_build_mask_context mask;
boolean early_depth_test;
unsigned attrib;
consts_ptr = lp_jit_context_constants(builder, context_ptr);
- lp_build_mask_begin(&mask, builder, type, *pmask);
+ flow = lp_build_flow_create(builder);
+
+ memset(outputs, 0, sizeof outputs);
+
+ lp_build_flow_scope_begin(flow);
+
+ /* Declare the color and z variables */
+ for(chan = 0; chan < NUM_CHANNELS; ++chan) {
+ color[chan] = LLVMGetUndef(vec_type);
+ lp_build_flow_scope_declare(flow, &color[chan]);
+ }
+ lp_build_flow_scope_declare(flow, &z);
+
+ lp_build_mask_begin(&mask, flow, type, *pmask);
early_depth_test =
- lp->depth_stencil->depth.enabled &&
- lp->framebuffer.zsbuf &&
- !lp->depth_stencil->alpha.enabled &&
- !lp->fs->info.uses_kill &&
- !lp->fs->info.writes_z;
+ key->depth.enabled &&
+ !key->alpha.enabled &&
+ !shader->info.uses_kill &&
+ !shader->info.writes_z;
if(early_depth_test)
- generate_depth(lp, builder, &key->depth,
+ generate_depth(builder, key,
type, &mask,
z, depth_ptr);
- memset(outputs, 0, sizeof outputs);
-
lp_build_tgsi_soa(builder, tokens, type, &mask,
consts_ptr, interp->pos, interp->inputs,
- outputs, emit_fetch_texel, sampler);
+ outputs, sampler);
for (attrib = 0; attrib < shader->info.num_outputs; ++attrib) {
for(chan = 0; chan < NUM_CHANNELS; ++chan) {
}
if(!early_depth_test)
- generate_depth(lp, builder, &key->depth,
+ generate_depth(builder, key,
type, &mask,
z, depth_ptr);
lp_build_mask_end(&mask);
+ lp_build_flow_scope_end(flow);
+
+ lp_build_flow_destroy(flow);
+
*pmask = mask.value;
}
LLVMValueRef dst_ptr)
{
struct lp_build_context bld;
+ struct lp_build_flow_context *flow;
+ struct lp_build_mask_context mask_ctx;
LLVMTypeRef vec_type;
LLVMTypeRef int_vec_type;
LLVMValueRef const_ptr;
LLVMValueRef res[4];
unsigned chan;
+ lp_build_context_init(&bld, builder, type);
+
+ flow = lp_build_flow_create(builder);
+ lp_build_mask_begin(&mask_ctx, flow, type, mask);
+
vec_type = lp_build_vec_type(type);
int_vec_type = lp_build_int_vec_type(type);
- lp_build_context_init(&bld, builder, type);
-
const_ptr = lp_jit_context_blend_color(builder, context_ptr);
const_ptr = LLVMBuildBitCast(builder, const_ptr,
LLVMPointerType(vec_type, 0), "");
lp_build_blend_soa(builder, blend, type, src, dst, con, res);
for(chan = 0; chan < 4; ++chan) {
- LLVMValueRef index = LLVMConstInt(LLVMInt32Type(), chan, 0);
- lp_build_name(res[chan], "res.%c", "rgba"[chan]);
- res[chan] = lp_build_select(&bld, mask, res[chan], dst[chan]);
- LLVMBuildStore(builder, res[chan], LLVMBuildGEP(builder, dst_ptr, &index, 1, ""));
+ if(blend->colormask & (1 << chan)) {
+ LLVMValueRef index = LLVMConstInt(LLVMInt32Type(), chan, 0);
+ lp_build_name(res[chan], "res.%c", "rgba"[chan]);
+ res[chan] = lp_build_select(&bld, mask, res[chan], dst[chan]);
+ LLVMBuildStore(builder, res[chan], LLVMBuildGEP(builder, dst_ptr, &index, 1, ""));
+ }
}
+
+ lp_build_mask_end(&mask_ctx);
+ lp_build_flow_destroy(flow);
}
LLVMBuilderRef builder;
LLVMValueRef x0;
LLVMValueRef y0;
- struct build_fetch_texel_context sampler;
+ struct lp_build_sampler_soa *sampler;
struct lp_build_interp_soa_context interp;
LLVMValueRef fs_mask[LP_MAX_VECTOR_LENGTH];
LLVMValueRef fs_out_color[NUM_CHANNELS][LP_MAX_VECTOR_LENGTH];
a0_ptr, dadx_ptr, dady_ptr,
x0, y0, 2, 0);
- memset(&sampler, 0, sizeof sampler);
- sampler.context_ptr = context_ptr;
+#if 0
+ /* C texture sampling */
+ sampler = lp_c_sampler_soa_create(context_ptr);
+#else
+ /* code generated texture sampling */
+ sampler = lp_llvm_sampler_soa_create(key->sampler, context_ptr);
+#endif
for(i = 0; i < num_fs; ++i) {
LLVMValueRef index = LLVMConstInt(LLVMInt32Type(), i, 0);
context_ptr,
i,
&interp,
- &sampler,
+ sampler,
&fs_mask[i],
out_color,
depth_ptr_i);
fs_out_color[chan][i] = out_color[chan];
}
+ sampler->destroy(sampler);
+
/*
* Convert the fs's output color and mask to fit to the blending type.
*/
*/
static void
make_variant_key(struct llvmpipe_context *lp,
+ struct lp_fragment_shader *shader,
struct lp_fragment_shader_variant_key *key)
{
+ unsigned i;
+
memset(key, 0, sizeof *key);
- memcpy(&key->depth, &lp->depth_stencil->depth, sizeof key->depth);
+ if(lp->framebuffer.zsbuf &&
+ lp->depth_stencil->depth.enabled) {
+ key->zsbuf_format = lp->framebuffer.zsbuf->format;
+ memcpy(&key->depth, &lp->depth_stencil->depth, sizeof key->depth);
+ }
key->alpha.enabled = lp->depth_stencil->alpha.enabled;
if(key->alpha.enabled)
key->alpha.func = lp->depth_stencil->alpha.func;
/* alpha.ref_value is passed in jit_context */
- memcpy(&key->blend, lp->blend, sizeof key->blend);
+ if(lp->framebuffer.cbufs[0]) {
+ const struct util_format_description *format_desc;
+ unsigned chan;
+
+ memcpy(&key->blend, lp->blend, sizeof key->blend);
+
+ format_desc = util_format_description(lp->framebuffer.cbufs[0]->format);
+ assert(format_desc->layout == UTIL_FORMAT_COLORSPACE_RGB ||
+ format_desc->layout == UTIL_FORMAT_COLORSPACE_SRGB);
+
+ /* mask out color channels not present in the color buffer */
+ for(chan = 0; chan < 4; ++chan) {
+ enum util_format_swizzle swizzle = format_desc->swizzle[chan];
+ if(swizzle > 4)
+ key->blend.colormask &= ~(1 << chan);
+ }
+ }
+
+ for(i = 0; i < PIPE_MAX_SAMPLERS; ++i)
+ if(shader->info.file_mask[TGSI_FILE_SAMPLER] & (1 << i))
+ lp_sampler_static_state(&key->sampler[i], lp->texture[i], lp->sampler[i]);
}
struct lp_fragment_shader_variant_key key;
struct lp_fragment_shader_variant *variant;
- make_variant_key(lp, &key);
+ make_variant_key(lp, shader, &key);
variant = shader->variants;
while(variant) {
pipe_texture_reference(&llvmpipe->texture[i], tex);
lp_tex_tile_cache_set_texture(llvmpipe->tex_cache[i], tex);
+
+ if(tex) {
+ struct llvmpipe_texture *lp_tex = llvmpipe_texture(tex);
+ struct lp_jit_texture *jit_tex = &llvmpipe->jit_context.textures[i];
+ jit_tex->width = tex->width[0];
+ jit_tex->height = tex->height[0];
+ jit_tex->stride = lp_tex->stride[0];
+ if(!lp_tex->dt)
+ jit_tex->data = lp_tex->data;
+ }
}
llvmpipe->num_textures = num;
lp_build_loop_begin(builder, LLVMConstInt(LLVMInt32Type(), 1, 0), &loop);
- rgba = lp_build_load_rgba(builder, format, ptr);
+ rgba = lp_build_load_rgba_aos(builder, format, ptr);
LLVMBuildStore(builder, rgba, rgba_ptr);
lp_build_loop_end(builder, LLVMConstInt(LLVMInt32Type(), 4, 0), NULL, &loop);
rgba = LLVMBuildLoad(builder, rgba_ptr, "");
- lp_build_store_rgba(builder, format, ptr, rgba);
+ lp_build_store_rgba_aos(builder, format, ptr, rgba);
LLVMBuildRetVoid(builder);
if (lpt->timestamp != tc->timestamp) {
/* texture was modified, invalidate all cached tiles */
uint i;
- _debug_printf("INV %d %d\n", tc->timestamp, lpt->timestamp);
+ debug_printf("INV %d %d\n", tc->timestamp, lpt->timestamp);
for (i = 0; i < NUM_ENTRIES; i++) {
tc->entries[i].addr.bits.invalid = 1;
}
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
- * All Rights Reserved.
- * Copyright 2008 VMware, Inc. All rights reserved.
- *
- * 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, sub license, 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 (including the
- * next paragraph) 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 NON-INFRINGEMENT.
- * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS 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.
- *
- **************************************************************************/
-
-/**
- * Texture sampling
- *
- * Authors:
- * Brian Paul
- */
-
-#include "lp_context.h"
-#include "lp_quad.h"
-#include "lp_surface.h"
-#include "lp_texture.h"
-#include "lp_tex_sample.h"
-#include "lp_tex_cache.h"
-#include "pipe/p_context.h"
-#include "pipe/p_defines.h"
-#include "pipe/p_shader_tokens.h"
-#include "util/u_math.h"
-#include "util/u_memory.h"
-
-
-
-/*
- * Note, the FRAC macro has to work perfectly. Otherwise you'll sometimes
- * see 1-pixel bands of improperly weighted linear-filtered textures.
- * The tests/texwrap.c demo is a good test.
- * Also note, FRAC(x) doesn't truly return the fractional part of x for x < 0.
- * Instead, if x < 0 then FRAC(x) = 1 - true_frac(x).
- */
-#define FRAC(f) ((f) - util_ifloor(f))
-
-
-/**
- * Linear interpolation macro
- */
-static INLINE float
-lerp(float a, float v0, float v1)
-{
- return v0 + a * (v1 - v0);
-}
-
-
-/**
- * Do 2D/biliner interpolation of float values.
- * v00, v10, v01 and v11 are typically four texture samples in a square/box.
- * a and b are the horizontal and vertical interpolants.
- * It's important that this function is inlined when compiled with
- * optimization! If we find that's not true on some systems, convert
- * to a macro.
- */
-static INLINE float
-lerp_2d(float a, float b,
- float v00, float v10, float v01, float v11)
-{
- const float temp0 = lerp(a, v00, v10);
- const float temp1 = lerp(a, v01, v11);
- return lerp(b, temp0, temp1);
-}
-
-
-/**
- * As above, but 3D interpolation of 8 values.
- */
-static INLINE float
-lerp_3d(float a, float b, float c,
- float v000, float v100, float v010, float v110,
- float v001, float v101, float v011, float v111)
-{
- const float temp0 = lerp_2d(a, b, v000, v100, v010, v110);
- const float temp1 = lerp_2d(a, b, v001, v101, v011, v111);
- return lerp(c, temp0, temp1);
-}
-
-
-
-/**
- * If A is a signed integer, A % B doesn't give the right value for A < 0
- * (in terms of texture repeat). Just casting to unsigned fixes that.
- */
-#define REMAINDER(A, B) ((unsigned) (A) % (unsigned) (B))
-
-
-/**
- * Apply texture coord wrapping mode and return integer texture indexes
- * for a vector of four texcoords (S or T or P).
- * \param wrapMode PIPE_TEX_WRAP_x
- * \param s the incoming texcoords
- * \param size the texture image size
- * \param icoord returns the integer texcoords
- * \return integer texture index
- */
-static INLINE void
-nearest_texcoord_4(unsigned wrapMode, const float s[4], unsigned size,
- int icoord[4])
-{
- uint ch;
- switch (wrapMode) {
- case PIPE_TEX_WRAP_REPEAT:
- /* s limited to [0,1) */
- /* i limited to [0,size-1] */
- for (ch = 0; ch < 4; ch++) {
- int i = util_ifloor(s[ch] * size);
- icoord[ch] = REMAINDER(i, size);
- }
- return;
- case PIPE_TEX_WRAP_CLAMP:
- /* s limited to [0,1] */
- /* i limited to [0,size-1] */
- for (ch = 0; ch < 4; ch++) {
- if (s[ch] <= 0.0F)
- icoord[ch] = 0;
- else if (s[ch] >= 1.0F)
- icoord[ch] = size - 1;
- else
- icoord[ch] = util_ifloor(s[ch] * size);
- }
- return;
- case PIPE_TEX_WRAP_CLAMP_TO_EDGE:
- {
- /* s limited to [min,max] */
- /* i limited to [0, size-1] */
- const float min = 1.0F / (2.0F * size);
- const float max = 1.0F - min;
- for (ch = 0; ch < 4; ch++) {
- if (s[ch] < min)
- icoord[ch] = 0;
- else if (s[ch] > max)
- icoord[ch] = size - 1;
- else
- icoord[ch] = util_ifloor(s[ch] * size);
- }
- }
- return;
- case PIPE_TEX_WRAP_CLAMP_TO_BORDER:
- {
- /* s limited to [min,max] */
- /* i limited to [-1, size] */
- const float min = -1.0F / (2.0F * size);
- const float max = 1.0F - min;
- for (ch = 0; ch < 4; ch++) {
- if (s[ch] <= min)
- icoord[ch] = -1;
- else if (s[ch] >= max)
- icoord[ch] = size;
- else
- icoord[ch] = util_ifloor(s[ch] * size);
- }
- }
- return;
- case PIPE_TEX_WRAP_MIRROR_REPEAT:
- {
- const float min = 1.0F / (2.0F * size);
- const float max = 1.0F - min;
- for (ch = 0; ch < 4; ch++) {
- const int flr = util_ifloor(s[ch]);
- float u;
- if (flr & 1)
- u = 1.0F - (s[ch] - (float) flr);
- else
- u = s[ch] - (float) flr;
- if (u < min)
- icoord[ch] = 0;
- else if (u > max)
- icoord[ch] = size - 1;
- else
- icoord[ch] = util_ifloor(u * size);
- }
- }
- return;
- case PIPE_TEX_WRAP_MIRROR_CLAMP:
- for (ch = 0; ch < 4; ch++) {
- /* s limited to [0,1] */
- /* i limited to [0,size-1] */
- const float u = fabsf(s[ch]);
- if (u <= 0.0F)
- icoord[ch] = 0;
- else if (u >= 1.0F)
- icoord[ch] = size - 1;
- else
- icoord[ch] = util_ifloor(u * size);
- }
- return;
- case PIPE_TEX_WRAP_MIRROR_CLAMP_TO_EDGE:
- {
- /* s limited to [min,max] */
- /* i limited to [0, size-1] */
- const float min = 1.0F / (2.0F * size);
- const float max = 1.0F - min;
- for (ch = 0; ch < 4; ch++) {
- const float u = fabsf(s[ch]);
- if (u < min)
- icoord[ch] = 0;
- else if (u > max)
- icoord[ch] = size - 1;
- else
- icoord[ch] = util_ifloor(u * size);
- }
- }
- return;
- case PIPE_TEX_WRAP_MIRROR_CLAMP_TO_BORDER:
- {
- /* s limited to [min,max] */
- /* i limited to [0, size-1] */
- const float min = -1.0F / (2.0F * size);
- const float max = 1.0F - min;
- for (ch = 0; ch < 4; ch++) {
- const float u = fabsf(s[ch]);
- if (u < min)
- icoord[ch] = -1;
- else if (u > max)
- icoord[ch] = size;
- else
- icoord[ch] = util_ifloor(u * size);
- }
- }
- return;
- default:
- assert(0);
- }
-}
-
-
-/**
- * Used to compute texel locations for linear sampling for four texcoords.
- * \param wrapMode PIPE_TEX_WRAP_x
- * \param s the texcoords
- * \param size the texture image size
- * \param icoord0 returns first texture indexes
- * \param icoord1 returns second texture indexes (usually icoord0 + 1)
- * \param w returns blend factor/weight between texture indexes
- * \param icoord returns the computed integer texture coords
- */
-static INLINE void
-linear_texcoord_4(unsigned wrapMode, const float s[4], unsigned size,
- int icoord0[4], int icoord1[4], float w[4])
-{
- uint ch;
-
- switch (wrapMode) {
- case PIPE_TEX_WRAP_REPEAT:
- for (ch = 0; ch < 4; ch++) {
- float u = s[ch] * size - 0.5F;
- icoord0[ch] = REMAINDER(util_ifloor(u), size);
- icoord1[ch] = REMAINDER(icoord0[ch] + 1, size);
- w[ch] = FRAC(u);
- }
- break;;
- case PIPE_TEX_WRAP_CLAMP:
- for (ch = 0; ch < 4; ch++) {
- float u = CLAMP(s[ch], 0.0F, 1.0F);
- u = u * size - 0.5f;
- icoord0[ch] = util_ifloor(u);
- icoord1[ch] = icoord0[ch] + 1;
- w[ch] = FRAC(u);
- }
- break;;
- case PIPE_TEX_WRAP_CLAMP_TO_EDGE:
- for (ch = 0; ch < 4; ch++) {
- float u = CLAMP(s[ch], 0.0F, 1.0F);
- u = u * size - 0.5f;
- icoord0[ch] = util_ifloor(u);
- icoord1[ch] = icoord0[ch] + 1;
- if (icoord0[ch] < 0)
- icoord0[ch] = 0;
- if (icoord1[ch] >= (int) size)
- icoord1[ch] = size - 1;
- w[ch] = FRAC(u);
- }
- break;;
- case PIPE_TEX_WRAP_CLAMP_TO_BORDER:
- {
- const float min = -1.0F / (2.0F * size);
- const float max = 1.0F - min;
- for (ch = 0; ch < 4; ch++) {
- float u = CLAMP(s[ch], min, max);
- u = u * size - 0.5f;
- icoord0[ch] = util_ifloor(u);
- icoord1[ch] = icoord0[ch] + 1;
- w[ch] = FRAC(u);
- }
- }
- break;;
- case PIPE_TEX_WRAP_MIRROR_REPEAT:
- for (ch = 0; ch < 4; ch++) {
- const int flr = util_ifloor(s[ch]);
- float u;
- if (flr & 1)
- u = 1.0F - (s[ch] - (float) flr);
- else
- u = s[ch] - (float) flr;
- u = u * size - 0.5F;
- icoord0[ch] = util_ifloor(u);
- icoord1[ch] = icoord0[ch] + 1;
- if (icoord0[ch] < 0)
- icoord0[ch] = 0;
- if (icoord1[ch] >= (int) size)
- icoord1[ch] = size - 1;
- w[ch] = FRAC(u);
- }
- break;;
- case PIPE_TEX_WRAP_MIRROR_CLAMP:
- for (ch = 0; ch < 4; ch++) {
- float u = fabsf(s[ch]);
- if (u >= 1.0F)
- u = (float) size;
- else
- u *= size;
- u -= 0.5F;
- icoord0[ch] = util_ifloor(u);
- icoord1[ch] = icoord0[ch] + 1;
- w[ch] = FRAC(u);
- }
- break;;
- case PIPE_TEX_WRAP_MIRROR_CLAMP_TO_EDGE:
- for (ch = 0; ch < 4; ch++) {
- float u = fabsf(s[ch]);
- if (u >= 1.0F)
- u = (float) size;
- else
- u *= size;
- u -= 0.5F;
- icoord0[ch] = util_ifloor(u);
- icoord1[ch] = icoord0[ch] + 1;
- if (icoord0[ch] < 0)
- icoord0[ch] = 0;
- if (icoord1[ch] >= (int) size)
- icoord1[ch] = size - 1;
- w[ch] = FRAC(u);
- }
- break;;
- case PIPE_TEX_WRAP_MIRROR_CLAMP_TO_BORDER:
- {
- const float min = -1.0F / (2.0F * size);
- const float max = 1.0F - min;
- for (ch = 0; ch < 4; ch++) {
- float u = fabsf(s[ch]);
- if (u <= min)
- u = min * size;
- else if (u >= max)
- u = max * size;
- else
- u *= size;
- u -= 0.5F;
- icoord0[ch] = util_ifloor(u);
- icoord1[ch] = icoord0[ch] + 1;
- w[ch] = FRAC(u);
- }
- }
- break;;
- default:
- assert(0);
- }
-}
-
-
-/**
- * For RECT textures / unnormalized texcoords
- * Only a subset of wrap modes supported.
- */
-static INLINE void
-nearest_texcoord_unnorm_4(unsigned wrapMode, const float s[4], unsigned size,
- int icoord[4])
-{
- uint ch;
- switch (wrapMode) {
- case PIPE_TEX_WRAP_CLAMP:
- for (ch = 0; ch < 4; ch++) {
- int i = util_ifloor(s[ch]);
- icoord[ch]= CLAMP(i, 0, (int) size-1);
- }
- return;
- case PIPE_TEX_WRAP_CLAMP_TO_EDGE:
- /* fall-through */
- case PIPE_TEX_WRAP_CLAMP_TO_BORDER:
- for (ch = 0; ch < 4; ch++) {
- icoord[ch]= util_ifloor( CLAMP(s[ch], 0.5F, (float) size - 0.5F) );
- }
- return;
- default:
- assert(0);
- }
-}
-
-
-/**
- * For RECT textures / unnormalized texcoords.
- * Only a subset of wrap modes supported.
- */
-static INLINE void
-linear_texcoord_unnorm_4(unsigned wrapMode, const float s[4], unsigned size,
- int icoord0[4], int icoord1[4], float w[4])
-{
- uint ch;
- switch (wrapMode) {
- case PIPE_TEX_WRAP_CLAMP:
- for (ch = 0; ch < 4; ch++) {
- /* Not exactly what the spec says, but it matches NVIDIA output */
- float u = CLAMP(s[ch] - 0.5F, 0.0f, (float) size - 1.0f);
- icoord0[ch] = util_ifloor(u);
- icoord1[ch] = icoord0[ch] + 1;
- w[ch] = FRAC(u);
- }
- return;
- case PIPE_TEX_WRAP_CLAMP_TO_EDGE:
- /* fall-through */
- case PIPE_TEX_WRAP_CLAMP_TO_BORDER:
- for (ch = 0; ch < 4; ch++) {
- float u = CLAMP(s[ch], 0.5F, (float) size - 0.5F);
- u -= 0.5F;
- icoord0[ch] = util_ifloor(u);
- icoord1[ch] = icoord0[ch] + 1;
- if (icoord1[ch] > (int) size - 1)
- icoord1[ch] = size - 1;
- w[ch] = FRAC(u);
- }
- break;
- default:
- assert(0);
- }
-}
-
-
-static unsigned
-choose_cube_face(float rx, float ry, float rz, float *newS, float *newT)
-{
- /*
- major axis
- direction target sc tc ma
- ---------- ------------------------------- --- --- ---
- +rx TEXTURE_CUBE_MAP_POSITIVE_X_EXT -rz -ry rx
- -rx TEXTURE_CUBE_MAP_NEGATIVE_X_EXT +rz -ry rx
- +ry TEXTURE_CUBE_MAP_POSITIVE_Y_EXT +rx +rz ry
- -ry TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT +rx -rz ry
- +rz TEXTURE_CUBE_MAP_POSITIVE_Z_EXT +rx -ry rz
- -rz TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT -rx -ry rz
- */
- const float arx = fabsf(rx), ary = fabsf(ry), arz = fabsf(rz);
- unsigned face;
- float sc, tc, ma;
-
- if (arx > ary && arx > arz) {
- if (rx >= 0.0F) {
- face = PIPE_TEX_FACE_POS_X;
- sc = -rz;
- tc = -ry;
- ma = arx;
- }
- else {
- face = PIPE_TEX_FACE_NEG_X;
- sc = rz;
- tc = -ry;
- ma = arx;
- }
- }
- else if (ary > arx && ary > arz) {
- if (ry >= 0.0F) {
- face = PIPE_TEX_FACE_POS_Y;
- sc = rx;
- tc = rz;
- ma = ary;
- }
- else {
- face = PIPE_TEX_FACE_NEG_Y;
- sc = rx;
- tc = -rz;
- ma = ary;
- }
- }
- else {
- if (rz > 0.0F) {
- face = PIPE_TEX_FACE_POS_Z;
- sc = rx;
- tc = -ry;
- ma = arz;
- }
- else {
- face = PIPE_TEX_FACE_NEG_Z;
- sc = -rx;
- tc = -ry;
- ma = arz;
- }
- }
-
- *newS = ( sc / ma + 1.0F ) * 0.5F;
- *newT = ( tc / ma + 1.0F ) * 0.5F;
-
- return face;
-}
-
-
-/**
- * Examine the quad's texture coordinates to compute the partial
- * derivatives w.r.t X and Y, then compute lambda (level of detail).
- *
- * This is only done for fragment shaders, not vertex shaders.
- */
-static float
-compute_lambda(struct tgsi_sampler *tgsi_sampler,
- const float s[QUAD_SIZE],
- const float t[QUAD_SIZE],
- const float p[QUAD_SIZE],
- float lodbias)
-{
- const struct lp_shader_sampler *samp = lp_shader_sampler(tgsi_sampler);
- const struct pipe_texture *texture = samp->texture;
- const struct pipe_sampler_state *sampler = samp->sampler;
- float rho, lambda;
-
- if (samp->processor == TGSI_PROCESSOR_VERTEX)
- return lodbias;
-
- assert(sampler->normalized_coords);
-
- assert(s);
- {
- float dsdx = s[QUAD_BOTTOM_RIGHT] - s[QUAD_BOTTOM_LEFT];
- float dsdy = s[QUAD_TOP_LEFT] - s[QUAD_BOTTOM_LEFT];
- dsdx = fabsf(dsdx);
- dsdy = fabsf(dsdy);
- rho = MAX2(dsdx, dsdy) * texture->width[0];
- }
- if (t) {
- float dtdx = t[QUAD_BOTTOM_RIGHT] - t[QUAD_BOTTOM_LEFT];
- float dtdy = t[QUAD_TOP_LEFT] - t[QUAD_BOTTOM_LEFT];
- float max;
- dtdx = fabsf(dtdx);
- dtdy = fabsf(dtdy);
- max = MAX2(dtdx, dtdy) * texture->height[0];
- rho = MAX2(rho, max);
- }
- if (p) {
- float dpdx = p[QUAD_BOTTOM_RIGHT] - p[QUAD_BOTTOM_LEFT];
- float dpdy = p[QUAD_TOP_LEFT] - p[QUAD_BOTTOM_LEFT];
- float max;
- dpdx = fabsf(dpdx);
- dpdy = fabsf(dpdy);
- max = MAX2(dpdx, dpdy) * texture->depth[0];
- rho = MAX2(rho, max);
- }
-
- lambda = util_fast_log2(rho);
- lambda += lodbias + sampler->lod_bias;
- lambda = CLAMP(lambda, sampler->min_lod, sampler->max_lod);
-
- return lambda;
-}
-
-
-/**
- * Do several things here:
- * 1. Compute lambda from the texcoords, if needed
- * 2. Determine if we're minifying or magnifying
- * 3. If minifying, choose mipmap levels
- * 4. Return image filter to use within mipmap images
- * \param level0 Returns first mipmap level to sample from
- * \param level1 Returns second mipmap level to sample from
- * \param levelBlend Returns blend factor between levels, in [0,1]
- * \param imgFilter Returns either the min or mag filter, depending on lambda
- */
-static void
-choose_mipmap_levels(struct tgsi_sampler *tgsi_sampler,
- const float s[QUAD_SIZE],
- const float t[QUAD_SIZE],
- const float p[QUAD_SIZE],
- float lodbias,
- unsigned *level0, unsigned *level1, float *levelBlend,
- unsigned *imgFilter)
-{
- const struct lp_shader_sampler *samp = lp_shader_sampler(tgsi_sampler);
- const struct pipe_texture *texture = samp->texture;
- const struct pipe_sampler_state *sampler = samp->sampler;
-
- if (sampler->min_mip_filter == PIPE_TEX_MIPFILTER_NONE) {
- /* no mipmap selection needed */
- *level0 = *level1 = CLAMP((int) sampler->min_lod,
- 0, (int) texture->last_level);
-
- if (sampler->min_img_filter != sampler->mag_img_filter) {
- /* non-mipmapped texture, but still need to determine if doing
- * minification or magnification.
- */
- float lambda = compute_lambda(tgsi_sampler, s, t, p, lodbias);
- if (lambda <= 0.0) {
- *imgFilter = sampler->mag_img_filter;
- }
- else {
- *imgFilter = sampler->min_img_filter;
- }
- }
- else {
- *imgFilter = sampler->mag_img_filter;
- }
- }
- else {
- float lambda = compute_lambda(tgsi_sampler, s, t, p, lodbias);
-
- if (lambda <= 0.0) { /* XXX threshold depends on the filter */
- /* magnifying */
- *imgFilter = sampler->mag_img_filter;
- *level0 = *level1 = 0;
- }
- else {
- /* minifying */
- *imgFilter = sampler->min_img_filter;
-
- /* choose mipmap level(s) and compute the blend factor between them */
- if (sampler->min_mip_filter == PIPE_TEX_MIPFILTER_NEAREST) {
- /* Nearest mipmap level */
- const int lvl = (int) (lambda + 0.5);
- *level0 =
- *level1 = CLAMP(lvl, 0, (int) texture->last_level);
- }
- else {
- /* Linear interpolation between mipmap levels */
- const int lvl = (int) lambda;
- *level0 = CLAMP(lvl, 0, (int) texture->last_level);
- *level1 = CLAMP(lvl + 1, 0, (int) texture->last_level);
- *levelBlend = FRAC(lambda); /* blending weight between levels */
- }
- }
- }
-}
-
-
-/**
- * Get a texel from a texture, using the texture tile cache.
- *
- * \param face the cube face in 0..5
- * \param level the mipmap level
- * \param x the x coord of texel within 2D image
- * \param y the y coord of texel within 2D image
- * \param z which slice of a 3D texture
- * \param rgba the quad to put the texel/color into
- * \param j which element of the rgba quad to write to
- *
- * XXX maybe move this into lp_tile_cache.c and merge with the
- * lp_get_cached_tile_tex() function. Also, get 4 texels instead of 1...
- */
-static void
-get_texel_quad_2d(const struct tgsi_sampler *tgsi_sampler,
- unsigned face, unsigned level, int x, int y,
- const uint8_t *out[4])
-{
- const struct lp_shader_sampler *samp = lp_shader_sampler(tgsi_sampler);
-
- const struct llvmpipe_cached_tex_tile *tile
- = lp_get_cached_tex_tile(samp->cache,
- tex_tile_address(x, y, 0, face, level));
-
- y %= TEX_TILE_SIZE;
- x %= TEX_TILE_SIZE;
-
- out[0] = &tile->color[y ][x ][0];
- out[1] = &tile->color[y ][x+1][0];
- out[2] = &tile->color[y+1][x ][0];
- out[3] = &tile->color[y+1][x+1][0];
-}
-
-static INLINE const uint8_t *
-get_texel_2d_ptr(const struct tgsi_sampler *tgsi_sampler,
- unsigned face, unsigned level, int x, int y)
-{
- const struct lp_shader_sampler *samp = lp_shader_sampler(tgsi_sampler);
-
- const struct llvmpipe_cached_tex_tile *tile
- = lp_get_cached_tex_tile(samp->cache,
- tex_tile_address(x, y, 0, face, level));
-
- y %= TEX_TILE_SIZE;
- x %= TEX_TILE_SIZE;
-
- return &tile->color[y][x][0];
-}
-
-
-static void
-get_texel_quad_2d_mt(const struct tgsi_sampler *tgsi_sampler,
- unsigned face, unsigned level,
- int x0, int y0,
- int x1, int y1,
- const uint8_t *out[4])
-{
- unsigned i;
-
- for (i = 0; i < 4; i++) {
- unsigned tx = (i & 1) ? x1 : x0;
- unsigned ty = (i >> 1) ? y1 : y0;
-
- out[i] = get_texel_2d_ptr( tgsi_sampler, face, level, tx, ty );
- }
-}
-
-static void
-get_texel(const struct tgsi_sampler *tgsi_sampler,
- unsigned face, unsigned level, int x, int y, int z,
- float rgba[NUM_CHANNELS][QUAD_SIZE], unsigned j)
-{
- const struct lp_shader_sampler *samp = lp_shader_sampler(tgsi_sampler);
- const struct pipe_texture *texture = samp->texture;
- const struct pipe_sampler_state *sampler = samp->sampler;
-
- if (x < 0 || x >= (int) texture->width[level] ||
- y < 0 || y >= (int) texture->height[level] ||
- z < 0 || z >= (int) texture->depth[level]) {
- rgba[0][j] = sampler->border_color[0];
- rgba[1][j] = sampler->border_color[1];
- rgba[2][j] = sampler->border_color[2];
- rgba[3][j] = sampler->border_color[3];
- }
- else {
- const unsigned tx = x % TEX_TILE_SIZE;
- const unsigned ty = y % TEX_TILE_SIZE;
- const struct llvmpipe_cached_tex_tile *tile;
-
- tile = lp_get_cached_tex_tile(samp->cache,
- tex_tile_address(x, y, z, face, level));
-
- rgba[0][j] = ubyte_to_float(tile->color[ty][tx][0]);
- rgba[1][j] = ubyte_to_float(tile->color[ty][tx][1]);
- rgba[2][j] = ubyte_to_float(tile->color[ty][tx][2]);
- rgba[3][j] = ubyte_to_float(tile->color[ty][tx][3]);
- if (0)
- {
- debug_printf("Get texel %f %f %f %f from %s\n",
- rgba[0][j], rgba[1][j], rgba[2][j], rgba[3][j],
- pf_name(texture->format));
- }
- }
-}
-
-
-/**
- * Compare texcoord 'p' (aka R) against texture value 'rgba[0]'
- * When we sampled the depth texture, the depth value was put into all
- * RGBA channels. We look at the red channel here.
- * \param rgba quad of (depth) texel values
- * \param p texture 'P' components for four pixels in quad
- * \param j which pixel in the quad to test [0..3]
- */
-static INLINE void
-shadow_compare(const struct pipe_sampler_state *sampler,
- float rgba[NUM_CHANNELS][QUAD_SIZE],
- const float p[QUAD_SIZE],
- uint j)
-{
- int k;
- switch (sampler->compare_func) {
- case PIPE_FUNC_LESS:
- k = p[j] < rgba[0][j];
- break;
- case PIPE_FUNC_LEQUAL:
- k = p[j] <= rgba[0][j];
- break;
- case PIPE_FUNC_GREATER:
- k = p[j] > rgba[0][j];
- break;
- case PIPE_FUNC_GEQUAL:
- k = p[j] >= rgba[0][j];
- break;
- case PIPE_FUNC_EQUAL:
- k = p[j] == rgba[0][j];
- break;
- case PIPE_FUNC_NOTEQUAL:
- k = p[j] != rgba[0][j];
- break;
- case PIPE_FUNC_ALWAYS:
- k = 1;
- break;
- case PIPE_FUNC_NEVER:
- k = 0;
- break;
- default:
- k = 0;
- assert(0);
- break;
- }
-
- /* XXX returning result for default GL_DEPTH_TEXTURE_MODE = GL_LUMINANCE */
- rgba[0][j] = rgba[1][j] = rgba[2][j] = (float) k;
- rgba[3][j] = 1.0F;
-}
-
-
-/**
- * As above, but do four z/texture comparisons.
- */
-static INLINE void
-shadow_compare4(const struct pipe_sampler_state *sampler,
- float rgba[NUM_CHANNELS][QUAD_SIZE],
- const float p[QUAD_SIZE])
-{
- int j, k0, k1, k2, k3;
- float val;
-
- /* compare four texcoords vs. four texture samples */
- switch (sampler->compare_func) {
- case PIPE_FUNC_LESS:
- k0 = p[0] < rgba[0][0];
- k1 = p[1] < rgba[0][1];
- k2 = p[2] < rgba[0][2];
- k3 = p[3] < rgba[0][3];
- break;
- case PIPE_FUNC_LEQUAL:
- k0 = p[0] <= rgba[0][0];
- k1 = p[1] <= rgba[0][1];
- k2 = p[2] <= rgba[0][2];
- k3 = p[3] <= rgba[0][3];
- break;
- case PIPE_FUNC_GREATER:
- k0 = p[0] > rgba[0][0];
- k1 = p[1] > rgba[0][1];
- k2 = p[2] > rgba[0][2];
- k3 = p[3] > rgba[0][3];
- break;
- case PIPE_FUNC_GEQUAL:
- k0 = p[0] >= rgba[0][0];
- k1 = p[1] >= rgba[0][1];
- k2 = p[2] >= rgba[0][2];
- k3 = p[3] >= rgba[0][3];
- break;
- case PIPE_FUNC_EQUAL:
- k0 = p[0] == rgba[0][0];
- k1 = p[1] == rgba[0][1];
- k2 = p[2] == rgba[0][2];
- k3 = p[3] == rgba[0][3];
- break;
- case PIPE_FUNC_NOTEQUAL:
- k0 = p[0] != rgba[0][0];
- k1 = p[1] != rgba[0][1];
- k2 = p[2] != rgba[0][2];
- k3 = p[3] != rgba[0][3];
- break;
- case PIPE_FUNC_ALWAYS:
- k0 = k1 = k2 = k3 = 1;
- break;
- case PIPE_FUNC_NEVER:
- k0 = k1 = k2 = k3 = 0;
- break;
- default:
- k0 = k1 = k2 = k3 = 0;
- assert(0);
- break;
- }
-
- /* convert four pass/fail values to an intensity in [0,1] */
- val = 0.25F * (k0 + k1 + k2 + k3);
-
- /* XXX returning result for default GL_DEPTH_TEXTURE_MODE = GL_LUMINANCE */
- for (j = 0; j < 4; j++) {
- rgba[0][j] = rgba[1][j] = rgba[2][j] = val;
- rgba[3][j] = 1.0F;
- }
-}
-
-
-
-static void
-lp_get_samples_2d_linear_repeat_POT(struct tgsi_sampler *tgsi_sampler,
- const float s[QUAD_SIZE],
- const float t[QUAD_SIZE],
- const float p[QUAD_SIZE],
- float lodbias,
- float rgba[NUM_CHANNELS][QUAD_SIZE])
-{
- const struct lp_shader_sampler *samp = lp_shader_sampler(tgsi_sampler);
- unsigned j;
- unsigned level = samp->level;
- unsigned xpot = 1 << (samp->xpot - level);
- unsigned ypot = 1 << (samp->ypot - level);
- unsigned xmax = (xpot - 1) & (TEX_TILE_SIZE - 1); /* MIN2(TEX_TILE_SIZE, xpot) - 1; */
- unsigned ymax = (ypot - 1) & (TEX_TILE_SIZE - 1); /* MIN2(TEX_TILE_SIZE, ypot) - 1; */
-
- for (j = 0; j < QUAD_SIZE; j++) {
- int c;
-
- float u = s[j] * xpot - 0.5F;
- float v = t[j] * ypot - 0.5F;
-
- int uflr = util_ifloor(u);
- int vflr = util_ifloor(v);
-
- float xw = u - (float)uflr;
- float yw = v - (float)vflr;
-
- int x0 = uflr & (xpot - 1);
- int y0 = vflr & (ypot - 1);
-
- const uint8_t *tx[4];
-
-
- /* Can we fetch all four at once:
- */
- if (x0 < xmax && y0 < ymax)
- {
- get_texel_quad_2d(tgsi_sampler, 0, level, x0, y0, tx);
- }
- else
- {
- unsigned x1 = (x0 + 1) & (xpot - 1);
- unsigned y1 = (y0 + 1) & (ypot - 1);
- get_texel_quad_2d_mt(tgsi_sampler, 0, level,
- x0, y0, x1, y1, tx);
- }
-
-
- /* interpolate R, G, B, A */
- for (c = 0; c < 4; c++) {
- rgba[c][j] = lerp_2d(xw, yw,
- ubyte_to_float(tx[0][c]), ubyte_to_float(tx[1][c]),
- ubyte_to_float(tx[2][c]), ubyte_to_float(tx[3][c]));
- }
- }
-}
-
-
-static void
-lp_get_samples_2d_nearest_repeat_POT(struct tgsi_sampler *tgsi_sampler,
- const float s[QUAD_SIZE],
- const float t[QUAD_SIZE],
- const float p[QUAD_SIZE],
- float lodbias,
- float rgba[NUM_CHANNELS][QUAD_SIZE])
-{
- const struct lp_shader_sampler *samp = lp_shader_sampler(tgsi_sampler);
- unsigned j;
- unsigned level = samp->level;
- unsigned xpot = 1 << (samp->xpot - level);
- unsigned ypot = 1 << (samp->ypot - level);
-
- for (j = 0; j < QUAD_SIZE; j++) {
- int c;
-
- float u = s[j] * xpot;
- float v = t[j] * ypot;
-
- int uflr = util_ifloor(u);
- int vflr = util_ifloor(v);
-
- int x0 = uflr & (xpot - 1);
- int y0 = vflr & (ypot - 1);
-
- const uint8_t *out = get_texel_2d_ptr(tgsi_sampler, 0, level, x0, y0);
-
- for (c = 0; c < 4; c++) {
- rgba[c][j] = ubyte_to_float(out[c]);
- }
- }
-}
-
-
-static void
-lp_get_samples_2d_nearest_clamp_POT(struct tgsi_sampler *tgsi_sampler,
- const float s[QUAD_SIZE],
- const float t[QUAD_SIZE],
- const float p[QUAD_SIZE],
- float lodbias,
- float rgba[NUM_CHANNELS][QUAD_SIZE])
-{
- const struct lp_shader_sampler *samp = lp_shader_sampler(tgsi_sampler);
- unsigned j;
- unsigned level = samp->level;
- unsigned xpot = 1 << (samp->xpot - level);
- unsigned ypot = 1 << (samp->ypot - level);
-
- for (j = 0; j < QUAD_SIZE; j++) {
- int c;
-
- float u = s[j] * xpot;
- float v = t[j] * ypot;
-
- int x0, y0;
- const uint8_t *out;
-
- x0 = util_ifloor(u);
- if (x0 < 0)
- x0 = 0;
- else if (x0 > xpot - 1)
- x0 = xpot - 1;
-
- y0 = util_ifloor(v);
- if (y0 < 0)
- y0 = 0;
- else if (y0 > ypot - 1)
- y0 = ypot - 1;
-
- out = get_texel_2d_ptr(tgsi_sampler, 0, level, x0, y0);
-
- for (c = 0; c < 4; c++) {
- rgba[c][j] = ubyte_to_float(out[c]);
- }
- }
-}
-
-
-static void
-lp_get_samples_2d_linear_mip_linear_repeat_POT(struct tgsi_sampler *tgsi_sampler,
- const float s[QUAD_SIZE],
- const float t[QUAD_SIZE],
- const float p[QUAD_SIZE],
- float lodbias,
- float rgba[NUM_CHANNELS][QUAD_SIZE])
-{
- struct lp_shader_sampler *samp = lp_shader_sampler(tgsi_sampler);
- const struct pipe_texture *texture = samp->texture;
- int level0;
- float lambda;
-
- lambda = compute_lambda(tgsi_sampler, s, t, p, lodbias);
- level0 = (int)lambda;
-
- if (lambda < 0.0) {
- samp->level = 0;
- lp_get_samples_2d_linear_repeat_POT( tgsi_sampler,
- s, t, p, 0, rgba );
- }
- else if (level0 >= texture->last_level) {
- samp->level = texture->last_level;
- lp_get_samples_2d_linear_repeat_POT( tgsi_sampler,
- s, t, p, 0, rgba );
- }
- else {
- float levelBlend = lambda - level0;
- float rgba0[4][4];
- float rgba1[4][4];
- int c,j;
-
- samp->level = level0;
- lp_get_samples_2d_linear_repeat_POT( tgsi_sampler,
- s, t, p, 0, rgba0 );
-
- samp->level = level0+1;
- lp_get_samples_2d_linear_repeat_POT( tgsi_sampler,
- s, t, p, 0, rgba1 );
-
- for (j = 0; j < QUAD_SIZE; j++) {
- for (c = 0; c < 4; c++) {
- rgba[c][j] = lerp(levelBlend, rgba0[c][j], rgba1[c][j]);
- }
- }
- }
-}
-
-/**
- * Common code for sampling 1D/2D/cube textures.
- * Could probably extend for 3D...
- */
-static void
-lp_get_samples_2d_common(struct tgsi_sampler *tgsi_sampler,
- const float s[QUAD_SIZE],
- const float t[QUAD_SIZE],
- const float p[QUAD_SIZE],
- float lodbias,
- float rgba[NUM_CHANNELS][QUAD_SIZE],
- const unsigned faces[4])
-{
- const struct lp_shader_sampler *samp = lp_shader_sampler(tgsi_sampler);
- const struct pipe_texture *texture = samp->texture;
- const struct pipe_sampler_state *sampler = samp->sampler;
- unsigned level0, level1, j, imgFilter;
- int width, height;
- float levelBlend;
-
- choose_mipmap_levels(tgsi_sampler, s, t, p,
- lodbias,
- &level0, &level1, &levelBlend, &imgFilter);
-
- assert(sampler->normalized_coords);
-
- width = texture->width[level0];
- height = texture->height[level0];
-
- assert(width > 0);
-
- switch (imgFilter) {
- case PIPE_TEX_FILTER_NEAREST:
- {
- int x[4], y[4];
- nearest_texcoord_4(sampler->wrap_s, s, width, x);
- nearest_texcoord_4(sampler->wrap_t, t, height, y);
-
- for (j = 0; j < QUAD_SIZE; j++) {
- get_texel(tgsi_sampler, faces[j], level0, x[j], y[j], 0, rgba, j);
- if (sampler->compare_mode == PIPE_TEX_COMPARE_R_TO_TEXTURE) {
- shadow_compare(sampler, rgba, p, j);
- }
-
- if (level0 != level1) {
- /* get texels from second mipmap level and blend */
- float rgba2[4][4];
- unsigned c;
- x[j] /= 2;
- y[j] /= 2;
- get_texel(tgsi_sampler, faces[j], level1, x[j], y[j], 0,
- rgba2, j);
- if (sampler->compare_mode == PIPE_TEX_COMPARE_R_TO_TEXTURE){
- shadow_compare(sampler, rgba2, p, j);
- }
-
- for (c = 0; c < NUM_CHANNELS; c++) {
- rgba[c][j] = lerp(levelBlend, rgba[c][j], rgba2[c][j]);
- }
- }
- }
- }
- break;
- case PIPE_TEX_FILTER_LINEAR:
- case PIPE_TEX_FILTER_ANISO:
- {
- int x0[4], y0[4], x1[4], y1[4];
- float xw[4], yw[4]; /* weights */
-
- linear_texcoord_4(sampler->wrap_s, s, width, x0, x1, xw);
- linear_texcoord_4(sampler->wrap_t, t, height, y0, y1, yw);
-
- for (j = 0; j < QUAD_SIZE; j++) {
- float tx[4][4]; /* texels */
- int c;
- get_texel(tgsi_sampler, faces[j], level0, x0[j], y0[j], 0, tx, 0);
- get_texel(tgsi_sampler, faces[j], level0, x1[j], y0[j], 0, tx, 1);
- get_texel(tgsi_sampler, faces[j], level0, x0[j], y1[j], 0, tx, 2);
- get_texel(tgsi_sampler, faces[j], level0, x1[j], y1[j], 0, tx, 3);
- if (sampler->compare_mode == PIPE_TEX_COMPARE_R_TO_TEXTURE) {
- shadow_compare4(sampler, tx, p);
- }
-
- /* interpolate R, G, B, A */
- for (c = 0; c < 4; c++) {
- rgba[c][j] = lerp_2d(xw[j], yw[j],
- tx[c][0], tx[c][1],
- tx[c][2], tx[c][3]);
- }
-
- if (level0 != level1) {
- /* get texels from second mipmap level and blend */
- float rgba2[4][4];
-
- /* XXX: This is incorrect -- will often end up with (x0
- * == x1 && y0 == y1), meaning that we fetch the same
- * texel four times and linearly interpolate between
- * identical values. The correct approach would be to
- * call linear_texcoord again for the second level.
- */
- x0[j] /= 2;
- y0[j] /= 2;
- x1[j] /= 2;
- y1[j] /= 2;
- get_texel(tgsi_sampler, faces[j], level1, x0[j], y0[j], 0, tx, 0);
- get_texel(tgsi_sampler, faces[j], level1, x1[j], y0[j], 0, tx, 1);
- get_texel(tgsi_sampler, faces[j], level1, x0[j], y1[j], 0, tx, 2);
- get_texel(tgsi_sampler, faces[j], level1, x1[j], y1[j], 0, tx, 3);
- if (sampler->compare_mode == PIPE_TEX_COMPARE_R_TO_TEXTURE){
- shadow_compare4(sampler, tx, p);
- }
-
- /* interpolate R, G, B, A */
- for (c = 0; c < 4; c++) {
- rgba2[c][j] = lerp_2d(xw[j], yw[j],
- tx[c][0], tx[c][1], tx[c][2], tx[c][3]);
- }
-
- for (c = 0; c < NUM_CHANNELS; c++) {
- rgba[c][j] = lerp(levelBlend, rgba[c][j], rgba2[c][j]);
- }
- }
- }
- }
- break;
- default:
- assert(0);
- }
-}
-
-
-static INLINE void
-lp_get_samples_1d(struct tgsi_sampler *sampler,
- const float s[QUAD_SIZE],
- const float t[QUAD_SIZE],
- const float p[QUAD_SIZE],
- float lodbias,
- float rgba[NUM_CHANNELS][QUAD_SIZE])
-{
- static const unsigned faces[4] = {0, 0, 0, 0};
- static const float tzero[4] = {0, 0, 0, 0};
- lp_get_samples_2d_common(sampler, s, tzero, NULL,
- lodbias, rgba, faces);
-}
-
-
-static INLINE void
-lp_get_samples_2d(struct tgsi_sampler *sampler,
- const float s[QUAD_SIZE],
- const float t[QUAD_SIZE],
- const float p[QUAD_SIZE],
- float lodbias,
- float rgba[NUM_CHANNELS][QUAD_SIZE])
-{
- static const unsigned faces[4] = {0, 0, 0, 0};
- lp_get_samples_2d_common(sampler, s, t, p,
- lodbias, rgba, faces);
-}
-
-
-static INLINE void
-lp_get_samples_3d(struct tgsi_sampler *tgsi_sampler,
- const float s[QUAD_SIZE],
- const float t[QUAD_SIZE],
- const float p[QUAD_SIZE],
- float lodbias,
- float rgba[NUM_CHANNELS][QUAD_SIZE])
-{
- const struct lp_shader_sampler *samp = lp_shader_sampler(tgsi_sampler);
- const struct pipe_texture *texture = samp->texture;
- const struct pipe_sampler_state *sampler = samp->sampler;
- /* get/map pipe_surfaces corresponding to 3D tex slices */
- unsigned level0, level1, j, imgFilter;
- int width, height, depth;
- float levelBlend;
- const uint face = 0;
-
- choose_mipmap_levels(tgsi_sampler, s, t, p,
- lodbias,
- &level0, &level1, &levelBlend, &imgFilter);
-
- assert(sampler->normalized_coords);
-
- width = texture->width[level0];
- height = texture->height[level0];
- depth = texture->depth[level0];
-
- assert(width > 0);
- assert(height > 0);
- assert(depth > 0);
-
- switch (imgFilter) {
- case PIPE_TEX_FILTER_NEAREST:
- {
- int x[4], y[4], z[4];
- nearest_texcoord_4(sampler->wrap_s, s, width, x);
- nearest_texcoord_4(sampler->wrap_t, t, height, y);
- nearest_texcoord_4(sampler->wrap_r, p, depth, z);
- for (j = 0; j < QUAD_SIZE; j++) {
- get_texel(tgsi_sampler, face, level0, x[j], y[j], z[j], rgba, j);
- if (level0 != level1) {
- /* get texels from second mipmap level and blend */
- float rgba2[4][4];
- unsigned c;
- x[j] /= 2;
- y[j] /= 2;
- z[j] /= 2;
- get_texel(tgsi_sampler, face, level1, x[j], y[j], z[j], rgba2, j);
- for (c = 0; c < NUM_CHANNELS; c++) {
- rgba[c][j] = lerp(levelBlend, rgba2[c][j], rgba[c][j]);
- }
- }
- }
- }
- break;
- case PIPE_TEX_FILTER_LINEAR:
- case PIPE_TEX_FILTER_ANISO:
- {
- int x0[4], x1[4], y0[4], y1[4], z0[4], z1[4];
- float xw[4], yw[4], zw[4]; /* interpolation weights */
- linear_texcoord_4(sampler->wrap_s, s, width, x0, x1, xw);
- linear_texcoord_4(sampler->wrap_t, t, height, y0, y1, yw);
- linear_texcoord_4(sampler->wrap_r, p, depth, z0, z1, zw);
-
- for (j = 0; j < QUAD_SIZE; j++) {
- int c;
- float tx0[4][4], tx1[4][4];
- get_texel(tgsi_sampler, face, level0, x0[j], y0[j], z0[j], tx0, 0);
- get_texel(tgsi_sampler, face, level0, x1[j], y0[j], z0[j], tx0, 1);
- get_texel(tgsi_sampler, face, level0, x0[j], y1[j], z0[j], tx0, 2);
- get_texel(tgsi_sampler, face, level0, x1[j], y1[j], z0[j], tx0, 3);
- get_texel(tgsi_sampler, face, level0, x0[j], y0[j], z1[j], tx1, 0);
- get_texel(tgsi_sampler, face, level0, x1[j], y0[j], z1[j], tx1, 1);
- get_texel(tgsi_sampler, face, level0, x0[j], y1[j], z1[j], tx1, 2);
- get_texel(tgsi_sampler, face, level0, x1[j], y1[j], z1[j], tx1, 3);
-
- /* interpolate R, G, B, A */
- for (c = 0; c < 4; c++) {
- rgba[c][j] = lerp_3d(xw[j], yw[j], zw[j],
- tx0[c][0], tx0[c][1],
- tx0[c][2], tx0[c][3],
- tx1[c][0], tx1[c][1],
- tx1[c][2], tx1[c][3]);
- }
-
- if (level0 != level1) {
- /* get texels from second mipmap level and blend */
- float rgba2[4][4];
- x0[j] /= 2;
- y0[j] /= 2;
- z0[j] /= 2;
- x1[j] /= 2;
- y1[j] /= 2;
- z1[j] /= 2;
- get_texel(tgsi_sampler, face, level1, x0[j], y0[j], z0[j], tx0, 0);
- get_texel(tgsi_sampler, face, level1, x1[j], y0[j], z0[j], tx0, 1);
- get_texel(tgsi_sampler, face, level1, x0[j], y1[j], z0[j], tx0, 2);
- get_texel(tgsi_sampler, face, level1, x1[j], y1[j], z0[j], tx0, 3);
- get_texel(tgsi_sampler, face, level1, x0[j], y0[j], z1[j], tx1, 0);
- get_texel(tgsi_sampler, face, level1, x1[j], y0[j], z1[j], tx1, 1);
- get_texel(tgsi_sampler, face, level1, x0[j], y1[j], z1[j], tx1, 2);
- get_texel(tgsi_sampler, face, level1, x1[j], y1[j], z1[j], tx1, 3);
-
- /* interpolate R, G, B, A */
- for (c = 0; c < 4; c++) {
- rgba2[c][j] = lerp_3d(xw[j], yw[j], zw[j],
- tx0[c][0], tx0[c][1],
- tx0[c][2], tx0[c][3],
- tx1[c][0], tx1[c][1],
- tx1[c][2], tx1[c][3]);
- }
-
- /* blend mipmap levels */
- for (c = 0; c < NUM_CHANNELS; c++) {
- rgba[c][j] = lerp(levelBlend, rgba[c][j], rgba2[c][j]);
- }
- }
- }
- }
- break;
- default:
- assert(0);
- }
-}
-
-
-static void
-lp_get_samples_cube(struct tgsi_sampler *sampler,
- const float s[QUAD_SIZE],
- const float t[QUAD_SIZE],
- const float p[QUAD_SIZE],
- float lodbias,
- float rgba[NUM_CHANNELS][QUAD_SIZE])
-{
- unsigned faces[QUAD_SIZE], j;
- float ssss[4], tttt[4];
- for (j = 0; j < QUAD_SIZE; j++) {
- faces[j] = choose_cube_face(s[j], t[j], p[j], ssss + j, tttt + j);
- }
- lp_get_samples_2d_common(sampler, ssss, tttt, NULL,
- lodbias, rgba, faces);
-}
-
-
-static void
-lp_get_samples_rect(struct tgsi_sampler *tgsi_sampler,
- const float s[QUAD_SIZE],
- const float t[QUAD_SIZE],
- const float p[QUAD_SIZE],
- float lodbias,
- float rgba[NUM_CHANNELS][QUAD_SIZE])
-{
- const struct lp_shader_sampler *samp = lp_shader_sampler(tgsi_sampler);
- const struct pipe_texture *texture = samp->texture;
- const struct pipe_sampler_state *sampler = samp->sampler;
- const uint face = 0;
- unsigned level0, level1, j, imgFilter;
- int width, height;
- float levelBlend;
-
- choose_mipmap_levels(tgsi_sampler, s, t, p,
- lodbias,
- &level0, &level1, &levelBlend, &imgFilter);
-
- /* texture RECTS cannot be mipmapped */
- assert(level0 == level1);
-
- width = texture->width[level0];
- height = texture->height[level0];
-
- assert(width > 0);
-
- switch (imgFilter) {
- case PIPE_TEX_FILTER_NEAREST:
- {
- int x[4], y[4];
- nearest_texcoord_unnorm_4(sampler->wrap_s, s, width, x);
- nearest_texcoord_unnorm_4(sampler->wrap_t, t, height, y);
- for (j = 0; j < QUAD_SIZE; j++) {
- get_texel(tgsi_sampler, face, level0, x[j], y[j], 0, rgba, j);
- if (sampler->compare_mode == PIPE_TEX_COMPARE_R_TO_TEXTURE) {
- shadow_compare(sampler, rgba, p, j);
- }
- }
- }
- break;
- case PIPE_TEX_FILTER_LINEAR:
- case PIPE_TEX_FILTER_ANISO:
- {
- int x0[4], y0[4], x1[4], y1[4];
- float xw[4], yw[4]; /* weights */
- linear_texcoord_unnorm_4(sampler->wrap_s, s, width, x0, x1, xw);
- linear_texcoord_unnorm_4(sampler->wrap_t, t, height, y0, y1, yw);
- for (j = 0; j < QUAD_SIZE; j++) {
- float tx[4][4]; /* texels */
- int c;
- get_texel(tgsi_sampler, face, level0, x0[j], y0[j], 0, tx, 0);
- get_texel(tgsi_sampler, face, level0, x1[j], y0[j], 0, tx, 1);
- get_texel(tgsi_sampler, face, level0, x0[j], y1[j], 0, tx, 2);
- get_texel(tgsi_sampler, face, level0, x1[j], y1[j], 0, tx, 3);
- if (sampler->compare_mode == PIPE_TEX_COMPARE_R_TO_TEXTURE) {
- shadow_compare4(sampler, tx, p);
- }
- for (c = 0; c < 4; c++) {
- rgba[c][j] = lerp_2d(xw[j], yw[j],
- tx[c][0], tx[c][1], tx[c][2], tx[c][3]);
- }
- }
- }
- break;
- default:
- assert(0);
- }
-}
-
-
-/**
- * Error condition handler
- */
-static INLINE void
-lp_get_samples_null(struct tgsi_sampler *tgsi_sampler,
- const float s[QUAD_SIZE],
- const float t[QUAD_SIZE],
- const float p[QUAD_SIZE],
- float lodbias,
- float rgba[NUM_CHANNELS][QUAD_SIZE])
-{
- int i,j;
-
- for (i = 0; i < 4; i++)
- for (j = 0; j < 4; j++)
- rgba[i][j] = 1.0;
-}
-
-/**
- * Called via tgsi_sampler::get_samples() when using a sampler for the
- * first time. Determine the actual sampler function, link it in and
- * call it.
- */
-void
-lp_get_samples(struct tgsi_sampler *tgsi_sampler,
- const float s[QUAD_SIZE],
- const float t[QUAD_SIZE],
- const float p[QUAD_SIZE],
- float lodbias,
- float rgba[NUM_CHANNELS][QUAD_SIZE])
-{
- struct lp_shader_sampler *samp = lp_shader_sampler(tgsi_sampler);
- const struct pipe_texture *texture = samp->texture;
- const struct pipe_sampler_state *sampler = samp->sampler;
-
- /* Default to the 'undefined' case:
- */
- tgsi_sampler->get_samples = lp_get_samples_null;
-
- if (!texture) {
- assert(0); /* is this legal?? */
- goto out;
- }
-
- if (!sampler->normalized_coords) {
- assert (texture->target == PIPE_TEXTURE_2D);
- tgsi_sampler->get_samples = lp_get_samples_rect;
- goto out;
- }
-
- switch (texture->target) {
- case PIPE_TEXTURE_1D:
- tgsi_sampler->get_samples = lp_get_samples_1d;
- break;
- case PIPE_TEXTURE_2D:
- tgsi_sampler->get_samples = lp_get_samples_2d;
- break;
- case PIPE_TEXTURE_3D:
- tgsi_sampler->get_samples = lp_get_samples_3d;
- break;
- case PIPE_TEXTURE_CUBE:
- tgsi_sampler->get_samples = lp_get_samples_cube;
- break;
- default:
- assert(0);
- break;
- }
-
- /* Do this elsewhere:
- */
- samp->xpot = util_unsigned_logbase2( samp->texture->width[0] );
- samp->ypot = util_unsigned_logbase2( samp->texture->height[0] );
-
- /* Try to hook in a faster sampler. Ultimately we'll have to
- * code-generate these. Luckily most of this looks like it is
- * orthogonal state within the sampler.
- */
- if (texture->target == PIPE_TEXTURE_2D &&
- sampler->min_img_filter == sampler->mag_img_filter &&
- sampler->wrap_s == sampler->wrap_t &&
- sampler->compare_mode == FALSE &&
- sampler->normalized_coords)
- {
- if (sampler->min_mip_filter == PIPE_TEX_MIPFILTER_NONE) {
- samp->level = CLAMP((int) sampler->min_lod,
- 0, (int) texture->last_level);
-
- if (sampler->wrap_s == PIPE_TEX_WRAP_REPEAT) {
- switch (sampler->min_img_filter) {
- case PIPE_TEX_FILTER_NEAREST:
- tgsi_sampler->get_samples = lp_get_samples_2d_nearest_repeat_POT;
- break;
- case PIPE_TEX_FILTER_LINEAR:
- tgsi_sampler->get_samples = lp_get_samples_2d_linear_repeat_POT;
- break;
- default:
- break;
- }
- }
- else if (sampler->wrap_s == PIPE_TEX_WRAP_CLAMP) {
- switch (sampler->min_img_filter) {
- case PIPE_TEX_FILTER_NEAREST:
- tgsi_sampler->get_samples = lp_get_samples_2d_nearest_clamp_POT;
- break;
- default:
- break;
- }
- }
- }
- else if (sampler->min_mip_filter == PIPE_TEX_MIPFILTER_LINEAR) {
- if (sampler->wrap_s == PIPE_TEX_WRAP_REPEAT) {
- switch (sampler->min_img_filter) {
- case PIPE_TEX_FILTER_LINEAR:
- tgsi_sampler->get_samples = lp_get_samples_2d_linear_mip_linear_repeat_POT;
- break;
- default:
- break;
- }
- }
- }
- }
- else if (0) {
- _debug_printf("target %d/%d min_mip %d/%d min_img %d/%d wrap %d/%d compare %d/%d norm %d/%d\n",
- texture->target, PIPE_TEXTURE_2D,
- sampler->min_mip_filter, PIPE_TEX_MIPFILTER_NONE,
- sampler->min_img_filter, sampler->mag_img_filter,
- sampler->wrap_s, sampler->wrap_t,
- sampler->compare_mode, FALSE,
- sampler->normalized_coords, TRUE);
- }
-
-out:
- tgsi_sampler->get_samples( tgsi_sampler, s, t, p, lodbias, rgba );
-}
-
#define LP_TEX_SAMPLE_H
+#include <llvm-c/Core.h>
+
#include "tgsi/tgsi_exec.h"
struct llvmpipe_tex_tile_cache;
+struct lp_sampler_static_state;
/**
float rgba[NUM_CHANNELS][QUAD_SIZE]);
+/**
+ * Texture sampling code generator that just calls lp_get_samples C function
+ * for the actual sampling computation.
+ *
+ * @param context_ptr LLVM value with the pointer to the struct lp_jit_context.
+ */
+struct lp_build_sampler_soa *
+lp_c_sampler_soa_create(LLVMValueRef context_ptr);
+
+
+/**
+ * Pure-LLVM texture sampling code generator.
+ *
+ * @param context_ptr LLVM value with the pointer to the struct lp_jit_context.
+ */
+struct lp_build_sampler_soa *
+lp_llvm_sampler_soa_create(const struct lp_sampler_static_state *key,
+ LLVMValueRef context_ptr);
+
+
#endif /* LP_TEX_SAMPLE_H */
--- /dev/null
+/**************************************************************************
+ *
+ * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
+ * All Rights Reserved.
+ * Copyright 2008 VMware, Inc. All rights reserved.
+ *
+ * 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, sub license, 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 (including the
+ * next paragraph) 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 NON-INFRINGEMENT.
+ * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS 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.
+ *
+ **************************************************************************/
+
+/**
+ * Texture sampling
+ *
+ * Authors:
+ * Brian Paul
+ */
+
+#include "lp_context.h"
+#include "lp_quad.h"
+#include "lp_surface.h"
+#include "lp_texture.h"
+#include "lp_tex_sample.h"
+#include "lp_tex_cache.h"
+#include "pipe/p_context.h"
+#include "pipe/p_defines.h"
+#include "pipe/p_shader_tokens.h"
+#include "util/u_math.h"
+#include "util/u_memory.h"
+
+
+
+/*
+ * Note, the FRAC macro has to work perfectly. Otherwise you'll sometimes
+ * see 1-pixel bands of improperly weighted linear-filtered textures.
+ * The tests/texwrap.c demo is a good test.
+ * Also note, FRAC(x) doesn't truly return the fractional part of x for x < 0.
+ * Instead, if x < 0 then FRAC(x) = 1 - true_frac(x).
+ */
+#define FRAC(f) ((f) - util_ifloor(f))
+
+
+/**
+ * Linear interpolation macro
+ */
+static INLINE float
+lerp(float a, float v0, float v1)
+{
+ return v0 + a * (v1 - v0);
+}
+
+
+/**
+ * Do 2D/biliner interpolation of float values.
+ * v00, v10, v01 and v11 are typically four texture samples in a square/box.
+ * a and b are the horizontal and vertical interpolants.
+ * It's important that this function is inlined when compiled with
+ * optimization! If we find that's not true on some systems, convert
+ * to a macro.
+ */
+static INLINE float
+lerp_2d(float a, float b,
+ float v00, float v10, float v01, float v11)
+{
+ const float temp0 = lerp(a, v00, v10);
+ const float temp1 = lerp(a, v01, v11);
+ return lerp(b, temp0, temp1);
+}
+
+
+/**
+ * As above, but 3D interpolation of 8 values.
+ */
+static INLINE float
+lerp_3d(float a, float b, float c,
+ float v000, float v100, float v010, float v110,
+ float v001, float v101, float v011, float v111)
+{
+ const float temp0 = lerp_2d(a, b, v000, v100, v010, v110);
+ const float temp1 = lerp_2d(a, b, v001, v101, v011, v111);
+ return lerp(c, temp0, temp1);
+}
+
+
+
+/**
+ * If A is a signed integer, A % B doesn't give the right value for A < 0
+ * (in terms of texture repeat). Just casting to unsigned fixes that.
+ */
+#define REMAINDER(A, B) ((unsigned) (A) % (unsigned) (B))
+
+
+/**
+ * Apply texture coord wrapping mode and return integer texture indexes
+ * for a vector of four texcoords (S or T or P).
+ * \param wrapMode PIPE_TEX_WRAP_x
+ * \param s the incoming texcoords
+ * \param size the texture image size
+ * \param icoord returns the integer texcoords
+ * \return integer texture index
+ */
+static INLINE void
+nearest_texcoord_4(unsigned wrapMode, const float s[4], unsigned size,
+ int icoord[4])
+{
+ uint ch;
+ switch (wrapMode) {
+ case PIPE_TEX_WRAP_REPEAT:
+ /* s limited to [0,1) */
+ /* i limited to [0,size-1] */
+ for (ch = 0; ch < 4; ch++) {
+ int i = util_ifloor(s[ch] * size);
+ icoord[ch] = REMAINDER(i, size);
+ }
+ return;
+ case PIPE_TEX_WRAP_CLAMP:
+ /* s limited to [0,1] */
+ /* i limited to [0,size-1] */
+ for (ch = 0; ch < 4; ch++) {
+ if (s[ch] <= 0.0F)
+ icoord[ch] = 0;
+ else if (s[ch] >= 1.0F)
+ icoord[ch] = size - 1;
+ else
+ icoord[ch] = util_ifloor(s[ch] * size);
+ }
+ return;
+ case PIPE_TEX_WRAP_CLAMP_TO_EDGE:
+ {
+ /* s limited to [min,max] */
+ /* i limited to [0, size-1] */
+ const float min = 1.0F / (2.0F * size);
+ const float max = 1.0F - min;
+ for (ch = 0; ch < 4; ch++) {
+ if (s[ch] < min)
+ icoord[ch] = 0;
+ else if (s[ch] > max)
+ icoord[ch] = size - 1;
+ else
+ icoord[ch] = util_ifloor(s[ch] * size);
+ }
+ }
+ return;
+ case PIPE_TEX_WRAP_CLAMP_TO_BORDER:
+ {
+ /* s limited to [min,max] */
+ /* i limited to [-1, size] */
+ const float min = -1.0F / (2.0F * size);
+ const float max = 1.0F - min;
+ for (ch = 0; ch < 4; ch++) {
+ if (s[ch] <= min)
+ icoord[ch] = -1;
+ else if (s[ch] >= max)
+ icoord[ch] = size;
+ else
+ icoord[ch] = util_ifloor(s[ch] * size);
+ }
+ }
+ return;
+ case PIPE_TEX_WRAP_MIRROR_REPEAT:
+ {
+ const float min = 1.0F / (2.0F * size);
+ const float max = 1.0F - min;
+ for (ch = 0; ch < 4; ch++) {
+ const int flr = util_ifloor(s[ch]);
+ float u;
+ if (flr & 1)
+ u = 1.0F - (s[ch] - (float) flr);
+ else
+ u = s[ch] - (float) flr;
+ if (u < min)
+ icoord[ch] = 0;
+ else if (u > max)
+ icoord[ch] = size - 1;
+ else
+ icoord[ch] = util_ifloor(u * size);
+ }
+ }
+ return;
+ case PIPE_TEX_WRAP_MIRROR_CLAMP:
+ for (ch = 0; ch < 4; ch++) {
+ /* s limited to [0,1] */
+ /* i limited to [0,size-1] */
+ const float u = fabsf(s[ch]);
+ if (u <= 0.0F)
+ icoord[ch] = 0;
+ else if (u >= 1.0F)
+ icoord[ch] = size - 1;
+ else
+ icoord[ch] = util_ifloor(u * size);
+ }
+ return;
+ case PIPE_TEX_WRAP_MIRROR_CLAMP_TO_EDGE:
+ {
+ /* s limited to [min,max] */
+ /* i limited to [0, size-1] */
+ const float min = 1.0F / (2.0F * size);
+ const float max = 1.0F - min;
+ for (ch = 0; ch < 4; ch++) {
+ const float u = fabsf(s[ch]);
+ if (u < min)
+ icoord[ch] = 0;
+ else if (u > max)
+ icoord[ch] = size - 1;
+ else
+ icoord[ch] = util_ifloor(u * size);
+ }
+ }
+ return;
+ case PIPE_TEX_WRAP_MIRROR_CLAMP_TO_BORDER:
+ {
+ /* s limited to [min,max] */
+ /* i limited to [0, size-1] */
+ const float min = -1.0F / (2.0F * size);
+ const float max = 1.0F - min;
+ for (ch = 0; ch < 4; ch++) {
+ const float u = fabsf(s[ch]);
+ if (u < min)
+ icoord[ch] = -1;
+ else if (u > max)
+ icoord[ch] = size;
+ else
+ icoord[ch] = util_ifloor(u * size);
+ }
+ }
+ return;
+ default:
+ assert(0);
+ }
+}
+
+
+/**
+ * Used to compute texel locations for linear sampling for four texcoords.
+ * \param wrapMode PIPE_TEX_WRAP_x
+ * \param s the texcoords
+ * \param size the texture image size
+ * \param icoord0 returns first texture indexes
+ * \param icoord1 returns second texture indexes (usually icoord0 + 1)
+ * \param w returns blend factor/weight between texture indexes
+ * \param icoord returns the computed integer texture coords
+ */
+static INLINE void
+linear_texcoord_4(unsigned wrapMode, const float s[4], unsigned size,
+ int icoord0[4], int icoord1[4], float w[4])
+{
+ uint ch;
+
+ switch (wrapMode) {
+ case PIPE_TEX_WRAP_REPEAT:
+ for (ch = 0; ch < 4; ch++) {
+ float u = s[ch] * size - 0.5F;
+ icoord0[ch] = REMAINDER(util_ifloor(u), size);
+ icoord1[ch] = REMAINDER(icoord0[ch] + 1, size);
+ w[ch] = FRAC(u);
+ }
+ break;;
+ case PIPE_TEX_WRAP_CLAMP:
+ for (ch = 0; ch < 4; ch++) {
+ float u = CLAMP(s[ch], 0.0F, 1.0F);
+ u = u * size - 0.5f;
+ icoord0[ch] = util_ifloor(u);
+ icoord1[ch] = icoord0[ch] + 1;
+ w[ch] = FRAC(u);
+ }
+ break;;
+ case PIPE_TEX_WRAP_CLAMP_TO_EDGE:
+ for (ch = 0; ch < 4; ch++) {
+ float u = CLAMP(s[ch], 0.0F, 1.0F);
+ u = u * size - 0.5f;
+ icoord0[ch] = util_ifloor(u);
+ icoord1[ch] = icoord0[ch] + 1;
+ if (icoord0[ch] < 0)
+ icoord0[ch] = 0;
+ if (icoord1[ch] >= (int) size)
+ icoord1[ch] = size - 1;
+ w[ch] = FRAC(u);
+ }
+ break;;
+ case PIPE_TEX_WRAP_CLAMP_TO_BORDER:
+ {
+ const float min = -1.0F / (2.0F * size);
+ const float max = 1.0F - min;
+ for (ch = 0; ch < 4; ch++) {
+ float u = CLAMP(s[ch], min, max);
+ u = u * size - 0.5f;
+ icoord0[ch] = util_ifloor(u);
+ icoord1[ch] = icoord0[ch] + 1;
+ w[ch] = FRAC(u);
+ }
+ }
+ break;;
+ case PIPE_TEX_WRAP_MIRROR_REPEAT:
+ for (ch = 0; ch < 4; ch++) {
+ const int flr = util_ifloor(s[ch]);
+ float u;
+ if (flr & 1)
+ u = 1.0F - (s[ch] - (float) flr);
+ else
+ u = s[ch] - (float) flr;
+ u = u * size - 0.5F;
+ icoord0[ch] = util_ifloor(u);
+ icoord1[ch] = icoord0[ch] + 1;
+ if (icoord0[ch] < 0)
+ icoord0[ch] = 0;
+ if (icoord1[ch] >= (int) size)
+ icoord1[ch] = size - 1;
+ w[ch] = FRAC(u);
+ }
+ break;;
+ case PIPE_TEX_WRAP_MIRROR_CLAMP:
+ for (ch = 0; ch < 4; ch++) {
+ float u = fabsf(s[ch]);
+ if (u >= 1.0F)
+ u = (float) size;
+ else
+ u *= size;
+ u -= 0.5F;
+ icoord0[ch] = util_ifloor(u);
+ icoord1[ch] = icoord0[ch] + 1;
+ w[ch] = FRAC(u);
+ }
+ break;;
+ case PIPE_TEX_WRAP_MIRROR_CLAMP_TO_EDGE:
+ for (ch = 0; ch < 4; ch++) {
+ float u = fabsf(s[ch]);
+ if (u >= 1.0F)
+ u = (float) size;
+ else
+ u *= size;
+ u -= 0.5F;
+ icoord0[ch] = util_ifloor(u);
+ icoord1[ch] = icoord0[ch] + 1;
+ if (icoord0[ch] < 0)
+ icoord0[ch] = 0;
+ if (icoord1[ch] >= (int) size)
+ icoord1[ch] = size - 1;
+ w[ch] = FRAC(u);
+ }
+ break;;
+ case PIPE_TEX_WRAP_MIRROR_CLAMP_TO_BORDER:
+ {
+ const float min = -1.0F / (2.0F * size);
+ const float max = 1.0F - min;
+ for (ch = 0; ch < 4; ch++) {
+ float u = fabsf(s[ch]);
+ if (u <= min)
+ u = min * size;
+ else if (u >= max)
+ u = max * size;
+ else
+ u *= size;
+ u -= 0.5F;
+ icoord0[ch] = util_ifloor(u);
+ icoord1[ch] = icoord0[ch] + 1;
+ w[ch] = FRAC(u);
+ }
+ }
+ break;;
+ default:
+ assert(0);
+ }
+}
+
+
+/**
+ * For RECT textures / unnormalized texcoords
+ * Only a subset of wrap modes supported.
+ */
+static INLINE void
+nearest_texcoord_unnorm_4(unsigned wrapMode, const float s[4], unsigned size,
+ int icoord[4])
+{
+ uint ch;
+ switch (wrapMode) {
+ case PIPE_TEX_WRAP_CLAMP:
+ for (ch = 0; ch < 4; ch++) {
+ int i = util_ifloor(s[ch]);
+ icoord[ch]= CLAMP(i, 0, (int) size-1);
+ }
+ return;
+ case PIPE_TEX_WRAP_CLAMP_TO_EDGE:
+ /* fall-through */
+ case PIPE_TEX_WRAP_CLAMP_TO_BORDER:
+ for (ch = 0; ch < 4; ch++) {
+ icoord[ch]= util_ifloor( CLAMP(s[ch], 0.5F, (float) size - 0.5F) );
+ }
+ return;
+ default:
+ assert(0);
+ }
+}
+
+
+/**
+ * For RECT textures / unnormalized texcoords.
+ * Only a subset of wrap modes supported.
+ */
+static INLINE void
+linear_texcoord_unnorm_4(unsigned wrapMode, const float s[4], unsigned size,
+ int icoord0[4], int icoord1[4], float w[4])
+{
+ uint ch;
+ switch (wrapMode) {
+ case PIPE_TEX_WRAP_CLAMP:
+ for (ch = 0; ch < 4; ch++) {
+ /* Not exactly what the spec says, but it matches NVIDIA output */
+ float u = CLAMP(s[ch] - 0.5F, 0.0f, (float) size - 1.0f);
+ icoord0[ch] = util_ifloor(u);
+ icoord1[ch] = icoord0[ch] + 1;
+ w[ch] = FRAC(u);
+ }
+ return;
+ case PIPE_TEX_WRAP_CLAMP_TO_EDGE:
+ /* fall-through */
+ case PIPE_TEX_WRAP_CLAMP_TO_BORDER:
+ for (ch = 0; ch < 4; ch++) {
+ float u = CLAMP(s[ch], 0.5F, (float) size - 0.5F);
+ u -= 0.5F;
+ icoord0[ch] = util_ifloor(u);
+ icoord1[ch] = icoord0[ch] + 1;
+ if (icoord1[ch] > (int) size - 1)
+ icoord1[ch] = size - 1;
+ w[ch] = FRAC(u);
+ }
+ break;
+ default:
+ assert(0);
+ }
+}
+
+
+static unsigned
+choose_cube_face(float rx, float ry, float rz, float *newS, float *newT)
+{
+ /*
+ major axis
+ direction target sc tc ma
+ ---------- ------------------------------- --- --- ---
+ +rx TEXTURE_CUBE_MAP_POSITIVE_X_EXT -rz -ry rx
+ -rx TEXTURE_CUBE_MAP_NEGATIVE_X_EXT +rz -ry rx
+ +ry TEXTURE_CUBE_MAP_POSITIVE_Y_EXT +rx +rz ry
+ -ry TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT +rx -rz ry
+ +rz TEXTURE_CUBE_MAP_POSITIVE_Z_EXT +rx -ry rz
+ -rz TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT -rx -ry rz
+ */
+ const float arx = fabsf(rx), ary = fabsf(ry), arz = fabsf(rz);
+ unsigned face;
+ float sc, tc, ma;
+
+ if (arx > ary && arx > arz) {
+ if (rx >= 0.0F) {
+ face = PIPE_TEX_FACE_POS_X;
+ sc = -rz;
+ tc = -ry;
+ ma = arx;
+ }
+ else {
+ face = PIPE_TEX_FACE_NEG_X;
+ sc = rz;
+ tc = -ry;
+ ma = arx;
+ }
+ }
+ else if (ary > arx && ary > arz) {
+ if (ry >= 0.0F) {
+ face = PIPE_TEX_FACE_POS_Y;
+ sc = rx;
+ tc = rz;
+ ma = ary;
+ }
+ else {
+ face = PIPE_TEX_FACE_NEG_Y;
+ sc = rx;
+ tc = -rz;
+ ma = ary;
+ }
+ }
+ else {
+ if (rz > 0.0F) {
+ face = PIPE_TEX_FACE_POS_Z;
+ sc = rx;
+ tc = -ry;
+ ma = arz;
+ }
+ else {
+ face = PIPE_TEX_FACE_NEG_Z;
+ sc = -rx;
+ tc = -ry;
+ ma = arz;
+ }
+ }
+
+ *newS = ( sc / ma + 1.0F ) * 0.5F;
+ *newT = ( tc / ma + 1.0F ) * 0.5F;
+
+ return face;
+}
+
+
+/**
+ * Examine the quad's texture coordinates to compute the partial
+ * derivatives w.r.t X and Y, then compute lambda (level of detail).
+ *
+ * This is only done for fragment shaders, not vertex shaders.
+ */
+static float
+compute_lambda(struct tgsi_sampler *tgsi_sampler,
+ const float s[QUAD_SIZE],
+ const float t[QUAD_SIZE],
+ const float p[QUAD_SIZE],
+ float lodbias)
+{
+ const struct lp_shader_sampler *samp = lp_shader_sampler(tgsi_sampler);
+ const struct pipe_texture *texture = samp->texture;
+ const struct pipe_sampler_state *sampler = samp->sampler;
+ float rho, lambda;
+
+ if (samp->processor == TGSI_PROCESSOR_VERTEX)
+ return lodbias;
+
+ assert(sampler->normalized_coords);
+
+ assert(s);
+ {
+ float dsdx = s[QUAD_BOTTOM_RIGHT] - s[QUAD_BOTTOM_LEFT];
+ float dsdy = s[QUAD_TOP_LEFT] - s[QUAD_BOTTOM_LEFT];
+ dsdx = fabsf(dsdx);
+ dsdy = fabsf(dsdy);
+ rho = MAX2(dsdx, dsdy) * texture->width[0];
+ }
+ if (t) {
+ float dtdx = t[QUAD_BOTTOM_RIGHT] - t[QUAD_BOTTOM_LEFT];
+ float dtdy = t[QUAD_TOP_LEFT] - t[QUAD_BOTTOM_LEFT];
+ float max;
+ dtdx = fabsf(dtdx);
+ dtdy = fabsf(dtdy);
+ max = MAX2(dtdx, dtdy) * texture->height[0];
+ rho = MAX2(rho, max);
+ }
+ if (p) {
+ float dpdx = p[QUAD_BOTTOM_RIGHT] - p[QUAD_BOTTOM_LEFT];
+ float dpdy = p[QUAD_TOP_LEFT] - p[QUAD_BOTTOM_LEFT];
+ float max;
+ dpdx = fabsf(dpdx);
+ dpdy = fabsf(dpdy);
+ max = MAX2(dpdx, dpdy) * texture->depth[0];
+ rho = MAX2(rho, max);
+ }
+
+ lambda = util_fast_log2(rho);
+ lambda += lodbias + sampler->lod_bias;
+ lambda = CLAMP(lambda, sampler->min_lod, sampler->max_lod);
+
+ return lambda;
+}
+
+
+/**
+ * Do several things here:
+ * 1. Compute lambda from the texcoords, if needed
+ * 2. Determine if we're minifying or magnifying
+ * 3. If minifying, choose mipmap levels
+ * 4. Return image filter to use within mipmap images
+ * \param level0 Returns first mipmap level to sample from
+ * \param level1 Returns second mipmap level to sample from
+ * \param levelBlend Returns blend factor between levels, in [0,1]
+ * \param imgFilter Returns either the min or mag filter, depending on lambda
+ */
+static void
+choose_mipmap_levels(struct tgsi_sampler *tgsi_sampler,
+ const float s[QUAD_SIZE],
+ const float t[QUAD_SIZE],
+ const float p[QUAD_SIZE],
+ float lodbias,
+ unsigned *level0, unsigned *level1, float *levelBlend,
+ unsigned *imgFilter)
+{
+ const struct lp_shader_sampler *samp = lp_shader_sampler(tgsi_sampler);
+ const struct pipe_texture *texture = samp->texture;
+ const struct pipe_sampler_state *sampler = samp->sampler;
+
+ if (sampler->min_mip_filter == PIPE_TEX_MIPFILTER_NONE) {
+ /* no mipmap selection needed */
+ *level0 = *level1 = CLAMP((int) sampler->min_lod,
+ 0, (int) texture->last_level);
+
+ if (sampler->min_img_filter != sampler->mag_img_filter) {
+ /* non-mipmapped texture, but still need to determine if doing
+ * minification or magnification.
+ */
+ float lambda = compute_lambda(tgsi_sampler, s, t, p, lodbias);
+ if (lambda <= 0.0) {
+ *imgFilter = sampler->mag_img_filter;
+ }
+ else {
+ *imgFilter = sampler->min_img_filter;
+ }
+ }
+ else {
+ *imgFilter = sampler->mag_img_filter;
+ }
+ }
+ else {
+ float lambda = compute_lambda(tgsi_sampler, s, t, p, lodbias);
+
+ if (lambda <= 0.0) { /* XXX threshold depends on the filter */
+ /* magnifying */
+ *imgFilter = sampler->mag_img_filter;
+ *level0 = *level1 = 0;
+ }
+ else {
+ /* minifying */
+ *imgFilter = sampler->min_img_filter;
+
+ /* choose mipmap level(s) and compute the blend factor between them */
+ if (sampler->min_mip_filter == PIPE_TEX_MIPFILTER_NEAREST) {
+ /* Nearest mipmap level */
+ const int lvl = (int) (lambda + 0.5);
+ *level0 =
+ *level1 = CLAMP(lvl, 0, (int) texture->last_level);
+ }
+ else {
+ /* Linear interpolation between mipmap levels */
+ const int lvl = (int) lambda;
+ *level0 = CLAMP(lvl, 0, (int) texture->last_level);
+ *level1 = CLAMP(lvl + 1, 0, (int) texture->last_level);
+ *levelBlend = FRAC(lambda); /* blending weight between levels */
+ }
+ }
+ }
+}
+
+
+/**
+ * Get a texel from a texture, using the texture tile cache.
+ *
+ * \param face the cube face in 0..5
+ * \param level the mipmap level
+ * \param x the x coord of texel within 2D image
+ * \param y the y coord of texel within 2D image
+ * \param z which slice of a 3D texture
+ * \param rgba the quad to put the texel/color into
+ * \param j which element of the rgba quad to write to
+ *
+ * XXX maybe move this into lp_tile_cache.c and merge with the
+ * lp_get_cached_tile_tex() function. Also, get 4 texels instead of 1...
+ */
+static void
+get_texel_quad_2d(const struct tgsi_sampler *tgsi_sampler,
+ unsigned face, unsigned level, int x, int y,
+ const uint8_t *out[4])
+{
+ const struct lp_shader_sampler *samp = lp_shader_sampler(tgsi_sampler);
+
+ const struct llvmpipe_cached_tex_tile *tile
+ = lp_get_cached_tex_tile(samp->cache,
+ tex_tile_address(x, y, 0, face, level));
+
+ y %= TEX_TILE_SIZE;
+ x %= TEX_TILE_SIZE;
+
+ out[0] = &tile->color[y ][x ][0];
+ out[1] = &tile->color[y ][x+1][0];
+ out[2] = &tile->color[y+1][x ][0];
+ out[3] = &tile->color[y+1][x+1][0];
+}
+
+static INLINE const uint8_t *
+get_texel_2d_ptr(const struct tgsi_sampler *tgsi_sampler,
+ unsigned face, unsigned level, int x, int y)
+{
+ const struct lp_shader_sampler *samp = lp_shader_sampler(tgsi_sampler);
+
+ const struct llvmpipe_cached_tex_tile *tile
+ = lp_get_cached_tex_tile(samp->cache,
+ tex_tile_address(x, y, 0, face, level));
+
+ y %= TEX_TILE_SIZE;
+ x %= TEX_TILE_SIZE;
+
+ return &tile->color[y][x][0];
+}
+
+
+static void
+get_texel_quad_2d_mt(const struct tgsi_sampler *tgsi_sampler,
+ unsigned face, unsigned level,
+ int x0, int y0,
+ int x1, int y1,
+ const uint8_t *out[4])
+{
+ unsigned i;
+
+ for (i = 0; i < 4; i++) {
+ unsigned tx = (i & 1) ? x1 : x0;
+ unsigned ty = (i >> 1) ? y1 : y0;
+
+ out[i] = get_texel_2d_ptr( tgsi_sampler, face, level, tx, ty );
+ }
+}
+
+static void
+get_texel(const struct tgsi_sampler *tgsi_sampler,
+ unsigned face, unsigned level, int x, int y, int z,
+ float rgba[NUM_CHANNELS][QUAD_SIZE], unsigned j)
+{
+ const struct lp_shader_sampler *samp = lp_shader_sampler(tgsi_sampler);
+ const struct pipe_texture *texture = samp->texture;
+ const struct pipe_sampler_state *sampler = samp->sampler;
+
+ if (x < 0 || x >= (int) texture->width[level] ||
+ y < 0 || y >= (int) texture->height[level] ||
+ z < 0 || z >= (int) texture->depth[level]) {
+ rgba[0][j] = sampler->border_color[0];
+ rgba[1][j] = sampler->border_color[1];
+ rgba[2][j] = sampler->border_color[2];
+ rgba[3][j] = sampler->border_color[3];
+ }
+ else {
+ const unsigned tx = x % TEX_TILE_SIZE;
+ const unsigned ty = y % TEX_TILE_SIZE;
+ const struct llvmpipe_cached_tex_tile *tile;
+
+ tile = lp_get_cached_tex_tile(samp->cache,
+ tex_tile_address(x, y, z, face, level));
+
+ rgba[0][j] = ubyte_to_float(tile->color[ty][tx][0]);
+ rgba[1][j] = ubyte_to_float(tile->color[ty][tx][1]);
+ rgba[2][j] = ubyte_to_float(tile->color[ty][tx][2]);
+ rgba[3][j] = ubyte_to_float(tile->color[ty][tx][3]);
+ if (0)
+ {
+ debug_printf("Get texel %f %f %f %f from %s\n",
+ rgba[0][j], rgba[1][j], rgba[2][j], rgba[3][j],
+ pf_name(texture->format));
+ }
+ }
+}
+
+
+/**
+ * Compare texcoord 'p' (aka R) against texture value 'rgba[0]'
+ * When we sampled the depth texture, the depth value was put into all
+ * RGBA channels. We look at the red channel here.
+ * \param rgba quad of (depth) texel values
+ * \param p texture 'P' components for four pixels in quad
+ * \param j which pixel in the quad to test [0..3]
+ */
+static INLINE void
+shadow_compare(const struct pipe_sampler_state *sampler,
+ float rgba[NUM_CHANNELS][QUAD_SIZE],
+ const float p[QUAD_SIZE],
+ uint j)
+{
+ int k;
+ switch (sampler->compare_func) {
+ case PIPE_FUNC_LESS:
+ k = p[j] < rgba[0][j];
+ break;
+ case PIPE_FUNC_LEQUAL:
+ k = p[j] <= rgba[0][j];
+ break;
+ case PIPE_FUNC_GREATER:
+ k = p[j] > rgba[0][j];
+ break;
+ case PIPE_FUNC_GEQUAL:
+ k = p[j] >= rgba[0][j];
+ break;
+ case PIPE_FUNC_EQUAL:
+ k = p[j] == rgba[0][j];
+ break;
+ case PIPE_FUNC_NOTEQUAL:
+ k = p[j] != rgba[0][j];
+ break;
+ case PIPE_FUNC_ALWAYS:
+ k = 1;
+ break;
+ case PIPE_FUNC_NEVER:
+ k = 0;
+ break;
+ default:
+ k = 0;
+ assert(0);
+ break;
+ }
+
+ /* XXX returning result for default GL_DEPTH_TEXTURE_MODE = GL_LUMINANCE */
+ rgba[0][j] = rgba[1][j] = rgba[2][j] = (float) k;
+ rgba[3][j] = 1.0F;
+}
+
+
+/**
+ * As above, but do four z/texture comparisons.
+ */
+static INLINE void
+shadow_compare4(const struct pipe_sampler_state *sampler,
+ float rgba[NUM_CHANNELS][QUAD_SIZE],
+ const float p[QUAD_SIZE])
+{
+ int j, k0, k1, k2, k3;
+ float val;
+
+ /* compare four texcoords vs. four texture samples */
+ switch (sampler->compare_func) {
+ case PIPE_FUNC_LESS:
+ k0 = p[0] < rgba[0][0];
+ k1 = p[1] < rgba[0][1];
+ k2 = p[2] < rgba[0][2];
+ k3 = p[3] < rgba[0][3];
+ break;
+ case PIPE_FUNC_LEQUAL:
+ k0 = p[0] <= rgba[0][0];
+ k1 = p[1] <= rgba[0][1];
+ k2 = p[2] <= rgba[0][2];
+ k3 = p[3] <= rgba[0][3];
+ break;
+ case PIPE_FUNC_GREATER:
+ k0 = p[0] > rgba[0][0];
+ k1 = p[1] > rgba[0][1];
+ k2 = p[2] > rgba[0][2];
+ k3 = p[3] > rgba[0][3];
+ break;
+ case PIPE_FUNC_GEQUAL:
+ k0 = p[0] >= rgba[0][0];
+ k1 = p[1] >= rgba[0][1];
+ k2 = p[2] >= rgba[0][2];
+ k3 = p[3] >= rgba[0][3];
+ break;
+ case PIPE_FUNC_EQUAL:
+ k0 = p[0] == rgba[0][0];
+ k1 = p[1] == rgba[0][1];
+ k2 = p[2] == rgba[0][2];
+ k3 = p[3] == rgba[0][3];
+ break;
+ case PIPE_FUNC_NOTEQUAL:
+ k0 = p[0] != rgba[0][0];
+ k1 = p[1] != rgba[0][1];
+ k2 = p[2] != rgba[0][2];
+ k3 = p[3] != rgba[0][3];
+ break;
+ case PIPE_FUNC_ALWAYS:
+ k0 = k1 = k2 = k3 = 1;
+ break;
+ case PIPE_FUNC_NEVER:
+ k0 = k1 = k2 = k3 = 0;
+ break;
+ default:
+ k0 = k1 = k2 = k3 = 0;
+ assert(0);
+ break;
+ }
+
+ /* convert four pass/fail values to an intensity in [0,1] */
+ val = 0.25F * (k0 + k1 + k2 + k3);
+
+ /* XXX returning result for default GL_DEPTH_TEXTURE_MODE = GL_LUMINANCE */
+ for (j = 0; j < 4; j++) {
+ rgba[0][j] = rgba[1][j] = rgba[2][j] = val;
+ rgba[3][j] = 1.0F;
+ }
+}
+
+
+
+static void
+lp_get_samples_2d_linear_repeat_POT(struct tgsi_sampler *tgsi_sampler,
+ const float s[QUAD_SIZE],
+ const float t[QUAD_SIZE],
+ const float p[QUAD_SIZE],
+ float lodbias,
+ float rgba[NUM_CHANNELS][QUAD_SIZE])
+{
+ const struct lp_shader_sampler *samp = lp_shader_sampler(tgsi_sampler);
+ unsigned j;
+ unsigned level = samp->level;
+ unsigned xpot = 1 << (samp->xpot - level);
+ unsigned ypot = 1 << (samp->ypot - level);
+ unsigned xmax = (xpot - 1) & (TEX_TILE_SIZE - 1); /* MIN2(TEX_TILE_SIZE, xpot) - 1; */
+ unsigned ymax = (ypot - 1) & (TEX_TILE_SIZE - 1); /* MIN2(TEX_TILE_SIZE, ypot) - 1; */
+
+ for (j = 0; j < QUAD_SIZE; j++) {
+ int c;
+
+ float u = s[j] * xpot - 0.5F;
+ float v = t[j] * ypot - 0.5F;
+
+ int uflr = util_ifloor(u);
+ int vflr = util_ifloor(v);
+
+ float xw = u - (float)uflr;
+ float yw = v - (float)vflr;
+
+ int x0 = uflr & (xpot - 1);
+ int y0 = vflr & (ypot - 1);
+
+ const uint8_t *tx[4];
+
+
+ /* Can we fetch all four at once:
+ */
+ if (x0 < xmax && y0 < ymax)
+ {
+ get_texel_quad_2d(tgsi_sampler, 0, level, x0, y0, tx);
+ }
+ else
+ {
+ unsigned x1 = (x0 + 1) & (xpot - 1);
+ unsigned y1 = (y0 + 1) & (ypot - 1);
+ get_texel_quad_2d_mt(tgsi_sampler, 0, level,
+ x0, y0, x1, y1, tx);
+ }
+
+
+ /* interpolate R, G, B, A */
+ for (c = 0; c < 4; c++) {
+ rgba[c][j] = lerp_2d(xw, yw,
+ ubyte_to_float(tx[0][c]), ubyte_to_float(tx[1][c]),
+ ubyte_to_float(tx[2][c]), ubyte_to_float(tx[3][c]));
+ }
+ }
+}
+
+
+static void
+lp_get_samples_2d_nearest_repeat_POT(struct tgsi_sampler *tgsi_sampler,
+ const float s[QUAD_SIZE],
+ const float t[QUAD_SIZE],
+ const float p[QUAD_SIZE],
+ float lodbias,
+ float rgba[NUM_CHANNELS][QUAD_SIZE])
+{
+ const struct lp_shader_sampler *samp = lp_shader_sampler(tgsi_sampler);
+ unsigned j;
+ unsigned level = samp->level;
+ unsigned xpot = 1 << (samp->xpot - level);
+ unsigned ypot = 1 << (samp->ypot - level);
+
+ for (j = 0; j < QUAD_SIZE; j++) {
+ int c;
+
+ float u = s[j] * xpot;
+ float v = t[j] * ypot;
+
+ int uflr = util_ifloor(u);
+ int vflr = util_ifloor(v);
+
+ int x0 = uflr & (xpot - 1);
+ int y0 = vflr & (ypot - 1);
+
+ const uint8_t *out = get_texel_2d_ptr(tgsi_sampler, 0, level, x0, y0);
+
+ for (c = 0; c < 4; c++) {
+ rgba[c][j] = ubyte_to_float(out[c]);
+ }
+ }
+}
+
+
+static void
+lp_get_samples_2d_nearest_clamp_POT(struct tgsi_sampler *tgsi_sampler,
+ const float s[QUAD_SIZE],
+ const float t[QUAD_SIZE],
+ const float p[QUAD_SIZE],
+ float lodbias,
+ float rgba[NUM_CHANNELS][QUAD_SIZE])
+{
+ const struct lp_shader_sampler *samp = lp_shader_sampler(tgsi_sampler);
+ unsigned j;
+ unsigned level = samp->level;
+ unsigned xpot = 1 << (samp->xpot - level);
+ unsigned ypot = 1 << (samp->ypot - level);
+
+ for (j = 0; j < QUAD_SIZE; j++) {
+ int c;
+
+ float u = s[j] * xpot;
+ float v = t[j] * ypot;
+
+ int x0, y0;
+ const uint8_t *out;
+
+ x0 = util_ifloor(u);
+ if (x0 < 0)
+ x0 = 0;
+ else if (x0 > xpot - 1)
+ x0 = xpot - 1;
+
+ y0 = util_ifloor(v);
+ if (y0 < 0)
+ y0 = 0;
+ else if (y0 > ypot - 1)
+ y0 = ypot - 1;
+
+ out = get_texel_2d_ptr(tgsi_sampler, 0, level, x0, y0);
+
+ for (c = 0; c < 4; c++) {
+ rgba[c][j] = ubyte_to_float(out[c]);
+ }
+ }
+}
+
+
+static void
+lp_get_samples_2d_linear_mip_linear_repeat_POT(struct tgsi_sampler *tgsi_sampler,
+ const float s[QUAD_SIZE],
+ const float t[QUAD_SIZE],
+ const float p[QUAD_SIZE],
+ float lodbias,
+ float rgba[NUM_CHANNELS][QUAD_SIZE])
+{
+ struct lp_shader_sampler *samp = lp_shader_sampler(tgsi_sampler);
+ const struct pipe_texture *texture = samp->texture;
+ int level0;
+ float lambda;
+
+ lambda = compute_lambda(tgsi_sampler, s, t, p, lodbias);
+ level0 = (int)lambda;
+
+ if (lambda < 0.0) {
+ samp->level = 0;
+ lp_get_samples_2d_linear_repeat_POT( tgsi_sampler,
+ s, t, p, 0, rgba );
+ }
+ else if (level0 >= texture->last_level) {
+ samp->level = texture->last_level;
+ lp_get_samples_2d_linear_repeat_POT( tgsi_sampler,
+ s, t, p, 0, rgba );
+ }
+ else {
+ float levelBlend = lambda - level0;
+ float rgba0[4][4];
+ float rgba1[4][4];
+ int c,j;
+
+ samp->level = level0;
+ lp_get_samples_2d_linear_repeat_POT( tgsi_sampler,
+ s, t, p, 0, rgba0 );
+
+ samp->level = level0+1;
+ lp_get_samples_2d_linear_repeat_POT( tgsi_sampler,
+ s, t, p, 0, rgba1 );
+
+ for (j = 0; j < QUAD_SIZE; j++) {
+ for (c = 0; c < 4; c++) {
+ rgba[c][j] = lerp(levelBlend, rgba0[c][j], rgba1[c][j]);
+ }
+ }
+ }
+}
+
+/**
+ * Common code for sampling 1D/2D/cube textures.
+ * Could probably extend for 3D...
+ */
+static void
+lp_get_samples_2d_common(struct tgsi_sampler *tgsi_sampler,
+ const float s[QUAD_SIZE],
+ const float t[QUAD_SIZE],
+ const float p[QUAD_SIZE],
+ float lodbias,
+ float rgba[NUM_CHANNELS][QUAD_SIZE],
+ const unsigned faces[4])
+{
+ const struct lp_shader_sampler *samp = lp_shader_sampler(tgsi_sampler);
+ const struct pipe_texture *texture = samp->texture;
+ const struct pipe_sampler_state *sampler = samp->sampler;
+ unsigned level0, level1, j, imgFilter;
+ int width, height;
+ float levelBlend;
+
+ choose_mipmap_levels(tgsi_sampler, s, t, p,
+ lodbias,
+ &level0, &level1, &levelBlend, &imgFilter);
+
+ assert(sampler->normalized_coords);
+
+ width = texture->width[level0];
+ height = texture->height[level0];
+
+ assert(width > 0);
+
+ switch (imgFilter) {
+ case PIPE_TEX_FILTER_NEAREST:
+ {
+ int x[4], y[4];
+ nearest_texcoord_4(sampler->wrap_s, s, width, x);
+ nearest_texcoord_4(sampler->wrap_t, t, height, y);
+
+ for (j = 0; j < QUAD_SIZE; j++) {
+ get_texel(tgsi_sampler, faces[j], level0, x[j], y[j], 0, rgba, j);
+ if (sampler->compare_mode == PIPE_TEX_COMPARE_R_TO_TEXTURE) {
+ shadow_compare(sampler, rgba, p, j);
+ }
+
+ if (level0 != level1) {
+ /* get texels from second mipmap level and blend */
+ float rgba2[4][4];
+ unsigned c;
+ x[j] /= 2;
+ y[j] /= 2;
+ get_texel(tgsi_sampler, faces[j], level1, x[j], y[j], 0,
+ rgba2, j);
+ if (sampler->compare_mode == PIPE_TEX_COMPARE_R_TO_TEXTURE){
+ shadow_compare(sampler, rgba2, p, j);
+ }
+
+ for (c = 0; c < NUM_CHANNELS; c++) {
+ rgba[c][j] = lerp(levelBlend, rgba[c][j], rgba2[c][j]);
+ }
+ }
+ }
+ }
+ break;
+ case PIPE_TEX_FILTER_LINEAR:
+ case PIPE_TEX_FILTER_ANISO:
+ {
+ int x0[4], y0[4], x1[4], y1[4];
+ float xw[4], yw[4]; /* weights */
+
+ linear_texcoord_4(sampler->wrap_s, s, width, x0, x1, xw);
+ linear_texcoord_4(sampler->wrap_t, t, height, y0, y1, yw);
+
+ for (j = 0; j < QUAD_SIZE; j++) {
+ float tx[4][4]; /* texels */
+ int c;
+ get_texel(tgsi_sampler, faces[j], level0, x0[j], y0[j], 0, tx, 0);
+ get_texel(tgsi_sampler, faces[j], level0, x1[j], y0[j], 0, tx, 1);
+ get_texel(tgsi_sampler, faces[j], level0, x0[j], y1[j], 0, tx, 2);
+ get_texel(tgsi_sampler, faces[j], level0, x1[j], y1[j], 0, tx, 3);
+ if (sampler->compare_mode == PIPE_TEX_COMPARE_R_TO_TEXTURE) {
+ shadow_compare4(sampler, tx, p);
+ }
+
+ /* interpolate R, G, B, A */
+ for (c = 0; c < 4; c++) {
+ rgba[c][j] = lerp_2d(xw[j], yw[j],
+ tx[c][0], tx[c][1],
+ tx[c][2], tx[c][3]);
+ }
+
+ if (level0 != level1) {
+ /* get texels from second mipmap level and blend */
+ float rgba2[4][4];
+
+ /* XXX: This is incorrect -- will often end up with (x0
+ * == x1 && y0 == y1), meaning that we fetch the same
+ * texel four times and linearly interpolate between
+ * identical values. The correct approach would be to
+ * call linear_texcoord again for the second level.
+ */
+ x0[j] /= 2;
+ y0[j] /= 2;
+ x1[j] /= 2;
+ y1[j] /= 2;
+ get_texel(tgsi_sampler, faces[j], level1, x0[j], y0[j], 0, tx, 0);
+ get_texel(tgsi_sampler, faces[j], level1, x1[j], y0[j], 0, tx, 1);
+ get_texel(tgsi_sampler, faces[j], level1, x0[j], y1[j], 0, tx, 2);
+ get_texel(tgsi_sampler, faces[j], level1, x1[j], y1[j], 0, tx, 3);
+ if (sampler->compare_mode == PIPE_TEX_COMPARE_R_TO_TEXTURE){
+ shadow_compare4(sampler, tx, p);
+ }
+
+ /* interpolate R, G, B, A */
+ for (c = 0; c < 4; c++) {
+ rgba2[c][j] = lerp_2d(xw[j], yw[j],
+ tx[c][0], tx[c][1], tx[c][2], tx[c][3]);
+ }
+
+ for (c = 0; c < NUM_CHANNELS; c++) {
+ rgba[c][j] = lerp(levelBlend, rgba[c][j], rgba2[c][j]);
+ }
+ }
+ }
+ }
+ break;
+ default:
+ assert(0);
+ }
+}
+
+
+static INLINE void
+lp_get_samples_1d(struct tgsi_sampler *sampler,
+ const float s[QUAD_SIZE],
+ const float t[QUAD_SIZE],
+ const float p[QUAD_SIZE],
+ float lodbias,
+ float rgba[NUM_CHANNELS][QUAD_SIZE])
+{
+ static const unsigned faces[4] = {0, 0, 0, 0};
+ static const float tzero[4] = {0, 0, 0, 0};
+ lp_get_samples_2d_common(sampler, s, tzero, NULL,
+ lodbias, rgba, faces);
+}
+
+
+static INLINE void
+lp_get_samples_2d(struct tgsi_sampler *sampler,
+ const float s[QUAD_SIZE],
+ const float t[QUAD_SIZE],
+ const float p[QUAD_SIZE],
+ float lodbias,
+ float rgba[NUM_CHANNELS][QUAD_SIZE])
+{
+ static const unsigned faces[4] = {0, 0, 0, 0};
+ lp_get_samples_2d_common(sampler, s, t, p,
+ lodbias, rgba, faces);
+}
+
+
+static INLINE void
+lp_get_samples_3d(struct tgsi_sampler *tgsi_sampler,
+ const float s[QUAD_SIZE],
+ const float t[QUAD_SIZE],
+ const float p[QUAD_SIZE],
+ float lodbias,
+ float rgba[NUM_CHANNELS][QUAD_SIZE])
+{
+ const struct lp_shader_sampler *samp = lp_shader_sampler(tgsi_sampler);
+ const struct pipe_texture *texture = samp->texture;
+ const struct pipe_sampler_state *sampler = samp->sampler;
+ /* get/map pipe_surfaces corresponding to 3D tex slices */
+ unsigned level0, level1, j, imgFilter;
+ int width, height, depth;
+ float levelBlend;
+ const uint face = 0;
+
+ choose_mipmap_levels(tgsi_sampler, s, t, p,
+ lodbias,
+ &level0, &level1, &levelBlend, &imgFilter);
+
+ assert(sampler->normalized_coords);
+
+ width = texture->width[level0];
+ height = texture->height[level0];
+ depth = texture->depth[level0];
+
+ assert(width > 0);
+ assert(height > 0);
+ assert(depth > 0);
+
+ switch (imgFilter) {
+ case PIPE_TEX_FILTER_NEAREST:
+ {
+ int x[4], y[4], z[4];
+ nearest_texcoord_4(sampler->wrap_s, s, width, x);
+ nearest_texcoord_4(sampler->wrap_t, t, height, y);
+ nearest_texcoord_4(sampler->wrap_r, p, depth, z);
+ for (j = 0; j < QUAD_SIZE; j++) {
+ get_texel(tgsi_sampler, face, level0, x[j], y[j], z[j], rgba, j);
+ if (level0 != level1) {
+ /* get texels from second mipmap level and blend */
+ float rgba2[4][4];
+ unsigned c;
+ x[j] /= 2;
+ y[j] /= 2;
+ z[j] /= 2;
+ get_texel(tgsi_sampler, face, level1, x[j], y[j], z[j], rgba2, j);
+ for (c = 0; c < NUM_CHANNELS; c++) {
+ rgba[c][j] = lerp(levelBlend, rgba2[c][j], rgba[c][j]);
+ }
+ }
+ }
+ }
+ break;
+ case PIPE_TEX_FILTER_LINEAR:
+ case PIPE_TEX_FILTER_ANISO:
+ {
+ int x0[4], x1[4], y0[4], y1[4], z0[4], z1[4];
+ float xw[4], yw[4], zw[4]; /* interpolation weights */
+ linear_texcoord_4(sampler->wrap_s, s, width, x0, x1, xw);
+ linear_texcoord_4(sampler->wrap_t, t, height, y0, y1, yw);
+ linear_texcoord_4(sampler->wrap_r, p, depth, z0, z1, zw);
+
+ for (j = 0; j < QUAD_SIZE; j++) {
+ int c;
+ float tx0[4][4], tx1[4][4];
+ get_texel(tgsi_sampler, face, level0, x0[j], y0[j], z0[j], tx0, 0);
+ get_texel(tgsi_sampler, face, level0, x1[j], y0[j], z0[j], tx0, 1);
+ get_texel(tgsi_sampler, face, level0, x0[j], y1[j], z0[j], tx0, 2);
+ get_texel(tgsi_sampler, face, level0, x1[j], y1[j], z0[j], tx0, 3);
+ get_texel(tgsi_sampler, face, level0, x0[j], y0[j], z1[j], tx1, 0);
+ get_texel(tgsi_sampler, face, level0, x1[j], y0[j], z1[j], tx1, 1);
+ get_texel(tgsi_sampler, face, level0, x0[j], y1[j], z1[j], tx1, 2);
+ get_texel(tgsi_sampler, face, level0, x1[j], y1[j], z1[j], tx1, 3);
+
+ /* interpolate R, G, B, A */
+ for (c = 0; c < 4; c++) {
+ rgba[c][j] = lerp_3d(xw[j], yw[j], zw[j],
+ tx0[c][0], tx0[c][1],
+ tx0[c][2], tx0[c][3],
+ tx1[c][0], tx1[c][1],
+ tx1[c][2], tx1[c][3]);
+ }
+
+ if (level0 != level1) {
+ /* get texels from second mipmap level and blend */
+ float rgba2[4][4];
+ x0[j] /= 2;
+ y0[j] /= 2;
+ z0[j] /= 2;
+ x1[j] /= 2;
+ y1[j] /= 2;
+ z1[j] /= 2;
+ get_texel(tgsi_sampler, face, level1, x0[j], y0[j], z0[j], tx0, 0);
+ get_texel(tgsi_sampler, face, level1, x1[j], y0[j], z0[j], tx0, 1);
+ get_texel(tgsi_sampler, face, level1, x0[j], y1[j], z0[j], tx0, 2);
+ get_texel(tgsi_sampler, face, level1, x1[j], y1[j], z0[j], tx0, 3);
+ get_texel(tgsi_sampler, face, level1, x0[j], y0[j], z1[j], tx1, 0);
+ get_texel(tgsi_sampler, face, level1, x1[j], y0[j], z1[j], tx1, 1);
+ get_texel(tgsi_sampler, face, level1, x0[j], y1[j], z1[j], tx1, 2);
+ get_texel(tgsi_sampler, face, level1, x1[j], y1[j], z1[j], tx1, 3);
+
+ /* interpolate R, G, B, A */
+ for (c = 0; c < 4; c++) {
+ rgba2[c][j] = lerp_3d(xw[j], yw[j], zw[j],
+ tx0[c][0], tx0[c][1],
+ tx0[c][2], tx0[c][3],
+ tx1[c][0], tx1[c][1],
+ tx1[c][2], tx1[c][3]);
+ }
+
+ /* blend mipmap levels */
+ for (c = 0; c < NUM_CHANNELS; c++) {
+ rgba[c][j] = lerp(levelBlend, rgba[c][j], rgba2[c][j]);
+ }
+ }
+ }
+ }
+ break;
+ default:
+ assert(0);
+ }
+}
+
+
+static void
+lp_get_samples_cube(struct tgsi_sampler *sampler,
+ const float s[QUAD_SIZE],
+ const float t[QUAD_SIZE],
+ const float p[QUAD_SIZE],
+ float lodbias,
+ float rgba[NUM_CHANNELS][QUAD_SIZE])
+{
+ unsigned faces[QUAD_SIZE], j;
+ float ssss[4], tttt[4];
+ for (j = 0; j < QUAD_SIZE; j++) {
+ faces[j] = choose_cube_face(s[j], t[j], p[j], ssss + j, tttt + j);
+ }
+ lp_get_samples_2d_common(sampler, ssss, tttt, NULL,
+ lodbias, rgba, faces);
+}
+
+
+static void
+lp_get_samples_rect(struct tgsi_sampler *tgsi_sampler,
+ const float s[QUAD_SIZE],
+ const float t[QUAD_SIZE],
+ const float p[QUAD_SIZE],
+ float lodbias,
+ float rgba[NUM_CHANNELS][QUAD_SIZE])
+{
+ const struct lp_shader_sampler *samp = lp_shader_sampler(tgsi_sampler);
+ const struct pipe_texture *texture = samp->texture;
+ const struct pipe_sampler_state *sampler = samp->sampler;
+ const uint face = 0;
+ unsigned level0, level1, j, imgFilter;
+ int width, height;
+ float levelBlend;
+
+ choose_mipmap_levels(tgsi_sampler, s, t, p,
+ lodbias,
+ &level0, &level1, &levelBlend, &imgFilter);
+
+ /* texture RECTS cannot be mipmapped */
+ assert(level0 == level1);
+
+ width = texture->width[level0];
+ height = texture->height[level0];
+
+ assert(width > 0);
+
+ switch (imgFilter) {
+ case PIPE_TEX_FILTER_NEAREST:
+ {
+ int x[4], y[4];
+ nearest_texcoord_unnorm_4(sampler->wrap_s, s, width, x);
+ nearest_texcoord_unnorm_4(sampler->wrap_t, t, height, y);
+ for (j = 0; j < QUAD_SIZE; j++) {
+ get_texel(tgsi_sampler, face, level0, x[j], y[j], 0, rgba, j);
+ if (sampler->compare_mode == PIPE_TEX_COMPARE_R_TO_TEXTURE) {
+ shadow_compare(sampler, rgba, p, j);
+ }
+ }
+ }
+ break;
+ case PIPE_TEX_FILTER_LINEAR:
+ case PIPE_TEX_FILTER_ANISO:
+ {
+ int x0[4], y0[4], x1[4], y1[4];
+ float xw[4], yw[4]; /* weights */
+ linear_texcoord_unnorm_4(sampler->wrap_s, s, width, x0, x1, xw);
+ linear_texcoord_unnorm_4(sampler->wrap_t, t, height, y0, y1, yw);
+ for (j = 0; j < QUAD_SIZE; j++) {
+ float tx[4][4]; /* texels */
+ int c;
+ get_texel(tgsi_sampler, face, level0, x0[j], y0[j], 0, tx, 0);
+ get_texel(tgsi_sampler, face, level0, x1[j], y0[j], 0, tx, 1);
+ get_texel(tgsi_sampler, face, level0, x0[j], y1[j], 0, tx, 2);
+ get_texel(tgsi_sampler, face, level0, x1[j], y1[j], 0, tx, 3);
+ if (sampler->compare_mode == PIPE_TEX_COMPARE_R_TO_TEXTURE) {
+ shadow_compare4(sampler, tx, p);
+ }
+ for (c = 0; c < 4; c++) {
+ rgba[c][j] = lerp_2d(xw[j], yw[j],
+ tx[c][0], tx[c][1], tx[c][2], tx[c][3]);
+ }
+ }
+ }
+ break;
+ default:
+ assert(0);
+ }
+}
+
+
+/**
+ * Error condition handler
+ */
+static INLINE void
+lp_get_samples_null(struct tgsi_sampler *tgsi_sampler,
+ const float s[QUAD_SIZE],
+ const float t[QUAD_SIZE],
+ const float p[QUAD_SIZE],
+ float lodbias,
+ float rgba[NUM_CHANNELS][QUAD_SIZE])
+{
+ int i,j;
+
+ for (i = 0; i < 4; i++)
+ for (j = 0; j < 4; j++)
+ rgba[i][j] = 1.0;
+}
+
+/**
+ * Called via tgsi_sampler::get_samples() when using a sampler for the
+ * first time. Determine the actual sampler function, link it in and
+ * call it.
+ */
+void
+lp_get_samples(struct tgsi_sampler *tgsi_sampler,
+ const float s[QUAD_SIZE],
+ const float t[QUAD_SIZE],
+ const float p[QUAD_SIZE],
+ float lodbias,
+ float rgba[NUM_CHANNELS][QUAD_SIZE])
+{
+ struct lp_shader_sampler *samp = lp_shader_sampler(tgsi_sampler);
+ const struct pipe_texture *texture = samp->texture;
+ const struct pipe_sampler_state *sampler = samp->sampler;
+
+ /* Default to the 'undefined' case:
+ */
+ tgsi_sampler->get_samples = lp_get_samples_null;
+
+ if (!texture) {
+ assert(0); /* is this legal?? */
+ goto out;
+ }
+
+ if (!sampler->normalized_coords) {
+ assert (texture->target == PIPE_TEXTURE_2D);
+ tgsi_sampler->get_samples = lp_get_samples_rect;
+ goto out;
+ }
+
+ switch (texture->target) {
+ case PIPE_TEXTURE_1D:
+ tgsi_sampler->get_samples = lp_get_samples_1d;
+ break;
+ case PIPE_TEXTURE_2D:
+ tgsi_sampler->get_samples = lp_get_samples_2d;
+ break;
+ case PIPE_TEXTURE_3D:
+ tgsi_sampler->get_samples = lp_get_samples_3d;
+ break;
+ case PIPE_TEXTURE_CUBE:
+ tgsi_sampler->get_samples = lp_get_samples_cube;
+ break;
+ default:
+ assert(0);
+ break;
+ }
+
+ /* Do this elsewhere:
+ */
+ samp->xpot = util_unsigned_logbase2( samp->texture->width[0] );
+ samp->ypot = util_unsigned_logbase2( samp->texture->height[0] );
+
+ /* Try to hook in a faster sampler. Ultimately we'll have to
+ * code-generate these. Luckily most of this looks like it is
+ * orthogonal state within the sampler.
+ */
+ if (texture->target == PIPE_TEXTURE_2D &&
+ sampler->min_img_filter == sampler->mag_img_filter &&
+ sampler->wrap_s == sampler->wrap_t &&
+ sampler->compare_mode == FALSE &&
+ sampler->normalized_coords)
+ {
+ if (sampler->min_mip_filter == PIPE_TEX_MIPFILTER_NONE) {
+ samp->level = CLAMP((int) sampler->min_lod,
+ 0, (int) texture->last_level);
+
+ if (sampler->wrap_s == PIPE_TEX_WRAP_REPEAT) {
+ switch (sampler->min_img_filter) {
+ case PIPE_TEX_FILTER_NEAREST:
+ tgsi_sampler->get_samples = lp_get_samples_2d_nearest_repeat_POT;
+ break;
+ case PIPE_TEX_FILTER_LINEAR:
+ tgsi_sampler->get_samples = lp_get_samples_2d_linear_repeat_POT;
+ break;
+ default:
+ break;
+ }
+ }
+ else if (sampler->wrap_s == PIPE_TEX_WRAP_CLAMP) {
+ switch (sampler->min_img_filter) {
+ case PIPE_TEX_FILTER_NEAREST:
+ tgsi_sampler->get_samples = lp_get_samples_2d_nearest_clamp_POT;
+ break;
+ default:
+ break;
+ }
+ }
+ }
+ else if (sampler->min_mip_filter == PIPE_TEX_MIPFILTER_LINEAR) {
+ if (sampler->wrap_s == PIPE_TEX_WRAP_REPEAT) {
+ switch (sampler->min_img_filter) {
+ case PIPE_TEX_FILTER_LINEAR:
+ tgsi_sampler->get_samples = lp_get_samples_2d_linear_mip_linear_repeat_POT;
+ break;
+ default:
+ break;
+ }
+ }
+ }
+ }
+ else if (0) {
+ _debug_printf("target %d/%d min_mip %d/%d min_img %d/%d wrap %d/%d compare %d/%d norm %d/%d\n",
+ texture->target, PIPE_TEXTURE_2D,
+ sampler->min_mip_filter, PIPE_TEX_MIPFILTER_NONE,
+ sampler->min_img_filter, sampler->mag_img_filter,
+ sampler->wrap_s, sampler->wrap_t,
+ sampler->compare_mode, FALSE,
+ sampler->normalized_coords, TRUE);
+ }
+
+out:
+ tgsi_sampler->get_samples( tgsi_sampler, s, t, p, lodbias, rgba );
+}
+
+
+void PIPE_CDECL
+lp_fetch_texel_soa( struct tgsi_sampler **samplers,
+ uint32_t unit,
+ float *store )
+{
+ struct tgsi_sampler *sampler = samplers[unit];
+
+#if 0
+ uint j;
+
+ debug_printf("%s sampler: %p (%p) store: %p\n",
+ __FUNCTION__,
+ sampler, *sampler,
+ store );
+
+ debug_printf("lodbias %f\n", store[12]);
+
+ for (j = 0; j < 4; j++)
+ debug_printf("sample %d texcoord %f %f\n",
+ j,
+ store[0+j],
+ store[4+j]);
+#endif
+
+ {
+ float rgba[NUM_CHANNELS][QUAD_SIZE];
+ sampler->get_samples(sampler,
+ &store[0],
+ &store[4],
+ &store[8],
+ 0.0f, /*store[12], lodbias */
+ rgba);
+ memcpy(store, rgba, sizeof rgba);
+ }
+
+#if 0
+ for (j = 0; j < 4; j++)
+ debug_printf("sample %d result %f %f %f %f\n",
+ j,
+ store[0+j],
+ store[4+j],
+ store[8+j],
+ store[12+j]);
+#endif
+}
+
+
+#include "lp_bld_type.h"
+#include "lp_bld_intr.h"
+#include "lp_bld_tgsi.h"
+
+
+struct lp_c_sampler_soa
+{
+ struct lp_build_sampler_soa base;
+
+ LLVMValueRef context_ptr;
+
+ LLVMValueRef samplers_ptr;
+
+ /** Coords/texels store */
+ LLVMValueRef store_ptr;
+};
+
+
+static void
+lp_c_sampler_soa_destroy(struct lp_build_sampler_soa *sampler)
+{
+ FREE(sampler);
+}
+
+
+static void
+lp_c_sampler_soa_emit_fetch_texel(struct lp_build_sampler_soa *_sampler,
+ LLVMBuilderRef builder,
+ union lp_type type,
+ unsigned unit,
+ unsigned num_coords,
+ const LLVMValueRef *coords,
+ LLVMValueRef lodbias,
+ LLVMValueRef *texel)
+{
+ struct lp_c_sampler_soa *sampler = (struct lp_c_sampler_soa *)_sampler;
+ LLVMTypeRef vec_type = LLVMTypeOf(coords[0]);
+ LLVMValueRef args[3];
+ unsigned i;
+
+ if(!sampler->samplers_ptr)
+ sampler->samplers_ptr = lp_jit_context_samplers(builder, sampler->context_ptr);
+
+ if(!sampler->store_ptr)
+ sampler->store_ptr = LLVMBuildArrayAlloca(builder,
+ vec_type,
+ LLVMConstInt(LLVMInt32Type(), 4, 0),
+ "texel_store");
+
+ for (i = 0; i < num_coords; i++) {
+ LLVMValueRef index = LLVMConstInt(LLVMInt32Type(), i, 0);
+ LLVMValueRef coord_ptr = LLVMBuildGEP(builder, sampler->store_ptr, &index, 1, "");
+ LLVMBuildStore(builder, coords[i], coord_ptr);
+ }
+
+ args[0] = sampler->samplers_ptr;
+ args[1] = LLVMConstInt(LLVMInt32Type(), unit, 0);
+ args[2] = sampler->store_ptr;
+
+ lp_build_intrinsic(builder, "fetch_texel", LLVMVoidType(), args, 3);
+
+ for (i = 0; i < NUM_CHANNELS; ++i) {
+ LLVMValueRef index = LLVMConstInt(LLVMInt32Type(), i, 0);
+ LLVMValueRef texel_ptr = LLVMBuildGEP(builder, sampler->store_ptr, &index, 1, "");
+ texel[i] = LLVMBuildLoad(builder, texel_ptr, "");
+ }
+}
+
+
+struct lp_build_sampler_soa *
+lp_c_sampler_soa_create(LLVMValueRef context_ptr)
+{
+ struct lp_c_sampler_soa *sampler;
+
+ sampler = CALLOC_STRUCT(lp_c_sampler_soa);
+ if(!sampler)
+ return NULL;
+
+ sampler->base.destroy = lp_c_sampler_soa_destroy;
+ sampler->base.emit_fetch_texel = lp_c_sampler_soa_emit_fetch_texel;
+ sampler->context_ptr = context_ptr;
+
+ return &sampler->base;
+}
+
--- /dev/null
+/**************************************************************************
+ *
+ * Copyright 2009 VMware, Inc.
+ * All rights reserved.
+ *
+ * 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, sub license, 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 (including the
+ * next paragraph) 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 NON-INFRINGEMENT.
+ * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS 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.
+ *
+ **************************************************************************/
+
+/**
+ * Texture sampling code generation
+ *
+ * This file is nothing more than ugly glue between three largely independent
+ * entities:
+ * - TGSI -> LLVM translation (i.e., lp_build_tgsi_soa)
+ * - texture sampling code generation (i.e., lp_build_sample_soa)
+ * - LLVM pipe driver
+ *
+ * All interesting code is in the functions mentioned above. There is really
+ * nothing to see here.
+ *
+ * @author Jose Fonseca <jfonseca@vmware.com>
+ */
+
+#include "pipe/p_defines.h"
+#include "pipe/p_shader_tokens.h"
+#include "lp_bld_debug.h"
+#include "lp_bld_type.h"
+#include "lp_bld_intr.h"
+#include "lp_bld_sample.h"
+#include "lp_bld_tgsi.h"
+#include "lp_state.h"
+#include "lp_tex_sample.h"
+
+
+/**
+ * This provides the bridge between the sampler state store in lp_jit_context
+ * and lp_jit_texture and the sampler code generator. It provides the
+ * texture layout information required by the texture sampler code generator
+ * in terms of the state stored in lp_jit_context and lp_jit_texture in runtime.
+ */
+struct llvmpipe_sampler_dynamic_state
+{
+ struct lp_sampler_dynamic_state base;
+
+ const struct lp_sampler_static_state *static_state;
+
+ LLVMValueRef context_ptr;
+};
+
+
+/**
+ * This is the bridge between our sampler and the TGSI translator.
+ */
+struct lp_llvm_sampler_soa
+{
+ struct lp_build_sampler_soa base;
+
+ struct llvmpipe_sampler_dynamic_state dynamic_state;
+};
+
+
+/**
+ * Fetch the specified member of the lp_jit_texture structure.
+ *
+ * @sa http://llvm.org/docs/GetElementPtr.html
+ */
+static LLVMValueRef
+lp_llvm_texture_member(struct lp_sampler_dynamic_state *base,
+ LLVMBuilderRef builder,
+ unsigned unit,
+ unsigned member_index,
+ const char *member_name)
+{
+ struct llvmpipe_sampler_dynamic_state *state = (struct llvmpipe_sampler_dynamic_state *)base;
+ LLVMValueRef indices[4];
+ LLVMValueRef ptr;
+ LLVMValueRef res;
+
+ assert(unit < PIPE_MAX_SAMPLERS);
+
+ /* context[0] */
+ indices[0] = LLVMConstInt(LLVMInt32Type(), 0, 0);
+ /* context[0].textures */
+ indices[1] = LLVMConstInt(LLVMInt32Type(), LP_JIT_CONTEXT_TEXTURES_INDEX, 0);
+ /* context[0].textures[unit] */
+ indices[2] = LLVMConstInt(LLVMInt32Type(), unit, 0);
+ /* context[0].textures[unit].member */
+ indices[3] = LLVMConstInt(LLVMInt32Type(), member_index, 0);
+
+ ptr = LLVMBuildGEP(builder, state->context_ptr, indices, Elements(indices), "");
+
+ res = LLVMBuildLoad(builder, ptr, "");
+
+ lp_build_name(res, "context.texture%u.%s", unit, member_name);
+
+ return res;
+}
+
+
+/**
+ * Helper macro to instantiate the functions that generate the code to fetch
+ * the members of lp_jit_texture to fulfill the sampler code generator requests.
+ *
+ * This complexity is the price we have to pay to keep the texture sampler code
+ * generator a reusable module without dependencies to llvmpipe internals.
+ */
+#define LP_LLVM_TEXTURE_MEMBER(_name, _index) \
+ static LLVMValueRef \
+ lp_llvm_texture_##_name( struct lp_sampler_dynamic_state *base, \
+ LLVMBuilderRef builder, \
+ unsigned unit) \
+ { \
+ return lp_llvm_texture_member(base, builder, unit, _index, #_name ); \
+ }
+
+
+LP_LLVM_TEXTURE_MEMBER(width, LP_JIT_TEXTURE_WIDTH)
+LP_LLVM_TEXTURE_MEMBER(height, LP_JIT_TEXTURE_HEIGHT)
+LP_LLVM_TEXTURE_MEMBER(stride, LP_JIT_TEXTURE_STRIDE)
+LP_LLVM_TEXTURE_MEMBER(data_ptr, LP_JIT_TEXTURE_DATA)
+
+
+static void
+lp_llvm_sampler_soa_destroy(struct lp_build_sampler_soa *sampler)
+{
+ FREE(sampler);
+}
+
+
+static void
+lp_llvm_sampler_soa_emit_fetch_texel(struct lp_build_sampler_soa *base,
+ LLVMBuilderRef builder,
+ union lp_type type,
+ unsigned unit,
+ unsigned num_coords,
+ const LLVMValueRef *coords,
+ LLVMValueRef lodbias,
+ LLVMValueRef *texel)
+{
+ struct lp_llvm_sampler_soa *sampler = (struct lp_llvm_sampler_soa *)base;
+
+ assert(unit < PIPE_MAX_SAMPLERS);
+
+ lp_build_sample_soa(builder,
+ &sampler->dynamic_state.static_state[unit],
+ &sampler->dynamic_state.base,
+ type,
+ unit,
+ num_coords,
+ coords,
+ lodbias,
+ texel);
+}
+
+
+struct lp_build_sampler_soa *
+lp_llvm_sampler_soa_create(const struct lp_sampler_static_state *static_state,
+ LLVMValueRef context_ptr)
+{
+ struct lp_llvm_sampler_soa *sampler;
+
+ sampler = CALLOC_STRUCT(lp_llvm_sampler_soa);
+ if(!sampler)
+ return NULL;
+
+ sampler->base.destroy = lp_llvm_sampler_soa_destroy;
+ sampler->base.emit_fetch_texel = lp_llvm_sampler_soa_emit_fetch_texel;
+ sampler->dynamic_state.base.width = lp_llvm_texture_width;
+ sampler->dynamic_state.base.height = lp_llvm_texture_height;
+ sampler->dynamic_state.base.stride = lp_llvm_texture_stride;
+ sampler->dynamic_state.base.data_ptr = lp_llvm_texture_data_ptr;
+ sampler->dynamic_state.static_state = static_state;
+ sampler->dynamic_state.context_ptr = context_ptr;
+
+ return &sampler->base;
+}
+
mt->image_nr = 1;
mt->level[0].pitch = *stride;
mt->level[0].image_offset = CALLOC(1, sizeof(unsigned));
+ mt->level[0].tile_mode = bo->tile_mode;
nouveau_bo_ref(bo, &mt->base.bo);
return &mt->base.base;
so_data(so, NV50TCL_RT_FORMAT_X8R8G8B8_UNORM);
break;
}
- so_data(so, bo->tile_mode << 4);
+ so_data(so, nv50_miptree(pt)->
+ level[fb->cbufs[i]->level].tile_mode << 4);
so_data(so, 0x00000000);
so_method(so, tesla, 0x1224, 1);
so_data(so, NV50TCL_ZETA_FORMAT_S8Z24_UNORM);
break;
}
- so_data(so, bo->tile_mode << 4);
+ so_data(so, nv50_miptree(pt)->
+ level[fb->zsbuf->level].tile_mode << 4);
so_data(so, 0x00000000);
so_method(so, tesla, 0x1538, 1);
format = nv50_format(ps->format);
if (format < 0)
return 1;
-
+
if (!bo->tile_flags) {
BEGIN_RING(chan, eng2d, mthd, 2);
OUT_RING (chan, format);
OUT_RING (chan, 1);
BEGIN_RING(chan, eng2d, mthd + 0x14, 5);
- OUT_RING (chan, mt->level[0].pitch);
+ OUT_RING (chan, mt->level[ps->level].pitch);
OUT_RING (chan, ps->width);
OUT_RING (chan, ps->height);
OUT_RELOCh(chan, bo, ps->offset, flags);
BEGIN_RING(chan, eng2d, mthd, 5);
OUT_RING (chan, format);
OUT_RING (chan, 0);
- OUT_RING (chan, bo->tile_mode << 4);
+ OUT_RING (chan, mt->level[ps->level].tile_mode << 4);
OUT_RING (chan, 1);
OUT_RING (chan, 0);
BEGIN_RING(chan, eng2d, mthd + 0x18, 4);
/* Offsets into the buffer. */
unsigned offset[PIPE_MAX_TEXTURE_LEVELS];
- /* Stride (pitch?) of this texture in bytes */
- unsigned stride;
+ /**
+ * If non-zero, override the natural texture layout with
+ * a custom stride (in bytes).
+ *
+ * \note Mipmapping fails for textures with a non-natural layout!
+ *
+ * \sa r300_texture_get_stride
+ */
+ unsigned stride_override;
/* Total size of this texture, in bytes. */
unsigned size;
for (i = 0; i < fb->nr_cbufs; i++) {
tex = (struct r300_texture*)fb->cbufs[i]->texture;
assert(tex && tex->buffer && "cbuf is marked, but NULL!");
- pixpitch = tex->stride / tex->tex.block.size;
+ pixpitch = r300_texture_get_stride(tex, 0) / tex->tex.block.size;
OUT_CS_REG_SEQ(R300_RB3D_COLOROFFSET0 + (4 * i), 1);
OUT_CS_RELOC(tex->buffer, 0, 0, RADEON_GEM_DOMAIN_VRAM, 0);
if (fb->zsbuf) {
tex = (struct r300_texture*)fb->zsbuf->texture;
assert(tex && tex->buffer && "zsbuf is marked, but NULL!");
- pixpitch = tex->stride / tex->tex.block.size;
+ pixpitch = r300_texture_get_stride(tex, 0) / tex->tex.block.size;
OUT_CS_REG_SEQ(R300_ZB_DEPTHOFFSET, 1);
OUT_CS_RELOC(tex->buffer, 0, 0, RADEON_GEM_DOMAIN_VRAM, 0);
#include "r300_state_derived.h"
/* r300_render: Vertex and index buffer primitive emission. */
+#define R300_MAX_VBO_SIZE (1024 * 1024)
struct r300_render {
/* Parent class */
/* VBO */
struct pipe_buffer* vbo;
- size_t vbo_alloc_size;
+ size_t vbo_size;
+ size_t vbo_offset;
+ size_t vbo_max_used;
+ void * vbo_ptr;
};
static INLINE struct r300_render*
struct pipe_screen* screen = r300->context.screen;
size_t size = (size_t)vertex_size * (size_t)count;
- if (r300render->vbo && (size > r300render->vbo_alloc_size)) {
- pipe_buffer_reference(&r300render->vbo, NULL);
- }
-
- if (!r300render->vbo) {
+ if (size + r300render->vbo_offset > r300render->vbo_size)
+ {
r300render->vbo = pipe_buffer_create(screen,
64,
PIPE_BUFFER_USAGE_VERTEX,
- size);
+ R300_MAX_VBO_SIZE);
+ r300render->vbo_size = R300_MAX_VBO_SIZE;
}
- r300render->vbo_alloc_size = MAX2(size, r300render->vbo_alloc_size);
r300render->vertex_size = vertex_size;
+ r300->vbo = r300render->vbo;
+ r300->vbo_offset = r300render->vbo_offset;
return (r300render->vbo) ? TRUE : FALSE;
}
struct r300_render* r300render = r300_render(render);
struct pipe_screen* screen = r300render->r300->context.screen;
- return (unsigned char*)pipe_buffer_map(screen, r300render->vbo,
- PIPE_BUFFER_USAGE_CPU_WRITE);
+ r300render->vbo_ptr = pipe_buffer_map(screen, r300render->vbo,
+ PIPE_BUFFER_USAGE_CPU_WRITE);
+
+ return (r300render->vbo_ptr + r300render->vbo_offset);
}
static void r300_render_unmap_vertices(struct vbuf_render* render,
{
struct r300_render* r300render = r300_render(render);
struct pipe_screen* screen = r300render->r300->context.screen;
+ CS_LOCALS(r300render->r300);
+ BEGIN_CS(2);
+ OUT_CS_REG(R300_VAP_VF_MAX_VTX_INDX, max);
+ END_CS;
+ r300render->vbo_max_used = MAX2(r300render->vbo_max_used,
+ r300render->vertex_size * (max + 1));
pipe_buffer_unmap(screen, r300render->vbo);
}
static void r300_render_release_vertices(struct vbuf_render* render)
{
struct r300_render* r300render = r300_render(render);
+ struct r300_context* r300 = r300render->r300;
- pipe_buffer_reference(&r300render->vbo, NULL);
+ r300render->vbo_offset += r300render->vbo_max_used;
+ r300render->vbo_max_used = 0;
+ r300->vbo = NULL;
}
static boolean r300_render_set_primitive(struct vbuf_render* render,
return TRUE;
}
-static void prepare_render(struct r300_render* render, unsigned count)
+static void r300_prepare_render(struct r300_render* render, unsigned count)
{
struct r300_context* r300 = render->r300;
CS_LOCALS(r300);
- r300->vbo = render->vbo;
-
r300_emit_dirty_state(r300);
}
CS_LOCALS(r300);
- prepare_render(r300render, count);
+ r300_prepare_render(r300render, count);
DBG(r300, DBG_DRAW, "r300: Doing vbuf render, count %d\n", count);
CS_LOCALS(r300);
- prepare_render(r300render, count);
+ r300_prepare_render(r300render, count);
/* Send our indices into an index buffer. */
index_buffer = pipe_buffer_create(screen, 64, PIPE_BUFFER_USAGE_VERTEX,
return;
}
-/*
- index_map = pipe_buffer_map(screen, index_buffer,
- PIPE_BUFFER_USAGE_CPU_WRITE);
- memcpy(index_map, indices, count);
- pipe_buffer_unmap(screen, index_buffer);
-
- debug_printf("r300: Doing indexbuf render, count %d\n", count);
-
- BEGIN_CS(8);
- OUT_CS_PKT3(R300_PACKET3_3D_DRAW_INDX_2, 0);
- OUT_CS(R300_VAP_VF_CNTL__PRIM_WALK_INDICES | (count << 16) |
- r300render->hwprim);
- OUT_CS_PKT3(R300_PACKET3_INDX_BUFFER, 2);
- OUT_CS(R300_INDX_BUFFER_ONE_REG_WR | (R300_VAP_PORT_IDX0 >> 2));
- OUT_CS_INDEX_RELOC(index_buffer, 0, count, RADEON_GEM_DOMAIN_GTT, 0, 0);
- END_CS; */
-
- BEGIN_CS(4 + (count+1)/2);
- OUT_CS_REG(R300_VAP_VF_MAX_VTX_INDX, count);
+ BEGIN_CS(2 + (count+1)/2);
OUT_CS_PKT3(R300_PACKET3_3D_DRAW_INDX_2, (count+1)/2);
OUT_CS(R300_VAP_VF_CNTL__PRIM_WALK_INDICES | (count << 16) |
r300render->hwprim);
r300render->base.release_vertices = r300_render_release_vertices;
r300render->base.destroy = r300_render_destroy;
+ r300render->vbo = NULL;
+ r300render->vbo_size = 0;
+ r300render->vbo_offset = 0;
+
return &r300render->base;
}
if (trans) {
pipe_texture_reference(&trans->transfer.texture, texture);
trans->transfer.format = texture->format;
+ trans->transfer.x = x;
+ trans->transfer.y = y;
trans->transfer.width = w;
trans->transfer.height = h;
trans->transfer.block = texture->block;
trans->transfer.nblocksx = texture->nblocksx[level];
trans->transfer.nblocksy = texture->nblocksy[level];
- trans->transfer.stride = align(pf_get_stride(&trans->transfer.block,
- texture->width[level]), 32);
+ trans->transfer.stride = r300_texture_get_stride(tex, level);
trans->transfer.usage = usage;
trans->offset = offset;
}
if (transfer->usage != PIPE_TRANSFER_READ) {
flags |= PIPE_BUFFER_USAGE_CPU_WRITE;
}
-
+
map = pipe_buffer_map(screen, tex->buffer, flags);
if (!map) {
unsigned w, unsigned h)
{
struct r300_capabilities* caps = r300_screen(r300->context.screen)->caps;
- unsigned pixpitch = dest->stride / dest->tex.block.size;
+ unsigned pixpitch = r300_texture_get_stride(dest, 0) / dest->tex.block.size;
CS_LOCALS(r300);
r300_emit_blend_state(r300, &blend_clear_state);
struct r300_context* r300 = r300_context(pipe);
struct r300_capabilities* caps = r300_screen(pipe->screen)->caps;
struct r300_texture* tex = (struct r300_texture*)dest->texture;
- unsigned pixpitch = tex->stride / tex->tex.block.size;
+ unsigned pixpitch = r300_texture_get_stride(tex, 0) / tex->tex.block.size;
boolean invalid = FALSE;
CS_LOCALS(r300);
struct r300_capabilities* caps = r300_screen(pipe->screen)->caps;
struct r300_texture* srctex = (struct r300_texture*)src->texture;
struct r300_texture* desttex = (struct r300_texture*)dest->texture;
- unsigned pixpitch = srctex->stride / srctex->tex.block.size;
+ unsigned pixpitch = r300_texture_get_stride(srctex, 0) / srctex->tex.block.size;
boolean invalid = FALSE;
float fsrcx = srcx, fsrcy = srcy, fdestx = destx, fdesty = desty;
CS_LOCALS(r300);
static void r300_setup_texture_state(struct r300_texture* tex,
unsigned width,
unsigned height,
- unsigned pitch,
unsigned levels)
{
struct r300_texture_state* state = &tex->state;
/* XXX */
state->format1 = r300_translate_texformat(tex->tex.format);
- state->format2 = pitch - 1;
+ state->format2 = r300_texture_get_stride(tex, 0);
/* Assume (somewhat foolishly) that oversized textures will
* not be permitted by the state tracker. */
}
debug_printf("r300: Set texture state (%dx%d, pitch %d, %d levels)\n",
- width, height, pitch, levels);
+ width, height, levels);
+}
+
+/**
+ * Return the stride, in bytes, of the texture images of the given texture
+ * at the given level.
+ */
+unsigned r300_texture_get_stride(struct r300_texture* tex, unsigned level)
+{
+ if (tex->stride_override)
+ return tex->stride_override;
+
+ if (level > tex->tex.last_level) {
+ debug_printf("%s: level (%u) > last_level (%u)\n", level, tex->tex.last_level);
+ return 0;
+ }
+
+ return align(pf_get_stride(&tex->tex.block, tex->tex.width[level]), 32);
}
static void r300_setup_miptree(struct r300_texture* tex)
{
struct pipe_texture* base = &tex->tex;
- int stride, size, offset;
+ int stride, size;
int i;
for (i = 0; i <= base->last_level; i++) {
* XXX
* POT, uncompressed, unmippmapped textures can be aligned to 32,
* instead of 64. */
- stride = align(pf_get_stride(&base->block, base->width[i]), 32);
+ stride = r300_texture_get_stride(tex, i);
size = stride * base->nblocksy[i] * base->depth[i];
tex->offset[i] = align(tex->size, 32);
"(%dx%dx%d px, pitch %d bytes)\n",
i, base->width[i], base->height[i], base->depth[i],
stride);
- /* Save stride of first level to the texture. */
- if (i == 0) {
- tex->stride = stride;
- }
}
}
r300_setup_miptree(tex);
r300_setup_texture_state(tex, template->width[0], template->height[0],
- template->width[0], template->last_level);
+ template->last_level);
tex->buffer = screen->buffer_create(screen, 1024,
PIPE_BUFFER_USAGE_PIXEL,
pipe_reference_init(&tex->tex.reference, 1);
tex->tex.screen = screen;
- tex->stride = *stride;
+ tex->stride_override = *stride;
/* XXX */
- r300_setup_texture_state(tex, tex->tex.width[0], tex->tex.height[0],
- tex->stride, 0);
+ r300_setup_texture_state(tex, tex->tex.width[0], tex->tex.height[0], 0);
pipe_buffer_reference(&tex->buffer, buffer);
pipe_buffer_reference(buffer, tex->buffer);
if (stride) {
- *stride = tex->stride;
+ *stride = r300_texture_get_stride(tex, 0);
}
return TRUE;
#include "r300_context.h"
#include "r300_reg.h"
+struct r300_texture;
+
void r300_init_screen_texture_functions(struct pipe_screen* screen);
+unsigned r300_texture_get_stride(struct r300_texture* tex, unsigned level);
+
/* Note the signature of R300_EASY_TX_FORMAT(A, R, G, B, FORMAT)... */
static INLINE uint32_t r300_translate_texformat(enum pipe_format format)
{
switch(saturate) {
case TGSI_SAT_NONE: return SATURATE_OFF;
case TGSI_SAT_ZERO_ONE: return SATURATE_ZERO_ONE;
- case TGSI_SAT_MINUS_PLUS_ONE: return SATURATE_PLUS_MINUS_ONE;
}
fprintf(stderr, "Unknown saturate mode: %i\n", saturate);
#include "util/u_pack_color.h"
#include "sp_clear.h"
#include "sp_context.h"
-#include "sp_surface.h"
-#include "sp_state.h"
#include "sp_tile_cache.h"
/* non-cached surface */
pipe->surface_fill(pipe, ps, 0, 0, ps->width, ps->height, cv);
#endif
- }
+ }
+
+ softpipe->dirty_render_cache = TRUE;
}
#ifndef SP_CLEAR_H
#define SP_CLEAR_H
-#include "pipe/p_state.h"
struct pipe_context;
extern void
}
-static void softpipe_destroy( struct pipe_context *pipe )
+static void
+softpipe_destroy( struct pipe_context *pipe )
{
struct softpipe_context *softpipe = softpipe_context( pipe );
uint i;
FREE( softpipe );
}
+
+/**
+ * if (the texture is being used as a framebuffer surface)
+ * return PIPE_REFERENCED_FOR_WRITE
+ * else if (the texture is a bound texture source)
+ * return PIPE_REFERENCED_FOR_READ XXX not done yet
+ * else
+ * return PIPE_UNREFERENCED
+ */
static unsigned int
softpipe_is_texture_referenced( struct pipe_context *pipe,
struct pipe_texture *texture,
struct softpipe_context *softpipe = softpipe_context( pipe );
unsigned i;
- if(softpipe->dirty_render_cache) {
+ if (softpipe->dirty_render_cache) {
for (i = 0; i < softpipe->framebuffer.nr_cbufs; i++) {
- if(softpipe->framebuffer.cbufs[i] &&
- softpipe->framebuffer.cbufs[i]->texture == texture)
+ if (softpipe->framebuffer.cbufs[i] &&
+ softpipe->framebuffer.cbufs[i]->texture == texture) {
return PIPE_REFERENCED_FOR_WRITE;
+ }
}
- if(softpipe->framebuffer.zsbuf &&
- softpipe->framebuffer.zsbuf->texture == texture)
+ if (softpipe->framebuffer.zsbuf &&
+ softpipe->framebuffer.zsbuf->texture == texture) {
return PIPE_REFERENCED_FOR_WRITE;
+ }
}
/* FIXME: we also need to do the same for the texture cache */
return PIPE_UNREFERENCED;
}
+
static unsigned int
softpipe_is_buffer_referenced( struct pipe_context *pipe,
struct pipe_buffer *buf)
return PIPE_UNREFERENCED;
}
+
struct pipe_context *
softpipe_create( struct pipe_screen *screen )
{
softpipe->pipe.is_buffer_referenced = softpipe_is_buffer_referenced;
softpipe_init_query_funcs( softpipe );
- softpipe_init_texture_funcs( softpipe );
/*
* Alloc caches for accessing drawing surfaces and textures.
* Michel Dänzer <michel@tungstengraphics.com>
*/
-#include "pipe/p_context.h"
#include "pipe/p_defines.h"
#include "pipe/p_inlines.h"
-#include "pipe/internal/p_winsys_screen.h"
#include "util/u_math.h"
#include "util/u_memory.h"
#include "sp_context.h"
#include "sp_state.h"
#include "sp_texture.h"
-#include "sp_tile_cache.h"
#include "sp_screen.h"
#include "sp_winsys.h"
-/* Simple, maximally packed layout.
- */
-
-
-/* Conventional allocation path for non-display textures:
+/**
+ * Conventional allocation path for non-display textures:
+ * Use a simple, maximally packed layout.
*/
static boolean
softpipe_texture_layout(struct pipe_screen *screen,
return spt->buffer != NULL;
}
+
+/**
+ * Texture layout for simple color buffers.
+ */
static boolean
softpipe_displaytarget_layout(struct pipe_screen *screen,
struct softpipe_texture * spt)
}
-
-
-
static struct pipe_texture *
softpipe_texture_create(struct pipe_screen *screen,
const struct pipe_texture *templat)
/* May want to different things here depending on read/write nature
* of the map:
*/
- if (transfer->texture && transfer->usage != PIPE_TRANSFER_READ)
- {
+ if (transfer->texture && transfer->usage != PIPE_TRANSFER_READ) {
/* Do something to notify sharing contexts of a texture change.
* In softpipe, that would mean flushing the texture cache.
*/
softpipe_screen(screen)->timestamp++;
}
-
+
xfer_map = map + softpipe_transfer(transfer)->offset +
transfer->y / transfer->block.height * transfer->stride +
transfer->x / transfer->block.width * transfer->block.size;
static void
softpipe_transfer_unmap(struct pipe_screen *screen,
- struct pipe_transfer *transfer)
+ struct pipe_transfer *transfer)
{
struct softpipe_texture *spt;
}
-void
-softpipe_init_texture_funcs(struct softpipe_context *sp)
-{
-}
-
-
void
softpipe_init_screen_texture_funcs(struct pipe_screen *screen)
{
struct pipe_buffer **buf,
unsigned *stride )
{
- struct softpipe_texture *tex = (struct softpipe_texture *)texture;
+ struct softpipe_texture *tex = (struct softpipe_texture *) texture;
if (!tex)
return FALSE;
}
-extern void
-softpipe_init_texture_funcs( struct softpipe_context *softpipe );
-
extern void
softpipe_init_screen_texture_funcs(struct pipe_screen *screen);
#endif
+#ifndef __HAIKU__
typedef unsigned int uint;
-typedef unsigned char ubyte;
typedef unsigned short ushort;
+#endif
+typedef unsigned char ubyte;
#if 0
#define boolean bool
#define PIPE_OS_WINDOWS
#endif
+#if defined(__HAIKU__)
+#define PIPE_OS_HAIKU
+#endif
/*
* Subsystem.
#include "util/u_debug.h" /* for assert */
-#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS)
+#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS) || defined(PIPE_OS_HAIKU)
#include <pthread.h> /* POSIX threads headers */
#include <stdio.h> /* for perror() */
*/
typedef struct {
-#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS)
+#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS) || defined(PIPE_OS_HAIKU)
pthread_key_t key;
#elif defined(PIPE_SUBSYSTEM_WINDOWS_USER)
DWORD key;
static INLINE void
pipe_tsd_init(pipe_tsd *tsd)
{
-#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS)
+#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS) || defined(PIPE_OS_HAIKU)
if (pthread_key_create(&tsd->key, NULL/*free*/) != 0) {
perror("pthread_key_create(): failed to allocate key for thread specific data");
exit(-1);
if (tsd->initMagic != (int) PIPE_TSD_INIT_MAGIC) {
pipe_tsd_init(tsd);
}
-#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS)
+#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS) || defined(PIPE_OS_HAIKU)
return pthread_getspecific(tsd->key);
#elif defined(PIPE_SUBSYSTEM_WINDOWS_USER)
assert(0);
if (tsd->initMagic != (int) PIPE_TSD_INIT_MAGIC) {
pipe_tsd_init(tsd);
}
-#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS)
+#if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS) || defined(PIPE_OS_HAIKU)
if (pthread_setspecific(tsd->key, value) != 0) {
perror("pthread_set_specific() failed");
exit(-1);
*/
for (i = 0; i < 2; ++i)
{
- inst = vl_inst4(TGSI_OPCODE_MADD, TGSI_FILE_OUTPUT, i, TGSI_FILE_INPUT, i, TGSI_FILE_CONSTANT, i * 2, TGSI_FILE_CONSTANT, i * 2 + 1);
+ inst = vl_inst4(TGSI_OPCODE_MAD, TGSI_FILE_OUTPUT, i, TGSI_FILE_INPUT, i, TGSI_FILE_CONSTANT, i * 2, TGSI_FILE_CONSTANT, i * 2 + 1);
ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
}
ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
/* floor t3, t3 ; Get rid of fractional part */
- inst = vl_inst2(TGSI_OPCODE_FLOOR, TGSI_FILE_TEMPORARY, 3, TGSI_FILE_TEMPORARY, 3);
+ inst = vl_inst2(TGSI_OPCODE_FLR, TGSI_FILE_TEMPORARY, 3, TGSI_FILE_TEMPORARY, 3);
ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
/* mul t3, t3, c1.y ; Multiply by 2 */
/* TODO: Move to conditional tex fetch on t3 instead of lerp */
/* lerp t1, t3, t1, t2 ; Choose between top and bottom fields based on Y % 2 */
- inst = vl_inst4(TGSI_OPCODE_LERP, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_TEMPORARY, 3, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_TEMPORARY, 2);
+ inst = vl_inst4(TGSI_OPCODE_LRP, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_TEMPORARY, 3, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_TEMPORARY, 2);
ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
/* add o0, t0, t1 ; Add ref and differential to form final output */
}
/* lerp t1, c1.x, t1, t2 ; Blend past and future texels */
- inst = vl_inst4(TGSI_OPCODE_LERP, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_CONSTANT, 1, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_TEMPORARY, 2);
+ inst = vl_inst4(TGSI_OPCODE_LRP, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_CONSTANT, 1, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_TEMPORARY, 2);
inst.FullSrcRegisters[0].SrcRegister.SwizzleX = TGSI_SWIZZLE_X;
inst.FullSrcRegisters[0].SrcRegister.SwizzleY = TGSI_SWIZZLE_X;
inst.FullSrcRegisters[0].SrcRegister.SwizzleZ = TGSI_SWIZZLE_X;
ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
/* floor t3, t3 ; Get rid of fractional part */
- inst = vl_inst2(TGSI_OPCODE_FLOOR, TGSI_FILE_TEMPORARY, 3, TGSI_FILE_TEMPORARY, 3);
+ inst = vl_inst2(TGSI_OPCODE_FLR, TGSI_FILE_TEMPORARY, 3, TGSI_FILE_TEMPORARY, 3);
ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
/* mul t3, t3, c1.y ; Multiply by 2 */
/* TODO: Move to conditional tex fetch on t3 instead of lerp */
/* lerp t1, t3, t1, t2 ; Choose between top and bottom fields based on Y % 2 */
- inst = vl_inst4(TGSI_OPCODE_LERP, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_TEMPORARY, 3, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_TEMPORARY, 2);
+ inst = vl_inst4(TGSI_OPCODE_LRP, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_TEMPORARY, 3, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_TEMPORARY, 2);
ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
/*
/* TODO: Move to conditional tex fetch on t3 instead of lerp */
/* lerp t2, t3, t4, t5 ; Choose between top and bottom fields based on Y % 2 */
- inst = vl_inst4(TGSI_OPCODE_LERP, TGSI_FILE_TEMPORARY, 2, TGSI_FILE_TEMPORARY, 3, TGSI_FILE_TEMPORARY, 4, TGSI_FILE_TEMPORARY, 5);
+ inst = vl_inst4(TGSI_OPCODE_LRP, TGSI_FILE_TEMPORARY, 2, TGSI_FILE_TEMPORARY, 3, TGSI_FILE_TEMPORARY, 4, TGSI_FILE_TEMPORARY, 5);
ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
/* lerp t1, c1.x, t1, t2 ; Blend past and future texels */
- inst = vl_inst4(TGSI_OPCODE_LERP, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_CONSTANT, 1, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_TEMPORARY, 2);
+ inst = vl_inst4(TGSI_OPCODE_LRP, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_CONSTANT, 1, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_TEMPORARY, 2);
inst.FullSrcRegisters[0].SrcRegister.SwizzleX = TGSI_SWIZZLE_X;
inst.FullSrcRegisters[0].SrcRegister.SwizzleY = TGSI_SWIZZLE_X;
inst.FullSrcRegisters[0].SrcRegister.SwizzleZ = TGSI_SWIZZLE_X;
#include "cso_cache/cso_context.h"
#include "util/u_draw_quad.h"
+#include "util/u_math.h"
#include "pipe/p_inlines.h"
PIPE_BLENDFACTOR_INV_SRC_ALPHA, PIPE_BLENDFACTOR_INV_SRC_ALPHA },
};
+
static INLINE void
-pixel_to_float4(PictFormatPtr format,
- CARD32 pixel, float *color)
+pixel_to_float4(Pixel pixel, float *color)
+{
+ CARD32 r, g, b, a;
+
+ a = (pixel >> 24) & 0xff;
+ r = (pixel >> 16) & 0xff;
+ g = (pixel >> 8) & 0xff;
+ b = (pixel >> 0) & 0xff;
+ color[0] = ((float)r) / 255.;
+ color[1] = ((float)g) / 255.;
+ color[2] = ((float)b) / 255.;
+ color[3] = ((float)a) / 255.;
+}
+
+static INLINE void
+render_pixel_to_float4(PictFormatPtr format,
+ CARD32 pixel, float *color)
{
CARD32 r, g, b, a;
setup_vertex0(vertices[3], dstX, dstY + height,
ctx->solid_color);
- return pipe_user_buffer_create(ctx->ctx->screen,
+ return pipe_user_buffer_create(ctx->pipe->screen,
vertices,
sizeof(vertices));
}
setup_vertex1(vertices[3], dstX, dstY + height,
s0, t1);
- return pipe_user_buffer_create(ctx->ctx->screen,
+ return pipe_user_buffer_create(ctx->pipe->screen,
+ vertices,
+ sizeof(vertices));
+}
+
+static struct pipe_buffer *
+setup_vertex_data_tex(struct exa_context *ctx,
+ float x0, float y0, float x1, float y1,
+ float s0, float t0, float s1, float t1,
+ float z)
+{
+ float vertices[4][2][4];
+
+ /* 1st vertex */
+ setup_vertex1(vertices[0], x0, y0,
+ s0, t0);
+ /* 2nd vertex */
+ setup_vertex1(vertices[1], x1, y0,
+ s1, t0);
+ /* 3rd vertex */
+ setup_vertex1(vertices[2], x1, y1,
+ s1, t1);
+ /* 4th vertex */
+ setup_vertex1(vertices[3], x0, y1,
+ s0, t1);
+
+ return pipe_user_buffer_create(ctx->pipe->screen,
vertices,
sizeof(vertices));
}
+
static INLINE void
setup_vertex2(float vertex[3][4], float x, float y,
float s0, float t0, float s1, float t1)
setup_vertex2(vertices[3], dstX, dstY + height,
st0[0], st0[3], st1[0], st1[3]);
- return pipe_user_buffer_create(ctx->ctx->screen,
+ return pipe_user_buffer_create(ctx->pipe->screen,
vertices,
sizeof(vertices));
}
}
static void
-bind_framebuffer_state(struct exa_context *exa, PicturePtr pDstPicture,
- struct exa_pixmap_priv *pDst)
+bind_clip_state(struct exa_context *exa)
+{
+}
+
+static void
+bind_framebuffer_state(struct exa_context *exa, struct exa_pixmap_priv *pDst)
{
unsigned i;
struct pipe_framebuffer_state state;
struct pipe_surface *surface = exa_gpu_surface(exa, pDst);
memset(&state, 0, sizeof(struct pipe_framebuffer_state));
- state.width = pDstPicture->pDrawable->width;
- state.height = pDstPicture->pDrawable->height;
+ state.width = pDst->tex->width[0];
+ state.height = pDst->tex->height[0];
state.nr_cbufs = 1;
state.cbufs[0] = surface;
}
static void
-bind_viewport_state(struct exa_context *exa, PicturePtr pDstPicture)
+bind_viewport_state(struct exa_context *exa, struct exa_pixmap_priv *pDst)
{
- int width = pDstPicture->pDrawable->width;
- int height = pDstPicture->pDrawable->height;
+ int width = pDst->tex->width[0];
+ int height = pDst->tex->height[0];
+
+ debug_printf("Bind viewport (%d, %d)\n", width, height);
set_viewport(exa, width, height, Y0_TOP);
}
bind_blend_state(struct exa_context *exa, int op,
PicturePtr pSrcPicture, PicturePtr pMaskPicture)
{
- boolean component_alpha = pSrcPicture->componentAlpha;
+ boolean component_alpha = (pSrcPicture) ?
+ pSrcPicture->componentAlpha : FALSE;
struct xorg_composite_blend blend_opt;
struct pipe_blend_state blend;
unsigned vs_traits = 0, fs_traits = 0;
struct xorg_shader shader;
+ exa->has_solid_color = FALSE;
+
if (pSrcPicture) {
if (pSrcPicture->pSourcePict) {
if (pSrcPicture->pSourcePict->type == SourcePictTypeSolidFill) {
fs_traits |= FS_SOLID_FILL;
vs_traits |= VS_SOLID_FILL;
- pixel_to_float4(pSrcPicture->pFormat,
- pSrcPicture->pSourcePict->solidFill.color,
- exa->solid_color);
+ render_pixel_to_float4(pSrcPicture->pFormat,
+ pSrcPicture->pSourcePict->solidFill.color,
+ exa->solid_color);
+ exa->has_solid_color = TRUE;
} else {
debug_assert("!gradients not supported");
}
struct pipe_constant_buffer *cbuf = &exa->vs_const_buffer;
pipe_buffer_reference(&cbuf->buffer, NULL);
- cbuf->buffer = pipe_buffer_create(exa->ctx->screen, 16,
+ cbuf->buffer = pipe_buffer_create(exa->pipe->screen, 16,
PIPE_BUFFER_USAGE_CONSTANT,
param_bytes);
if (cbuf->buffer) {
- pipe_buffer_write(exa->ctx->screen, cbuf->buffer,
+ pipe_buffer_write(exa->pipe->screen, cbuf->buffer,
0, param_bytes, vs_consts);
}
- exa->ctx->set_constant_buffer(exa->ctx, PIPE_SHADER_VERTEX, 0, cbuf);
+ exa->pipe->set_constant_buffer(exa->pipe, PIPE_SHADER_VERTEX, 0, cbuf);
}
struct pipe_constant_buffer *cbuf = &exa->fs_const_buffer;
pipe_buffer_reference(&cbuf->buffer, NULL);
- cbuf->buffer = pipe_buffer_create(exa->ctx->screen, 16,
+ cbuf->buffer = pipe_buffer_create(exa->pipe->screen, 16,
PIPE_BUFFER_USAGE_CONSTANT,
param_bytes);
if (cbuf->buffer) {
- pipe_buffer_write(exa->ctx->screen, cbuf->buffer,
+ pipe_buffer_write(exa->pipe->screen, cbuf->buffer,
0, param_bytes, fs_consts);
}
- exa->ctx->set_constant_buffer(exa->ctx, PIPE_SHADER_FRAGMENT, 0, cbuf);
+ exa->pipe->set_constant_buffer(exa->pipe, PIPE_SHADER_FRAGMENT, 0, cbuf);
}
static void
-setup_constant_buffers(struct exa_context *exa, PicturePtr pDstPicture)
+setup_constant_buffers(struct exa_context *exa, struct exa_pixmap_priv *pDst)
{
- int width = pDstPicture->pDrawable->width;
- int height = pDstPicture->pDrawable->height;
+ int width = pDst->tex->width[0];
+ int height = pDst->tex->height[0];
setup_vs_constant_buffer(exa, width, height);
setup_fs_constant_buffer(exa);
struct exa_pixmap_priv *pMask,
struct exa_pixmap_priv *pDst)
{
- bind_framebuffer_state(exa, pDstPicture, pDst);
- bind_viewport_state(exa, pDstPicture);
+ bind_framebuffer_state(exa, pDst);
+ bind_viewport_state(exa, pDst);
bind_blend_state(exa, op, pSrcPicture, pMaskPicture);
bind_rasterizer_state(exa);
bind_shaders(exa, op, pSrcPicture, pMaskPicture);
bind_samplers(exa, op, pSrcPicture, pMaskPicture,
pDstPicture, pSrc, pMask, pDst);
-
- setup_constant_buffers(exa, pDstPicture);
+ bind_clip_state(exa);
+ setup_constant_buffers(exa, pDst);
return FALSE;
}
int srcX, int srcY, int maskX, int maskY,
int dstX, int dstY, int width, int height)
{
- struct pipe_context *pipe = exa->ctx;
+ struct pipe_context *pipe = exa->pipe;
struct pipe_buffer *buf = 0;
if (exa->num_bound_samplers == 0 ) { /* solid fill */
}
if (buf) {
+ int num_attribs = 1; /*pos*/
+ num_attribs += exa->num_bound_samplers;
+ if (exa->has_solid_color)
+ ++num_attribs;
+
util_draw_vertex_buffer(pipe, buf, 0,
PIPE_PRIM_TRIANGLE_FAN,
4, /* verts */
- 1 + exa->num_bound_samplers); /* attribs/vert */
+ num_attribs); /* attribs/vert */
pipe_buffer_reference(&buf, NULL);
}
}
+boolean xorg_solid_bind_state(struct exa_context *exa,
+ struct exa_pixmap_priv *pixmap,
+ Pixel fg)
+{
+ unsigned vs_traits, fs_traits;
+ struct xorg_shader shader;
+
+ pixel_to_float4(fg, exa->solid_color);
+ exa->has_solid_color = TRUE;
+
+ exa->solid_color[3] = 1.f;
+
+ debug_printf("Color Pixel=(%d, %d, %d, %d), RGBA=(%f, %f, %f, %f)\n",
+ (fg >> 24) & 0xff, (fg >> 16) & 0xff,
+ (fg >> 8) & 0xff, (fg >> 0) & 0xff,
+ exa->solid_color[0], exa->solid_color[1],
+ exa->solid_color[2], exa->solid_color[3]);
+
+#if 0
+ exa->solid_color[0] = 1.f;
+ exa->solid_color[1] = 0.f;
+ exa->solid_color[2] = 0.f;
+ exa->solid_color[3] = 1.f;
+#endif
+
+ vs_traits = VS_SOLID_FILL;
+ fs_traits = FS_SOLID_FILL;
+
+ bind_framebuffer_state(exa, pixmap);
+ bind_viewport_state(exa, pixmap);
+ bind_rasterizer_state(exa);
+ bind_blend_state(exa, PictOpSrc, NULL, NULL);
+ setup_constant_buffers(exa, pixmap);
+ bind_clip_state(exa);
+
+ shader = xorg_shaders_get(exa->shaders, vs_traits, fs_traits);
+ cso_set_vertex_shader_handle(exa->cso, shader.vs);
+ cso_set_fragment_shader_handle(exa->cso, shader.fs);
+
+ return FALSE;
+}
+
+void xorg_solid(struct exa_context *exa,
+ struct exa_pixmap_priv *pixmap,
+ int x0, int y0, int x1, int y1)
+{
+ struct pipe_context *pipe = exa->pipe;
+ struct pipe_buffer *buf = 0;
+ float vertices[4][2][4];
+
+ x0 = 10; y0 = 10;
+ x1 = 300; y1 = 300;
+
+ /* 1st vertex */
+ setup_vertex0(vertices[0], x0, y0,
+ exa->solid_color);
+ /* 2nd vertex */
+ setup_vertex0(vertices[1], x1, y0,
+ exa->solid_color);
+ /* 3rd vertex */
+ setup_vertex0(vertices[2], x1, y1,
+ exa->solid_color);
+ /* 4th vertex */
+ setup_vertex0(vertices[3], x0, y1,
+ exa->solid_color);
+
+ buf = pipe_user_buffer_create(exa->pipe->screen,
+ vertices,
+ sizeof(vertices));
+
+
+ if (buf) {
+ debug_printf("Drawing buf is %p\n", buf);
+ util_draw_vertex_buffer(pipe, buf, 0,
+ PIPE_PRIM_TRIANGLE_FAN,
+ 4, /* verts */
+ 2); /* attribs/vert */
+
+ pipe_buffer_reference(&buf, NULL);
+ }
+}
+
+
+static INLINE void shift_rectx(float coords[4],
+ const float *bounds,
+ const float shift)
+{
+ coords[0] += shift;
+ coords[2] -= shift;
+ if (bounds) {
+ coords[2] = MIN2(coords[2], bounds[2]);
+ /* bound x/y + width/height */
+ if ((coords[0] + coords[2]) > (bounds[0] + bounds[2])) {
+ coords[2] = (bounds[0] + bounds[2]) - coords[0];
+ }
+ }
+}
+
+static INLINE void shift_recty(float coords[4],
+ const float *bounds,
+ const float shift)
+{
+ coords[1] += shift;
+ coords[3] -= shift;
+ if (bounds) {
+ coords[3] = MIN2(coords[3], bounds[3]);
+ if ((coords[1] + coords[3]) > (bounds[1] + bounds[3])) {
+ coords[3] = (bounds[1] + bounds[3]) - coords[1];
+ }
+ }
+}
+
+static INLINE void bound_rect(float coords[4],
+ const float bounds[4],
+ float shift[4])
+{
+ /* if outside the bounds */
+ if (coords[0] > (bounds[0] + bounds[2]) ||
+ coords[1] > (bounds[1] + bounds[3]) ||
+ (coords[0] + coords[2]) < bounds[0] ||
+ (coords[1] + coords[3]) < bounds[1]) {
+ coords[0] = 0.f;
+ coords[1] = 0.f;
+ coords[2] = 0.f;
+ coords[3] = 0.f;
+ shift[0] = 0.f;
+ shift[1] = 0.f;
+ return;
+ }
+
+ /* bound x */
+ if (coords[0] < bounds[0]) {
+ shift[0] = bounds[0] - coords[0];
+ coords[2] -= shift[0];
+ coords[0] = bounds[0];
+ } else
+ shift[0] = 0.f;
+
+ /* bound y */
+ if (coords[1] < bounds[1]) {
+ shift[1] = bounds[1] - coords[1];
+ coords[3] -= shift[1];
+ coords[1] = bounds[1];
+ } else
+ shift[1] = 0.f;
+
+ shift[2] = bounds[2] - coords[2];
+ shift[3] = bounds[3] - coords[3];
+ /* bound width/height */
+ coords[2] = MIN2(coords[2], bounds[2]);
+ coords[3] = MIN2(coords[3], bounds[3]);
+
+ /* bound x/y + width/height */
+ if ((coords[0] + coords[2]) > (bounds[0] + bounds[2])) {
+ coords[2] = (bounds[0] + bounds[2]) - coords[0];
+ }
+ if ((coords[1] + coords[3]) > (bounds[1] + bounds[3])) {
+ coords[3] = (bounds[1] + bounds[3]) - coords[1];
+ }
+
+ /* if outside the bounds */
+ if ((coords[0] + coords[2]) < bounds[0] ||
+ (coords[1] + coords[3]) < bounds[1]) {
+ coords[0] = 0.f;
+ coords[1] = 0.f;
+ coords[2] = 0.f;
+ coords[3] = 0.f;
+ return;
+ }
+}
+
+static INLINE void sync_size(float *src_loc, float *dst_loc)
+{
+ src_loc[2] = MIN2(src_loc[2], dst_loc[2]);
+ src_loc[3] = MIN2(src_loc[3], dst_loc[3]);
+ dst_loc[2] = src_loc[2];
+ dst_loc[3] = src_loc[3];
+}
+
+
+static void renderer_copy_texture(struct exa_context *exa,
+ struct pipe_texture *src,
+ float sx1, float sy1,
+ float sx2, float sy2,
+ struct pipe_texture *dst,
+ float dx1, float dy1,
+ float dx2, float dy2)
+{
+ struct pipe_context *pipe = exa->pipe;
+ struct pipe_screen *screen = pipe->screen;
+ struct pipe_buffer *buf;
+ struct pipe_surface *dst_surf = screen->get_tex_surface(
+ screen, dst, 0, 0, 0,
+ PIPE_BUFFER_USAGE_GPU_WRITE);
+ struct pipe_framebuffer_state fb;
+ float s0, t0, s1, t1;
+ struct xorg_shader shader;
+
+ assert(src->width[0] != 0);
+ assert(src->height[0] != 0);
+ assert(dst->width[0] != 0);
+ assert(dst->height[0] != 0);
+
+#if 0
+ debug_printf("copy texture [%f, %f, %f, %f], [%f, %f, %f, %f]\n",
+ sx1, sy1, sx2, sy2, dx1, dy1, dx2, dy2);
+#endif
+
+#if 1
+ s0 = sx1 / src->width[0];
+ s1 = sx2 / src->width[0];
+ t0 = sy1 / src->height[0];
+ t1 = sy2 / src->height[0];
+#else
+ s0 = 0;
+ s1 = 1;
+ t0 = 0;
+ t1 = 1;
+#endif
+
+ assert(screen->is_format_supported(screen, dst_surf->format, PIPE_TEXTURE_2D,
+ PIPE_TEXTURE_USAGE_RENDER_TARGET, 0));
+
+ /* save state (restored below) */
+ cso_save_blend(exa->cso);
+ cso_save_samplers(exa->cso);
+ cso_save_sampler_textures(exa->cso);
+ cso_save_framebuffer(exa->cso);
+ cso_save_fragment_shader(exa->cso);
+ cso_save_vertex_shader(exa->cso);
+
+ cso_save_viewport(exa->cso);
+
+
+ /* set misc state we care about */
+ {
+ struct pipe_blend_state blend;
+ memset(&blend, 0, sizeof(blend));
+ blend.rgb_src_factor = PIPE_BLENDFACTOR_ONE;
+ blend.alpha_src_factor = PIPE_BLENDFACTOR_ONE;
+ blend.rgb_dst_factor = PIPE_BLENDFACTOR_ZERO;
+ blend.alpha_dst_factor = PIPE_BLENDFACTOR_ZERO;
+ blend.colormask = PIPE_MASK_RGBA;
+ cso_set_blend(exa->cso, &blend);
+ }
+
+ /* sampler */
+ {
+ struct pipe_sampler_state sampler;
+ memset(&sampler, 0, sizeof(sampler));
+ sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
+ sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
+ sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
+ sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE;
+ sampler.min_img_filter = PIPE_TEX_FILTER_NEAREST;
+ sampler.mag_img_filter = PIPE_TEX_FILTER_NEAREST;
+ sampler.normalized_coords = 1;
+ cso_single_sampler(exa->cso, 0, &sampler);
+ cso_single_sampler_done(exa->cso);
+ }
+
+ set_viewport(exa, dst_surf->width, dst_surf->height, Y0_TOP);
+
+ /* texture */
+ cso_set_sampler_textures(exa->cso, 1, &src);
+
+ /* shaders */
+ shader = xorg_shaders_get(exa->shaders,
+ VS_COMPOSITE,
+ FS_COMPOSITE);
+ cso_set_vertex_shader_handle(exa->cso, shader.vs);
+ cso_set_fragment_shader_handle(exa->cso, shader.fs);
+
+ /* drawing dest */
+ memset(&fb, 0, sizeof(fb));
+ fb.width = dst_surf->width;
+ fb.height = dst_surf->height;
+ fb.nr_cbufs = 1;
+ fb.cbufs[0] = dst_surf;
+ {
+ int i;
+ for (i = 1; i < PIPE_MAX_COLOR_BUFS; ++i)
+ fb.cbufs[i] = 0;
+ }
+ cso_set_framebuffer(exa->cso, &fb);
+
+ /* draw quad */
+ buf = setup_vertex_data_tex(exa,
+ dx1, dy1,
+ dx2, dy2,
+ s0, t0, s1, t1,
+ 0.0f);
+
+ if (buf) {
+ util_draw_vertex_buffer(exa->pipe, buf, 0,
+ PIPE_PRIM_TRIANGLE_FAN,
+ 4, /* verts */
+ 2); /* attribs/vert */
+
+ pipe_buffer_reference(&buf, NULL);
+ }
+
+ /* restore state we changed */
+ cso_restore_blend(exa->cso);
+ cso_restore_samplers(exa->cso);
+ cso_restore_sampler_textures(exa->cso);
+ cso_restore_framebuffer(exa->cso);
+ cso_restore_vertex_shader(exa->cso);
+ cso_restore_fragment_shader(exa->cso);
+ cso_restore_viewport(exa->cso);
+
+ pipe_surface_reference(&dst_surf, NULL);
+}
+
+void xorg_copy_pixmap(struct exa_context *ctx,
+ struct exa_pixmap_priv *dst_priv, int dx, int dy,
+ struct exa_pixmap_priv *src_priv, int sx, int sy,
+ int width, int height)
+{
+ float dst_loc[4], src_loc[4];
+ float dst_bounds[4], src_bounds[4];
+ float src_shift[4], dst_shift[4], shift[4];
+ struct pipe_texture *dst = dst_priv->tex;
+ struct pipe_texture *src = src_priv->tex;
+
+ dst_loc[0] = dx;
+ dst_loc[1] = dy;
+ dst_loc[2] = width;
+ dst_loc[3] = height;
+ dst_bounds[0] = 0.f;
+ dst_bounds[1] = 0.f;
+ dst_bounds[2] = dst->width[0];
+ dst_bounds[3] = dst->height[0];
+
+ src_loc[0] = sx;
+ src_loc[1] = sy;
+ src_loc[2] = width;
+ src_loc[3] = height;
+ src_bounds[0] = 0.f;
+ src_bounds[1] = 0.f;
+ src_bounds[2] = src->width[0];
+ src_bounds[3] = src->height[0];
+
+ bound_rect(src_loc, src_bounds, src_shift);
+ bound_rect(dst_loc, dst_bounds, dst_shift);
+ shift[0] = src_shift[0] - dst_shift[0];
+ shift[1] = src_shift[1] - dst_shift[1];
+
+ if (shift[0] < 0)
+ shift_rectx(src_loc, src_bounds, -shift[0]);
+ else
+ shift_rectx(dst_loc, dst_bounds, shift[0]);
+
+ if (shift[1] < 0)
+ shift_recty(src_loc, src_bounds, -shift[1]);
+ else
+ shift_recty(dst_loc, dst_bounds, shift[1]);
+
+ sync_size(src_loc, dst_loc);
+
+ if (src_loc[2] >= 0 && src_loc[3] >= 0 &&
+ dst_loc[2] >= 0 && dst_loc[3] >= 0) {
+ renderer_copy_texture(ctx,
+ src,
+ src_loc[0],
+ src_loc[1] + src_loc[3],
+ src_loc[0] + src_loc[2],
+ src_loc[1],
+ dst,
+ dst_loc[0],
+ dst_loc[1] + dst_loc[3],
+ dst_loc[0] + dst_loc[2],
+ dst_loc[1]);
+ }
+}
+
int srcX, int srcY, int maskX, int maskY,
int dstX, int dstY, int width, int height);
+boolean xorg_solid_bind_state(struct exa_context *exa,
+ struct exa_pixmap_priv *pixmap,
+ Pixel fg);
+void xorg_solid(struct exa_context *exa,
+ struct exa_pixmap_priv *pixmap,
+ int x0, int y0, int x1, int y1);
+
+void xorg_copy_pixmap(struct exa_context *ctx,
+ struct exa_pixmap_priv *dst, int dx, int dy,
+ struct exa_pixmap_priv *src, int sx, int sy,
+ int width, int height);
+
#endif
}
if (!tex) {
+ exaMoveInPixmap(private->pPixmap);
xorg_exa_set_shared_usage(private->pPixmap);
pScreen->ModifyPixmapHeader(private->pPixmap, 0, 0, 0, 0, 0, NULL);
tex = xorg_exa_get_texture(private->pPixmap);
}
}
+static void
+xorg_exa_init_state(struct exa_context *exa)
+{
+ struct pipe_depth_stencil_alpha_state dsa;
+
+ /* set common initial clip state */
+ memset(&dsa, 0, sizeof(struct pipe_depth_stencil_alpha_state));
+ cso_set_depth_stencil_alpha(exa->cso, &dsa);
+}
+
+static void
+xorg_exa_common_done(struct exa_context *exa)
+{
+ exa->copy.src = NULL;
+ exa->copy.dst = NULL;
+ exa->has_solid_color = FALSE;
+ exa->num_bound_samplers = 0;
+}
+
/*
* Static exported EXA functions
*/
if (!priv || !priv->tex)
return FALSE;
- if (exa->ctx->is_texture_referenced(exa->ctx, priv->tex, 0, 0) &
+ if (exa->pipe->is_texture_referenced(exa->pipe, priv->tex, 0, 0) &
PIPE_REFERENCED_FOR_WRITE)
- exa->ctx->flush(exa->ctx, 0, NULL);
+ exa->pipe->flush(exa->pipe, 0, NULL);
transfer = exa->scrn->get_tex_transfer(exa->scrn, priv->tex, 0, 0, 0,
PIPE_TRANSFER_READ, x, y, w, h);
if (priv->map_count++ == 0)
{
- if (exa->ctx->is_texture_referenced(exa->ctx, priv->tex, 0, 0) &
+ if (exa->pipe->is_texture_referenced(exa->pipe, priv->tex, 0, 0) &
PIPE_REFERENCED_FOR_WRITE)
- exa->ctx->flush(exa->ctx, 0, NULL);
+ exa->pipe->flush(exa->pipe, 0, NULL);
priv->map_transfer =
exa->scrn->get_tex_transfer(exa->scrn, priv->tex, 0, 0, 0,
if (!priv)
return;
- if (priv->src_surf)
- exa->scrn->tex_surface_destroy(priv->src_surf);
- priv->src_surf = NULL;
+#if 1
+ xorg_exa_flush(exa, PIPE_FLUSH_RENDER_CACHE, NULL);
+#else
+ xorg_finish(exa);
+#endif
+ xorg_exa_common_done(exa);
}
static void
ExaDoneComposite(PixmapPtr pPixmap)
{
+ ScrnInfoPtr pScrn = xf86Screens[pPixmap->drawable.pScreen->myNum];
+ modesettingPtr ms = modesettingPTR(pScrn);
+ struct exa_context *exa = ms->exa;
+ xorg_exa_common_done(exa);
}
static Bool
struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPixmap);
struct exa_context *exa = ms->exa;
+ debug_printf("ExaPrepareSolid - test\n");
if (pPixmap->drawable.depth < 15)
return FALSE;
if (alu != GXcopy)
return FALSE;
- if (!exa->ctx || !exa->ctx->surface_fill)
+ if (!exa->pipe)
return FALSE;
- priv->color = fg;
-
- return TRUE;
+ debug_printf(" ExaPrepareSolid(0x%x)\n", fg);
+ return xorg_solid_bind_state(exa, priv, fg);
}
static void
modesettingPtr ms = modesettingPTR(pScrn);
struct exa_context *exa = ms->exa;
struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPixmap);
- struct pipe_surface *surf = exa_gpu_surface(exa, priv);
- exa->ctx->surface_fill(exa->ctx, surf, x0, y0, x1 - x0, y1 - y0,
- priv->color);
+ debug_printf("\tExaSolid(%d, %d, %d, %d)\n", x0, y0, x1, y1);
- exa->scrn->tex_surface_destroy(surf);
+#if 0
+ if (x0 == 0 && y0 == 0 &&
+ x1 == priv->tex->width[0] &&
+ y1 == priv->tex->height[0]) {
+ exa->ctx->clear(exa->ctx, PIPE_CLEAR_COLOR | PIPE_CLEAR_DEPTHSTENCIL,
+ exa->solid_color, 1., 0);
+ } else
+#endif
+ xorg_solid(exa, priv, x0, y0, x1, y1) ;
}
static Bool
struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pDstPixmap);
struct exa_pixmap_priv *src_priv = exaGetPixmapDriverPrivate(pSrcPixmap);
+ debug_printf("ExaPrepareCopy\n");
+
if (alu != GXcopy)
return FALSE;
if (!priv->tex || !src_priv->tex)
return FALSE;
- if (!exa->ctx || !exa->ctx->surface_copy)
+ if (!exa->pipe)
return FALSE;
- priv->src_surf = exa_gpu_surface(exa, src_priv);
+ exa->copy.src = src_priv;
+ exa->copy.dst = priv;
- return TRUE;
+ /*XXX disabled until some issues with syncing are fixed */
+ return FALSE;
}
static void
ExaCopy(PixmapPtr pDstPixmap, int srcX, int srcY, int dstX, int dstY,
int width, int height)
{
- ScrnInfoPtr pScrn = xf86Screens[pDstPixmap->drawable.pScreen->myNum];
- modesettingPtr ms = modesettingPTR(pScrn);
- struct exa_context *exa = ms->exa;
- struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pDstPixmap);
- struct pipe_surface *surf = exa_gpu_surface(exa, priv);
+ ScrnInfoPtr pScrn = xf86Screens[pDstPixmap->drawable.pScreen->myNum];
+ modesettingPtr ms = modesettingPTR(pScrn);
+ struct exa_context *exa = ms->exa;
+ struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pDstPixmap);
+
+ debug_printf("\tExaCopy(srcx=%d, srcy=%d, dstX=%d, dstY=%d, w=%d, h=%d)\n",
+ srcX, srcY, dstX, dstY, width, height);
- exa->ctx->surface_copy(exa->ctx, surf, dstX, dstY, priv->src_surf,
- srcX, srcY, width, height);
- exa->scrn->tex_surface_destroy(surf);
+ debug_assert(priv == exa->copy.dst);
+
+ xorg_copy_pixmap(exa, exa->copy.dst, dstX, dstY,
+ exa->copy.src, srcX, srcY,
+ width, height);
}
static Bool
modesettingPtr ms = modesettingPTR(pScrn);
struct exa_context *exa = ms->exa;
+ debug_printf("ExaPrepareComposite\n");
+
return xorg_composite_bind_state(exa, op, pSrcPicture, pMaskPicture,
pDstPicture,
exaGetPixmapDriverPrivate(pSrc),
struct exa_context *exa = ms->exa;
struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pDst);
+ debug_printf("\tExaComposite\n");
+
xorg_composite(exa, priv, srcX, srcY, maskX, maskY,
dstX, dstY, width, height);
}
if (priv->tex) {
struct pipe_surface *dst_surf;
+ struct pipe_surface *src_surf;
dst_surf = exa->scrn->get_tex_surface(exa->scrn, texture, 0, 0, 0,
PIPE_BUFFER_USAGE_GPU_WRITE);
- priv->src_surf = exa_gpu_surface(exa, priv);
- exa->ctx->surface_copy(exa->ctx, dst_surf, 0, 0, priv->src_surf,
- 0, 0, min(width, texture->width[0]),
- min(height, texture->height[0]));
+ src_surf = exa_gpu_surface(exa, priv);
+ exa->pipe->surface_copy(exa->pipe, dst_surf, 0, 0, src_surf,
+ 0, 0, min(width, texture->width[0]),
+ min(height, texture->height[0]));
exa->scrn->tex_surface_destroy(dst_surf);
- exa->scrn->tex_surface_destroy(priv->src_surf);
- priv->src_surf = NULL;
+ exa->scrn->tex_surface_destroy(src_surf);
} else if (pPixmap->devPrivate.ptr) {
struct pipe_transfer *transfer;
pPixmap->devKind, 0, 0);
exa->scrn->transfer_unmap(exa->scrn, transfer);
exa->scrn->tex_transfer_destroy(transfer);
+
+ xfree(pPixmap->devPrivate.ptr);
+ pPixmap->devPrivate.ptr = NULL;
}
}
#ifdef DRM_MODE_FEATURE_DIRTYFB
cso_destroy_context(exa->cso);
}
- if (exa->ctx)
- exa->ctx->destroy(exa->ctx);
+ if (exa->pipe)
+ exa->pipe->destroy(exa->pipe);
exaDriverFini(pScrn->pScreen);
xfree(exa);
pExa->pixmapOffsetAlign = 0;
pExa->pixmapPitchAlign = 1;
pExa->flags = EXA_OFFSCREEN_PIXMAPS | EXA_HANDLES_PIXMAPS;
+#ifdef EXA_SUPPORTS_PREPARE_AUX
+ pExa->flags |= EXA_SUPPORTS_PREPARE_AUX;
+#endif
+#ifdef EXA_MIXED_PIXMAPS
+ pExa->flags |= EXA_MIXED_PIXMAPS;
+#endif
pExa->maxX = 8191; /* FIXME */
pExa->maxY = 8191; /* FIXME */
}
exa->scrn = ms->screen;
- exa->ctx = ms->api->create_context(ms->api, exa->scrn);
+ exa->pipe = ms->api->create_context(ms->api, exa->scrn);
/* Share context with DRI */
- ms->ctx = exa->ctx;
+ ms->ctx = exa->pipe;
- exa->cso = cso_create_context(exa->ctx);
+ exa->cso = cso_create_context(exa->pipe);
exa->shaders = xorg_shaders_create(exa);
+ xorg_exa_init_state(exa);
+
return (void *)exa;
out_err:
}
+void xorg_exa_flush(struct exa_context *exa, uint pipeFlushFlags,
+ struct pipe_fence_handle **fence)
+{
+ exa->pipe->flush(exa->pipe, pipeFlushFlags, fence);
+}
+
+void xorg_exa_finish(struct exa_context *exa)
+{
+ struct pipe_fence_handle *fence = NULL;
+
+ xorg_exa_flush(exa, PIPE_FLUSH_RENDER_CACHE, &fence);
+
+ exa->pipe->screen->fence_finish(exa->pipe->screen, fence, 0);
+ exa->pipe->screen->fence_reference(exa->pipe->screen, &fence, NULL);
+}
+
struct exa_context
{
ExaDriverPtr pExa;
- struct pipe_context *ctx;
+ struct pipe_context *pipe;
struct pipe_screen *scrn;
struct cso_context *cso;
struct xorg_shaders *shaders;
int num_bound_samplers;
float solid_color[4];
+ boolean has_solid_color;
+
+ struct {
+ struct exa_pixmap_priv *src;
+ struct exa_pixmap_priv *dst;
+ } copy;
};
struct pipe_texture *tex;
struct pipe_texture *depth_stencil_tex;
- unsigned int color;
- struct pipe_surface *src_surf; /* for copies */
struct pipe_transfer *map_transfer;
unsigned map_count;
struct pipe_surface *
exa_gpu_surface(struct exa_context *exa, struct exa_pixmap_priv *priv);
+void xorg_exa_flush(struct exa_context *exa, uint pipeFlushFlags,
+ struct pipe_fence_handle **fence);
+void xorg_exa_finish(struct exa_context *exa);
#endif
boolean is_fill = vs_traits & VS_FILL;
boolean is_composite = vs_traits & VS_COMPOSITE;
boolean has_mask = vs_traits & VS_MASK;
+ unsigned input_slot = 0;
ureg = ureg_create(TGSI_PROCESSOR_VERTEX);
if (ureg == NULL)
return 0;
- const0 = ureg_DECL_constant(ureg);
- const1 = ureg_DECL_constant(ureg);
+ const0 = ureg_DECL_constant(ureg, 0);
+ const1 = ureg_DECL_constant(ureg, 1);
/* it has to be either a fill or a composite op */
debug_assert(is_fill ^ is_composite);
- src = ureg_DECL_vs_input(ureg,
- TGSI_SEMANTIC_POSITION, 0);
+ src = ureg_DECL_vs_input(ureg, input_slot++);
dst = ureg_DECL_output(ureg, TGSI_SEMANTIC_POSITION, 0);
src = vs_normalize_coords(ureg, src,
const0, const1);
ureg_MOV(ureg, dst, src);
-
if (is_composite) {
- src = ureg_DECL_vs_input(ureg,
- TGSI_SEMANTIC_GENERIC, 1);
+ src = ureg_DECL_vs_input(ureg, input_slot++);
dst = ureg_DECL_output(ureg, TGSI_SEMANTIC_GENERIC, 1);
ureg_MOV(ureg, dst, src);
}
+
if (is_fill) {
- src = ureg_DECL_vs_input(ureg,
- TGSI_SEMANTIC_COLOR, 1);
- dst = ureg_DECL_output(ureg, TGSI_SEMANTIC_COLOR, 1);
+ src = ureg_DECL_vs_input(ureg, input_slot++);
+ dst = ureg_DECL_output(ureg, TGSI_SEMANTIC_COLOR, 0);
ureg_MOV(ureg, dst, src);
}
if (has_mask) {
- src = ureg_DECL_vs_input(ureg,
- TGSI_SEMANTIC_GENERIC, 2);
+ src = ureg_DECL_vs_input(ureg, input_slot++);
dst = ureg_DECL_output(ureg, TGSI_SEMANTIC_POSITION, 2);
ureg_MOV(ureg, dst, src);
}
TGSI_SEMANTIC_POSITION,
0,
TGSI_INTERPOLATE_PERSPECTIVE);
- }
- if (is_fill) {
+ } else {
+ debug_assert(is_fill);
if (is_solid)
src_input = ureg_DECL_fs_input(ureg,
TGSI_SEMANTIC_COLOR,
struct xorg_shader shader = {0};
void *vs, *fs;
- vs = shader_from_cache(sc->exa->ctx, PIPE_SHADER_VERTEX,
+ vs = shader_from_cache(sc->exa->pipe, PIPE_SHADER_VERTEX,
sc->vs_hash, vs_traits);
- fs = shader_from_cache(sc->exa->ctx, PIPE_SHADER_FRAGMENT,
+ fs = shader_from_cache(sc->exa->pipe, PIPE_SHADER_FRAGMENT,
sc->fs_hash, fs_traits);
debug_assert(vs && fs);
trace,
]
-env.SharedLibrary(
+env.LoadableModule(
target ='i915_dri.so',
source = COMMON_GALLIUM_SOURCES,
LIBS = drivers + mesa + auxiliaries + env['LIBS'],
+ SHLIBPREFIX = '',
)
#define INTEL_BATCH_CLIPRECTS 0x2
#undef INTEL_RUN_SYNC
+#undef INTEL_MAP_BATCHBUFFER
struct intel_drm_batchbuffer
{
"gallium3d_batchbuffer",
batch->actual_size,
4096);
+
+#ifdef INTEL_MAP_BATCHBUFFER
drm_intel_bo_map(batch->bo, TRUE);
batch->base.map = batch->bo->virtual;
+#endif
memset(batch->base.map, 0, batch->actual_size);
batch->base.ptr = batch->base.map;
struct intel_drm_winsys *idws = intel_drm_winsys(iws);
struct intel_drm_batchbuffer *batch = CALLOC_STRUCT(intel_drm_batchbuffer);
+ batch->actual_size = idws->max_batch_size;
+
+#ifdef INTEL_MAP_BATCHBUFFER
batch->base.map = NULL;
+#else
+ batch->base.map = MALLOC(batch->actual_size);
+#endif
batch->base.ptr = NULL;
batch->base.size = 0;
batch->base.iws = iws;
- batch->actual_size = idws->max_batch_size;
-
intel_drm_batchbuffer_reset(batch);
return &batch->base;
used = batch->base.ptr - batch->base.map;
+#ifdef INTEL_MAP_BATCHBUFFER
drm_intel_bo_unmap(batch->bo);
+#else
+ drm_intel_bo_subdata(batch->bo, 0, used, batch->base.map);
+#endif
/* Do the sending to HW */
ret = drm_intel_bo_exec(batch->bo, used, NULL, 0, 0);
if (batch->bo)
drm_intel_bo_unreference(batch->bo);
- free(batch);
+#ifndef INTEL_MAP_BATCHBUFFER
+ FREE(batch->base.map);
+#endif
+ FREE(batch);
}
void intel_drm_winsys_init_batchbuffer_functions(struct intel_drm_winsys *idws)
} else if (type == INTEL_NEW_VERTEX) {
name = "gallium3d_vertex";
pool = idws->pools.gem;
+ buf->map_gtt = TRUE;
} else if (type == INTEL_NEW_SCANOUT) {
name = "gallium3d_scanout";
pool = idws->pools.gem;
drm_intel_bo_unmap(intel_bo(buffer));
}
+static int
+intel_drm_buffer_write(struct intel_winsys *iws,
+ struct intel_buffer *buffer,
+ const void *data,
+ size_t size,
+ size_t offset)
+{
+ struct intel_drm_buffer *buf = intel_drm_buffer(buffer);
+
+ return drm_intel_bo_subdata(buf->bo, offset, size, (void*)data);
+}
+
static void
intel_drm_buffer_destroy(struct intel_winsys *iws,
struct intel_buffer *buffer)
idws->base.buffer_set_fence_reg = intel_drm_buffer_set_fence_reg;
idws->base.buffer_map = intel_drm_buffer_map;
idws->base.buffer_unmap = intel_drm_buffer_unmap;
+ idws->base.buffer_write = intel_drm_buffer_write;
idws->base.buffer_destroy = intel_drm_buffer_destroy;
}
#include "drivers/common/meta.h"
+/** Return offset in bytes of the field within a vertex struct */
+#define OFFSET(FIELD) ((void *) offsetof(struct vertex, FIELD))
+
+
/**
* State which we may save/restore across meta ops.
* XXX this may be incomplete...
const GLint srcH = abs(srcY1 - srcY0);
const GLboolean srcFlipX = srcX1 < srcX0;
const GLboolean srcFlipY = srcY1 < srcY0;
- GLfloat verts[4][4]; /* four verts of X,Y,S,T */
+ struct vertex {
+ GLfloat x, y, s, t;
+ };
+ struct vertex verts[4];
GLboolean newTex;
if (srcW > maxTexSize || srcH > maxTexSize) {
NULL, GL_DYNAMIC_DRAW_ARB);
/* setup vertex arrays */
- _mesa_VertexPointer(2, GL_FLOAT, sizeof(verts[0]),
- (void *) (0 * sizeof(GLfloat)));
- _mesa_TexCoordPointer(2, GL_FLOAT, sizeof(verts[0]),
- (void *) (2 * sizeof(GLfloat)));
+ _mesa_VertexPointer(2, GL_FLOAT, sizeof(struct vertex), OFFSET(x));
+ _mesa_TexCoordPointer(2, GL_FLOAT, sizeof(struct vertex), OFFSET(s));
_mesa_EnableClientState(GL_VERTEX_ARRAY);
_mesa_EnableClientState(GL_TEXTURE_COORD_ARRAY);
}
/* vertex positions/texcoords (after texture allocation!) */
{
- verts[0][0] = (GLfloat) dstX0;
- verts[0][1] = (GLfloat) dstY0;
- verts[1][0] = (GLfloat) dstX1;
- verts[1][1] = (GLfloat) dstY0;
- verts[2][0] = (GLfloat) dstX1;
- verts[2][1] = (GLfloat) dstY1;
- verts[3][0] = (GLfloat) dstX0;
- verts[3][1] = (GLfloat) dstY1;
-
- verts[0][2] = 0.0F;
- verts[0][3] = 0.0F;
- verts[1][2] = tex->Sright;
- verts[1][3] = 0.0F;
- verts[2][2] = tex->Sright;
- verts[2][3] = tex->Ttop;
- verts[3][2] = 0.0F;
- verts[3][3] = tex->Ttop;
+ verts[0].x = (GLfloat) dstX0;
+ verts[0].y = (GLfloat) dstY0;
+ verts[1].x = (GLfloat) dstX1;
+ verts[1].y = (GLfloat) dstY0;
+ verts[2].x = (GLfloat) dstX1;
+ verts[2].y = (GLfloat) dstY1;
+ verts[3].x = (GLfloat) dstX0;
+ verts[3].y = (GLfloat) dstY1;
+
+ verts[0].s = 0.0F;
+ verts[0].t = 0.0F;
+ verts[1].s = tex->Sright;
+ verts[1].t = 0.0F;
+ verts[2].s = tex->Sright;
+ verts[2].t = tex->Ttop;
+ verts[3].s = 0.0F;
+ verts[3].t = tex->Ttop;
/* upload new vertex data */
_mesa_BufferSubDataARB(GL_ARRAY_BUFFER_ARB, 0, sizeof(verts), verts);
_mesa_meta_clear(GLcontext *ctx, GLbitfield buffers)
{
struct clear_state *clear = &ctx->Meta->Clear;
- GLfloat verts[4][7]; /* four verts of X,Y,Z,R,G,B,A */
+ struct vertex {
+ GLfloat x, y, z, r, g, b, a;
+ };
+ struct vertex verts[4];
/* save all state but scissor, pixel pack/unpack */
GLbitfield metaSave = META_ALL - META_SCISSOR - META_PIXEL_STORE;
NULL, GL_DYNAMIC_DRAW_ARB);
/* setup vertex arrays */
- _mesa_VertexPointer(3, GL_FLOAT, sizeof(verts[0]),
- (void *) (0 * sizeof(GLfloat)));
- _mesa_ColorPointer(4, GL_FLOAT, sizeof(verts[0]),
- (void *) (3 * sizeof(GLfloat)));
+ _mesa_VertexPointer(3, GL_FLOAT, sizeof(struct vertex), OFFSET(x));
+ _mesa_ColorPointer(4, GL_FLOAT, sizeof(struct vertex), OFFSET(r));
_mesa_EnableClientState(GL_VERTEX_ARRAY);
_mesa_EnableClientState(GL_COLOR_ARRAY);
}
const GLfloat z = 1.0 - 2.0 * ctx->Depth.Clear;
GLuint i;
- verts[0][0] = x0;
- verts[0][1] = y0;
- verts[0][2] = z;
- verts[1][0] = x1;
- verts[1][1] = y0;
- verts[1][2] = z;
- verts[2][0] = x1;
- verts[2][1] = y1;
- verts[2][2] = z;
- verts[3][0] = x0;
- verts[3][1] = y1;
- verts[3][2] = z;
+ verts[0].x = x0;
+ verts[0].y = y0;
+ verts[0].z = z;
+ verts[1].x = x1;
+ verts[1].y = y0;
+ verts[1].z = z;
+ verts[2].x = x1;
+ verts[2].y = y1;
+ verts[2].z = z;
+ verts[3].x = x0;
+ verts[3].y = y1;
+ verts[3].z = z;
/* vertex colors */
for (i = 0; i < 4; i++) {
- COPY_4FV(&verts[i][3], ctx->Color.ClearColor);
+ verts[i].r = ctx->Color.ClearColor[0];
+ verts[i].g = ctx->Color.ClearColor[1];
+ verts[i].b = ctx->Color.ClearColor[2];
+ verts[i].a = ctx->Color.ClearColor[3];
}
/* upload new vertex data */
{
struct copypix_state *copypix = &ctx->Meta->CopyPix;
struct temp_texture *tex = get_temp_texture(ctx);
- GLfloat verts[4][5]; /* four verts of X,Y,Z,S,T */
+ struct vertex {
+ GLfloat x, y, z, s, t;
+ };
+ struct vertex verts[4];
GLboolean newTex;
GLenum intFormat = GL_RGBA;
NULL, GL_DYNAMIC_DRAW_ARB);
/* setup vertex arrays */
- _mesa_VertexPointer(3, GL_FLOAT, sizeof(verts[0]),
- (void *) (0 * sizeof(GLfloat)));
- _mesa_TexCoordPointer(2, GL_FLOAT, sizeof(verts[0]),
- (void *) (3 * sizeof(GLfloat)));
+ _mesa_VertexPointer(3, GL_FLOAT, sizeof(struct vertex), OFFSET(x));
+ _mesa_TexCoordPointer(2, GL_FLOAT, sizeof(struct vertex), OFFSET(s));
_mesa_EnableClientState(GL_VERTEX_ARRAY);
_mesa_EnableClientState(GL_TEXTURE_COORD_ARRAY);
}
const GLfloat dstY1 = dstY + height * ctx->Pixel.ZoomY;
const GLfloat z = ctx->Current.RasterPos[2];
- verts[0][0] = dstX0;
- verts[0][1] = dstY0;
- verts[0][2] = z;
- verts[0][3] = 0.0F;
- verts[0][4] = 0.0F;
- verts[1][0] = dstX1;
- verts[1][1] = dstY0;
- verts[1][2] = z;
- verts[1][3] = tex->Sright;
- verts[1][4] = 0.0F;
- verts[2][0] = dstX1;
- verts[2][1] = dstY1;
- verts[2][2] = z;
- verts[2][3] = tex->Sright;
- verts[2][4] = tex->Ttop;
- verts[3][0] = dstX0;
- verts[3][1] = dstY1;
- verts[3][2] = z;
- verts[3][3] = 0.0F;
- verts[3][4] = tex->Ttop;
+ verts[0].x = dstX0;
+ verts[0].y = dstY0;
+ verts[0].z = z;
+ verts[0].s = 0.0F;
+ verts[0].t = 0.0F;
+ verts[1].x = dstX1;
+ verts[1].y = dstY0;
+ verts[1].z = z;
+ verts[1].s = tex->Sright;
+ verts[1].t = 0.0F;
+ verts[2].x = dstX1;
+ verts[2].y = dstY1;
+ verts[2].z = z;
+ verts[2].s = tex->Sright;
+ verts[2].t = tex->Ttop;
+ verts[3].x = dstX0;
+ verts[3].y = dstY1;
+ verts[3].z = z;
+ verts[3].s = 0.0F;
+ verts[3].t = tex->Ttop;
/* upload new vertex data */
_mesa_BufferSubDataARB(GL_ARRAY_BUFFER_ARB, 0, sizeof(verts), verts);
struct temp_texture *tex = get_temp_texture(ctx);
const struct gl_pixelstore_attrib unpackSave = ctx->Unpack;
const GLuint origStencilMask = ctx->Stencil.WriteMask[0];
- GLfloat verts[4][5]; /* four verts of X,Y,Z,S,T */
+ struct vertex {
+ GLfloat x, y, z, s, t;
+ };
+ struct vertex verts[4];
GLenum texIntFormat;
GLboolean fallback, newTex;
GLbitfield metaExtraSave = 0x0;
if (_mesa_is_color_format(format)) {
/* use more compact format when possible */
- if (format == GL_LUMINANCE || format == GL_LUMINANCE_ALPHA)
+ /* XXX disable special case for GL_LUMINANCE for now to work around
+ * apparent i965 driver bug (see bug #23670).
+ */
+ if (/*format == GL_LUMINANCE ||*/ format == GL_LUMINANCE_ALPHA)
texIntFormat = format;
else
texIntFormat = GL_RGBA;
}
else if (_mesa_is_stencil_format(format)) {
if (ctx->Extensions.ARB_fragment_program &&
+ ctx->Pixel.IndexShift == 0 &&
+ ctx->Pixel.IndexOffset == 0 &&
type == GL_UNSIGNED_BYTE) {
/* We'll store stencil as alpha. This only works for GLubyte
* image data because of how incoming values are mapped to alpha
NULL, GL_DYNAMIC_DRAW_ARB);
/* setup vertex arrays */
- _mesa_VertexPointer(3, GL_FLOAT, sizeof(verts[0]),
- (void *) (0 * sizeof(GLfloat)));
- _mesa_TexCoordPointer(2, GL_FLOAT, sizeof(verts[0]),
- (void *) (3 * sizeof(GLfloat)));
+ _mesa_VertexPointer(3, GL_FLOAT, sizeof(struct vertex), OFFSET(x));
+ _mesa_TexCoordPointer(2, GL_FLOAT, sizeof(struct vertex), OFFSET(s));
_mesa_EnableClientState(GL_VERTEX_ARRAY);
_mesa_EnableClientState(GL_TEXTURE_COORD_ARRAY);
}
const GLfloat y1 = y + height * ctx->Pixel.ZoomY;
const GLfloat z = ctx->Current.RasterPos[2];
- verts[0][0] = x0;
- verts[0][1] = y0;
- verts[0][2] = z;
- verts[0][3] = 0.0F;
- verts[0][4] = 0.0F;
- verts[1][0] = x1;
- verts[1][1] = y0;
- verts[1][2] = z;
- verts[1][3] = tex->Sright;
- verts[1][4] = 0.0F;
- verts[2][0] = x1;
- verts[2][1] = y1;
- verts[2][2] = z;
- verts[2][3] = tex->Sright;
- verts[2][4] = tex->Ttop;
- verts[3][0] = x0;
- verts[3][1] = y1;
- verts[3][2] = z;
- verts[3][3] = 0.0F;
- verts[3][4] = tex->Ttop;
+ verts[0].x = x0;
+ verts[0].y = y0;
+ verts[0].z = z;
+ verts[0].s = 0.0F;
+ verts[0].t = 0.0F;
+ verts[1].x = x1;
+ verts[1].y = y0;
+ verts[1].z = z;
+ verts[1].s = tex->Sright;
+ verts[1].t = 0.0F;
+ verts[2].x = x1;
+ verts[2].y = y1;
+ verts[2].z = z;
+ verts[2].s = tex->Sright;
+ verts[2].t = tex->Ttop;
+ verts[3].x = x0;
+ verts[3].y = y1;
+ verts[3].z = z;
+ verts[3].s = 0.0F;
+ verts[3].t = tex->Ttop;
/* upload new vertex data */
_mesa_BufferSubDataARB(GL_ARRAY_BUFFER_ARB, 0, sizeof(verts), verts);
_mesa_ColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
_mesa_set_enable(ctx, GL_STENCIL_TEST, GL_TRUE);
+
+ /* set all stencil bits to 0 */
+ _mesa_StencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
+ _mesa_StencilFunc(GL_ALWAYS, 0, 255);
+ _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);
+
+ /* set stencil bits to 1 where needed */
_mesa_StencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
_mesa_BindProgram(GL_FRAGMENT_PROGRAM_ARB, drawpix->StencilFP);
struct temp_texture *tex = get_bitmap_temp_texture(ctx);
const GLenum texIntFormat = GL_ALPHA;
const struct gl_pixelstore_attrib unpackSave = *unpack;
- GLfloat verts[4][9]; /* four verts of X,Y,Z,S,T,R,G,B,A */
+ struct vertex {
+ GLfloat x, y, z, s, t, r, g, b, a;
+ };
+ struct vertex verts[4];
GLboolean newTex;
GLubyte *bitmap8;
NULL, GL_DYNAMIC_DRAW_ARB);
/* setup vertex arrays */
- _mesa_VertexPointer(3, GL_FLOAT, sizeof(verts[0]),
- (void *) (0 * sizeof(GLfloat)));
- _mesa_TexCoordPointer(2, GL_FLOAT, sizeof(verts[0]),
- (void *) (3 * sizeof(GLfloat)));
- _mesa_ColorPointer(4, GL_FLOAT, sizeof(verts[0]),
- (void *) (5 * sizeof(GLfloat)));
-
+ _mesa_VertexPointer(3, GL_FLOAT, sizeof(struct vertex), OFFSET(x));
+ _mesa_TexCoordPointer(2, GL_FLOAT, sizeof(struct vertex), OFFSET(s));
+ _mesa_ColorPointer(4, GL_FLOAT, sizeof(struct vertex), OFFSET(r));
_mesa_EnableClientState(GL_VERTEX_ARRAY);
_mesa_EnableClientState(GL_TEXTURE_COORD_ARRAY);
_mesa_EnableClientState(GL_COLOR_ARRAY);
const GLfloat z = ctx->Current.RasterPos[2];
GLuint i;
- verts[0][0] = x0;
- verts[0][1] = y0;
- verts[0][2] = z;
- verts[0][3] = 0.0F;
- verts[0][4] = 0.0F;
- verts[1][0] = x1;
- verts[1][1] = y0;
- verts[1][2] = z;
- verts[1][3] = tex->Sright;
- verts[1][4] = 0.0F;
- verts[2][0] = x1;
- verts[2][1] = y1;
- verts[2][2] = z;
- verts[2][3] = tex->Sright;
- verts[2][4] = tex->Ttop;
- verts[3][0] = x0;
- verts[3][1] = y1;
- verts[3][2] = z;
- verts[3][3] = 0.0F;
- verts[3][4] = tex->Ttop;
+ verts[0].x = x0;
+ verts[0].y = y0;
+ verts[0].z = z;
+ verts[0].s = 0.0F;
+ verts[0].t = 0.0F;
+ verts[1].x = x1;
+ verts[1].y = y0;
+ verts[1].z = z;
+ verts[1].s = tex->Sright;
+ verts[1].t = 0.0F;
+ verts[2].x = x1;
+ verts[2].y = y1;
+ verts[2].z = z;
+ verts[2].s = tex->Sright;
+ verts[2].t = tex->Ttop;
+ verts[3].x = x0;
+ verts[3].y = y1;
+ verts[3].z = z;
+ verts[3].s = 0.0F;
+ verts[3].t = tex->Ttop;
for (i = 0; i < 4; i++) {
- verts[i][5] = ctx->Current.RasterColor[0];
- verts[i][6] = ctx->Current.RasterColor[1];
- verts[i][7] = ctx->Current.RasterColor[2];
- verts[i][8] = ctx->Current.RasterColor[3];
+ verts[i].r = ctx->Current.RasterColor[0];
+ verts[i].g = ctx->Current.RasterColor[1];
+ verts[i].b = ctx->Current.RasterColor[2];
+ verts[i].a = ctx->Current.RasterColor[3];
}
/* upload new vertex data */
struct gl_texture_object *texObj)
{
struct gen_mipmap_state *mipmap = &ctx->Meta->Mipmap;
- struct { GLfloat x, y, s, t, r; } verts[4];
+ struct vertex {
+ GLfloat x, y, s, t, r;
+ };
+ struct vertex verts[4];
const GLuint baseLevel = texObj->BaseLevel;
const GLuint maxLevel = texObj->MaxLevel;
const GLenum minFilterSave = texObj->MinFilter;
NULL, GL_DYNAMIC_DRAW_ARB);
/* setup vertex arrays */
- _mesa_VertexPointer(2, GL_FLOAT, sizeof(verts[0]),
- (void *) (0 * sizeof(GLfloat)));
- _mesa_TexCoordPointer(3, GL_FLOAT, sizeof(verts[0]),
- (void *) (2 * sizeof(GLfloat)));
-
+ _mesa_VertexPointer(2, GL_FLOAT, sizeof(struct vertex), OFFSET(x));
+ _mesa_TexCoordPointer(3, GL_FLOAT, sizeof(struct vertex), OFFSET(s));
_mesa_EnableClientState(GL_VERTEX_ARRAY);
_mesa_EnableClientState(GL_TEXTURE_COORD_ARRAY);
}
verts[0].r = 0.0F;
verts[1].s = 1.0F;
verts[1].t = 0.0F;
+ verts[1].r = 0.0F;
+ verts[2].s = 1.0F;
+ verts[2].t = 1.0F;
verts[2].r = 0.0F;
- verts[3].s = 1.0F;
+ verts[3].s = 0.0F;
verts[3].t = 1.0F;
verts[3].r = 0.0F;
- verts[4].s = 0.0F;
- verts[4].t = 1.0F;
- verts[4].r = 0.0F;
break;
}
"";
#endif
+#if defined(need_GL_NV_vertex_program)
+static const char VertexAttribs3fvNV_names[] =
+ "iip\0" /* Parameter signature */
+ "glVertexAttribs3fvNV\0"
+ "";
+#endif
+
#if defined(need_GL_VERSION_2_0) || defined(need_GL_ARB_shader_objects)
static const char Uniform2fARB_names[] =
"iff\0" /* Parameter signature */
"";
#endif
+#if defined(need_GL_ARB_draw_elements_base_vertex)
+static const char DrawElementsBaseVertex_names[] =
+ "iiipi\0" /* Parameter signature */
+ "glDrawElementsBaseVertex\0"
+ "";
+#endif
+
#if defined(need_GL_VERSION_2_0) || defined(need_GL_ARB_vertex_program)
static const char DisableVertexAttribArrayARB_names[] =
"i\0" /* Parameter signature */
"";
#endif
-#if defined(need_GL_NV_vertex_program)
-static const char VertexAttribs3fvNV_names[] =
+#if defined(need_GL_NV_register_combiners)
+static const char GetFinalCombinerInputParameterfvNV_names[] =
"iip\0" /* Parameter signature */
- "glVertexAttribs3fvNV\0"
+ "glGetFinalCombinerInputParameterfvNV\0"
"";
#endif
"";
#endif
+#if defined(need_GL_ARB_draw_elements_base_vertex)
+static const char MultiDrawElementsBaseVertex_names[] =
+ "ipipip\0" /* Parameter signature */
+ "glMultiDrawElementsBaseVertex\0"
+ "";
+#endif
+
#if defined(need_GL_EXT_coordinate_frame)
static const char Binormal3svEXT_names[] =
"p\0" /* Parameter signature */
"";
#endif
-#if defined(need_GL_EXT_coordinate_frame)
-static const char Binormal3fvEXT_names[] =
- "p\0" /* Parameter signature */
- "glBinormal3fvEXT\0"
+#if defined(need_GL_ARB_draw_elements_base_vertex)
+static const char DrawRangeElementsBaseVertex_names[] =
+ "iiiiipi\0" /* Parameter signature */
+ "glDrawRangeElementsBaseVertex\0"
"";
#endif
"";
#endif
-#if defined(need_GL_NV_register_combiners)
-static const char GetFinalCombinerInputParameterfvNV_names[] =
- "iip\0" /* Parameter signature */
- "glGetFinalCombinerInputParameterfvNV\0"
+#if defined(need_GL_EXT_coordinate_frame)
+static const char Binormal3fvEXT_names[] =
+ "p\0" /* Parameter signature */
+ "glBinormal3fvEXT\0"
"";
#endif
};
#endif
+#if defined(need_GL_ARB_draw_elements_base_vertex)
+static const struct dri_extension_function GL_ARB_draw_elements_base_vertex_functions[] = {
+ { DrawElementsBaseVertex_names, DrawElementsBaseVertex_remap_index, -1 },
+ { MultiDrawElementsBaseVertex_names, MultiDrawElementsBaseVertex_remap_index, -1 },
+ { DrawRangeElementsBaseVertex_names, DrawRangeElementsBaseVertex_remap_index, -1 },
+ { NULL, 0, 0 }
+};
+#endif
+
#if defined(need_GL_ARB_framebuffer_object)
static const struct dri_extension_function GL_ARB_framebuffer_object_functions[] = {
{ BlitFramebufferEXT_names, BlitFramebufferEXT_remap_index, -1 },
{ Binormal3dvEXT_names, Binormal3dvEXT_remap_index, -1 },
{ Tangent3iEXT_names, Tangent3iEXT_remap_index, -1 },
{ Tangent3bvEXT_names, Tangent3bvEXT_remap_index, -1 },
- { Binormal3fvEXT_names, Binormal3fvEXT_remap_index, -1 },
{ Tangent3bEXT_names, Tangent3bEXT_remap_index, -1 },
+ { Binormal3fvEXT_names, Binormal3fvEXT_remap_index, -1 },
{ BinormalPointerEXT_names, BinormalPointerEXT_remap_index, -1 },
{ Tangent3svEXT_names, Tangent3svEXT_remap_index, -1 },
{ Binormal3bEXT_names, Binormal3bEXT_remap_index, -1 },
static const struct dri_extension_function GL_NV_register_combiners_functions[] = {
{ CombinerOutputNV_names, CombinerOutputNV_remap_index, -1 },
{ CombinerParameterfvNV_names, CombinerParameterfvNV_remap_index, -1 },
+ { GetFinalCombinerInputParameterfvNV_names, GetFinalCombinerInputParameterfvNV_remap_index, -1 },
{ GetCombinerOutputParameterfvNV_names, GetCombinerOutputParameterfvNV_remap_index, -1 },
{ FinalCombinerInputNV_names, FinalCombinerInputNV_remap_index, -1 },
{ GetCombinerInputParameterfvNV_names, GetCombinerInputParameterfvNV_remap_index, -1 },
{ GetFinalCombinerInputParameterivNV_names, GetFinalCombinerInputParameterivNV_remap_index, -1 },
{ CombinerInputNV_names, CombinerInputNV_remap_index, -1 },
{ CombinerParameterfNV_names, CombinerParameterfNV_remap_index, -1 },
- { GetFinalCombinerInputParameterfvNV_names, GetFinalCombinerInputParameterfvNV_remap_index, -1 },
{ GetCombinerInputParameterivNV_names, GetCombinerInputParameterivNV_remap_index, -1 },
{ CombinerParameterivNV_names, CombinerParameterivNV_remap_index, -1 },
{ NULL, 0, 0 }
static const struct dri_extension_function GL_NV_vertex_program_functions[] = {
{ VertexAttrib4ubvNV_names, VertexAttrib4ubvNV_remap_index, -1 },
{ VertexAttrib4svNV_names, VertexAttrib4svNV_remap_index, -1 },
+ { VertexAttribs3fvNV_names, VertexAttribs3fvNV_remap_index, -1 },
{ VertexAttribs1dvNV_names, VertexAttribs1dvNV_remap_index, -1 },
{ VertexAttrib1fvNV_names, VertexAttrib1fvNV_remap_index, -1 },
{ VertexAttrib4fNV_names, VertexAttrib4fNV_remap_index, -1 },
{ VertexAttribs3dvNV_names, VertexAttribs3dvNV_remap_index, -1 },
{ VertexAttribs4fvNV_names, VertexAttribs4fvNV_remap_index, -1 },
{ VertexAttrib2sNV_names, VertexAttrib2sNV_remap_index, -1 },
- { VertexAttribs3fvNV_names, VertexAttribs3fvNV_remap_index, -1 },
{ ProgramEnvParameter4fvARB_names, ProgramEnvParameter4fvARB_remap_index, -1 },
{ LoadProgramNV_names, LoadProgramNV_remap_index, -1 },
{ VertexAttrib4fvNV_names, VertexAttrib4fvNV_remap_index, -1 },
static void prepare_cc_vp( struct brw_context *brw )
{
+ GLcontext *ctx = &brw->intel.ctx;
struct brw_cc_viewport ccv;
memset(&ccv, 0, sizeof(ccv));
- ccv.min_depth = 0.0;
- ccv.max_depth = 1.0;
+ /* _NEW_VIEWPORT */
+ ccv.min_depth = ctx->Viewport.Near;
+ ccv.max_depth = ctx->Viewport.Far;
dri_bo_unreference(brw->cc.vp_bo);
brw->cc.vp_bo = brw_cache_data( &brw->cache, BRW_CC_VP, &ccv, NULL, 0 );
const struct brw_tracked_state brw_cc_vp = {
.dirty = {
- .mesa = 0,
+ .mesa = _NEW_VIEWPORT,
.brw = BRW_NEW_CONTEXT,
.cache = 0
},
unsigned int curbe_offset;
unsigned int nr_urb_entries, urb_size;
+
+ GLboolean depth_clamp;
};
static void
clip_unit_populate_key(struct brw_context *brw, struct brw_clip_unit_key *key)
{
+ GLcontext *ctx = &brw->intel.ctx;
memset(key, 0, sizeof(*key));
/* CACHE_NEW_CLIP_PROG */
/* BRW_NEW_URB_FENCE */
key->nr_urb_entries = brw->urb.nr_clip_entries;
key->urb_size = brw->urb.vsize;
+
+ /* _NEW_TRANSOFORM */
+ key->depth_clamp = ctx->Transform.DepthClamp;
}
static dri_bo *
clip.clip5.userclip_enable_flags = 0x7f;
clip.clip5.userclip_must_clip = 1;
clip.clip5.guard_band_enable = 0;
- clip.clip5.viewport_z_clip_enable = 1;
+ if (!key->depth_clamp)
+ clip.clip5.viewport_z_clip_enable = 1;
clip.clip5.viewport_xy_clip_enable = 1;
clip.clip5.vertex_position_space = BRW_CLIP_NDCSPACE;
clip.clip5.api_mode = BRW_CLIP_API_OGL;
const struct brw_tracked_state brw_clip_unit = {
.dirty = {
- .mesa = 0,
+ .mesa = _NEW_TRANSFORM,
.brw = (BRW_NEW_CURBE_OFFSETS |
BRW_NEW_URB_FENCE),
.cache = CACHE_NEW_CLIP_PROG
struct brw_vertex_element {
const struct gl_client_array *glarray;
+ /** The corresponding Mesa vertex attribute */
+ gl_vert_attrib attrib;
/** Size of a complete element */
GLuint element_size;
/** Number of uploaded elements for this input. */
*
**************************************************************************/
-#include <stdlib.h>
#include "main/glheader.h"
#include "main/context.h"
#include "main/state.h"
-#include "main/api_validate.h"
#include "main/enums.h"
+#include "tnl/tnl.h"
+#include "vbo/vbo_context.h"
+#include "swrast/swrast.h"
+#include "swrast_setup/swrast_setup.h"
#include "brw_draw.h"
#include "brw_defines.h"
#include "intel_batchbuffer.h"
#include "intel_buffer_objects.h"
-#include "tnl/tnl.h"
-#include "vbo/vbo_context.h"
-#include "swrast/swrast.h"
-#include "swrast_setup/swrast_setup.h"
-
#define FILE_DEBUG_FLAG DEBUG_BATCH
static GLuint prim_to_hw_prim[GL_POLYGON+1] = {
prim_packet.start_vert_location += brw->ib.start_vertex_offset;
prim_packet.instance_count = 1;
prim_packet.start_instance_location = 0;
- prim_packet.base_vert_location = 0;
+ prim_packet.base_vert_location = prim->basevertex;
/* Can't wrap here, since we rely on the validated state. */
brw->no_batch_wrap = GL_TRUE;
for (i = 0; i < VERT_ATTRIB_MAX; i++) {
brw->vb.inputs[i].glarray = arrays[i];
+ brw->vb.inputs[i].attrib = (gl_vert_attrib) i;
if (arrays[i]->StrideB != 0)
brw->vb.info.sizes[i/16] |= (brw->vb.inputs[i].glarray->Size - 1) <<
*
**************************************************************************/
-#include <stdlib.h>
#include "main/glheader.h"
+#include "main/bufferobj.h"
#include "main/context.h"
#include "main/state.h"
#include "main/api_validate.h"
input->element_size = get_size(input->glarray->Type) * input->glarray->Size;
- if (input->glarray->BufferObj->Name != 0) {
+ if (_mesa_is_bufferobj(input->glarray->BufferObj)) {
struct intel_buffer_object *intel_buffer =
intel_buffer_object(input->glarray->BufferObj);
/* Queue the buffer object up to be uploaded in the next pass,
* when we've decided if we're doing interleaved or not.
*/
- if (i == 0) {
+ if (input->attrib == VERT_ATTRIB_POS) {
/* Position array not properly enabled:
*/
if (input->glarray->StrideB == 0) {
/* Turn into a proper VBO:
*/
- if (!bufferobj->Name) {
+ if (!_mesa_is_bufferobj(bufferobj)) {
brw->ib.start_vertex_offset = 0;
/* Get new bufferobj, offset:
}
static uint32_t
-get_predicate(uint32_t swizzle)
+get_predicate(const struct prog_instruction *inst)
{
- switch (swizzle) {
+ if (inst->DstReg.CondMask == COND_TR)
+ return BRW_PREDICATE_NONE;
+
+ /* All of GLSL only produces predicates for COND_NE and one channel per
+ * vector. Fail badly if someone starts doing something else, as it might
+ * mean infinite looping or something.
+ *
+ * We'd like to support all the condition codes, but our hardware doesn't
+ * quite match the Mesa IR, which is modeled after the NV extensions. For
+ * those, the instruction may update the condition codes or not, then any
+ * later instruction may use one of those condition codes. For gen4, the
+ * instruction may update the flags register based on one of the condition
+ * codes output by the instruction, and then further instructions may
+ * predicate on that. We can probably support this, but it won't
+ * necessarily be easy.
+ */
+ assert(inst->DstReg.CondMask == COND_NE);
+
+ switch (inst->DstReg.CondSwizzle) {
case SWIZZLE_XXXX:
return BRW_PREDICATE_ALIGN16_REPLICATE_X;
case SWIZZLE_YYYY:
case SWIZZLE_WWWW:
return BRW_PREDICATE_ALIGN16_REPLICATE_W;
default:
- _mesa_problem(NULL, "Unexpected predicate: 0x%08x\n", swizzle);
+ _mesa_problem(NULL, "Unexpected predicate: 0x%08x\n",
+ inst->DstReg.CondMask);
return BRW_PREDICATE_NORMAL;
}
}
#define MAX_IF_DEPTH 32
#define MAX_LOOP_DEPTH 32
struct brw_compile *p = &c->func;
+ struct brw_context *brw = p->brw;
const GLuint nr_insns = c->vp->program.Base.NumInstructions;
GLuint insn, if_depth = 0, loop_depth = 0;
GLuint end_offset = 0;
case OPCODE_IF:
assert(if_depth < MAX_IF_DEPTH);
if_inst[if_depth] = brw_IF(p, BRW_EXECUTE_8);
- if_inst[if_depth]->header.predicate_control =
- get_predicate(inst->DstReg.CondSwizzle);
+ /* Note that brw_IF smashes the predicate_control field. */
+ if_inst[if_depth]->header.predicate_control = get_predicate(inst);
if_depth++;
break;
case OPCODE_ELSE:
assert(if_depth > 0);
brw_ENDIF(p, if_inst[--if_depth]);
break;
-#if 0
case OPCODE_BGNLOOP:
loop_inst[loop_depth++] = brw_DO(p, BRW_EXECUTE_8);
break;
case OPCODE_BRK:
+ brw_set_predicate_control(p, get_predicate(inst));
brw_BREAK(p);
- brw_set_predicate_control(p, BRW_PREDICATE_NONE);
+ brw_set_predicate_control(p, BRW_PREDICATE_NONE);
break;
case OPCODE_CONT:
+ brw_set_predicate_control(p, get_predicate(inst));
brw_CONT(p);
brw_set_predicate_control(p, BRW_PREDICATE_NONE);
break;
case OPCODE_ENDLOOP:
{
struct brw_instruction *inst0, *inst1;
+ GLuint br = 1;
+
loop_depth--;
+
+ if (BRW_IS_IGDNG(brw))
+ br = 2;
+
inst0 = inst1 = brw_WHILE(p, loop_inst[loop_depth]);
/* patch all the BREAK/CONT instructions from last BEGINLOOP */
while (inst0 > loop_inst[loop_depth]) {
inst0--;
if (inst0->header.opcode == BRW_OPCODE_BREAK) {
- inst0->bits3.if_else.jump_count = inst1 - inst0 + 1;
+ inst0->bits3.if_else.jump_count = br * (inst1 - inst0 + 1);
inst0->bits3.if_else.pop_count = 0;
}
else if (inst0->header.opcode == BRW_OPCODE_CONTINUE) {
- inst0->bits3.if_else.jump_count = inst1 - inst0;
+ inst0->bits3.if_else.jump_count = br * (inst1 - inst0);
inst0->bits3.if_else.pop_count = 0;
}
}
}
break;
-#else
- (void) loop_inst;
- (void) loop_depth;
-#endif
case OPCODE_BRA:
- brw_set_predicate_control(p, BRW_PREDICATE_NORMAL);
+ brw_set_predicate_control(p, get_predicate(inst));
brw_ADD(p, brw_ip_reg(), brw_ip_reg(), brw_imm_d(1*16));
- brw_set_predicate_control_flag_value(p, 0xff);
+ brw_set_predicate_control(p, BRW_PREDICATE_NONE);
break;
case OPCODE_CAL:
brw_set_access_mode(p, BRW_ALIGN_1);
#include "brw_context.h"
#include "brw_eu.h"
+#define SATURATE (1<<5)
+
/* A big lookup table is used to figure out which and how many
* additional regs will inserted before the main payload in the WM
* program execution. These mainly relate to depth and stencil
GLuint fp_temp;
GLuint fp_interp_emitted;
GLuint fp_fragcolor_emitted;
- GLuint fp_deriv_emitted;
struct prog_src_register pixel_xy;
struct prog_src_register delta_xy;
GLboolean brw_wm_is_glsl(const struct gl_fragment_program *fp);
void brw_wm_glsl_emit(struct brw_context *brw, struct brw_wm_compile *c);
+void emit_ddxy(struct brw_compile *p,
+ const struct brw_reg *dst,
+ GLuint mask,
+ GLboolean is_ddx,
+ const struct brw_reg *arg0);
#endif
#include "brw_context.h"
#include "brw_wm.h"
-#define SATURATE (1<<5)
-
/* Not quite sure how correct this is - need to understand horiz
* vs. vertical strides a little better.
*/
brw_set_predicate_control_flag_value(p, 0xff);
}
+/* For OPCODE_DDX and OPCODE_DDY, per channel of output we've got input
+ * looking like:
+ *
+ * arg0: ss0.tl ss0.tr ss0.bl ss0.br ss1.tl ss1.tr ss1.bl ss1.br
+ *
+ * and we're trying to produce:
+ *
+ * DDX DDY
+ * dst: (ss0.tr - ss0.tl) (ss0.tl - ss0.bl)
+ * (ss0.tr - ss0.tl) (ss0.tr - ss0.br)
+ * (ss0.br - ss0.bl) (ss0.tl - ss0.bl)
+ * (ss0.br - ss0.bl) (ss0.tr - ss0.br)
+ * (ss1.tr - ss1.tl) (ss1.tl - ss1.bl)
+ * (ss1.tr - ss1.tl) (ss1.tr - ss1.br)
+ * (ss1.br - ss1.bl) (ss1.tl - ss1.bl)
+ * (ss1.br - ss1.bl) (ss1.tr - ss1.br)
+ *
+ * and add another set of two more subspans if in 16-pixel dispatch mode.
+ *
+ * For DDX, it ends up being easy: width = 2, horiz=0 gets us the same result
+ * for each pair, and vertstride = 2 jumps us 2 elements after processing a
+ * pair. But for DDY, it's harder, as we want to produce the pairs swizzled
+ * between each other. We could probably do it like ddx and swizzle the right
+ * order later, but bail for now and just produce
+ * ((ss0.tl - ss0.bl)x4 (ss1.tl - ss1.bl)x4)
+ */
+void emit_ddxy(struct brw_compile *p,
+ const struct brw_reg *dst,
+ GLuint mask,
+ GLboolean is_ddx,
+ const struct brw_reg *arg0)
+{
+ int i;
+ struct brw_reg src0, src1;
+
+ if (mask & SATURATE)
+ brw_set_saturate(p, 1);
+ for (i = 0; i < 4; i++ ) {
+ if (mask & (1<<i)) {
+ if (is_ddx) {
+ src0 = brw_reg(arg0[i].file, arg0[i].nr, 1,
+ BRW_REGISTER_TYPE_F,
+ BRW_VERTICAL_STRIDE_2,
+ BRW_WIDTH_2,
+ BRW_HORIZONTAL_STRIDE_0,
+ BRW_SWIZZLE_XYZW, WRITEMASK_XYZW);
+ src1 = brw_reg(arg0[i].file, arg0[i].nr, 0,
+ BRW_REGISTER_TYPE_F,
+ BRW_VERTICAL_STRIDE_2,
+ BRW_WIDTH_2,
+ BRW_HORIZONTAL_STRIDE_0,
+ BRW_SWIZZLE_XYZW, WRITEMASK_XYZW);
+ } else {
+ src0 = brw_reg(arg0[i].file, arg0[i].nr, 0,
+ BRW_REGISTER_TYPE_F,
+ BRW_VERTICAL_STRIDE_4,
+ BRW_WIDTH_4,
+ BRW_HORIZONTAL_STRIDE_0,
+ BRW_SWIZZLE_XYZW, WRITEMASK_XYZW);
+ src1 = brw_reg(arg0[i].file, arg0[i].nr, 2,
+ BRW_REGISTER_TYPE_F,
+ BRW_VERTICAL_STRIDE_4,
+ BRW_WIDTH_4,
+ BRW_HORIZONTAL_STRIDE_0,
+ BRW_SWIZZLE_XYZW, WRITEMASK_XYZW);
+ }
+ brw_ADD(p, dst[i], src0, negate(src1));
+ }
+ }
+ if (mask & SATURATE)
+ brw_set_saturate(p, 0);
+}
+
static void emit_alu1( struct brw_compile *p,
struct brw_instruction *(*func)(struct brw_compile *,
struct brw_reg,
emit_alu1(p, brw_RNDD, dst, dst_flags, args[0]);
break;
+ case OPCODE_DDX:
+ emit_ddxy(p, dst, dst_flags, GL_TRUE, args[0]);
+ break;
+
+ case OPCODE_DDY:
+ emit_ddxy(p, dst, dst_flags, GL_FALSE, args[0]);
+ break;
+
case OPCODE_DP3:
emit_dp3(p, dst, dst_flags, args[0], args[1]);
break;
c->fp_interp_emitted |= 1<<idx;
}
-static void emit_ddx( struct brw_wm_compile *c,
- const struct prog_instruction *inst )
-{
- GLuint idx = inst->SrcReg[0].Index;
- struct prog_src_register interp = src_reg(PROGRAM_PAYLOAD, idx);
-
- c->fp_deriv_emitted |= 1<<idx;
- emit_op(c,
- OPCODE_DDX,
- inst->DstReg,
- 0,
- interp,
- get_pixel_w(c),
- src_undef());
-}
-
-static void emit_ddy( struct brw_wm_compile *c,
- const struct prog_instruction *inst )
-{
- GLuint idx = inst->SrcReg[0].Index;
- struct prog_src_register interp = src_reg(PROGRAM_PAYLOAD, idx);
-
- c->fp_deriv_emitted |= 1<<idx;
- emit_op(c,
- OPCODE_DDY,
- inst->DstReg,
- 0,
- interp,
- get_pixel_w(c),
- src_undef());
-}
-
/***********************************************************************
* Hacks to extend the program parameter and constant lists.
*/
*/
out->DstReg.WriteMask = 0;
break;
- case OPCODE_DDX:
- emit_ddx(c, inst);
- break;
- case OPCODE_DDY:
- emit_ddy(c, inst);
- break;
case OPCODE_END:
emit_fb_write(c);
break;
GLboolean brw_wm_is_glsl(const struct gl_fragment_program *fp)
{
int i;
+
for (i = 0; i < fp->Base.NumInstructions; i++) {
const struct prog_instruction *inst = &fp->Base.Instructions[i];
switch (inst->Opcode) {
case OPCODE_CAL:
case OPCODE_BRK:
case OPCODE_RET:
- case OPCODE_DDX:
- case OPCODE_DDY:
case OPCODE_NOISE1:
case OPCODE_NOISE2:
case OPCODE_NOISE3:
int i, j;
struct brw_reg reg;
int urb_read_length = 0;
- GLuint inputs = FRAG_BIT_WPOS | c->fp_interp_emitted | c->fp_deriv_emitted;
+ GLuint inputs = FRAG_BIT_WPOS | c->fp_interp_emitted;
GLuint reg_index = 0;
memset(c->used_grf, GL_FALSE, sizeof(c->used_grf));
emit_sop(c, inst, BRW_CONDITIONAL_NEQ);
}
-static void emit_ddx(struct brw_wm_compile *c,
- const struct prog_instruction *inst)
-{
- struct brw_compile *p = &c->func;
- GLuint mask = inst->DstReg.WriteMask;
- struct brw_reg interp[4];
- struct brw_reg dst;
- struct brw_reg src0, w;
- GLuint nr, i;
- src0 = get_src_reg(c, inst, 0, 0);
- w = get_src_reg(c, inst, 1, 3);
- nr = src0.nr;
- interp[0] = brw_vec1_grf(nr, 0);
- interp[1] = brw_vec1_grf(nr, 4);
- interp[2] = brw_vec1_grf(nr+1, 0);
- interp[3] = brw_vec1_grf(nr+1, 4);
- brw_set_saturate(p, inst->SaturateMode != SATURATE_OFF);
- for(i = 0; i < 4; i++ ) {
- if (mask & (1<<i)) {
- dst = get_dst_reg(c, inst, i);
- brw_MOV(p, dst, interp[i]);
- brw_MUL(p, dst, dst, w);
- }
- }
- brw_set_saturate(p, 0);
-}
-
-static void emit_ddy(struct brw_wm_compile *c,
- const struct prog_instruction *inst)
-{
- struct brw_compile *p = &c->func;
- GLuint mask = inst->DstReg.WriteMask;
- struct brw_reg interp[4];
- struct brw_reg dst;
- struct brw_reg src0, w;
- GLuint nr, i;
-
- src0 = get_src_reg(c, inst, 0, 0);
- nr = src0.nr;
- w = get_src_reg(c, inst, 1, 3);
- interp[0] = brw_vec1_grf(nr, 0);
- interp[1] = brw_vec1_grf(nr, 4);
- interp[2] = brw_vec1_grf(nr+1, 0);
- interp[3] = brw_vec1_grf(nr+1, 4);
- brw_set_saturate(p, inst->SaturateMode != SATURATE_OFF);
- for(i = 0; i < 4; i++ ) {
- if (mask & (1<<i)) {
- dst = get_dst_reg(c, inst, i);
- brw_MOV(p, dst, suboffset(interp[i], 1));
- brw_MUL(p, dst, dst, w);
- }
- }
- brw_set_saturate(p, 0);
-}
-
static INLINE struct brw_reg high_words( struct brw_reg reg )
{
return stride( suboffset( retype( reg, BRW_REGISTER_TYPE_W ), 1 ),
brw_resolve_cals(&c->func);
}
+static void
+get_argument_regs(struct brw_wm_compile *c,
+ const struct prog_instruction *inst,
+ int index,
+ struct brw_reg *regs,
+ int mask)
+{
+ int i;
+
+ for (i = 0; i < 4; i++) {
+ if (mask & (1 << i))
+ regs[i] = get_src_reg(c, inst, index, i);
+ }
+}
+
static void brw_wm_emit_glsl(struct brw_context *brw, struct brw_wm_compile *c)
{
#define MAX_IF_DEPTH 32
for (i = 0; i < c->nr_fp_insns; i++) {
const struct prog_instruction *inst = &c->prog_instructions[i];
+ int dst_flags;
+ struct brw_reg args[3][4], dst[4];
+ int j;
c->cur_inst = i;
else
brw_set_conditionalmod(p, BRW_CONDITIONAL_NONE);
+ dst_flags = inst->DstReg.WriteMask;
+ if (inst->SaturateMode == SATURATE_ZERO_ONE)
+ dst_flags |= SATURATE;
+
switch (inst->Opcode) {
case WM_PIXELXY:
emit_pixel_xy(c, inst);
emit_min_max(c, inst);
break;
case OPCODE_DDX:
- emit_ddx(c, inst);
- break;
case OPCODE_DDY:
- emit_ddy(c, inst);
+ for (j = 0; j < 4; j++) {
+ if (inst->DstReg.WriteMask & (1 << j))
+ dst[j] = get_dst_reg(c, inst, j);
+ else
+ dst[j] = brw_null_reg();
+ }
+ get_argument_regs(c, inst, 0, args[0], WRITEMASK_XYZW);
+ emit_ddxy(p, dst, dst_flags, (inst->Opcode == OPCODE_DDX),
+ args[0]);
break;
case OPCODE_SLT:
emit_slt(c, inst);
read1 = writemask;
break;
+ case OPCODE_DDX:
+ case OPCODE_DDY:
+ read0 = writemask;
+ break;
+
case OPCODE_MAD:
case OPCODE_CMP:
case OPCODE_LRP:
/* as far as we can tell */
key->computes_depth =
(fp->Base.OutputsWritten & (1 << FRAG_RESULT_DEPTH)) != 0;
+ /* BRW_NEW_DEPTH_BUFFER
+ * Override for NULL depthbuffer case, required by the Pixel Shader Computed
+ * Depth field.
+ */
+ if (brw->state.depth_region == NULL)
+ key->computes_depth = 0;
/* _NEW_COLOR */
key->uses_kill = fp->UsesKill || ctx->Color.AlphaEnabled;
.brw = (BRW_NEW_FRAGMENT_PROGRAM |
BRW_NEW_CURBE_OFFSETS |
+ BRW_NEW_DEPTH_BUFFER |
BRW_NEW_NR_WM_SURFACES),
.cache = (CACHE_NEW_WM_PROG |
irb->texformat->MesaFormat);
}
key.tiling = region->tiling;
- key.width = region->width;
- key.height = region->height;
+ if (brw->intel.intelScreen->driScrnPriv->dri2.enabled) {
+ key.width = rb->Width;
+ key.height = rb->Height;
+ } else {
+ key.width = region->width;
+ key.height = region->height;
+ }
key.pitch = region->pitch;
key.cpp = region->cpp;
key.draw_offset = region->draw_offset; /* cur 3d or cube face offset */
} else {
key.surface_type = BRW_SURFACE_NULL;
key.surface_format = BRW_SURFACEFORMAT_B8G8R8A8_UNORM;
- key.tiling = 0;
+ key.tiling = I915_TILING_X;
key.width = 1;
key.height = 1;
key.cpp = 4;
drm_intel_bo_emit_reloc(brw->wm.surf_bo[unit],
offsetof(struct brw_surface_state, ss1),
region_bo,
- surf.ss1.base_addr,
+ surf.ss1.base_addr - region_bo->offset,
I915_GEM_DOMAIN_RENDER,
I915_GEM_DOMAIN_RENDER);
}
**************************************************************************/
-#include <stdio.h>
-#include <errno.h>
-
#include "main/mtypes.h"
#include "main/context.h"
#include "main/enums.h"
#define PCI_CHIP_Q45_G 0x2E12
#define PCI_CHIP_G45_G 0x2E22
#define PCI_CHIP_G41_G 0x2E32
+#define PCI_CHIP_B43_G 0x2E42
#define PCI_CHIP_ILD_G 0x0042
#define PCI_CHIP_ILM_G 0x0046
#define IS_G45(devid) (devid == PCI_CHIP_IGD_E_G || \
devid == PCI_CHIP_Q45_G || \
devid == PCI_CHIP_G45_G || \
- devid == PCI_CHIP_G41_G)
+ devid == PCI_CHIP_G41_G || \
+ devid == PCI_CHIP_B43_G)
#define IS_GM45(devid) (devid == PCI_CHIP_GM45_GM)
#define IS_G4X(devid) (IS_G45(devid) || IS_GM45(devid))
case PCI_CHIP_G41_G:
chipset = "Intel(R) G41";
break;
+ case PCI_CHIP_B43_G:
+ chipset = "Intel(R) B43";
+ break;
case PCI_CHIP_ILD_G:
chipset = "Intel(R) IGDNG_D";
break;
intel->maxBatchSize = BATCH_SZ;
intel->bufmgr = intelScreen->bufmgr;
-
- if (0) /* for debug */
- drm_intel_bufmgr_set_debug(intel->bufmgr, 1);
-
intel->ttm = intelScreen->ttm;
if (intel->ttm) {
int bo_reuse_mode;
#define need_GL_ARB_copy_buffer
+#define need_GL_ARB_draw_elements_base_vertex
#define need_GL_ARB_framebuffer_object
#define need_GL_ARB_map_buffer_range
#define need_GL_ARB_occlusion_query
*/
static const struct dri_extension card_extensions[] = {
{ "GL_ARB_copy_buffer", GL_ARB_copy_buffer_functions },
+ { "GL_ARB_draw_elements_base_vertex", GL_ARB_draw_elements_base_vertex_functions },
{ "GL_ARB_half_float_pixel", NULL },
{ "GL_ARB_map_buffer_range", GL_ARB_map_buffer_range_functions },
{ "GL_ARB_multitexture", NULL },
/** i965-only extensions */
static const struct dri_extension brw_extensions[] = {
+ { "GL_ARB_depth_clamp", NULL },
{ "GL_ARB_depth_texture", NULL },
{ "GL_ARB_fragment_program", NULL },
{ "GL_ARB_fragment_program_shadow", NULL },
if (!dst)
return GL_FALSE;
- if (unpack->BufferObj->Name) {
+ if (_mesa_is_bufferobj(unpack->BufferObj)) {
bitmap = map_pbo(ctx, width, height, unpack, bitmap);
if (bitmap == NULL)
return GL_TRUE; /* even though this is an error, we're done */
if (INTEL_DEBUG & DEBUG_SYNC)
intel_batchbuffer_flush(intel->batch);
- if (unpack->BufferObj->Name) {
+ if (_mesa_is_bufferobj(unpack->BufferObj)) {
/* done with PBO so unmap it now */
ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT,
unpack->BufferObj);
return GL_FALSE;
}
- if (unpack->BufferObj->Name) {
+ if (_mesa_is_bufferobj(unpack->BufferObj)) {
bitmap = map_pbo(ctx, width, height, unpack, bitmap);
if (bitmap == NULL)
return GL_TRUE; /* even though this is an error, we're done */
a8_bitmap = _mesa_calloc(width * height);
_mesa_expand_bitmap(width, height, unpack, bitmap, a8_bitmap, width, 0xff);
- if (unpack->BufferObj->Name) {
+ if (_mesa_is_bufferobj(unpack->BufferObj)) {
/* done with PBO so unmap it now */
ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT,
unpack->BufferObj);
#include "main/depth.h"
#include "main/hash.h"
#include "main/blend.h"
+#include "swrast/swrast.h"
#include "drivers/common/meta.h"
#include "intel_context.h"
const struct gl_pixelstore_attrib *unpack,
const GLvoid * pixels)
{
+#if 0
+ /* XXX this function doesn't seem to work reliably even when all
+ * the pre-requisite conditions are met.
+ * Note that this function is never hit with conform.
+ * Fall back to swrast because even the _mesa_meta_draw_pixels() approach
+ * isn't working because of an apparent stencil bug.
+ */
if (intel_stencil_drawpixels(ctx, x, y, width, height, format, type,
unpack, pixels))
return;
+#else
+ (void) intel_stencil_drawpixels; /* silence warning */
+ if (format == GL_STENCIL_INDEX) {
+ _swrast_DrawPixels(ctx, x, y, width, height, format, type,
+ unpack, pixels);
+ return;
+ }
+#endif
_mesa_meta_draw_pixels(ctx, x, y, width, height, format, type,
unpack, pixels);
if (!src)
return GL_FALSE;
- if (pack->BufferObj->Name) {
- /* XXX This validation should be done by core mesa:
- */
- if (!_mesa_validate_pbo_access(2, pack, width, height, 1,
- format, type, pixels)) {
- _mesa_error(ctx, GL_INVALID_OPERATION, "glDrawPixels");
- return GL_TRUE;
- }
- }
- else {
+ if (!_mesa_is_bufferobj(pack->BufferObj)) {
/* PBO only for now:
*/
if (INTEL_DEBUG & DEBUG_PIXEL)
else
height = ALIGN(height, 2);
+ /* If we're untiled, we have to align to 2 rows high because the
+ * data port accesses 2x2 blocks even if the bottom row isn't to be
+ * rendered, so failure to align means we could walk off the end of the
+ * GTT and fault.
+ */
+ height = ALIGN(height, 2);
+
if (expect_accelerated_upload) {
buffer = drm_intel_bo_alloc_for_render(intel->bufmgr, "region",
pitch * cpp * height, 64);
* _ColorReadBuffer, _DepthBuffer or _StencilBuffer fields.
*/
static void
-intel_map_unmap_buffers(struct intel_context *intel, GLboolean map)
+intel_map_unmap_framebuffer(struct intel_context *intel,
+ struct gl_framebuffer *fb,
+ GLboolean map)
{
GLcontext *ctx = &intel->ctx;
GLuint i, j;
- /* color draw buffers */
- for (j = 0; j < ctx->DrawBuffer->_NumColorDrawBuffers; j++) {
+ /* color buffers */
+ if (fb == ctx->DrawBuffer) {
+ for (j = 0; j < fb->_NumColorDrawBuffers; j++) {
+ if (map)
+ intel_renderbuffer_map(intel, fb->_ColorDrawBuffers[j]);
+ else
+ intel_renderbuffer_unmap(intel, fb->_ColorDrawBuffers[j]);
+ }
+ } else {
if (map)
- intel_renderbuffer_map(intel, ctx->DrawBuffer->_ColorDrawBuffers[j]);
+ intel_renderbuffer_map(intel, fb->_ColorReadBuffer);
else
- intel_renderbuffer_unmap(intel, ctx->DrawBuffer->_ColorDrawBuffers[j]);
+ intel_renderbuffer_unmap(intel, fb->_ColorReadBuffer);
}
/* check for render to textures */
for (i = 0; i < BUFFER_COUNT; i++) {
struct gl_renderbuffer_attachment *att =
- ctx->DrawBuffer->Attachment + i;
+ fb->Attachment + i;
struct gl_texture_object *tex = att->Texture;
if (tex) {
/* render to texture */
}
}
- /* color read buffers */
- if (map)
- intel_renderbuffer_map(intel, ctx->ReadBuffer->_ColorReadBuffer);
- else
- intel_renderbuffer_unmap(intel, ctx->ReadBuffer->_ColorReadBuffer);
-
/* depth buffer (Note wrapper!) */
- if (ctx->DrawBuffer->_DepthBuffer) {
+ if (fb->_DepthBuffer) {
if (map)
- intel_renderbuffer_map(intel, ctx->DrawBuffer->_DepthBuffer->Wrapped);
+ intel_renderbuffer_map(intel, fb->_DepthBuffer->Wrapped);
else
intel_renderbuffer_unmap(intel,
- ctx->DrawBuffer->_DepthBuffer->Wrapped);
+ fb->_DepthBuffer->Wrapped);
}
/* stencil buffer (Note wrapper!) */
- if (ctx->DrawBuffer->_StencilBuffer) {
+ if (fb->_StencilBuffer) {
if (map)
intel_renderbuffer_map(intel,
- ctx->DrawBuffer->_StencilBuffer->Wrapped);
+ fb->_StencilBuffer->Wrapped);
else
intel_renderbuffer_unmap(intel,
- ctx->DrawBuffer->_StencilBuffer->Wrapped);
+ fb->_StencilBuffer->Wrapped);
}
}
-
-
/**
* Prepare for software rendering. Map current read/draw framebuffers'
* renderbuffes and all currently bound texture objects.
}
}
- intel_map_unmap_buffers(intel, GL_TRUE);
+ intel_map_unmap_framebuffer(intel, ctx->DrawBuffer, GL_TRUE);
+ intel_map_unmap_framebuffer(intel, ctx->ReadBuffer, GL_TRUE);
}
/**
}
}
- intel_map_unmap_buffers(intel, GL_FALSE);
+ intel_map_unmap_framebuffer(intel, ctx->DrawBuffer, GL_FALSE);
+ intel_map_unmap_framebuffer(intel, ctx->ReadBuffer, GL_FALSE);
UNLOCK_HARDWARE(intel);
}
intel_YTile_InitStencilPointers_z24_s8(rb);
break;
}
+ } else {
+ _mesa_problem(NULL,
+ "Unexpected ActualFormat in intelSetSpanFunctions");
}
break;
default:
-#include <stdlib.h>
-#include <stdio.h>
-
#include "main/glheader.h"
#include "main/macros.h"
#include "main/mtypes.h"
#include "main/enums.h"
-#include "main/colortab.h"
+#include "main/bufferobj.h"
#include "main/convolve.h"
#include "main/context.h"
-#include "main/simple_list.h"
#include "main/texcompress.h"
#include "main/texformat.h"
#include "main/texgetimage.h"
GLuint src_offset, src_stride;
GLuint dst_offset, dst_stride;
- if (unpack->BufferObj->Name == 0 ||
+ if (!_mesa_is_bufferobj(unpack->BufferObj) ||
intel->ctx._ImageTransferState ||
unpack->SkipPixels || unpack->SkipRows) {
DBG("%s: failure 1\n", __FUNCTION__);
GLuint src_offset, src_stride;
GLuint dst_offset, dst_stride;
- if (unpack->BufferObj->Name == 0 ||
+ if (!_mesa_is_bufferobj(unpack->BufferObj) ||
intel->ctx._ImageTransferState ||
unpack->SkipPixels || unpack->SkipRows) {
DBG("%s: failure 1\n", __FUNCTION__);
*/
if (dims <= 2 &&
intelImage->mt &&
- unpack->BufferObj->Name != 0 &&
+ _mesa_is_bufferobj(unpack->BufferObj) &&
check_pbo_format(internalFormat, format,
type, intelImage->base.TexFormat)) {
r300->hw.rb3d_dither_ctl.cmd[0] = cmdpacket0(r300->radeon.radeonScreen, R300_RB3D_DITHER_CTL, 9);
ALLOC_STATE(rb3d_aaresolve_ctl, always, 2, 0);
r300->hw.rb3d_aaresolve_ctl.cmd[0] = cmdpacket0(r300->radeon.radeonScreen, R300_RB3D_AARESOLVE_CTL, 1);
- if ((r300->radeon.radeonScreen->chip_family >= CHIP_FAMILY_RV515) ||
- ( !r300->radeon.radeonScreen->kernel_mm && (
- (r300->radeon.radeonScreen->chip_family == CHIP_FAMILY_RS400) ||
- (r300->radeon.radeonScreen->chip_family == CHIP_FAMILY_RV410) ||
- (r300->radeon.radeonScreen->chip_family == CHIP_FAMILY_R420) ) ) ) {
+ if (r300->radeon.radeonScreen->chip_family >= CHIP_FAMILY_RV350) {
ALLOC_STATE(rb3d_discard_src_pixel_lte_threshold, always, 3, 0);
} else {
ALLOC_STATE(rb3d_discard_src_pixel_lte_threshold, never, 3, 0);
ALLOC_STATE(zs, always, R300_ZS_CMDSIZE, 0);
r300->hw.zs.cmd[R300_ZS_CMD_0] =
cmdpacket0(r300->radeon.radeonScreen, R300_ZB_CNTL, 3);
+ if (is_r500) {
+ if (r300->radeon.radeonScreen->kernel_mm)
+ ALLOC_STATE(zsb, always, R300_ZSB_CMDSIZE, 0);
+ else
+ ALLOC_STATE(zsb, never, R300_ZSB_CMDSIZE, 0);
+ r300->hw.zsb.cmd[R300_ZSB_CMD_0] =
+ cmdpacket0(r300->radeon.radeonScreen, R500_ZB_STENCILREFMASK_BF, 1);
+ }
ALLOC_STATE(zstencil_format, always, 5, 0);
r300->hw.zstencil_format.cmd[0] =
#define R300_ZS_CNTL_2 3
#define R300_ZS_CMDSIZE 4
+#define R300_ZSB_CMD_0 0
+#define R300_ZSB_CNTL_0 1
+#define R300_ZSB_CMDSIZE 2
+
#define R300_ZB_CMD_0 0
#define R300_ZB_OFFSET 1
#define R300_ZB_PITCH 2
struct radeon_state_atom rb3d_aaresolve_ctl; /* (4E88) */
struct radeon_state_atom rb3d_discard_src_pixel_lte_threshold; /* (4E88) I saw it only written on RV350 hardware.. */
struct radeon_state_atom zs; /* zstencil control (4F00) */
+ struct radeon_state_atom zsb; /* zstencil bf */
struct radeon_state_atom zstencil_format;
struct radeon_state_atom zb; /* z buffer (4F20) */
struct radeon_state_atom zb_depthclearvalue; /* (4F28) */
# define R300_Z_WRITE_ENABLE (1 << 2)
# define R300_Z_SIGNED_COMPARE (1 << 3)
# define R300_STENCIL_FRONT_BACK (1 << 4)
+# define R400_ZSIGNED_MAGNITUDE (1 << 5)
+# define R500_STENCIL_REFMASK_FRONT_BACK (1 << 6)
#define R300_ZB_ZSTENCILCNTL 0x4f04
/* functions */
r300ContextPtr r300 = R300_CONTEXT(ctx);
R300_STATECHANGE(r300, zs);
- r300->hw.zs.cmd[R300_ZS_CNTL_0] &= R300_STENCIL_ENABLE|R300_STENCIL_FRONT_BACK;
+ r300->hw.zs.cmd[R300_ZS_CNTL_0] &= (R300_STENCIL_ENABLE |
+ R300_STENCIL_FRONT_BACK |
+ R500_STENCIL_REFMASK_FRONT_BACK);
r300->hw.zs.cmd[R300_ZS_CNTL_1] &= ~(R300_ZS_MASK << R300_Z_FUNC_SHIFT);
if (ctx->Depth.Test) {
static void r300CatchStencilFallback(GLcontext *ctx)
{
+ r300ContextPtr rmesa = R300_CONTEXT(ctx);
const unsigned back = ctx->Stencil._BackFace;
- if (ctx->Stencil._Enabled && (ctx->Stencil.Ref[0] != ctx->Stencil.Ref[back]
- || ctx->Stencil.ValueMask[0] != ctx->Stencil.ValueMask[back]
- || ctx->Stencil.WriteMask[0] != ctx->Stencil.WriteMask[back])) {
+ if (rmesa->radeon.radeonScreen->kernel_mm &&
+ (rmesa->radeon.radeonScreen->chip_family >= CHIP_FAMILY_RV515)) {
+ r300SwitchFallback(ctx, R300_FALLBACK_STENCIL_TWOSIDE, GL_FALSE);
+ } else if (ctx->Stencil._Enabled &&
+ (ctx->Stencil.Ref[0] != ctx->Stencil.Ref[back]
+ || ctx->Stencil.ValueMask[0] != ctx->Stencil.ValueMask[back]
+ || ctx->Stencil.WriteMask[0] != ctx->Stencil.WriteMask[back])) {
r300SwitchFallback(ctx, R300_FALLBACK_STENCIL_TWOSIDE, GL_TRUE);
} else {
r300SwitchFallback(ctx, R300_FALLBACK_STENCIL_TWOSIDE, GL_FALSE);
rmesa->hw.zs.cmd[R300_ZS_CNTL_1] |=
(flag << R300_S_BACK_FUNC_SHIFT);
rmesa->hw.zs.cmd[R300_ZS_CNTL_2] |= refmask;
+
+ if (rmesa->radeon.radeonScreen->chip_family >= CHIP_FAMILY_RV515) {
+ rmesa->hw.zs.cmd[R300_ZS_CNTL_0] |= R500_STENCIL_REFMASK_FRONT_BACK;
+ R300_STATECHANGE(rmesa, zsb);
+ refmask = ((ctx->Stencil.Ref[back] & 0xff) << R300_STENCILREF_SHIFT)
+ | ((ctx->Stencil.ValueMask[back] & 0xff) << R300_STENCILMASK_SHIFT);
+
+ rmesa->hw.zsb.cmd[R300_ZSB_CNTL_0] &=
+ ~((R300_STENCILREF_MASK << R300_STENCILREF_SHIFT) |
+ (R300_STENCILREF_MASK << R300_STENCILMASK_SHIFT));
+ rmesa->hw.zsb.cmd[R300_ZSB_CNTL_0] |= refmask;
+ }
}
static void r300StencilMaskSeparate(GLcontext * ctx, GLenum face, GLuint mask)
{
r300ContextPtr rmesa = R300_CONTEXT(ctx);
+ const unsigned back = ctx->Stencil._BackFace;
r300CatchStencilFallback(ctx);
(ctx->Stencil.
WriteMask[0] & R300_STENCILREF_MASK) <<
R300_STENCILWRITEMASK_SHIFT;
+ if (rmesa->radeon.radeonScreen->chip_family >= CHIP_FAMILY_RV515) {
+ R300_STATECHANGE(rmesa, zsb);
+ rmesa->hw.zsb.cmd[R300_ZSB_CNTL_0] |=
+ (ctx->Stencil.
+ WriteMask[back] & R300_STENCILREF_MASK) <<
+ R300_STENCILWRITEMASK_SHIFT;
+ }
}
static void r300StencilOpSeparate(GLcontext * ctx, GLenum face,
#include "r700_chip.h"
#include "r600_tex.h"
#include "r700_oglprog.h"
+#include "r700_vertprog.h"
struct r600_context;
typedef struct r600_context context_t;
struct r600_hw_state atoms;
+ struct r700_vertex_program *selected_vp;
+
/* Vertex buffers
*/
GLvector4f dummy_attrib[_TNL_ATTRIB_MAX];
for (unit = 0; unit < R700_MAX_TEXTURE_UNITS; unit++) {
texUnit = &ctx->Texture.Unit[unit];
t = radeon_tex_obj(ctx->Texture.Unit[unit]._Current);
-
+ r700->textures[unit] = NULL;
if (texUnit->_ReallyEnabled) {
if (!t)
continue;
int firstlevel = t->mt ? t->mt->firstLevel : 0;
GLuint uTexelPitch, row_align;
+ if (rmesa->radeon.radeonScreen->driScreen->dri2.enabled &&
+ t->image_override &&
+ t->bo)
+ return;
+
firstImage = t->base.Image[0][firstlevel];
if (!t->image_override) {
GLboolean tex_src(r700_AssemblerBase *pAsm)
{
struct prog_instruction *pILInst = &(pAsm->pILInst[pAsm->uiCurInst]);
-
+
GLboolean bValidTexCoord = GL_FALSE;
- switch (pILInst->SrcReg[0].File)
- {
+ switch (pILInst->SrcReg[0].File) {
+ case PROGRAM_CONSTANT:
+ case PROGRAM_LOCAL_PARAM:
+ case PROGRAM_ENV_PARAM:
+ case PROGRAM_STATE_VAR:
+ bValidTexCoord = GL_TRUE;
+ setaddrmode_PVSSRC(&(pAsm->S[0].src), ADDR_ABSOLUTE);
+ pAsm->S[0].src.rtype = SRC_REG_TEMPORARY;
+ pAsm->S[0].src.reg = pAsm->aArgSubst[1];
+ break;
case PROGRAM_TEMPORARY:
- bValidTexCoord = GL_TRUE;
-
- pAsm->S[0].src.reg = pILInst->SrcReg[0].Index + pAsm->starting_temp_register_number;
- pAsm->S[0].src.rtype = SRC_REG_TEMPORARY;
-
- break;
+ bValidTexCoord = GL_TRUE;
+ pAsm->S[0].src.reg = pILInst->SrcReg[0].Index +
+ pAsm->starting_temp_register_number;
+ pAsm->S[0].src.rtype = SRC_REG_TEMPORARY;
+ break;
case PROGRAM_INPUT:
- switch (pILInst->SrcReg[0].Index)
- {
- case FRAG_ATTRIB_COL0:
- case FRAG_ATTRIB_COL1:
- case FRAG_ATTRIB_TEX0:
- case FRAG_ATTRIB_TEX1:
- case FRAG_ATTRIB_TEX2:
- case FRAG_ATTRIB_TEX3:
- case FRAG_ATTRIB_TEX4:
- case FRAG_ATTRIB_TEX5:
- case FRAG_ATTRIB_TEX6:
- case FRAG_ATTRIB_TEX7:
- bValidTexCoord = GL_TRUE;
-
- pAsm->S[0].src.reg = pAsm->uiFP_AttributeMap[pILInst->SrcReg[0].Index];
- pAsm->S[0].src.rtype = SRC_REG_INPUT;
- }
- break;
+ switch (pILInst->SrcReg[0].Index)
+ {
+ case FRAG_ATTRIB_COL0:
+ case FRAG_ATTRIB_COL1:
+ case FRAG_ATTRIB_TEX0:
+ case FRAG_ATTRIB_TEX1:
+ case FRAG_ATTRIB_TEX2:
+ case FRAG_ATTRIB_TEX3:
+ case FRAG_ATTRIB_TEX4:
+ case FRAG_ATTRIB_TEX5:
+ case FRAG_ATTRIB_TEX6:
+ case FRAG_ATTRIB_TEX7:
+ bValidTexCoord = GL_TRUE;
+ pAsm->S[0].src.reg =
+ pAsm->uiFP_AttributeMap[pILInst->SrcReg[0].Index];
+ pAsm->S[0].src.rtype = SRC_REG_INPUT;
+ break;
+ }
+ break;
}
if(GL_TRUE == bValidTexCoord)
- {
+ {
setaddrmode_PVSSRC(&(pAsm->S[0].src), ADDR_ABSOLUTE);
}
else
pAsm->S[0].src.negy = (pILInst->SrcReg[0].Negate >> 1) & 0x1;
pAsm->S[0].src.negz = (pILInst->SrcReg[0].Negate >> 2) & 0x1;
pAsm->S[0].src.negw = (pILInst->SrcReg[0].Negate >> 3) & 0x1;
-
+
return GL_TRUE;
}
{
struct prog_instruction *pILInst = &(pAsm->pILInst[pAsm->uiCurInst]);
- if( GL_TRUE == IsTex(pILInst->Opcode) )
+ if( GL_TRUE == IsTex(pILInst->Opcode) &&
+ /* handle const moves to temp register */
+ !(pAsm->D.dst.opcode == SQ_OP2_INST_MOV) )
{
if (pILInst->TexSrcTarget == TEXTURE_RECT_INDEX) {
if( GL_FALSE == assemble_tex_instruction(pAsm, GL_FALSE) )
case PROGRAM_ENV_PARAM:
case PROGRAM_STATE_VAR:
src_const = GL_TRUE;
+ break;
case PROGRAM_TEMPORARY:
case PROGRAM_INPUT:
src_const = GL_FALSE;
+ break;
}
- if (GL_TRUE == src_const)
+ if (GL_TRUE == src_const)
{
- radeon_error("TODO: Texture coordinates from a constant register not supported.\n");
- return GL_FALSE;
+ if ( GL_FALSE == mov_temp(pAsm, 0) )
+ return GL_FALSE;
}
- switch (pAsm->pILInst[pAsm->uiCurInst].Opcode)
+ switch (pAsm->pILInst[pAsm->uiCurInst].Opcode)
{
case OPCODE_TEX:
- pAsm->D.dst.opcode = SQ_TEX_INST_SAMPLE;
+ pAsm->D.dst.opcode = SQ_TEX_INST_SAMPLE;
break;
- case OPCODE_TXB:
+ case OPCODE_TXB:
radeon_error("do not support TXB yet\n");
return GL_FALSE;
break;
- case OPCODE_TXP:
- /* TODO : tex proj version : divid first 3 components by 4th */
+ case OPCODE_TXP:
+ /* TODO : tex proj version : divid first 3 components by 4th */
pAsm->D.dst.opcode = SQ_TEX_INST_SAMPLE;
break;
default:
{
return GL_FALSE;
}
-
+
if( GL_FALSE == tex_src(pAsm) )
{
return GL_FALSE;
}
- if ( GL_FALSE == next_ins(pAsm) )
+ if ( GL_FALSE == next_ins(pAsm) )
{
return GL_FALSE;
}
radeon_print(RADEON_STATE, RADEON_VERBOSE, "%s\n", __func__);
for (i = 0; i < R700_TEXTURE_NUMBERUNITS; i++) {
- radeonTexObj *t = r700->textures[i];
- if (t) {
- if (!t->image_override)
- bo = t->mt->bo;
- else
- bo = t->bo;
- if (bo) {
-
- r700SyncSurf(context, bo,
- RADEON_GEM_DOMAIN_GTT|RADEON_GEM_DOMAIN_VRAM,
- 0, TC_ACTION_ENA_bit);
-
- BEGIN_BATCH_NO_AUTOSTATE(9 + 4);
- R600_OUT_BATCH(CP_PACKET3(R600_IT_SET_RESOURCE, 7));
- R600_OUT_BATCH(i * 7);
- R600_OUT_BATCH(r700->textures[i]->SQ_TEX_RESOURCE0);
- R600_OUT_BATCH(r700->textures[i]->SQ_TEX_RESOURCE1);
- R600_OUT_BATCH(r700->textures[i]->SQ_TEX_RESOURCE2);
- R600_OUT_BATCH(r700->textures[i]->SQ_TEX_RESOURCE3);
- R600_OUT_BATCH(r700->textures[i]->SQ_TEX_RESOURCE4);
- R600_OUT_BATCH(r700->textures[i]->SQ_TEX_RESOURCE5);
- R600_OUT_BATCH(r700->textures[i]->SQ_TEX_RESOURCE6);
- R600_OUT_BATCH_RELOC(r700->textures[i]->SQ_TEX_RESOURCE2,
- bo,
- 0,
- RADEON_GEM_DOMAIN_GTT|RADEON_GEM_DOMAIN_VRAM, 0, 0);
- R600_OUT_BATCH_RELOC(r700->textures[i]->SQ_TEX_RESOURCE3,
- bo,
- r700->textures[i]->SQ_TEX_RESOURCE3,
- RADEON_GEM_DOMAIN_GTT|RADEON_GEM_DOMAIN_VRAM, 0, 0);
- END_BATCH();
- COMMIT_BATCH();
+ if (ctx->Texture.Unit[i]._ReallyEnabled) {
+ radeonTexObj *t = r700->textures[i];
+ if (t) {
+ if (!t->image_override)
+ bo = t->mt->bo;
+ else
+ bo = t->bo;
+ if (bo) {
+
+ r700SyncSurf(context, bo,
+ RADEON_GEM_DOMAIN_GTT|RADEON_GEM_DOMAIN_VRAM,
+ 0, TC_ACTION_ENA_bit);
+
+ BEGIN_BATCH_NO_AUTOSTATE(9 + 4);
+ R600_OUT_BATCH(CP_PACKET3(R600_IT_SET_RESOURCE, 7));
+ R600_OUT_BATCH(i * 7);
+ R600_OUT_BATCH(r700->textures[i]->SQ_TEX_RESOURCE0);
+ R600_OUT_BATCH(r700->textures[i]->SQ_TEX_RESOURCE1);
+ R600_OUT_BATCH(r700->textures[i]->SQ_TEX_RESOURCE2);
+ R600_OUT_BATCH(r700->textures[i]->SQ_TEX_RESOURCE3);
+ R600_OUT_BATCH(r700->textures[i]->SQ_TEX_RESOURCE4);
+ R600_OUT_BATCH(r700->textures[i]->SQ_TEX_RESOURCE5);
+ R600_OUT_BATCH(r700->textures[i]->SQ_TEX_RESOURCE6);
+ R600_OUT_BATCH_RELOC(r700->textures[i]->SQ_TEX_RESOURCE2,
+ bo,
+ 0,
+ RADEON_GEM_DOMAIN_GTT|RADEON_GEM_DOMAIN_VRAM, 0, 0);
+ R600_OUT_BATCH_RELOC(r700->textures[i]->SQ_TEX_RESOURCE3,
+ bo,
+ r700->textures[i]->SQ_TEX_RESOURCE3,
+ RADEON_GEM_DOMAIN_GTT|RADEON_GEM_DOMAIN_VRAM, 0, 0);
+ END_BATCH();
+ COMMIT_BATCH();
+ }
}
}
}
radeon_print(RADEON_STATE, RADEON_VERBOSE, "%s\n", __func__);
for (i = 0; i < R700_TEXTURE_NUMBERUNITS; i++) {
- radeonTexObj *t = r700->textures[i];
- if (t) {
- BEGIN_BATCH_NO_AUTOSTATE(5);
- R600_OUT_BATCH(CP_PACKET3(R600_IT_SET_SAMPLER, 3));
- R600_OUT_BATCH(i * 3);
- R600_OUT_BATCH(r700->textures[i]->SQ_TEX_SAMPLER0);
- R600_OUT_BATCH(r700->textures[i]->SQ_TEX_SAMPLER1);
- R600_OUT_BATCH(r700->textures[i]->SQ_TEX_SAMPLER2);
- END_BATCH();
- COMMIT_BATCH();
+ if (ctx->Texture.Unit[i]._ReallyEnabled) {
+ radeonTexObj *t = r700->textures[i];
+ if (t) {
+ BEGIN_BATCH_NO_AUTOSTATE(5);
+ R600_OUT_BATCH(CP_PACKET3(R600_IT_SET_SAMPLER, 3));
+ R600_OUT_BATCH(i * 3);
+ R600_OUT_BATCH(r700->textures[i]->SQ_TEX_SAMPLER0);
+ R600_OUT_BATCH(r700->textures[i]->SQ_TEX_SAMPLER1);
+ R600_OUT_BATCH(r700->textures[i]->SQ_TEX_SAMPLER2);
+ END_BATCH();
+ COMMIT_BATCH();
+ }
}
}
}
radeon_print(RADEON_STATE, RADEON_VERBOSE, "%s\n", __func__);
for (i = 0; i < R700_TEXTURE_NUMBERUNITS; i++) {
- radeonTexObj *t = r700->textures[i];
- if (t) {
- BEGIN_BATCH_NO_AUTOSTATE(2 + 4);
- R600_OUT_BATCH_REGSEQ((TD_PS_SAMPLER0_BORDER_RED + (i * 16)), 4);
- R600_OUT_BATCH(r700->textures[i]->TD_PS_SAMPLER0_BORDER_RED);
- R600_OUT_BATCH(r700->textures[i]->TD_PS_SAMPLER0_BORDER_GREEN);
- R600_OUT_BATCH(r700->textures[i]->TD_PS_SAMPLER0_BORDER_BLUE);
- R600_OUT_BATCH(r700->textures[i]->TD_PS_SAMPLER0_BORDER_ALPHA);
- END_BATCH();
- COMMIT_BATCH();
+ if (ctx->Texture.Unit[i]._ReallyEnabled) {
+ radeonTexObj *t = r700->textures[i];
+ if (t) {
+ BEGIN_BATCH_NO_AUTOSTATE(2 + 4);
+ R600_OUT_BATCH_REGSEQ((TD_PS_SAMPLER0_BORDER_RED + (i * 16)), 4);
+ R600_OUT_BATCH(r700->textures[i]->TD_PS_SAMPLER0_BORDER_RED);
+ R600_OUT_BATCH(r700->textures[i]->TD_PS_SAMPLER0_BORDER_GREEN);
+ R600_OUT_BATCH(r700->textures[i]->TD_PS_SAMPLER0_BORDER_BLUE);
+ R600_OUT_BATCH(r700->textures[i]->TD_PS_SAMPLER0_BORDER_ALPHA);
+ END_BATCH();
+ COMMIT_BATCH();
+ }
}
}
}
void r700SetupStreams(GLcontext *ctx)
{
context_t *context = R700_CONTEXT(ctx);
- struct r700_vertex_program *vpc
- = (struct r700_vertex_program *)ctx->VertexProgram._Current;
+ struct r700_vertex_program *vp = context->selected_vp;
TNLcontext *tnl = TNL_CONTEXT(ctx);
struct vertex_buffer *vb = &tnl->vb;
unsigned int i, j = 0;
R600_STATECHANGE(context, vtx);
for(i=0; i<VERT_ATTRIB_MAX; i++) {
- if(vpc->mesa_program.Base.InputsRead & (1 << i)) {
+ if(vp->mesa_program->Base.InputsRead & (1 << i)) {
rcommon_emit_vector(ctx,
&context->radeon.tcl.aos[j],
vb->AttribPtr[i]->data,
static void r700SendVTXState(GLcontext *ctx, struct radeon_state_atom *atom)
{
context_t *context = R700_CONTEXT(ctx);
- struct r700_vertex_program *vpc
- = (struct r700_vertex_program *)ctx->VertexProgram._Current;
+ struct r700_vertex_program *vp = context->selected_vp;
unsigned int i, j = 0;
BATCH_LOCALS(&context->radeon);
radeon_print(RADEON_STATE, RADEON_VERBOSE, "%s\n", __func__);
COMMIT_BATCH();
for(i=0; i<VERT_ATTRIB_MAX; i++) {
- if(vpc->mesa_program.Base.InputsRead & (1 << i)) {
+ if(vp->mesa_program->Base.InputsRead & (1 << i)) {
/* currently aos are packed */
r700SetupVTXConstants(ctx,
i,
R700_CHIP_CONTEXT *r700 = (R700_CHIP_CONTEXT*)(&context->hw);
for (i = 0; i < R700_TEXTURE_NUMBERUNITS; i++) {
- radeonTexObj *t = r700->textures[i];
- if (t)
- count++;
+ if (ctx->Texture.Unit[i]._ReallyEnabled) {
+ radeonTexObj *t = r700->textures[i];
+ if (t)
+ count++;
+ }
}
radeon_print(RADEON_STATE, RADEON_TRACE, "%s %d\n", __func__, count);
return count * 31;
{
struct gl_program *pProgram = NULL;
- struct r700_vertex_program *vp;
+ struct r700_vertex_program_cont *vpc;
struct r700_fragment_program *fp;
radeon_print(RADEON_SHADER, RADEON_VERBOSE,
{
case GL_VERTEX_STATE_PROGRAM_NV:
case GL_VERTEX_PROGRAM_ARB:
- vp = CALLOC_STRUCT(r700_vertex_program);
+ vpc = CALLOC_STRUCT(r700_vertex_program_cont);
pProgram = _mesa_init_vertex_program(ctx,
- &vp->mesa_program,
+ &vpc->mesa_program,
target,
id);
- vp->translated = GL_FALSE;
- vp->loaded = GL_FALSE;
-
- vp->shaderbo = NULL;
-
break;
case GL_FRAGMENT_PROGRAM_NV:
case GL_FRAGMENT_PROGRAM_ARB:
static void r700DeleteProgram(GLcontext * ctx, struct gl_program *prog)
{
- struct r700_vertex_program * vp;
+ struct r700_vertex_program_cont * vpc;
+ struct r700_vertex_program *vp, *tmp;
struct r700_fragment_program * fp;
radeon_print(RADEON_SHADER, RADEON_VERBOSE,
{
case GL_VERTEX_STATE_PROGRAM_NV:
case GL_VERTEX_PROGRAM_ARB:
- vp = (struct r700_vertex_program*)prog;
- /* Release DMA region */
-
- r600DeleteShader(ctx, vp->shaderbo);
-
- /* Clean up */
- Clean_Up_Assembler(&(vp->r700AsmCode));
- Clean_Up_Shader(&(vp->r700Shader));
+ vpc = (struct r700_vertex_program_cont*)prog;
+ vp = vpc->progs;
+ while (vp) {
+ tmp = vp->next;
+ /* Release DMA region */
+
+ r600DeleteShader(ctx, vp->shaderbo);
+
+ /* Clean up */
+ Clean_Up_Assembler(&(vp->r700AsmCode));
+ Clean_Up_Shader(&(vp->r700Shader));
+ _mesa_free(vp);
+ vp = tmp;
+ }
break;
case GL_FRAGMENT_PROGRAM_NV:
case GL_FRAGMENT_PROGRAM_ARB:
{
context_t *context = R700_CONTEXT(ctx);
TNLcontext *tnl = TNL_CONTEXT(ctx);
- struct r700_vertex_program *vpc
- = (struct r700_vertex_program *)ctx->VertexProgram._Current;
+ struct r700_vertex_program *vp = context->selected_vp;
struct vertex_buffer *vb = &tnl->vb;
GLboolean flushed;
GLuint dwords, i;
GLuint state_size;
/* pre calculate aos count so state prediction works */
- context->radeon.tcl.aos_count = _mesa_bitcount(vpc->mesa_program.Base.InputsRead);
+ context->radeon.tcl.aos_count = _mesa_bitcount(vp->mesa_program->Base.InputsRead);
dwords = PRE_EMIT_STATE_BUFSZ;
for (i = 0; i < vb->PrimitiveCount; i++)
/* mark vtx as dirty since it changes per-draw */
R600_STATECHANGE(context, vtx);
- r700UpdateShaders(ctx);
r700SetScissor(context);
r700SetupVertexProgram(ctx);
r700SetupFragmentProgram(ctx);
/* TODO : sw fallback */
+ /* Need shader bo's setup before bo check */
+ r700UpdateShaders(ctx);
/**
+
* Ensure all enabled and complete textures are uploaded along with any buffers being used.
*/
if(!r600ValidateBuffers(ctx))
if (context->radeon.radeonScreen->driScreen->dri2.enabled) {
x1 = 0;
y1 = 0;
- x2 = rrb->base.Width - 1;
- y2 = rrb->base.Height - 1;
+ x2 = rrb->base.Width;
+ y2 = rrb->base.Height;
} else {
x1 = rrb->dPriv->x;
y1 = rrb->dPriv->y;
#include "main/mtypes.h"
#include "tnl/t_context.h"
+#include "shader/program.h"
#include "shader/prog_parameter.h"
#include "shader/prog_statevars.h"
return GL_TRUE;
}
-GLboolean r700TranslateVertexShader(struct r700_vertex_program *vp,
- struct gl_vertex_program *mesa_vp)
+struct r700_vertex_program* r700TranslateVertexShader(GLcontext *ctx,
+ struct gl_vertex_program *mesa_vp)
{
+ context_t *context = R700_CONTEXT(ctx);
+ struct r700_vertex_program *vp;
+ TNLcontext *tnl = TNL_CONTEXT(ctx);
+ struct vertex_buffer *vb = &tnl->vb;
+ unsigned int unBit;
+ unsigned int i;
+
+ vp = _mesa_calloc(sizeof(*vp));
+ vp->mesa_program = (struct gl_vertex_program *)_mesa_clone_program(ctx, &mesa_vp->Base);
+
+ for(i=0; i<VERT_ATTRIB_MAX; i++)
+ {
+ unBit = 1 << i;
+ if(vp->mesa_program->Base.InputsRead & unBit) /* ctx->Array.ArrayObj->xxxxxxx */
+ {
+ vp->aos_desc[i].size = vb->AttribPtr[i]->size;
+ vp->aos_desc[i].stride = vb->AttribPtr[i]->size * sizeof(GL_FLOAT);/* when emit array, data is packed. vb->AttribPtr[i]->stride;*/
+ vp->aos_desc[i].type = GL_FLOAT;
+ }
+ }
+
+ if (context->radeon.radeonScreen->chip_family < CHIP_FAMILY_RV770)
+ {
+ vp->r700AsmCode.bR6xx = 1;
+ }
+
//Init_Program
Init_r700_AssemblerBase(SPT_VP, &(vp->r700AsmCode), &(vp->r700Shader) );
Map_Vertex_Program( vp, mesa_vp );
if(GL_FALSE == Find_Instruction_Dependencies_vp(vp, mesa_vp))
{
- return GL_FALSE;
+ return NULL;
}
if(GL_FALSE == AssembleInstr(mesa_vp->Base.NumInstructions,
&(mesa_vp->Base.Instructions[0]),
&(vp->r700AsmCode)) )
{
- return GL_FALSE;
+ return NULL;
}
if(GL_FALSE == Process_Vertex_Exports(&(vp->r700AsmCode), mesa_vp->Base.OutputsWritten) )
{
- return GL_FALSE;
+ return NULL;
}
vp->r700Shader.nRegs = (vp->r700AsmCode.number_used_registers == 0) ? 0
vp->translated = GL_TRUE;
- return GL_TRUE;
+ return vp;
}
void r700SelectVertexShader(GLcontext *ctx)
{
context_t *context = R700_CONTEXT(ctx);
- struct r700_vertex_program *vpc
- = (struct r700_vertex_program *)ctx->VertexProgram._Current;
+ struct r700_vertex_program_cont *vpc;
+ struct r700_vertex_program *vp;
TNLcontext *tnl = TNL_CONTEXT(ctx);
struct vertex_buffer *vb = &tnl->vb;
unsigned int unBit;
unsigned int i;
+ GLboolean match;
+ vpc = (struct r700_vertex_program_cont *)ctx->VertexProgram._Current;
+
+#if 0
if (context->radeon.NewGLState & (_NEW_PROGRAM_CONSTANTS|_NEW_PROGRAM))
{
vpc->needUpdateVF = 1;
}
+#endif
- if (context->radeon.radeonScreen->chip_family < CHIP_FAMILY_RV770)
+ for (vp = vpc->progs; vp; vp = vp->next)
{
- vpc->r700AsmCode.bR6xx = 1;
- }
-
+ match = GL_TRUE;
for(i=0; i<VERT_ATTRIB_MAX; i++)
{
unBit = 1 << i;
- if(vpc->mesa_program.Base.InputsRead & unBit) /* ctx->Array.ArrayObj->xxxxxxx */
+ if(vpc->mesa_program.Base.InputsRead & unBit)
{
- vpc->aos_desc[i].size = vb->AttribPtr[i]->size;
- vpc->aos_desc[i].stride = vb->AttribPtr[i]->size * sizeof(GL_FLOAT);/* when emit array, data is packed. vb->AttribPtr[i]->stride;*/
- vpc->aos_desc[i].type = GL_FLOAT;
+ if (vp->aos_desc[i].size != vb->AttribPtr[i]->size)
+ match = GL_FALSE;
+ break;
}
}
-
- if(GL_FALSE == vpc->translated) {
- r700TranslateVertexShader(vpc, &(vpc->mesa_program) );
+ if (match)
+ {
+ context->selected_vp = vp;
+ return;
}
+ }
+
+ vp = r700TranslateVertexShader(ctx, &(vpc->mesa_program) );
+ if(!vp)
+ {
+ radeon_error("Failed to translate vertex shader. \n");
+ return;
+ }
+ vp->next = vpc->progs;
+ vpc->progs = vp;
+ context->selected_vp = vp;
+ return;
}
void * r700GetActiveVpShaderBo(GLcontext * ctx)
{
- struct r700_vertex_program *vp
- = (struct r700_vertex_program *)ctx->VertexProgram._Current;
+ context_t *context = R700_CONTEXT(ctx);
+ struct r700_vertex_program *vp = context->selected_vp;;
- return vp->shaderbo;
+ if (vp)
+ return vp->shaderbo;
+ else
+ return NULL;
}
GLboolean r700SetupVertexProgram(GLcontext * ctx)
{
context_t *context = R700_CONTEXT(ctx);
R700_CHIP_CONTEXT *r700 = (R700_CHIP_CONTEXT*)(&context->hw);
- struct r700_vertex_program *vp
- = (struct r700_vertex_program *)ctx->VertexProgram._Current;
+ struct r700_vertex_program *vp = context->selected_vp;
struct gl_program_parameter_list *paramList;
unsigned int unNumParamData;
unsigned int ui;
- if (vp->needUpdateVF)
- {
- vp->loaded = GL_FALSE;
- vp->r700Shader.bNeedsAssembly = GL_TRUE;
- Process_Vertex_Program_Vfetch_Instructions(vp, &(vp->mesa_program));
- r600DeleteShader(ctx, vp->shaderbo);
- }
-
if(GL_FALSE == vp->loaded)
{
if(vp->r700Shader.bNeedsAssembly == GL_TRUE)
*/
/* sent out shader constants. */
- paramList = vp->mesa_program.Base.Parameters;
+ paramList = vp->mesa_program->Base.Parameters;
if(NULL != paramList) {
_mesa_load_state_parameters(ctx, paramList);
struct r700_vertex_program
{
- struct gl_vertex_program mesa_program; /* Must be first */
+ struct gl_vertex_program *mesa_program; /* Must be first */
struct r700_vertex_program *next;
ArrayDesc aos_desc[VERT_ATTRIB_MAX];
};
+struct r700_vertex_program_cont
+{
+ struct gl_vertex_program mesa_program;
+
+ struct r700_vertex_program *progs;
+};
+
//Internal
unsigned int Map_Vertex_Output(r700_AssemblerBase *pAsm,
struct gl_vertex_program *mesa_vp,
GLboolean Find_Instruction_Dependencies_vp(struct r700_vertex_program *vp,
struct gl_vertex_program *mesa_vp);
-GLboolean r700TranslateVertexShader(struct r700_vertex_program *vp,
+struct r700_vertex_program* r700TranslateVertexShader(GLcontext *ctx,
struct gl_vertex_program *mesa_vp);
/* Interface */
UNLOCK_HARDWARE(rmesa);
if (ret) {
- fprintf(stderr, "drmRadeonCmdBuffer: %d\n", ret);
+ fprintf(stderr, "drmRadeonCmdBuffer: %d. Kernel failed to "
+ "parse or rejected command stream. See dmesg "
+ "for more info.\n", ret);
_mesa_exit(ret);
}
#include "radeon_debug.h"
#include "radeon_common_context.h"
+#include <stdarg.h>
+#include <stdio.h>
+
static const struct dri_debug_control debug_control[] = {
{"fall", RADEON_FALLBACKS},
{"tex", RADEON_TEXTURE},
}
}
-extern void _radeon_print(const radeon_debug_type_t type,
+void _radeon_print(const radeon_debug_type_t type,
const radeon_debug_level_t level,
const char* message,
- va_list values)
+ ...)
{
GET_CURRENT_CONTEXT(ctx);
if (ctx) {
if (radeon->debug.indent_depth)
fprintf(stderr, "%s", radeon->debug.indent);
}
+ va_list values;
+ va_start( values, message );
vfprintf(stderr, message, values);
+ va_end( values );
}
#ifndef RADEON_DEBUG_H_INCLUDED
#define RADEON_DEBUG_H_INCLUDED
-#include <stdarg.h>
-#include <stdio.h>
+#include <stdlib.h>
typedef enum radeon_debug_levels {
RADEON_CRITICAL = 0, /* Only errors */
extern void _radeon_print(const radeon_debug_type_t type,
const radeon_debug_level_t level,
const char* message,
- va_list values);
-/**
- * Format attribute requires declaration for setting it. Don't ask me why!
- */
-static inline void radeon_print(const radeon_debug_type_t type,
- const radeon_debug_level_t level,
- const char* message,
- ...) __attribute__((format(printf,3,4)));
-
+ ...) __attribute__((format(printf,3,4)));
/**
* Print out debug message if channel specified by type is enabled
* and compile time debugging level is at least as high as level parameter
*/
-static inline void radeon_print(const radeon_debug_type_t type,
- const radeon_debug_level_t level,
- const char* message,
- ...)
-{
- /* Compile out if level of message is too high */
- if (radeon_is_debug_enabled(type, level)) {
-
- va_list values;
- va_start( values, message );
- _radeon_print(type, level, message, values);
- va_end( values );
- }
-}
+#define radeon_print(type, level, message, ...) do { \
+ const radeon_debug_level_t _debug_level = (level); \
+ const radeon_debug_type_t _debug_type = (type); \
+ /* Compile out if level of message is too high */ \
+ if (radeon_is_debug_enabled(type, level)) { \
+ _radeon_print(_debug_type, _debug_level, \
+ (message), ## __VA_ARGS__); \
+ } \
+} while(0)
-static inline void radeon_error(const char* message, ...) __attribute__((format(printf,1,2)));
/**
* printf style function for writing error messages.
*/
-static inline void radeon_error(const char* message, ...)
-{
- va_list values;
- va_start( values, message );
- radeon_print(RADEON_GENERAL, RADEON_CRITICAL, message, values);
- va_end( values );
-}
+#define radeon_error(message, ...) do { \
+ radeon_print(RADEON_GENERAL, RADEON_CRITICAL, \
+ (message), ## __VA_ARGS__); \
+} while(0)
-static inline void radeon_warning(const char* message, ...) __attribute__((format(printf,1,2)));
/**
* printf style function for writing warnings.
*/
-static inline void radeon_warning(const char* message, ...)
-{
- va_list values;
- va_start( values, message );
- radeon_print(RADEON_GENERAL, RADEON_IMPORTANT, message, values);
- va_end( values );
-}
+#define radeon_warning(message, ...) do { \
+ radeon_print(RADEON_GENERAL, RADEON_IMPORTANT, \
+ (message), ## __VA_ARGS__); \
+} while(0)
extern void radeon_init_debug(void);
extern void _radeon_debug_add_indent(void);
#define need_GL_SGI_color_table
/* sw extensions not associated with some GL version */
+#define need_GL_ARB_draw_elements_base_vertex
#define need_GL_ARB_shader_objects
#define need_GL_ARB_vertex_array_object
#define need_GL_ARB_vertex_program
{ "GL_EXT_histogram", GL_EXT_histogram_functions },
{ "GL_SGI_color_table", GL_SGI_color_table_functions },
+ { "GL_ARB_depth_clamp", NULL },
+ { "GL_ARB_draw_elements_base_vertex", GL_ARB_draw_elements_base_vertex_functions },
{ "GL_ARB_shader_objects", GL_ARB_shader_objects_functions },
{ "GL_ARB_vertex_array_object", GL_ARB_vertex_array_object_functions },
{ "GL_ARB_vertex_program", GL_ARB_vertex_program_functions },
{ "GL_EXT_paletted_texture", GL_EXT_paletted_texture_functions },
{ "GL_EXT_stencil_two_side", GL_EXT_stencil_two_side_functions },
{ "GL_MESA_resize_buffers", GL_MESA_resize_buffers_functions },
+ { "GL_NV_depth_clamp", NULL },
{ "GL_NV_vertex_program", GL_NV_vertex_program_functions },
{ "GL_NV_fragment_program", GL_NV_fragment_program_functions },
{ NULL, NULL }
#define need_GL_SGI_color_table
/* sw extensions not associated with some GL version */
+#define need_GL_ARB_draw_elements_base_vertex
#define need_GL_ARB_shader_objects
#define need_GL_ARB_sync
#define need_GL_ARB_vertex_program
{ "GL_EXT_histogram", GL_EXT_histogram_functions },
{ "GL_SGI_color_table", GL_SGI_color_table_functions },
+ { "GL_ARB_depth_clamp", NULL },
+ { "GL_ARB_draw_elements_base_vertex", GL_ARB_draw_elements_base_vertex_functions },
{ "GL_ARB_shader_objects", GL_ARB_shader_objects_functions },
{ "GL_ARB_sync", GL_ARB_sync_functions },
{ "GL_ARB_vertex_program", GL_ARB_vertex_program_functions },
{ "GL_EXT_gpu_program_parameters", GL_EXT_gpu_program_parameters_functions },
{ "GL_EXT_paletted_texture", GL_EXT_paletted_texture_functions },
{ "GL_MESA_resize_buffers", GL_MESA_resize_buffers_functions },
+ { "GL_NV_depth_clamp", NULL },
{ "GL_NV_vertex_program", GL_NV_vertex_program_functions },
{ "GL_NV_fragment_program", GL_NV_fragment_program_functions },
{ NULL, NULL }
--- /dev/null
+<?xml version="1.0"?>
+<!DOCTYPE OpenGLAPI SYSTEM "gl_API.dtd">
+
+<OpenGLAPI>
+
+<category name="GL_ARB_depth_clamp" number="61">
+ <enum name="DEPTH_CLAMP" count="1" value="0x864F">
+ <size name="Get" mode="get"/>
+ </enum>
+</category>
+
+</OpenGLAPI>
--- /dev/null
+<?xml version="1.0"?>
+<!DOCTYPE OpenGLAPI SYSTEM "gl_API.dtd">
+
+<!-- Note: no GLX protocol info yet. -->
+
+
+<OpenGLAPI>
+
+<category name="GL_ARB_draw_elements_base_vertex" number="62">
+
+ <function name="DrawElementsBaseVertex" offset="assign">
+ <param name="mode" type="GLenum"/>
+ <param name="count" type="GLsizei"/>
+ <param name="type" type="GLenum"/>
+ <param name="indices" type="const GLvoid *"/>
+ <param name="basevertex" type="GLint"/>
+ </function>
+
+ <function name="DrawRangeElementsBaseVertex" offset="assign">
+ <param name="mode" type="GLenum"/>
+ <param name="start" type="GLuint"/>
+ <param name="end" type="GLuint"/>
+ <param name="count" type="GLsizei"/>
+ <param name="type" type="GLenum"/>
+ <param name="indices" type="const GLvoid *"/>
+ <param name="basevertex" type="GLint"/>
+ </function>
+
+ <function name="MultiDrawElementsBaseVertex" offset="assign">
+ <param name="mode" type="GLenum"/>
+ <param name="count" type="const GLsizei *"/>
+ <param name="type" type="GLenum"/>
+ <param name="indices" type="const GLvoid **"/>
+ <param name="primcount" type="GLsizei"/>
+ <param name="basevertex" type="const GLint *"/>
+ </function>
+
+</category>
+
+</OpenGLAPI>
API_XML = gl_API.xml \
EXT_framebuffer_object.xml \
ARB_copy_buffer.xml \
+ ARB_depth_clamp.xml \
ARB_framebuffer_object.xml \
ARB_map_buffer_range.xml \
ARB_seamless_cube_map.xml \
#define CALL_WaitSync(disp, parameters) (*((disp)->WaitSync)) parameters
#define GET_WaitSync(disp) ((disp)->WaitSync)
#define SET_WaitSync(disp, fn) ((disp)->WaitSync = fn)
+#define CALL_DrawElementsBaseVertex(disp, parameters) (*((disp)->DrawElementsBaseVertex)) parameters
+#define GET_DrawElementsBaseVertex(disp) ((disp)->DrawElementsBaseVertex)
+#define SET_DrawElementsBaseVertex(disp, fn) ((disp)->DrawElementsBaseVertex = fn)
+#define CALL_DrawRangeElementsBaseVertex(disp, parameters) (*((disp)->DrawRangeElementsBaseVertex)) parameters
+#define GET_DrawRangeElementsBaseVertex(disp) ((disp)->DrawRangeElementsBaseVertex)
+#define SET_DrawRangeElementsBaseVertex(disp, fn) ((disp)->DrawRangeElementsBaseVertex = fn)
+#define CALL_MultiDrawElementsBaseVertex(disp, parameters) (*((disp)->MultiDrawElementsBaseVertex)) parameters
+#define GET_MultiDrawElementsBaseVertex(disp) ((disp)->MultiDrawElementsBaseVertex)
+#define SET_MultiDrawElementsBaseVertex(disp, fn) ((disp)->MultiDrawElementsBaseVertex = fn)
#define CALL_PolygonOffsetEXT(disp, parameters) (*((disp)->PolygonOffsetEXT)) parameters
#define GET_PolygonOffsetEXT(disp) ((disp)->PolygonOffsetEXT)
#define SET_PolygonOffsetEXT(disp, fn) ((disp)->PolygonOffsetEXT = fn)
#else
-#define driDispatchRemapTable_size 384
+#define driDispatchRemapTable_size 387
extern int driDispatchRemapTable[ driDispatchRemapTable_size ];
#define AttachShader_remap_index 0
#define GetSynciv_remap_index 163
#define IsSync_remap_index 164
#define WaitSync_remap_index 165
-#define PolygonOffsetEXT_remap_index 166
-#define GetPixelTexGenParameterfvSGIS_remap_index 167
-#define GetPixelTexGenParameterivSGIS_remap_index 168
-#define PixelTexGenParameterfSGIS_remap_index 169
-#define PixelTexGenParameterfvSGIS_remap_index 170
-#define PixelTexGenParameteriSGIS_remap_index 171
-#define PixelTexGenParameterivSGIS_remap_index 172
-#define SampleMaskSGIS_remap_index 173
-#define SamplePatternSGIS_remap_index 174
-#define ColorPointerEXT_remap_index 175
-#define EdgeFlagPointerEXT_remap_index 176
-#define IndexPointerEXT_remap_index 177
-#define NormalPointerEXT_remap_index 178
-#define TexCoordPointerEXT_remap_index 179
-#define VertexPointerEXT_remap_index 180
-#define PointParameterfEXT_remap_index 181
-#define PointParameterfvEXT_remap_index 182
-#define LockArraysEXT_remap_index 183
-#define UnlockArraysEXT_remap_index 184
-#define CullParameterdvEXT_remap_index 185
-#define CullParameterfvEXT_remap_index 186
-#define SecondaryColor3bEXT_remap_index 187
-#define SecondaryColor3bvEXT_remap_index 188
-#define SecondaryColor3dEXT_remap_index 189
-#define SecondaryColor3dvEXT_remap_index 190
-#define SecondaryColor3fEXT_remap_index 191
-#define SecondaryColor3fvEXT_remap_index 192
-#define SecondaryColor3iEXT_remap_index 193
-#define SecondaryColor3ivEXT_remap_index 194
-#define SecondaryColor3sEXT_remap_index 195
-#define SecondaryColor3svEXT_remap_index 196
-#define SecondaryColor3ubEXT_remap_index 197
-#define SecondaryColor3ubvEXT_remap_index 198
-#define SecondaryColor3uiEXT_remap_index 199
-#define SecondaryColor3uivEXT_remap_index 200
-#define SecondaryColor3usEXT_remap_index 201
-#define SecondaryColor3usvEXT_remap_index 202
-#define SecondaryColorPointerEXT_remap_index 203
-#define MultiDrawArraysEXT_remap_index 204
-#define MultiDrawElementsEXT_remap_index 205
-#define FogCoordPointerEXT_remap_index 206
-#define FogCoorddEXT_remap_index 207
-#define FogCoorddvEXT_remap_index 208
-#define FogCoordfEXT_remap_index 209
-#define FogCoordfvEXT_remap_index 210
-#define PixelTexGenSGIX_remap_index 211
-#define BlendFuncSeparateEXT_remap_index 212
-#define FlushVertexArrayRangeNV_remap_index 213
-#define VertexArrayRangeNV_remap_index 214
-#define CombinerInputNV_remap_index 215
-#define CombinerOutputNV_remap_index 216
-#define CombinerParameterfNV_remap_index 217
-#define CombinerParameterfvNV_remap_index 218
-#define CombinerParameteriNV_remap_index 219
-#define CombinerParameterivNV_remap_index 220
-#define FinalCombinerInputNV_remap_index 221
-#define GetCombinerInputParameterfvNV_remap_index 222
-#define GetCombinerInputParameterivNV_remap_index 223
-#define GetCombinerOutputParameterfvNV_remap_index 224
-#define GetCombinerOutputParameterivNV_remap_index 225
-#define GetFinalCombinerInputParameterfvNV_remap_index 226
-#define GetFinalCombinerInputParameterivNV_remap_index 227
-#define ResizeBuffersMESA_remap_index 228
-#define WindowPos2dMESA_remap_index 229
-#define WindowPos2dvMESA_remap_index 230
-#define WindowPos2fMESA_remap_index 231
-#define WindowPos2fvMESA_remap_index 232
-#define WindowPos2iMESA_remap_index 233
-#define WindowPos2ivMESA_remap_index 234
-#define WindowPos2sMESA_remap_index 235
-#define WindowPos2svMESA_remap_index 236
-#define WindowPos3dMESA_remap_index 237
-#define WindowPos3dvMESA_remap_index 238
-#define WindowPos3fMESA_remap_index 239
-#define WindowPos3fvMESA_remap_index 240
-#define WindowPos3iMESA_remap_index 241
-#define WindowPos3ivMESA_remap_index 242
-#define WindowPos3sMESA_remap_index 243
-#define WindowPos3svMESA_remap_index 244
-#define WindowPos4dMESA_remap_index 245
-#define WindowPos4dvMESA_remap_index 246
-#define WindowPos4fMESA_remap_index 247
-#define WindowPos4fvMESA_remap_index 248
-#define WindowPos4iMESA_remap_index 249
-#define WindowPos4ivMESA_remap_index 250
-#define WindowPos4sMESA_remap_index 251
-#define WindowPos4svMESA_remap_index 252
-#define MultiModeDrawArraysIBM_remap_index 253
-#define MultiModeDrawElementsIBM_remap_index 254
-#define DeleteFencesNV_remap_index 255
-#define FinishFenceNV_remap_index 256
-#define GenFencesNV_remap_index 257
-#define GetFenceivNV_remap_index 258
-#define IsFenceNV_remap_index 259
-#define SetFenceNV_remap_index 260
-#define TestFenceNV_remap_index 261
-#define AreProgramsResidentNV_remap_index 262
-#define BindProgramNV_remap_index 263
-#define DeleteProgramsNV_remap_index 264
-#define ExecuteProgramNV_remap_index 265
-#define GenProgramsNV_remap_index 266
-#define GetProgramParameterdvNV_remap_index 267
-#define GetProgramParameterfvNV_remap_index 268
-#define GetProgramStringNV_remap_index 269
-#define GetProgramivNV_remap_index 270
-#define GetTrackMatrixivNV_remap_index 271
-#define GetVertexAttribPointervNV_remap_index 272
-#define GetVertexAttribdvNV_remap_index 273
-#define GetVertexAttribfvNV_remap_index 274
-#define GetVertexAttribivNV_remap_index 275
-#define IsProgramNV_remap_index 276
-#define LoadProgramNV_remap_index 277
-#define ProgramParameters4dvNV_remap_index 278
-#define ProgramParameters4fvNV_remap_index 279
-#define RequestResidentProgramsNV_remap_index 280
-#define TrackMatrixNV_remap_index 281
-#define VertexAttrib1dNV_remap_index 282
-#define VertexAttrib1dvNV_remap_index 283
-#define VertexAttrib1fNV_remap_index 284
-#define VertexAttrib1fvNV_remap_index 285
-#define VertexAttrib1sNV_remap_index 286
-#define VertexAttrib1svNV_remap_index 287
-#define VertexAttrib2dNV_remap_index 288
-#define VertexAttrib2dvNV_remap_index 289
-#define VertexAttrib2fNV_remap_index 290
-#define VertexAttrib2fvNV_remap_index 291
-#define VertexAttrib2sNV_remap_index 292
-#define VertexAttrib2svNV_remap_index 293
-#define VertexAttrib3dNV_remap_index 294
-#define VertexAttrib3dvNV_remap_index 295
-#define VertexAttrib3fNV_remap_index 296
-#define VertexAttrib3fvNV_remap_index 297
-#define VertexAttrib3sNV_remap_index 298
-#define VertexAttrib3svNV_remap_index 299
-#define VertexAttrib4dNV_remap_index 300
-#define VertexAttrib4dvNV_remap_index 301
-#define VertexAttrib4fNV_remap_index 302
-#define VertexAttrib4fvNV_remap_index 303
-#define VertexAttrib4sNV_remap_index 304
-#define VertexAttrib4svNV_remap_index 305
-#define VertexAttrib4ubNV_remap_index 306
-#define VertexAttrib4ubvNV_remap_index 307
-#define VertexAttribPointerNV_remap_index 308
-#define VertexAttribs1dvNV_remap_index 309
-#define VertexAttribs1fvNV_remap_index 310
-#define VertexAttribs1svNV_remap_index 311
-#define VertexAttribs2dvNV_remap_index 312
-#define VertexAttribs2fvNV_remap_index 313
-#define VertexAttribs2svNV_remap_index 314
-#define VertexAttribs3dvNV_remap_index 315
-#define VertexAttribs3fvNV_remap_index 316
-#define VertexAttribs3svNV_remap_index 317
-#define VertexAttribs4dvNV_remap_index 318
-#define VertexAttribs4fvNV_remap_index 319
-#define VertexAttribs4svNV_remap_index 320
-#define VertexAttribs4ubvNV_remap_index 321
-#define GetTexBumpParameterfvATI_remap_index 322
-#define GetTexBumpParameterivATI_remap_index 323
-#define TexBumpParameterfvATI_remap_index 324
-#define TexBumpParameterivATI_remap_index 325
-#define AlphaFragmentOp1ATI_remap_index 326
-#define AlphaFragmentOp2ATI_remap_index 327
-#define AlphaFragmentOp3ATI_remap_index 328
-#define BeginFragmentShaderATI_remap_index 329
-#define BindFragmentShaderATI_remap_index 330
-#define ColorFragmentOp1ATI_remap_index 331
-#define ColorFragmentOp2ATI_remap_index 332
-#define ColorFragmentOp3ATI_remap_index 333
-#define DeleteFragmentShaderATI_remap_index 334
-#define EndFragmentShaderATI_remap_index 335
-#define GenFragmentShadersATI_remap_index 336
-#define PassTexCoordATI_remap_index 337
-#define SampleMapATI_remap_index 338
-#define SetFragmentShaderConstantATI_remap_index 339
-#define PointParameteriNV_remap_index 340
-#define PointParameterivNV_remap_index 341
-#define ActiveStencilFaceEXT_remap_index 342
-#define BindVertexArrayAPPLE_remap_index 343
-#define DeleteVertexArraysAPPLE_remap_index 344
-#define GenVertexArraysAPPLE_remap_index 345
-#define IsVertexArrayAPPLE_remap_index 346
-#define GetProgramNamedParameterdvNV_remap_index 347
-#define GetProgramNamedParameterfvNV_remap_index 348
-#define ProgramNamedParameter4dNV_remap_index 349
-#define ProgramNamedParameter4dvNV_remap_index 350
-#define ProgramNamedParameter4fNV_remap_index 351
-#define ProgramNamedParameter4fvNV_remap_index 352
-#define DepthBoundsEXT_remap_index 353
-#define BlendEquationSeparateEXT_remap_index 354
-#define BindFramebufferEXT_remap_index 355
-#define BindRenderbufferEXT_remap_index 356
-#define CheckFramebufferStatusEXT_remap_index 357
-#define DeleteFramebuffersEXT_remap_index 358
-#define DeleteRenderbuffersEXT_remap_index 359
-#define FramebufferRenderbufferEXT_remap_index 360
-#define FramebufferTexture1DEXT_remap_index 361
-#define FramebufferTexture2DEXT_remap_index 362
-#define FramebufferTexture3DEXT_remap_index 363
-#define GenFramebuffersEXT_remap_index 364
-#define GenRenderbuffersEXT_remap_index 365
-#define GenerateMipmapEXT_remap_index 366
-#define GetFramebufferAttachmentParameterivEXT_remap_index 367
-#define GetRenderbufferParameterivEXT_remap_index 368
-#define IsFramebufferEXT_remap_index 369
-#define IsRenderbufferEXT_remap_index 370
-#define RenderbufferStorageEXT_remap_index 371
-#define BlitFramebufferEXT_remap_index 372
-#define BufferParameteriAPPLE_remap_index 373
-#define FlushMappedBufferRangeAPPLE_remap_index 374
-#define FramebufferTextureLayerEXT_remap_index 375
-#define ProvokingVertexEXT_remap_index 376
-#define GetTexParameterPointervAPPLE_remap_index 377
-#define TextureRangeAPPLE_remap_index 378
-#define StencilFuncSeparateATI_remap_index 379
-#define ProgramEnvParameters4fvEXT_remap_index 380
-#define ProgramLocalParameters4fvEXT_remap_index 381
-#define GetQueryObjecti64vEXT_remap_index 382
-#define GetQueryObjectui64vEXT_remap_index 383
+#define DrawElementsBaseVertex_remap_index 166
+#define DrawRangeElementsBaseVertex_remap_index 167
+#define MultiDrawElementsBaseVertex_remap_index 168
+#define PolygonOffsetEXT_remap_index 169
+#define GetPixelTexGenParameterfvSGIS_remap_index 170
+#define GetPixelTexGenParameterivSGIS_remap_index 171
+#define PixelTexGenParameterfSGIS_remap_index 172
+#define PixelTexGenParameterfvSGIS_remap_index 173
+#define PixelTexGenParameteriSGIS_remap_index 174
+#define PixelTexGenParameterivSGIS_remap_index 175
+#define SampleMaskSGIS_remap_index 176
+#define SamplePatternSGIS_remap_index 177
+#define ColorPointerEXT_remap_index 178
+#define EdgeFlagPointerEXT_remap_index 179
+#define IndexPointerEXT_remap_index 180
+#define NormalPointerEXT_remap_index 181
+#define TexCoordPointerEXT_remap_index 182
+#define VertexPointerEXT_remap_index 183
+#define PointParameterfEXT_remap_index 184
+#define PointParameterfvEXT_remap_index 185
+#define LockArraysEXT_remap_index 186
+#define UnlockArraysEXT_remap_index 187
+#define CullParameterdvEXT_remap_index 188
+#define CullParameterfvEXT_remap_index 189
+#define SecondaryColor3bEXT_remap_index 190
+#define SecondaryColor3bvEXT_remap_index 191
+#define SecondaryColor3dEXT_remap_index 192
+#define SecondaryColor3dvEXT_remap_index 193
+#define SecondaryColor3fEXT_remap_index 194
+#define SecondaryColor3fvEXT_remap_index 195
+#define SecondaryColor3iEXT_remap_index 196
+#define SecondaryColor3ivEXT_remap_index 197
+#define SecondaryColor3sEXT_remap_index 198
+#define SecondaryColor3svEXT_remap_index 199
+#define SecondaryColor3ubEXT_remap_index 200
+#define SecondaryColor3ubvEXT_remap_index 201
+#define SecondaryColor3uiEXT_remap_index 202
+#define SecondaryColor3uivEXT_remap_index 203
+#define SecondaryColor3usEXT_remap_index 204
+#define SecondaryColor3usvEXT_remap_index 205
+#define SecondaryColorPointerEXT_remap_index 206
+#define MultiDrawArraysEXT_remap_index 207
+#define MultiDrawElementsEXT_remap_index 208
+#define FogCoordPointerEXT_remap_index 209
+#define FogCoorddEXT_remap_index 210
+#define FogCoorddvEXT_remap_index 211
+#define FogCoordfEXT_remap_index 212
+#define FogCoordfvEXT_remap_index 213
+#define PixelTexGenSGIX_remap_index 214
+#define BlendFuncSeparateEXT_remap_index 215
+#define FlushVertexArrayRangeNV_remap_index 216
+#define VertexArrayRangeNV_remap_index 217
+#define CombinerInputNV_remap_index 218
+#define CombinerOutputNV_remap_index 219
+#define CombinerParameterfNV_remap_index 220
+#define CombinerParameterfvNV_remap_index 221
+#define CombinerParameteriNV_remap_index 222
+#define CombinerParameterivNV_remap_index 223
+#define FinalCombinerInputNV_remap_index 224
+#define GetCombinerInputParameterfvNV_remap_index 225
+#define GetCombinerInputParameterivNV_remap_index 226
+#define GetCombinerOutputParameterfvNV_remap_index 227
+#define GetCombinerOutputParameterivNV_remap_index 228
+#define GetFinalCombinerInputParameterfvNV_remap_index 229
+#define GetFinalCombinerInputParameterivNV_remap_index 230
+#define ResizeBuffersMESA_remap_index 231
+#define WindowPos2dMESA_remap_index 232
+#define WindowPos2dvMESA_remap_index 233
+#define WindowPos2fMESA_remap_index 234
+#define WindowPos2fvMESA_remap_index 235
+#define WindowPos2iMESA_remap_index 236
+#define WindowPos2ivMESA_remap_index 237
+#define WindowPos2sMESA_remap_index 238
+#define WindowPos2svMESA_remap_index 239
+#define WindowPos3dMESA_remap_index 240
+#define WindowPos3dvMESA_remap_index 241
+#define WindowPos3fMESA_remap_index 242
+#define WindowPos3fvMESA_remap_index 243
+#define WindowPos3iMESA_remap_index 244
+#define WindowPos3ivMESA_remap_index 245
+#define WindowPos3sMESA_remap_index 246
+#define WindowPos3svMESA_remap_index 247
+#define WindowPos4dMESA_remap_index 248
+#define WindowPos4dvMESA_remap_index 249
+#define WindowPos4fMESA_remap_index 250
+#define WindowPos4fvMESA_remap_index 251
+#define WindowPos4iMESA_remap_index 252
+#define WindowPos4ivMESA_remap_index 253
+#define WindowPos4sMESA_remap_index 254
+#define WindowPos4svMESA_remap_index 255
+#define MultiModeDrawArraysIBM_remap_index 256
+#define MultiModeDrawElementsIBM_remap_index 257
+#define DeleteFencesNV_remap_index 258
+#define FinishFenceNV_remap_index 259
+#define GenFencesNV_remap_index 260
+#define GetFenceivNV_remap_index 261
+#define IsFenceNV_remap_index 262
+#define SetFenceNV_remap_index 263
+#define TestFenceNV_remap_index 264
+#define AreProgramsResidentNV_remap_index 265
+#define BindProgramNV_remap_index 266
+#define DeleteProgramsNV_remap_index 267
+#define ExecuteProgramNV_remap_index 268
+#define GenProgramsNV_remap_index 269
+#define GetProgramParameterdvNV_remap_index 270
+#define GetProgramParameterfvNV_remap_index 271
+#define GetProgramStringNV_remap_index 272
+#define GetProgramivNV_remap_index 273
+#define GetTrackMatrixivNV_remap_index 274
+#define GetVertexAttribPointervNV_remap_index 275
+#define GetVertexAttribdvNV_remap_index 276
+#define GetVertexAttribfvNV_remap_index 277
+#define GetVertexAttribivNV_remap_index 278
+#define IsProgramNV_remap_index 279
+#define LoadProgramNV_remap_index 280
+#define ProgramParameters4dvNV_remap_index 281
+#define ProgramParameters4fvNV_remap_index 282
+#define RequestResidentProgramsNV_remap_index 283
+#define TrackMatrixNV_remap_index 284
+#define VertexAttrib1dNV_remap_index 285
+#define VertexAttrib1dvNV_remap_index 286
+#define VertexAttrib1fNV_remap_index 287
+#define VertexAttrib1fvNV_remap_index 288
+#define VertexAttrib1sNV_remap_index 289
+#define VertexAttrib1svNV_remap_index 290
+#define VertexAttrib2dNV_remap_index 291
+#define VertexAttrib2dvNV_remap_index 292
+#define VertexAttrib2fNV_remap_index 293
+#define VertexAttrib2fvNV_remap_index 294
+#define VertexAttrib2sNV_remap_index 295
+#define VertexAttrib2svNV_remap_index 296
+#define VertexAttrib3dNV_remap_index 297
+#define VertexAttrib3dvNV_remap_index 298
+#define VertexAttrib3fNV_remap_index 299
+#define VertexAttrib3fvNV_remap_index 300
+#define VertexAttrib3sNV_remap_index 301
+#define VertexAttrib3svNV_remap_index 302
+#define VertexAttrib4dNV_remap_index 303
+#define VertexAttrib4dvNV_remap_index 304
+#define VertexAttrib4fNV_remap_index 305
+#define VertexAttrib4fvNV_remap_index 306
+#define VertexAttrib4sNV_remap_index 307
+#define VertexAttrib4svNV_remap_index 308
+#define VertexAttrib4ubNV_remap_index 309
+#define VertexAttrib4ubvNV_remap_index 310
+#define VertexAttribPointerNV_remap_index 311
+#define VertexAttribs1dvNV_remap_index 312
+#define VertexAttribs1fvNV_remap_index 313
+#define VertexAttribs1svNV_remap_index 314
+#define VertexAttribs2dvNV_remap_index 315
+#define VertexAttribs2fvNV_remap_index 316
+#define VertexAttribs2svNV_remap_index 317
+#define VertexAttribs3dvNV_remap_index 318
+#define VertexAttribs3fvNV_remap_index 319
+#define VertexAttribs3svNV_remap_index 320
+#define VertexAttribs4dvNV_remap_index 321
+#define VertexAttribs4fvNV_remap_index 322
+#define VertexAttribs4svNV_remap_index 323
+#define VertexAttribs4ubvNV_remap_index 324
+#define GetTexBumpParameterfvATI_remap_index 325
+#define GetTexBumpParameterivATI_remap_index 326
+#define TexBumpParameterfvATI_remap_index 327
+#define TexBumpParameterivATI_remap_index 328
+#define AlphaFragmentOp1ATI_remap_index 329
+#define AlphaFragmentOp2ATI_remap_index 330
+#define AlphaFragmentOp3ATI_remap_index 331
+#define BeginFragmentShaderATI_remap_index 332
+#define BindFragmentShaderATI_remap_index 333
+#define ColorFragmentOp1ATI_remap_index 334
+#define ColorFragmentOp2ATI_remap_index 335
+#define ColorFragmentOp3ATI_remap_index 336
+#define DeleteFragmentShaderATI_remap_index 337
+#define EndFragmentShaderATI_remap_index 338
+#define GenFragmentShadersATI_remap_index 339
+#define PassTexCoordATI_remap_index 340
+#define SampleMapATI_remap_index 341
+#define SetFragmentShaderConstantATI_remap_index 342
+#define PointParameteriNV_remap_index 343
+#define PointParameterivNV_remap_index 344
+#define ActiveStencilFaceEXT_remap_index 345
+#define BindVertexArrayAPPLE_remap_index 346
+#define DeleteVertexArraysAPPLE_remap_index 347
+#define GenVertexArraysAPPLE_remap_index 348
+#define IsVertexArrayAPPLE_remap_index 349
+#define GetProgramNamedParameterdvNV_remap_index 350
+#define GetProgramNamedParameterfvNV_remap_index 351
+#define ProgramNamedParameter4dNV_remap_index 352
+#define ProgramNamedParameter4dvNV_remap_index 353
+#define ProgramNamedParameter4fNV_remap_index 354
+#define ProgramNamedParameter4fvNV_remap_index 355
+#define DepthBoundsEXT_remap_index 356
+#define BlendEquationSeparateEXT_remap_index 357
+#define BindFramebufferEXT_remap_index 358
+#define BindRenderbufferEXT_remap_index 359
+#define CheckFramebufferStatusEXT_remap_index 360
+#define DeleteFramebuffersEXT_remap_index 361
+#define DeleteRenderbuffersEXT_remap_index 362
+#define FramebufferRenderbufferEXT_remap_index 363
+#define FramebufferTexture1DEXT_remap_index 364
+#define FramebufferTexture2DEXT_remap_index 365
+#define FramebufferTexture3DEXT_remap_index 366
+#define GenFramebuffersEXT_remap_index 367
+#define GenRenderbuffersEXT_remap_index 368
+#define GenerateMipmapEXT_remap_index 369
+#define GetFramebufferAttachmentParameterivEXT_remap_index 370
+#define GetRenderbufferParameterivEXT_remap_index 371
+#define IsFramebufferEXT_remap_index 372
+#define IsRenderbufferEXT_remap_index 373
+#define RenderbufferStorageEXT_remap_index 374
+#define BlitFramebufferEXT_remap_index 375
+#define BufferParameteriAPPLE_remap_index 376
+#define FlushMappedBufferRangeAPPLE_remap_index 377
+#define FramebufferTextureLayerEXT_remap_index 378
+#define ProvokingVertexEXT_remap_index 379
+#define GetTexParameterPointervAPPLE_remap_index 380
+#define TextureRangeAPPLE_remap_index 381
+#define StencilFuncSeparateATI_remap_index 382
+#define ProgramEnvParameters4fvEXT_remap_index 383
+#define ProgramLocalParameters4fvEXT_remap_index 384
+#define GetQueryObjecti64vEXT_remap_index 385
+#define GetQueryObjectui64vEXT_remap_index 386
#define CALL_AttachShader(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLuint)), driDispatchRemapTable[AttachShader_remap_index], parameters)
#define GET_AttachShader(disp) GET_by_offset(disp, driDispatchRemapTable[AttachShader_remap_index])
#define CALL_WaitSync(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsync, GLbitfield, GLuint64)), driDispatchRemapTable[WaitSync_remap_index], parameters)
#define GET_WaitSync(disp) GET_by_offset(disp, driDispatchRemapTable[WaitSync_remap_index])
#define SET_WaitSync(disp, fn) SET_by_offset(disp, driDispatchRemapTable[WaitSync_remap_index], fn)
+#define CALL_DrawElementsBaseVertex(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLsizei, GLenum, const GLvoid *, GLint)), driDispatchRemapTable[DrawElementsBaseVertex_remap_index], parameters)
+#define GET_DrawElementsBaseVertex(disp) GET_by_offset(disp, driDispatchRemapTable[DrawElementsBaseVertex_remap_index])
+#define SET_DrawElementsBaseVertex(disp, fn) SET_by_offset(disp, driDispatchRemapTable[DrawElementsBaseVertex_remap_index], fn)
+#define CALL_DrawRangeElementsBaseVertex(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *, GLint)), driDispatchRemapTable[DrawRangeElementsBaseVertex_remap_index], parameters)
+#define GET_DrawRangeElementsBaseVertex(disp) GET_by_offset(disp, driDispatchRemapTable[DrawRangeElementsBaseVertex_remap_index])
+#define SET_DrawRangeElementsBaseVertex(disp, fn) SET_by_offset(disp, driDispatchRemapTable[DrawRangeElementsBaseVertex_remap_index], fn)
+#define CALL_MultiDrawElementsBaseVertex(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLsizei *, GLenum, const GLvoid **, GLsizei, const GLint *)), driDispatchRemapTable[MultiDrawElementsBaseVertex_remap_index], parameters)
+#define GET_MultiDrawElementsBaseVertex(disp) GET_by_offset(disp, driDispatchRemapTable[MultiDrawElementsBaseVertex_remap_index])
+#define SET_MultiDrawElementsBaseVertex(disp, fn) SET_by_offset(disp, driDispatchRemapTable[MultiDrawElementsBaseVertex_remap_index], fn)
#define CALL_PolygonOffsetEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat)), driDispatchRemapTable[PolygonOffsetEXT_remap_index], parameters)
#define GET_PolygonOffsetEXT(disp) GET_by_offset(disp, driDispatchRemapTable[PolygonOffsetEXT_remap_index])
#define SET_PolygonOffsetEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[PolygonOffsetEXT_remap_index], fn)
<xi:include href="ARB_copy_buffer.xml" xmlns:xi="http://www.w3.org/2001/XInclude"/>
+<xi:include href="ARB_depth_clamp.xml" xmlns:xi="http://www.w3.org/2001/XInclude"/>
+
<xi:include href="ARB_map_buffer_range.xml" xmlns:xi="http://www.w3.org/2001/XInclude"/>
<xi:include href="ARB_vertex_array_object.xml" xmlns:xi="http://www.w3.org/2001/XInclude"/>
<xi:include href="ARB_seamless_cube_map.xml" xmlns:xi="http://www.w3.org/2001/XInclude"/>
+<xi:include href="ARB_draw_elements_base_vertex.xml" xmlns:xi="http://www.w3.org/2001/XInclude"/>
+
<!-- Non-ARB extensions sorted by extension number. -->
#define _gloffset_GetSynciv 571
#define _gloffset_IsSync 572
#define _gloffset_WaitSync 573
-#define _gloffset_PolygonOffsetEXT 574
-#define _gloffset_GetPixelTexGenParameterfvSGIS 575
-#define _gloffset_GetPixelTexGenParameterivSGIS 576
-#define _gloffset_PixelTexGenParameterfSGIS 577
-#define _gloffset_PixelTexGenParameterfvSGIS 578
-#define _gloffset_PixelTexGenParameteriSGIS 579
-#define _gloffset_PixelTexGenParameterivSGIS 580
-#define _gloffset_SampleMaskSGIS 581
-#define _gloffset_SamplePatternSGIS 582
-#define _gloffset_ColorPointerEXT 583
-#define _gloffset_EdgeFlagPointerEXT 584
-#define _gloffset_IndexPointerEXT 585
-#define _gloffset_NormalPointerEXT 586
-#define _gloffset_TexCoordPointerEXT 587
-#define _gloffset_VertexPointerEXT 588
-#define _gloffset_PointParameterfEXT 589
-#define _gloffset_PointParameterfvEXT 590
-#define _gloffset_LockArraysEXT 591
-#define _gloffset_UnlockArraysEXT 592
-#define _gloffset_CullParameterdvEXT 593
-#define _gloffset_CullParameterfvEXT 594
-#define _gloffset_SecondaryColor3bEXT 595
-#define _gloffset_SecondaryColor3bvEXT 596
-#define _gloffset_SecondaryColor3dEXT 597
-#define _gloffset_SecondaryColor3dvEXT 598
-#define _gloffset_SecondaryColor3fEXT 599
-#define _gloffset_SecondaryColor3fvEXT 600
-#define _gloffset_SecondaryColor3iEXT 601
-#define _gloffset_SecondaryColor3ivEXT 602
-#define _gloffset_SecondaryColor3sEXT 603
-#define _gloffset_SecondaryColor3svEXT 604
-#define _gloffset_SecondaryColor3ubEXT 605
-#define _gloffset_SecondaryColor3ubvEXT 606
-#define _gloffset_SecondaryColor3uiEXT 607
-#define _gloffset_SecondaryColor3uivEXT 608
-#define _gloffset_SecondaryColor3usEXT 609
-#define _gloffset_SecondaryColor3usvEXT 610
-#define _gloffset_SecondaryColorPointerEXT 611
-#define _gloffset_MultiDrawArraysEXT 612
-#define _gloffset_MultiDrawElementsEXT 613
-#define _gloffset_FogCoordPointerEXT 614
-#define _gloffset_FogCoorddEXT 615
-#define _gloffset_FogCoorddvEXT 616
-#define _gloffset_FogCoordfEXT 617
-#define _gloffset_FogCoordfvEXT 618
-#define _gloffset_PixelTexGenSGIX 619
-#define _gloffset_BlendFuncSeparateEXT 620
-#define _gloffset_FlushVertexArrayRangeNV 621
-#define _gloffset_VertexArrayRangeNV 622
-#define _gloffset_CombinerInputNV 623
-#define _gloffset_CombinerOutputNV 624
-#define _gloffset_CombinerParameterfNV 625
-#define _gloffset_CombinerParameterfvNV 626
-#define _gloffset_CombinerParameteriNV 627
-#define _gloffset_CombinerParameterivNV 628
-#define _gloffset_FinalCombinerInputNV 629
-#define _gloffset_GetCombinerInputParameterfvNV 630
-#define _gloffset_GetCombinerInputParameterivNV 631
-#define _gloffset_GetCombinerOutputParameterfvNV 632
-#define _gloffset_GetCombinerOutputParameterivNV 633
-#define _gloffset_GetFinalCombinerInputParameterfvNV 634
-#define _gloffset_GetFinalCombinerInputParameterivNV 635
-#define _gloffset_ResizeBuffersMESA 636
-#define _gloffset_WindowPos2dMESA 637
-#define _gloffset_WindowPos2dvMESA 638
-#define _gloffset_WindowPos2fMESA 639
-#define _gloffset_WindowPos2fvMESA 640
-#define _gloffset_WindowPos2iMESA 641
-#define _gloffset_WindowPos2ivMESA 642
-#define _gloffset_WindowPos2sMESA 643
-#define _gloffset_WindowPos2svMESA 644
-#define _gloffset_WindowPos3dMESA 645
-#define _gloffset_WindowPos3dvMESA 646
-#define _gloffset_WindowPos3fMESA 647
-#define _gloffset_WindowPos3fvMESA 648
-#define _gloffset_WindowPos3iMESA 649
-#define _gloffset_WindowPos3ivMESA 650
-#define _gloffset_WindowPos3sMESA 651
-#define _gloffset_WindowPos3svMESA 652
-#define _gloffset_WindowPos4dMESA 653
-#define _gloffset_WindowPos4dvMESA 654
-#define _gloffset_WindowPos4fMESA 655
-#define _gloffset_WindowPos4fvMESA 656
-#define _gloffset_WindowPos4iMESA 657
-#define _gloffset_WindowPos4ivMESA 658
-#define _gloffset_WindowPos4sMESA 659
-#define _gloffset_WindowPos4svMESA 660
-#define _gloffset_MultiModeDrawArraysIBM 661
-#define _gloffset_MultiModeDrawElementsIBM 662
-#define _gloffset_DeleteFencesNV 663
-#define _gloffset_FinishFenceNV 664
-#define _gloffset_GenFencesNV 665
-#define _gloffset_GetFenceivNV 666
-#define _gloffset_IsFenceNV 667
-#define _gloffset_SetFenceNV 668
-#define _gloffset_TestFenceNV 669
-#define _gloffset_AreProgramsResidentNV 670
-#define _gloffset_BindProgramNV 671
-#define _gloffset_DeleteProgramsNV 672
-#define _gloffset_ExecuteProgramNV 673
-#define _gloffset_GenProgramsNV 674
-#define _gloffset_GetProgramParameterdvNV 675
-#define _gloffset_GetProgramParameterfvNV 676
-#define _gloffset_GetProgramStringNV 677
-#define _gloffset_GetProgramivNV 678
-#define _gloffset_GetTrackMatrixivNV 679
-#define _gloffset_GetVertexAttribPointervNV 680
-#define _gloffset_GetVertexAttribdvNV 681
-#define _gloffset_GetVertexAttribfvNV 682
-#define _gloffset_GetVertexAttribivNV 683
-#define _gloffset_IsProgramNV 684
-#define _gloffset_LoadProgramNV 685
-#define _gloffset_ProgramParameters4dvNV 686
-#define _gloffset_ProgramParameters4fvNV 687
-#define _gloffset_RequestResidentProgramsNV 688
-#define _gloffset_TrackMatrixNV 689
-#define _gloffset_VertexAttrib1dNV 690
-#define _gloffset_VertexAttrib1dvNV 691
-#define _gloffset_VertexAttrib1fNV 692
-#define _gloffset_VertexAttrib1fvNV 693
-#define _gloffset_VertexAttrib1sNV 694
-#define _gloffset_VertexAttrib1svNV 695
-#define _gloffset_VertexAttrib2dNV 696
-#define _gloffset_VertexAttrib2dvNV 697
-#define _gloffset_VertexAttrib2fNV 698
-#define _gloffset_VertexAttrib2fvNV 699
-#define _gloffset_VertexAttrib2sNV 700
-#define _gloffset_VertexAttrib2svNV 701
-#define _gloffset_VertexAttrib3dNV 702
-#define _gloffset_VertexAttrib3dvNV 703
-#define _gloffset_VertexAttrib3fNV 704
-#define _gloffset_VertexAttrib3fvNV 705
-#define _gloffset_VertexAttrib3sNV 706
-#define _gloffset_VertexAttrib3svNV 707
-#define _gloffset_VertexAttrib4dNV 708
-#define _gloffset_VertexAttrib4dvNV 709
-#define _gloffset_VertexAttrib4fNV 710
-#define _gloffset_VertexAttrib4fvNV 711
-#define _gloffset_VertexAttrib4sNV 712
-#define _gloffset_VertexAttrib4svNV 713
-#define _gloffset_VertexAttrib4ubNV 714
-#define _gloffset_VertexAttrib4ubvNV 715
-#define _gloffset_VertexAttribPointerNV 716
-#define _gloffset_VertexAttribs1dvNV 717
-#define _gloffset_VertexAttribs1fvNV 718
-#define _gloffset_VertexAttribs1svNV 719
-#define _gloffset_VertexAttribs2dvNV 720
-#define _gloffset_VertexAttribs2fvNV 721
-#define _gloffset_VertexAttribs2svNV 722
-#define _gloffset_VertexAttribs3dvNV 723
-#define _gloffset_VertexAttribs3fvNV 724
-#define _gloffset_VertexAttribs3svNV 725
-#define _gloffset_VertexAttribs4dvNV 726
-#define _gloffset_VertexAttribs4fvNV 727
-#define _gloffset_VertexAttribs4svNV 728
-#define _gloffset_VertexAttribs4ubvNV 729
-#define _gloffset_GetTexBumpParameterfvATI 730
-#define _gloffset_GetTexBumpParameterivATI 731
-#define _gloffset_TexBumpParameterfvATI 732
-#define _gloffset_TexBumpParameterivATI 733
-#define _gloffset_AlphaFragmentOp1ATI 734
-#define _gloffset_AlphaFragmentOp2ATI 735
-#define _gloffset_AlphaFragmentOp3ATI 736
-#define _gloffset_BeginFragmentShaderATI 737
-#define _gloffset_BindFragmentShaderATI 738
-#define _gloffset_ColorFragmentOp1ATI 739
-#define _gloffset_ColorFragmentOp2ATI 740
-#define _gloffset_ColorFragmentOp3ATI 741
-#define _gloffset_DeleteFragmentShaderATI 742
-#define _gloffset_EndFragmentShaderATI 743
-#define _gloffset_GenFragmentShadersATI 744
-#define _gloffset_PassTexCoordATI 745
-#define _gloffset_SampleMapATI 746
-#define _gloffset_SetFragmentShaderConstantATI 747
-#define _gloffset_PointParameteriNV 748
-#define _gloffset_PointParameterivNV 749
-#define _gloffset_ActiveStencilFaceEXT 750
-#define _gloffset_BindVertexArrayAPPLE 751
-#define _gloffset_DeleteVertexArraysAPPLE 752
-#define _gloffset_GenVertexArraysAPPLE 753
-#define _gloffset_IsVertexArrayAPPLE 754
-#define _gloffset_GetProgramNamedParameterdvNV 755
-#define _gloffset_GetProgramNamedParameterfvNV 756
-#define _gloffset_ProgramNamedParameter4dNV 757
-#define _gloffset_ProgramNamedParameter4dvNV 758
-#define _gloffset_ProgramNamedParameter4fNV 759
-#define _gloffset_ProgramNamedParameter4fvNV 760
-#define _gloffset_DepthBoundsEXT 761
-#define _gloffset_BlendEquationSeparateEXT 762
-#define _gloffset_BindFramebufferEXT 763
-#define _gloffset_BindRenderbufferEXT 764
-#define _gloffset_CheckFramebufferStatusEXT 765
-#define _gloffset_DeleteFramebuffersEXT 766
-#define _gloffset_DeleteRenderbuffersEXT 767
-#define _gloffset_FramebufferRenderbufferEXT 768
-#define _gloffset_FramebufferTexture1DEXT 769
-#define _gloffset_FramebufferTexture2DEXT 770
-#define _gloffset_FramebufferTexture3DEXT 771
-#define _gloffset_GenFramebuffersEXT 772
-#define _gloffset_GenRenderbuffersEXT 773
-#define _gloffset_GenerateMipmapEXT 774
-#define _gloffset_GetFramebufferAttachmentParameterivEXT 775
-#define _gloffset_GetRenderbufferParameterivEXT 776
-#define _gloffset_IsFramebufferEXT 777
-#define _gloffset_IsRenderbufferEXT 778
-#define _gloffset_RenderbufferStorageEXT 779
-#define _gloffset_BlitFramebufferEXT 780
-#define _gloffset_BufferParameteriAPPLE 781
-#define _gloffset_FlushMappedBufferRangeAPPLE 782
-#define _gloffset_FramebufferTextureLayerEXT 783
-#define _gloffset_ProvokingVertexEXT 784
-#define _gloffset_GetTexParameterPointervAPPLE 785
-#define _gloffset_TextureRangeAPPLE 786
-#define _gloffset_StencilFuncSeparateATI 787
-#define _gloffset_ProgramEnvParameters4fvEXT 788
-#define _gloffset_ProgramLocalParameters4fvEXT 789
-#define _gloffset_GetQueryObjecti64vEXT 790
-#define _gloffset_GetQueryObjectui64vEXT 791
-#define _gloffset_FIRST_DYNAMIC 792
+#define _gloffset_DrawElementsBaseVertex 574
+#define _gloffset_DrawRangeElementsBaseVertex 575
+#define _gloffset_MultiDrawElementsBaseVertex 576
+#define _gloffset_PolygonOffsetEXT 577
+#define _gloffset_GetPixelTexGenParameterfvSGIS 578
+#define _gloffset_GetPixelTexGenParameterivSGIS 579
+#define _gloffset_PixelTexGenParameterfSGIS 580
+#define _gloffset_PixelTexGenParameterfvSGIS 581
+#define _gloffset_PixelTexGenParameteriSGIS 582
+#define _gloffset_PixelTexGenParameterivSGIS 583
+#define _gloffset_SampleMaskSGIS 584
+#define _gloffset_SamplePatternSGIS 585
+#define _gloffset_ColorPointerEXT 586
+#define _gloffset_EdgeFlagPointerEXT 587
+#define _gloffset_IndexPointerEXT 588
+#define _gloffset_NormalPointerEXT 589
+#define _gloffset_TexCoordPointerEXT 590
+#define _gloffset_VertexPointerEXT 591
+#define _gloffset_PointParameterfEXT 592
+#define _gloffset_PointParameterfvEXT 593
+#define _gloffset_LockArraysEXT 594
+#define _gloffset_UnlockArraysEXT 595
+#define _gloffset_CullParameterdvEXT 596
+#define _gloffset_CullParameterfvEXT 597
+#define _gloffset_SecondaryColor3bEXT 598
+#define _gloffset_SecondaryColor3bvEXT 599
+#define _gloffset_SecondaryColor3dEXT 600
+#define _gloffset_SecondaryColor3dvEXT 601
+#define _gloffset_SecondaryColor3fEXT 602
+#define _gloffset_SecondaryColor3fvEXT 603
+#define _gloffset_SecondaryColor3iEXT 604
+#define _gloffset_SecondaryColor3ivEXT 605
+#define _gloffset_SecondaryColor3sEXT 606
+#define _gloffset_SecondaryColor3svEXT 607
+#define _gloffset_SecondaryColor3ubEXT 608
+#define _gloffset_SecondaryColor3ubvEXT 609
+#define _gloffset_SecondaryColor3uiEXT 610
+#define _gloffset_SecondaryColor3uivEXT 611
+#define _gloffset_SecondaryColor3usEXT 612
+#define _gloffset_SecondaryColor3usvEXT 613
+#define _gloffset_SecondaryColorPointerEXT 614
+#define _gloffset_MultiDrawArraysEXT 615
+#define _gloffset_MultiDrawElementsEXT 616
+#define _gloffset_FogCoordPointerEXT 617
+#define _gloffset_FogCoorddEXT 618
+#define _gloffset_FogCoorddvEXT 619
+#define _gloffset_FogCoordfEXT 620
+#define _gloffset_FogCoordfvEXT 621
+#define _gloffset_PixelTexGenSGIX 622
+#define _gloffset_BlendFuncSeparateEXT 623
+#define _gloffset_FlushVertexArrayRangeNV 624
+#define _gloffset_VertexArrayRangeNV 625
+#define _gloffset_CombinerInputNV 626
+#define _gloffset_CombinerOutputNV 627
+#define _gloffset_CombinerParameterfNV 628
+#define _gloffset_CombinerParameterfvNV 629
+#define _gloffset_CombinerParameteriNV 630
+#define _gloffset_CombinerParameterivNV 631
+#define _gloffset_FinalCombinerInputNV 632
+#define _gloffset_GetCombinerInputParameterfvNV 633
+#define _gloffset_GetCombinerInputParameterivNV 634
+#define _gloffset_GetCombinerOutputParameterfvNV 635
+#define _gloffset_GetCombinerOutputParameterivNV 636
+#define _gloffset_GetFinalCombinerInputParameterfvNV 637
+#define _gloffset_GetFinalCombinerInputParameterivNV 638
+#define _gloffset_ResizeBuffersMESA 639
+#define _gloffset_WindowPos2dMESA 640
+#define _gloffset_WindowPos2dvMESA 641
+#define _gloffset_WindowPos2fMESA 642
+#define _gloffset_WindowPos2fvMESA 643
+#define _gloffset_WindowPos2iMESA 644
+#define _gloffset_WindowPos2ivMESA 645
+#define _gloffset_WindowPos2sMESA 646
+#define _gloffset_WindowPos2svMESA 647
+#define _gloffset_WindowPos3dMESA 648
+#define _gloffset_WindowPos3dvMESA 649
+#define _gloffset_WindowPos3fMESA 650
+#define _gloffset_WindowPos3fvMESA 651
+#define _gloffset_WindowPos3iMESA 652
+#define _gloffset_WindowPos3ivMESA 653
+#define _gloffset_WindowPos3sMESA 654
+#define _gloffset_WindowPos3svMESA 655
+#define _gloffset_WindowPos4dMESA 656
+#define _gloffset_WindowPos4dvMESA 657
+#define _gloffset_WindowPos4fMESA 658
+#define _gloffset_WindowPos4fvMESA 659
+#define _gloffset_WindowPos4iMESA 660
+#define _gloffset_WindowPos4ivMESA 661
+#define _gloffset_WindowPos4sMESA 662
+#define _gloffset_WindowPos4svMESA 663
+#define _gloffset_MultiModeDrawArraysIBM 664
+#define _gloffset_MultiModeDrawElementsIBM 665
+#define _gloffset_DeleteFencesNV 666
+#define _gloffset_FinishFenceNV 667
+#define _gloffset_GenFencesNV 668
+#define _gloffset_GetFenceivNV 669
+#define _gloffset_IsFenceNV 670
+#define _gloffset_SetFenceNV 671
+#define _gloffset_TestFenceNV 672
+#define _gloffset_AreProgramsResidentNV 673
+#define _gloffset_BindProgramNV 674
+#define _gloffset_DeleteProgramsNV 675
+#define _gloffset_ExecuteProgramNV 676
+#define _gloffset_GenProgramsNV 677
+#define _gloffset_GetProgramParameterdvNV 678
+#define _gloffset_GetProgramParameterfvNV 679
+#define _gloffset_GetProgramStringNV 680
+#define _gloffset_GetProgramivNV 681
+#define _gloffset_GetTrackMatrixivNV 682
+#define _gloffset_GetVertexAttribPointervNV 683
+#define _gloffset_GetVertexAttribdvNV 684
+#define _gloffset_GetVertexAttribfvNV 685
+#define _gloffset_GetVertexAttribivNV 686
+#define _gloffset_IsProgramNV 687
+#define _gloffset_LoadProgramNV 688
+#define _gloffset_ProgramParameters4dvNV 689
+#define _gloffset_ProgramParameters4fvNV 690
+#define _gloffset_RequestResidentProgramsNV 691
+#define _gloffset_TrackMatrixNV 692
+#define _gloffset_VertexAttrib1dNV 693
+#define _gloffset_VertexAttrib1dvNV 694
+#define _gloffset_VertexAttrib1fNV 695
+#define _gloffset_VertexAttrib1fvNV 696
+#define _gloffset_VertexAttrib1sNV 697
+#define _gloffset_VertexAttrib1svNV 698
+#define _gloffset_VertexAttrib2dNV 699
+#define _gloffset_VertexAttrib2dvNV 700
+#define _gloffset_VertexAttrib2fNV 701
+#define _gloffset_VertexAttrib2fvNV 702
+#define _gloffset_VertexAttrib2sNV 703
+#define _gloffset_VertexAttrib2svNV 704
+#define _gloffset_VertexAttrib3dNV 705
+#define _gloffset_VertexAttrib3dvNV 706
+#define _gloffset_VertexAttrib3fNV 707
+#define _gloffset_VertexAttrib3fvNV 708
+#define _gloffset_VertexAttrib3sNV 709
+#define _gloffset_VertexAttrib3svNV 710
+#define _gloffset_VertexAttrib4dNV 711
+#define _gloffset_VertexAttrib4dvNV 712
+#define _gloffset_VertexAttrib4fNV 713
+#define _gloffset_VertexAttrib4fvNV 714
+#define _gloffset_VertexAttrib4sNV 715
+#define _gloffset_VertexAttrib4svNV 716
+#define _gloffset_VertexAttrib4ubNV 717
+#define _gloffset_VertexAttrib4ubvNV 718
+#define _gloffset_VertexAttribPointerNV 719
+#define _gloffset_VertexAttribs1dvNV 720
+#define _gloffset_VertexAttribs1fvNV 721
+#define _gloffset_VertexAttribs1svNV 722
+#define _gloffset_VertexAttribs2dvNV 723
+#define _gloffset_VertexAttribs2fvNV 724
+#define _gloffset_VertexAttribs2svNV 725
+#define _gloffset_VertexAttribs3dvNV 726
+#define _gloffset_VertexAttribs3fvNV 727
+#define _gloffset_VertexAttribs3svNV 728
+#define _gloffset_VertexAttribs4dvNV 729
+#define _gloffset_VertexAttribs4fvNV 730
+#define _gloffset_VertexAttribs4svNV 731
+#define _gloffset_VertexAttribs4ubvNV 732
+#define _gloffset_GetTexBumpParameterfvATI 733
+#define _gloffset_GetTexBumpParameterivATI 734
+#define _gloffset_TexBumpParameterfvATI 735
+#define _gloffset_TexBumpParameterivATI 736
+#define _gloffset_AlphaFragmentOp1ATI 737
+#define _gloffset_AlphaFragmentOp2ATI 738
+#define _gloffset_AlphaFragmentOp3ATI 739
+#define _gloffset_BeginFragmentShaderATI 740
+#define _gloffset_BindFragmentShaderATI 741
+#define _gloffset_ColorFragmentOp1ATI 742
+#define _gloffset_ColorFragmentOp2ATI 743
+#define _gloffset_ColorFragmentOp3ATI 744
+#define _gloffset_DeleteFragmentShaderATI 745
+#define _gloffset_EndFragmentShaderATI 746
+#define _gloffset_GenFragmentShadersATI 747
+#define _gloffset_PassTexCoordATI 748
+#define _gloffset_SampleMapATI 749
+#define _gloffset_SetFragmentShaderConstantATI 750
+#define _gloffset_PointParameteriNV 751
+#define _gloffset_PointParameterivNV 752
+#define _gloffset_ActiveStencilFaceEXT 753
+#define _gloffset_BindVertexArrayAPPLE 754
+#define _gloffset_DeleteVertexArraysAPPLE 755
+#define _gloffset_GenVertexArraysAPPLE 756
+#define _gloffset_IsVertexArrayAPPLE 757
+#define _gloffset_GetProgramNamedParameterdvNV 758
+#define _gloffset_GetProgramNamedParameterfvNV 759
+#define _gloffset_ProgramNamedParameter4dNV 760
+#define _gloffset_ProgramNamedParameter4dvNV 761
+#define _gloffset_ProgramNamedParameter4fNV 762
+#define _gloffset_ProgramNamedParameter4fvNV 763
+#define _gloffset_DepthBoundsEXT 764
+#define _gloffset_BlendEquationSeparateEXT 765
+#define _gloffset_BindFramebufferEXT 766
+#define _gloffset_BindRenderbufferEXT 767
+#define _gloffset_CheckFramebufferStatusEXT 768
+#define _gloffset_DeleteFramebuffersEXT 769
+#define _gloffset_DeleteRenderbuffersEXT 770
+#define _gloffset_FramebufferRenderbufferEXT 771
+#define _gloffset_FramebufferTexture1DEXT 772
+#define _gloffset_FramebufferTexture2DEXT 773
+#define _gloffset_FramebufferTexture3DEXT 774
+#define _gloffset_GenFramebuffersEXT 775
+#define _gloffset_GenRenderbuffersEXT 776
+#define _gloffset_GenerateMipmapEXT 777
+#define _gloffset_GetFramebufferAttachmentParameterivEXT 778
+#define _gloffset_GetRenderbufferParameterivEXT 779
+#define _gloffset_IsFramebufferEXT 780
+#define _gloffset_IsRenderbufferEXT 781
+#define _gloffset_RenderbufferStorageEXT 782
+#define _gloffset_BlitFramebufferEXT 783
+#define _gloffset_BufferParameteriAPPLE 784
+#define _gloffset_FlushMappedBufferRangeAPPLE 785
+#define _gloffset_FramebufferTextureLayerEXT 786
+#define _gloffset_ProvokingVertexEXT 787
+#define _gloffset_GetTexParameterPointervAPPLE 788
+#define _gloffset_TextureRangeAPPLE 789
+#define _gloffset_StencilFuncSeparateATI 790
+#define _gloffset_ProgramEnvParameters4fvEXT 791
+#define _gloffset_ProgramLocalParameters4fvEXT 792
+#define _gloffset_GetQueryObjecti64vEXT 793
+#define _gloffset_GetQueryObjectui64vEXT 794
+#define _gloffset_FIRST_DYNAMIC 795
#else
#define _gloffset_GetSynciv driDispatchRemapTable[GetSynciv_remap_index]
#define _gloffset_IsSync driDispatchRemapTable[IsSync_remap_index]
#define _gloffset_WaitSync driDispatchRemapTable[WaitSync_remap_index]
+#define _gloffset_DrawElementsBaseVertex driDispatchRemapTable[DrawElementsBaseVertex_remap_index]
+#define _gloffset_DrawRangeElementsBaseVertex driDispatchRemapTable[DrawRangeElementsBaseVertex_remap_index]
+#define _gloffset_MultiDrawElementsBaseVertex driDispatchRemapTable[MultiDrawElementsBaseVertex_remap_index]
#define _gloffset_PolygonOffsetEXT driDispatchRemapTable[PolygonOffsetEXT_remap_index]
#define _gloffset_GetPixelTexGenParameterfvSGIS driDispatchRemapTable[GetPixelTexGenParameterfvSGIS_remap_index]
#define _gloffset_GetPixelTexGenParameterivSGIS driDispatchRemapTable[GetPixelTexGenParameterivSGIS_remap_index]
void (GLAPIENTRYP GetSynciv)(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei * length, GLint * values); /* 571 */
GLboolean (GLAPIENTRYP IsSync)(GLsync sync); /* 572 */
void (GLAPIENTRYP WaitSync)(GLsync sync, GLbitfield flags, GLuint64 timeout); /* 573 */
- void (GLAPIENTRYP PolygonOffsetEXT)(GLfloat factor, GLfloat bias); /* 574 */
- void (GLAPIENTRYP GetPixelTexGenParameterfvSGIS)(GLenum pname, GLfloat * params); /* 575 */
- void (GLAPIENTRYP GetPixelTexGenParameterivSGIS)(GLenum pname, GLint * params); /* 576 */
- void (GLAPIENTRYP PixelTexGenParameterfSGIS)(GLenum pname, GLfloat param); /* 577 */
- void (GLAPIENTRYP PixelTexGenParameterfvSGIS)(GLenum pname, const GLfloat * params); /* 578 */
- void (GLAPIENTRYP PixelTexGenParameteriSGIS)(GLenum pname, GLint param); /* 579 */
- void (GLAPIENTRYP PixelTexGenParameterivSGIS)(GLenum pname, const GLint * params); /* 580 */
- void (GLAPIENTRYP SampleMaskSGIS)(GLclampf value, GLboolean invert); /* 581 */
- void (GLAPIENTRYP SamplePatternSGIS)(GLenum pattern); /* 582 */
- void (GLAPIENTRYP ColorPointerEXT)(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer); /* 583 */
- void (GLAPIENTRYP EdgeFlagPointerEXT)(GLsizei stride, GLsizei count, const GLboolean * pointer); /* 584 */
- void (GLAPIENTRYP IndexPointerEXT)(GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer); /* 585 */
- void (GLAPIENTRYP NormalPointerEXT)(GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer); /* 586 */
- void (GLAPIENTRYP TexCoordPointerEXT)(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer); /* 587 */
- void (GLAPIENTRYP VertexPointerEXT)(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer); /* 588 */
- void (GLAPIENTRYP PointParameterfEXT)(GLenum pname, GLfloat param); /* 589 */
- void (GLAPIENTRYP PointParameterfvEXT)(GLenum pname, const GLfloat * params); /* 590 */
- void (GLAPIENTRYP LockArraysEXT)(GLint first, GLsizei count); /* 591 */
- void (GLAPIENTRYP UnlockArraysEXT)(void); /* 592 */
- void (GLAPIENTRYP CullParameterdvEXT)(GLenum pname, GLdouble * params); /* 593 */
- void (GLAPIENTRYP CullParameterfvEXT)(GLenum pname, GLfloat * params); /* 594 */
- void (GLAPIENTRYP SecondaryColor3bEXT)(GLbyte red, GLbyte green, GLbyte blue); /* 595 */
- void (GLAPIENTRYP SecondaryColor3bvEXT)(const GLbyte * v); /* 596 */
- void (GLAPIENTRYP SecondaryColor3dEXT)(GLdouble red, GLdouble green, GLdouble blue); /* 597 */
- void (GLAPIENTRYP SecondaryColor3dvEXT)(const GLdouble * v); /* 598 */
- void (GLAPIENTRYP SecondaryColor3fEXT)(GLfloat red, GLfloat green, GLfloat blue); /* 599 */
- void (GLAPIENTRYP SecondaryColor3fvEXT)(const GLfloat * v); /* 600 */
- void (GLAPIENTRYP SecondaryColor3iEXT)(GLint red, GLint green, GLint blue); /* 601 */
- void (GLAPIENTRYP SecondaryColor3ivEXT)(const GLint * v); /* 602 */
- void (GLAPIENTRYP SecondaryColor3sEXT)(GLshort red, GLshort green, GLshort blue); /* 603 */
- void (GLAPIENTRYP SecondaryColor3svEXT)(const GLshort * v); /* 604 */
- void (GLAPIENTRYP SecondaryColor3ubEXT)(GLubyte red, GLubyte green, GLubyte blue); /* 605 */
- void (GLAPIENTRYP SecondaryColor3ubvEXT)(const GLubyte * v); /* 606 */
- void (GLAPIENTRYP SecondaryColor3uiEXT)(GLuint red, GLuint green, GLuint blue); /* 607 */
- void (GLAPIENTRYP SecondaryColor3uivEXT)(const GLuint * v); /* 608 */
- void (GLAPIENTRYP SecondaryColor3usEXT)(GLushort red, GLushort green, GLushort blue); /* 609 */
- void (GLAPIENTRYP SecondaryColor3usvEXT)(const GLushort * v); /* 610 */
- void (GLAPIENTRYP SecondaryColorPointerEXT)(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer); /* 611 */
- void (GLAPIENTRYP MultiDrawArraysEXT)(GLenum mode, GLint * first, GLsizei * count, GLsizei primcount); /* 612 */
- void (GLAPIENTRYP MultiDrawElementsEXT)(GLenum mode, const GLsizei * count, GLenum type, const GLvoid ** indices, GLsizei primcount); /* 613 */
- void (GLAPIENTRYP FogCoordPointerEXT)(GLenum type, GLsizei stride, const GLvoid * pointer); /* 614 */
- void (GLAPIENTRYP FogCoorddEXT)(GLdouble coord); /* 615 */
- void (GLAPIENTRYP FogCoorddvEXT)(const GLdouble * coord); /* 616 */
- void (GLAPIENTRYP FogCoordfEXT)(GLfloat coord); /* 617 */
- void (GLAPIENTRYP FogCoordfvEXT)(const GLfloat * coord); /* 618 */
- void (GLAPIENTRYP PixelTexGenSGIX)(GLenum mode); /* 619 */
- void (GLAPIENTRYP BlendFuncSeparateEXT)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); /* 620 */
- void (GLAPIENTRYP FlushVertexArrayRangeNV)(void); /* 621 */
- void (GLAPIENTRYP VertexArrayRangeNV)(GLsizei length, const GLvoid * pointer); /* 622 */
- void (GLAPIENTRYP CombinerInputNV)(GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage); /* 623 */
- void (GLAPIENTRYP CombinerOutputNV)(GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct, GLboolean muxSum); /* 624 */
- void (GLAPIENTRYP CombinerParameterfNV)(GLenum pname, GLfloat param); /* 625 */
- void (GLAPIENTRYP CombinerParameterfvNV)(GLenum pname, const GLfloat * params); /* 626 */
- void (GLAPIENTRYP CombinerParameteriNV)(GLenum pname, GLint param); /* 627 */
- void (GLAPIENTRYP CombinerParameterivNV)(GLenum pname, const GLint * params); /* 628 */
- void (GLAPIENTRYP FinalCombinerInputNV)(GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage); /* 629 */
- void (GLAPIENTRYP GetCombinerInputParameterfvNV)(GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat * params); /* 630 */
- void (GLAPIENTRYP GetCombinerInputParameterivNV)(GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint * params); /* 631 */
- void (GLAPIENTRYP GetCombinerOutputParameterfvNV)(GLenum stage, GLenum portion, GLenum pname, GLfloat * params); /* 632 */
- void (GLAPIENTRYP GetCombinerOutputParameterivNV)(GLenum stage, GLenum portion, GLenum pname, GLint * params); /* 633 */
- void (GLAPIENTRYP GetFinalCombinerInputParameterfvNV)(GLenum variable, GLenum pname, GLfloat * params); /* 634 */
- void (GLAPIENTRYP GetFinalCombinerInputParameterivNV)(GLenum variable, GLenum pname, GLint * params); /* 635 */
- void (GLAPIENTRYP ResizeBuffersMESA)(void); /* 636 */
- void (GLAPIENTRYP WindowPos2dMESA)(GLdouble x, GLdouble y); /* 637 */
- void (GLAPIENTRYP WindowPos2dvMESA)(const GLdouble * v); /* 638 */
- void (GLAPIENTRYP WindowPos2fMESA)(GLfloat x, GLfloat y); /* 639 */
- void (GLAPIENTRYP WindowPos2fvMESA)(const GLfloat * v); /* 640 */
- void (GLAPIENTRYP WindowPos2iMESA)(GLint x, GLint y); /* 641 */
- void (GLAPIENTRYP WindowPos2ivMESA)(const GLint * v); /* 642 */
- void (GLAPIENTRYP WindowPos2sMESA)(GLshort x, GLshort y); /* 643 */
- void (GLAPIENTRYP WindowPos2svMESA)(const GLshort * v); /* 644 */
- void (GLAPIENTRYP WindowPos3dMESA)(GLdouble x, GLdouble y, GLdouble z); /* 645 */
- void (GLAPIENTRYP WindowPos3dvMESA)(const GLdouble * v); /* 646 */
- void (GLAPIENTRYP WindowPos3fMESA)(GLfloat x, GLfloat y, GLfloat z); /* 647 */
- void (GLAPIENTRYP WindowPos3fvMESA)(const GLfloat * v); /* 648 */
- void (GLAPIENTRYP WindowPos3iMESA)(GLint x, GLint y, GLint z); /* 649 */
- void (GLAPIENTRYP WindowPos3ivMESA)(const GLint * v); /* 650 */
- void (GLAPIENTRYP WindowPos3sMESA)(GLshort x, GLshort y, GLshort z); /* 651 */
- void (GLAPIENTRYP WindowPos3svMESA)(const GLshort * v); /* 652 */
- void (GLAPIENTRYP WindowPos4dMESA)(GLdouble x, GLdouble y, GLdouble z, GLdouble w); /* 653 */
- void (GLAPIENTRYP WindowPos4dvMESA)(const GLdouble * v); /* 654 */
- void (GLAPIENTRYP WindowPos4fMESA)(GLfloat x, GLfloat y, GLfloat z, GLfloat w); /* 655 */
- void (GLAPIENTRYP WindowPos4fvMESA)(const GLfloat * v); /* 656 */
- void (GLAPIENTRYP WindowPos4iMESA)(GLint x, GLint y, GLint z, GLint w); /* 657 */
- void (GLAPIENTRYP WindowPos4ivMESA)(const GLint * v); /* 658 */
- void (GLAPIENTRYP WindowPos4sMESA)(GLshort x, GLshort y, GLshort z, GLshort w); /* 659 */
- void (GLAPIENTRYP WindowPos4svMESA)(const GLshort * v); /* 660 */
- void (GLAPIENTRYP MultiModeDrawArraysIBM)(const GLenum * mode, const GLint * first, const GLsizei * count, GLsizei primcount, GLint modestride); /* 661 */
- void (GLAPIENTRYP MultiModeDrawElementsIBM)(const GLenum * mode, const GLsizei * count, GLenum type, const GLvoid * const * indices, GLsizei primcount, GLint modestride); /* 662 */
- void (GLAPIENTRYP DeleteFencesNV)(GLsizei n, const GLuint * fences); /* 663 */
- void (GLAPIENTRYP FinishFenceNV)(GLuint fence); /* 664 */
- void (GLAPIENTRYP GenFencesNV)(GLsizei n, GLuint * fences); /* 665 */
- void (GLAPIENTRYP GetFenceivNV)(GLuint fence, GLenum pname, GLint * params); /* 666 */
- GLboolean (GLAPIENTRYP IsFenceNV)(GLuint fence); /* 667 */
- void (GLAPIENTRYP SetFenceNV)(GLuint fence, GLenum condition); /* 668 */
- GLboolean (GLAPIENTRYP TestFenceNV)(GLuint fence); /* 669 */
- GLboolean (GLAPIENTRYP AreProgramsResidentNV)(GLsizei n, const GLuint * ids, GLboolean * residences); /* 670 */
- void (GLAPIENTRYP BindProgramNV)(GLenum target, GLuint program); /* 671 */
- void (GLAPIENTRYP DeleteProgramsNV)(GLsizei n, const GLuint * programs); /* 672 */
- void (GLAPIENTRYP ExecuteProgramNV)(GLenum target, GLuint id, const GLfloat * params); /* 673 */
- void (GLAPIENTRYP GenProgramsNV)(GLsizei n, GLuint * programs); /* 674 */
- void (GLAPIENTRYP GetProgramParameterdvNV)(GLenum target, GLuint index, GLenum pname, GLdouble * params); /* 675 */
- void (GLAPIENTRYP GetProgramParameterfvNV)(GLenum target, GLuint index, GLenum pname, GLfloat * params); /* 676 */
- void (GLAPIENTRYP GetProgramStringNV)(GLuint id, GLenum pname, GLubyte * program); /* 677 */
- void (GLAPIENTRYP GetProgramivNV)(GLuint id, GLenum pname, GLint * params); /* 678 */
- void (GLAPIENTRYP GetTrackMatrixivNV)(GLenum target, GLuint address, GLenum pname, GLint * params); /* 679 */
- void (GLAPIENTRYP GetVertexAttribPointervNV)(GLuint index, GLenum pname, GLvoid ** pointer); /* 680 */
- void (GLAPIENTRYP GetVertexAttribdvNV)(GLuint index, GLenum pname, GLdouble * params); /* 681 */
- void (GLAPIENTRYP GetVertexAttribfvNV)(GLuint index, GLenum pname, GLfloat * params); /* 682 */
- void (GLAPIENTRYP GetVertexAttribivNV)(GLuint index, GLenum pname, GLint * params); /* 683 */
- GLboolean (GLAPIENTRYP IsProgramNV)(GLuint program); /* 684 */
- void (GLAPIENTRYP LoadProgramNV)(GLenum target, GLuint id, GLsizei len, const GLubyte * program); /* 685 */
- void (GLAPIENTRYP ProgramParameters4dvNV)(GLenum target, GLuint index, GLuint num, const GLdouble * params); /* 686 */
- void (GLAPIENTRYP ProgramParameters4fvNV)(GLenum target, GLuint index, GLuint num, const GLfloat * params); /* 687 */
- void (GLAPIENTRYP RequestResidentProgramsNV)(GLsizei n, const GLuint * ids); /* 688 */
- void (GLAPIENTRYP TrackMatrixNV)(GLenum target, GLuint address, GLenum matrix, GLenum transform); /* 689 */
- void (GLAPIENTRYP VertexAttrib1dNV)(GLuint index, GLdouble x); /* 690 */
- void (GLAPIENTRYP VertexAttrib1dvNV)(GLuint index, const GLdouble * v); /* 691 */
- void (GLAPIENTRYP VertexAttrib1fNV)(GLuint index, GLfloat x); /* 692 */
- void (GLAPIENTRYP VertexAttrib1fvNV)(GLuint index, const GLfloat * v); /* 693 */
- void (GLAPIENTRYP VertexAttrib1sNV)(GLuint index, GLshort x); /* 694 */
- void (GLAPIENTRYP VertexAttrib1svNV)(GLuint index, const GLshort * v); /* 695 */
- void (GLAPIENTRYP VertexAttrib2dNV)(GLuint index, GLdouble x, GLdouble y); /* 696 */
- void (GLAPIENTRYP VertexAttrib2dvNV)(GLuint index, const GLdouble * v); /* 697 */
- void (GLAPIENTRYP VertexAttrib2fNV)(GLuint index, GLfloat x, GLfloat y); /* 698 */
- void (GLAPIENTRYP VertexAttrib2fvNV)(GLuint index, const GLfloat * v); /* 699 */
- void (GLAPIENTRYP VertexAttrib2sNV)(GLuint index, GLshort x, GLshort y); /* 700 */
- void (GLAPIENTRYP VertexAttrib2svNV)(GLuint index, const GLshort * v); /* 701 */
- void (GLAPIENTRYP VertexAttrib3dNV)(GLuint index, GLdouble x, GLdouble y, GLdouble z); /* 702 */
- void (GLAPIENTRYP VertexAttrib3dvNV)(GLuint index, const GLdouble * v); /* 703 */
- void (GLAPIENTRYP VertexAttrib3fNV)(GLuint index, GLfloat x, GLfloat y, GLfloat z); /* 704 */
- void (GLAPIENTRYP VertexAttrib3fvNV)(GLuint index, const GLfloat * v); /* 705 */
- void (GLAPIENTRYP VertexAttrib3sNV)(GLuint index, GLshort x, GLshort y, GLshort z); /* 706 */
- void (GLAPIENTRYP VertexAttrib3svNV)(GLuint index, const GLshort * v); /* 707 */
- void (GLAPIENTRYP VertexAttrib4dNV)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); /* 708 */
- void (GLAPIENTRYP VertexAttrib4dvNV)(GLuint index, const GLdouble * v); /* 709 */
- void (GLAPIENTRYP VertexAttrib4fNV)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); /* 710 */
- void (GLAPIENTRYP VertexAttrib4fvNV)(GLuint index, const GLfloat * v); /* 711 */
- void (GLAPIENTRYP VertexAttrib4sNV)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); /* 712 */
- void (GLAPIENTRYP VertexAttrib4svNV)(GLuint index, const GLshort * v); /* 713 */
- void (GLAPIENTRYP VertexAttrib4ubNV)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); /* 714 */
- void (GLAPIENTRYP VertexAttrib4ubvNV)(GLuint index, const GLubyte * v); /* 715 */
- void (GLAPIENTRYP VertexAttribPointerNV)(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid * pointer); /* 716 */
- void (GLAPIENTRYP VertexAttribs1dvNV)(GLuint index, GLsizei n, const GLdouble * v); /* 717 */
- void (GLAPIENTRYP VertexAttribs1fvNV)(GLuint index, GLsizei n, const GLfloat * v); /* 718 */
- void (GLAPIENTRYP VertexAttribs1svNV)(GLuint index, GLsizei n, const GLshort * v); /* 719 */
- void (GLAPIENTRYP VertexAttribs2dvNV)(GLuint index, GLsizei n, const GLdouble * v); /* 720 */
- void (GLAPIENTRYP VertexAttribs2fvNV)(GLuint index, GLsizei n, const GLfloat * v); /* 721 */
- void (GLAPIENTRYP VertexAttribs2svNV)(GLuint index, GLsizei n, const GLshort * v); /* 722 */
- void (GLAPIENTRYP VertexAttribs3dvNV)(GLuint index, GLsizei n, const GLdouble * v); /* 723 */
- void (GLAPIENTRYP VertexAttribs3fvNV)(GLuint index, GLsizei n, const GLfloat * v); /* 724 */
- void (GLAPIENTRYP VertexAttribs3svNV)(GLuint index, GLsizei n, const GLshort * v); /* 725 */
- void (GLAPIENTRYP VertexAttribs4dvNV)(GLuint index, GLsizei n, const GLdouble * v); /* 726 */
- void (GLAPIENTRYP VertexAttribs4fvNV)(GLuint index, GLsizei n, const GLfloat * v); /* 727 */
- void (GLAPIENTRYP VertexAttribs4svNV)(GLuint index, GLsizei n, const GLshort * v); /* 728 */
- void (GLAPIENTRYP VertexAttribs4ubvNV)(GLuint index, GLsizei n, const GLubyte * v); /* 729 */
- void (GLAPIENTRYP GetTexBumpParameterfvATI)(GLenum pname, GLfloat * param); /* 730 */
- void (GLAPIENTRYP GetTexBumpParameterivATI)(GLenum pname, GLint * param); /* 731 */
- void (GLAPIENTRYP TexBumpParameterfvATI)(GLenum pname, const GLfloat * param); /* 732 */
- void (GLAPIENTRYP TexBumpParameterivATI)(GLenum pname, const GLint * param); /* 733 */
- void (GLAPIENTRYP AlphaFragmentOp1ATI)(GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod); /* 734 */
- void (GLAPIENTRYP AlphaFragmentOp2ATI)(GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod); /* 735 */
- void (GLAPIENTRYP AlphaFragmentOp3ATI)(GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod); /* 736 */
- void (GLAPIENTRYP BeginFragmentShaderATI)(void); /* 737 */
- void (GLAPIENTRYP BindFragmentShaderATI)(GLuint id); /* 738 */
- void (GLAPIENTRYP ColorFragmentOp1ATI)(GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod); /* 739 */
- void (GLAPIENTRYP ColorFragmentOp2ATI)(GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod); /* 740 */
- void (GLAPIENTRYP ColorFragmentOp3ATI)(GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod); /* 741 */
- void (GLAPIENTRYP DeleteFragmentShaderATI)(GLuint id); /* 742 */
- void (GLAPIENTRYP EndFragmentShaderATI)(void); /* 743 */
- GLuint (GLAPIENTRYP GenFragmentShadersATI)(GLuint range); /* 744 */
- void (GLAPIENTRYP PassTexCoordATI)(GLuint dst, GLuint coord, GLenum swizzle); /* 745 */
- void (GLAPIENTRYP SampleMapATI)(GLuint dst, GLuint interp, GLenum swizzle); /* 746 */
- void (GLAPIENTRYP SetFragmentShaderConstantATI)(GLuint dst, const GLfloat * value); /* 747 */
- void (GLAPIENTRYP PointParameteriNV)(GLenum pname, GLint param); /* 748 */
- void (GLAPIENTRYP PointParameterivNV)(GLenum pname, const GLint * params); /* 749 */
- void (GLAPIENTRYP ActiveStencilFaceEXT)(GLenum face); /* 750 */
- void (GLAPIENTRYP BindVertexArrayAPPLE)(GLuint array); /* 751 */
- void (GLAPIENTRYP DeleteVertexArraysAPPLE)(GLsizei n, const GLuint * arrays); /* 752 */
- void (GLAPIENTRYP GenVertexArraysAPPLE)(GLsizei n, GLuint * arrays); /* 753 */
- GLboolean (GLAPIENTRYP IsVertexArrayAPPLE)(GLuint array); /* 754 */
- void (GLAPIENTRYP GetProgramNamedParameterdvNV)(GLuint id, GLsizei len, const GLubyte * name, GLdouble * params); /* 755 */
- void (GLAPIENTRYP GetProgramNamedParameterfvNV)(GLuint id, GLsizei len, const GLubyte * name, GLfloat * params); /* 756 */
- void (GLAPIENTRYP ProgramNamedParameter4dNV)(GLuint id, GLsizei len, const GLubyte * name, GLdouble x, GLdouble y, GLdouble z, GLdouble w); /* 757 */
- void (GLAPIENTRYP ProgramNamedParameter4dvNV)(GLuint id, GLsizei len, const GLubyte * name, const GLdouble * v); /* 758 */
- void (GLAPIENTRYP ProgramNamedParameter4fNV)(GLuint id, GLsizei len, const GLubyte * name, GLfloat x, GLfloat y, GLfloat z, GLfloat w); /* 759 */
- void (GLAPIENTRYP ProgramNamedParameter4fvNV)(GLuint id, GLsizei len, const GLubyte * name, const GLfloat * v); /* 760 */
- void (GLAPIENTRYP DepthBoundsEXT)(GLclampd zmin, GLclampd zmax); /* 761 */
- void (GLAPIENTRYP BlendEquationSeparateEXT)(GLenum modeRGB, GLenum modeA); /* 762 */
- void (GLAPIENTRYP BindFramebufferEXT)(GLenum target, GLuint framebuffer); /* 763 */
- void (GLAPIENTRYP BindRenderbufferEXT)(GLenum target, GLuint renderbuffer); /* 764 */
- GLenum (GLAPIENTRYP CheckFramebufferStatusEXT)(GLenum target); /* 765 */
- void (GLAPIENTRYP DeleteFramebuffersEXT)(GLsizei n, const GLuint * framebuffers); /* 766 */
- void (GLAPIENTRYP DeleteRenderbuffersEXT)(GLsizei n, const GLuint * renderbuffers); /* 767 */
- void (GLAPIENTRYP FramebufferRenderbufferEXT)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); /* 768 */
- void (GLAPIENTRYP FramebufferTexture1DEXT)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); /* 769 */
- void (GLAPIENTRYP FramebufferTexture2DEXT)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); /* 770 */
- void (GLAPIENTRYP FramebufferTexture3DEXT)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); /* 771 */
- void (GLAPIENTRYP GenFramebuffersEXT)(GLsizei n, GLuint * framebuffers); /* 772 */
- void (GLAPIENTRYP GenRenderbuffersEXT)(GLsizei n, GLuint * renderbuffers); /* 773 */
- void (GLAPIENTRYP GenerateMipmapEXT)(GLenum target); /* 774 */
- void (GLAPIENTRYP GetFramebufferAttachmentParameterivEXT)(GLenum target, GLenum attachment, GLenum pname, GLint * params); /* 775 */
- void (GLAPIENTRYP GetRenderbufferParameterivEXT)(GLenum target, GLenum pname, GLint * params); /* 776 */
- GLboolean (GLAPIENTRYP IsFramebufferEXT)(GLuint framebuffer); /* 777 */
- GLboolean (GLAPIENTRYP IsRenderbufferEXT)(GLuint renderbuffer); /* 778 */
- void (GLAPIENTRYP RenderbufferStorageEXT)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height); /* 779 */
- void (GLAPIENTRYP BlitFramebufferEXT)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); /* 780 */
- void (GLAPIENTRYP BufferParameteriAPPLE)(GLenum target, GLenum pname, GLint param); /* 781 */
- void (GLAPIENTRYP FlushMappedBufferRangeAPPLE)(GLenum target, GLintptr offset, GLsizeiptr size); /* 782 */
- void (GLAPIENTRYP FramebufferTextureLayerEXT)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); /* 783 */
- void (GLAPIENTRYP ProvokingVertexEXT)(GLenum mode); /* 784 */
- void (GLAPIENTRYP GetTexParameterPointervAPPLE)(GLenum target, GLenum pname, GLvoid ** params); /* 785 */
- void (GLAPIENTRYP TextureRangeAPPLE)(GLenum target, GLsizei length, GLvoid * pointer); /* 786 */
- void (GLAPIENTRYP StencilFuncSeparateATI)(GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask); /* 787 */
- void (GLAPIENTRYP ProgramEnvParameters4fvEXT)(GLenum target, GLuint index, GLsizei count, const GLfloat * params); /* 788 */
- void (GLAPIENTRYP ProgramLocalParameters4fvEXT)(GLenum target, GLuint index, GLsizei count, const GLfloat * params); /* 789 */
- void (GLAPIENTRYP GetQueryObjecti64vEXT)(GLuint id, GLenum pname, GLint64EXT * params); /* 790 */
- void (GLAPIENTRYP GetQueryObjectui64vEXT)(GLuint id, GLenum pname, GLuint64EXT * params); /* 791 */
+ void (GLAPIENTRYP DrawElementsBaseVertex)(GLenum mode, GLsizei count, GLenum type, const GLvoid * indices, GLint basevertex); /* 574 */
+ void (GLAPIENTRYP DrawRangeElementsBaseVertex)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid * indices, GLint basevertex); /* 575 */
+ void (GLAPIENTRYP MultiDrawElementsBaseVertex)(GLenum mode, const GLsizei * count, GLenum type, const GLvoid ** indices, GLsizei primcount, const GLint * basevertex); /* 576 */
+ void (GLAPIENTRYP PolygonOffsetEXT)(GLfloat factor, GLfloat bias); /* 577 */
+ void (GLAPIENTRYP GetPixelTexGenParameterfvSGIS)(GLenum pname, GLfloat * params); /* 578 */
+ void (GLAPIENTRYP GetPixelTexGenParameterivSGIS)(GLenum pname, GLint * params); /* 579 */
+ void (GLAPIENTRYP PixelTexGenParameterfSGIS)(GLenum pname, GLfloat param); /* 580 */
+ void (GLAPIENTRYP PixelTexGenParameterfvSGIS)(GLenum pname, const GLfloat * params); /* 581 */
+ void (GLAPIENTRYP PixelTexGenParameteriSGIS)(GLenum pname, GLint param); /* 582 */
+ void (GLAPIENTRYP PixelTexGenParameterivSGIS)(GLenum pname, const GLint * params); /* 583 */
+ void (GLAPIENTRYP SampleMaskSGIS)(GLclampf value, GLboolean invert); /* 584 */
+ void (GLAPIENTRYP SamplePatternSGIS)(GLenum pattern); /* 585 */
+ void (GLAPIENTRYP ColorPointerEXT)(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer); /* 586 */
+ void (GLAPIENTRYP EdgeFlagPointerEXT)(GLsizei stride, GLsizei count, const GLboolean * pointer); /* 587 */
+ void (GLAPIENTRYP IndexPointerEXT)(GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer); /* 588 */
+ void (GLAPIENTRYP NormalPointerEXT)(GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer); /* 589 */
+ void (GLAPIENTRYP TexCoordPointerEXT)(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer); /* 590 */
+ void (GLAPIENTRYP VertexPointerEXT)(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer); /* 591 */
+ void (GLAPIENTRYP PointParameterfEXT)(GLenum pname, GLfloat param); /* 592 */
+ void (GLAPIENTRYP PointParameterfvEXT)(GLenum pname, const GLfloat * params); /* 593 */
+ void (GLAPIENTRYP LockArraysEXT)(GLint first, GLsizei count); /* 594 */
+ void (GLAPIENTRYP UnlockArraysEXT)(void); /* 595 */
+ void (GLAPIENTRYP CullParameterdvEXT)(GLenum pname, GLdouble * params); /* 596 */
+ void (GLAPIENTRYP CullParameterfvEXT)(GLenum pname, GLfloat * params); /* 597 */
+ void (GLAPIENTRYP SecondaryColor3bEXT)(GLbyte red, GLbyte green, GLbyte blue); /* 598 */
+ void (GLAPIENTRYP SecondaryColor3bvEXT)(const GLbyte * v); /* 599 */
+ void (GLAPIENTRYP SecondaryColor3dEXT)(GLdouble red, GLdouble green, GLdouble blue); /* 600 */
+ void (GLAPIENTRYP SecondaryColor3dvEXT)(const GLdouble * v); /* 601 */
+ void (GLAPIENTRYP SecondaryColor3fEXT)(GLfloat red, GLfloat green, GLfloat blue); /* 602 */
+ void (GLAPIENTRYP SecondaryColor3fvEXT)(const GLfloat * v); /* 603 */
+ void (GLAPIENTRYP SecondaryColor3iEXT)(GLint red, GLint green, GLint blue); /* 604 */
+ void (GLAPIENTRYP SecondaryColor3ivEXT)(const GLint * v); /* 605 */
+ void (GLAPIENTRYP SecondaryColor3sEXT)(GLshort red, GLshort green, GLshort blue); /* 606 */
+ void (GLAPIENTRYP SecondaryColor3svEXT)(const GLshort * v); /* 607 */
+ void (GLAPIENTRYP SecondaryColor3ubEXT)(GLubyte red, GLubyte green, GLubyte blue); /* 608 */
+ void (GLAPIENTRYP SecondaryColor3ubvEXT)(const GLubyte * v); /* 609 */
+ void (GLAPIENTRYP SecondaryColor3uiEXT)(GLuint red, GLuint green, GLuint blue); /* 610 */
+ void (GLAPIENTRYP SecondaryColor3uivEXT)(const GLuint * v); /* 611 */
+ void (GLAPIENTRYP SecondaryColor3usEXT)(GLushort red, GLushort green, GLushort blue); /* 612 */
+ void (GLAPIENTRYP SecondaryColor3usvEXT)(const GLushort * v); /* 613 */
+ void (GLAPIENTRYP SecondaryColorPointerEXT)(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer); /* 614 */
+ void (GLAPIENTRYP MultiDrawArraysEXT)(GLenum mode, GLint * first, GLsizei * count, GLsizei primcount); /* 615 */
+ void (GLAPIENTRYP MultiDrawElementsEXT)(GLenum mode, const GLsizei * count, GLenum type, const GLvoid ** indices, GLsizei primcount); /* 616 */
+ void (GLAPIENTRYP FogCoordPointerEXT)(GLenum type, GLsizei stride, const GLvoid * pointer); /* 617 */
+ void (GLAPIENTRYP FogCoorddEXT)(GLdouble coord); /* 618 */
+ void (GLAPIENTRYP FogCoorddvEXT)(const GLdouble * coord); /* 619 */
+ void (GLAPIENTRYP FogCoordfEXT)(GLfloat coord); /* 620 */
+ void (GLAPIENTRYP FogCoordfvEXT)(const GLfloat * coord); /* 621 */
+ void (GLAPIENTRYP PixelTexGenSGIX)(GLenum mode); /* 622 */
+ void (GLAPIENTRYP BlendFuncSeparateEXT)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); /* 623 */
+ void (GLAPIENTRYP FlushVertexArrayRangeNV)(void); /* 624 */
+ void (GLAPIENTRYP VertexArrayRangeNV)(GLsizei length, const GLvoid * pointer); /* 625 */
+ void (GLAPIENTRYP CombinerInputNV)(GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage); /* 626 */
+ void (GLAPIENTRYP CombinerOutputNV)(GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct, GLboolean muxSum); /* 627 */
+ void (GLAPIENTRYP CombinerParameterfNV)(GLenum pname, GLfloat param); /* 628 */
+ void (GLAPIENTRYP CombinerParameterfvNV)(GLenum pname, const GLfloat * params); /* 629 */
+ void (GLAPIENTRYP CombinerParameteriNV)(GLenum pname, GLint param); /* 630 */
+ void (GLAPIENTRYP CombinerParameterivNV)(GLenum pname, const GLint * params); /* 631 */
+ void (GLAPIENTRYP FinalCombinerInputNV)(GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage); /* 632 */
+ void (GLAPIENTRYP GetCombinerInputParameterfvNV)(GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat * params); /* 633 */
+ void (GLAPIENTRYP GetCombinerInputParameterivNV)(GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint * params); /* 634 */
+ void (GLAPIENTRYP GetCombinerOutputParameterfvNV)(GLenum stage, GLenum portion, GLenum pname, GLfloat * params); /* 635 */
+ void (GLAPIENTRYP GetCombinerOutputParameterivNV)(GLenum stage, GLenum portion, GLenum pname, GLint * params); /* 636 */
+ void (GLAPIENTRYP GetFinalCombinerInputParameterfvNV)(GLenum variable, GLenum pname, GLfloat * params); /* 637 */
+ void (GLAPIENTRYP GetFinalCombinerInputParameterivNV)(GLenum variable, GLenum pname, GLint * params); /* 638 */
+ void (GLAPIENTRYP ResizeBuffersMESA)(void); /* 639 */
+ void (GLAPIENTRYP WindowPos2dMESA)(GLdouble x, GLdouble y); /* 640 */
+ void (GLAPIENTRYP WindowPos2dvMESA)(const GLdouble * v); /* 641 */
+ void (GLAPIENTRYP WindowPos2fMESA)(GLfloat x, GLfloat y); /* 642 */
+ void (GLAPIENTRYP WindowPos2fvMESA)(const GLfloat * v); /* 643 */
+ void (GLAPIENTRYP WindowPos2iMESA)(GLint x, GLint y); /* 644 */
+ void (GLAPIENTRYP WindowPos2ivMESA)(const GLint * v); /* 645 */
+ void (GLAPIENTRYP WindowPos2sMESA)(GLshort x, GLshort y); /* 646 */
+ void (GLAPIENTRYP WindowPos2svMESA)(const GLshort * v); /* 647 */
+ void (GLAPIENTRYP WindowPos3dMESA)(GLdouble x, GLdouble y, GLdouble z); /* 648 */
+ void (GLAPIENTRYP WindowPos3dvMESA)(const GLdouble * v); /* 649 */
+ void (GLAPIENTRYP WindowPos3fMESA)(GLfloat x, GLfloat y, GLfloat z); /* 650 */
+ void (GLAPIENTRYP WindowPos3fvMESA)(const GLfloat * v); /* 651 */
+ void (GLAPIENTRYP WindowPos3iMESA)(GLint x, GLint y, GLint z); /* 652 */
+ void (GLAPIENTRYP WindowPos3ivMESA)(const GLint * v); /* 653 */
+ void (GLAPIENTRYP WindowPos3sMESA)(GLshort x, GLshort y, GLshort z); /* 654 */
+ void (GLAPIENTRYP WindowPos3svMESA)(const GLshort * v); /* 655 */
+ void (GLAPIENTRYP WindowPos4dMESA)(GLdouble x, GLdouble y, GLdouble z, GLdouble w); /* 656 */
+ void (GLAPIENTRYP WindowPos4dvMESA)(const GLdouble * v); /* 657 */
+ void (GLAPIENTRYP WindowPos4fMESA)(GLfloat x, GLfloat y, GLfloat z, GLfloat w); /* 658 */
+ void (GLAPIENTRYP WindowPos4fvMESA)(const GLfloat * v); /* 659 */
+ void (GLAPIENTRYP WindowPos4iMESA)(GLint x, GLint y, GLint z, GLint w); /* 660 */
+ void (GLAPIENTRYP WindowPos4ivMESA)(const GLint * v); /* 661 */
+ void (GLAPIENTRYP WindowPos4sMESA)(GLshort x, GLshort y, GLshort z, GLshort w); /* 662 */
+ void (GLAPIENTRYP WindowPos4svMESA)(const GLshort * v); /* 663 */
+ void (GLAPIENTRYP MultiModeDrawArraysIBM)(const GLenum * mode, const GLint * first, const GLsizei * count, GLsizei primcount, GLint modestride); /* 664 */
+ void (GLAPIENTRYP MultiModeDrawElementsIBM)(const GLenum * mode, const GLsizei * count, GLenum type, const GLvoid * const * indices, GLsizei primcount, GLint modestride); /* 665 */
+ void (GLAPIENTRYP DeleteFencesNV)(GLsizei n, const GLuint * fences); /* 666 */
+ void (GLAPIENTRYP FinishFenceNV)(GLuint fence); /* 667 */
+ void (GLAPIENTRYP GenFencesNV)(GLsizei n, GLuint * fences); /* 668 */
+ void (GLAPIENTRYP GetFenceivNV)(GLuint fence, GLenum pname, GLint * params); /* 669 */
+ GLboolean (GLAPIENTRYP IsFenceNV)(GLuint fence); /* 670 */
+ void (GLAPIENTRYP SetFenceNV)(GLuint fence, GLenum condition); /* 671 */
+ GLboolean (GLAPIENTRYP TestFenceNV)(GLuint fence); /* 672 */
+ GLboolean (GLAPIENTRYP AreProgramsResidentNV)(GLsizei n, const GLuint * ids, GLboolean * residences); /* 673 */
+ void (GLAPIENTRYP BindProgramNV)(GLenum target, GLuint program); /* 674 */
+ void (GLAPIENTRYP DeleteProgramsNV)(GLsizei n, const GLuint * programs); /* 675 */
+ void (GLAPIENTRYP ExecuteProgramNV)(GLenum target, GLuint id, const GLfloat * params); /* 676 */
+ void (GLAPIENTRYP GenProgramsNV)(GLsizei n, GLuint * programs); /* 677 */
+ void (GLAPIENTRYP GetProgramParameterdvNV)(GLenum target, GLuint index, GLenum pname, GLdouble * params); /* 678 */
+ void (GLAPIENTRYP GetProgramParameterfvNV)(GLenum target, GLuint index, GLenum pname, GLfloat * params); /* 679 */
+ void (GLAPIENTRYP GetProgramStringNV)(GLuint id, GLenum pname, GLubyte * program); /* 680 */
+ void (GLAPIENTRYP GetProgramivNV)(GLuint id, GLenum pname, GLint * params); /* 681 */
+ void (GLAPIENTRYP GetTrackMatrixivNV)(GLenum target, GLuint address, GLenum pname, GLint * params); /* 682 */
+ void (GLAPIENTRYP GetVertexAttribPointervNV)(GLuint index, GLenum pname, GLvoid ** pointer); /* 683 */
+ void (GLAPIENTRYP GetVertexAttribdvNV)(GLuint index, GLenum pname, GLdouble * params); /* 684 */
+ void (GLAPIENTRYP GetVertexAttribfvNV)(GLuint index, GLenum pname, GLfloat * params); /* 685 */
+ void (GLAPIENTRYP GetVertexAttribivNV)(GLuint index, GLenum pname, GLint * params); /* 686 */
+ GLboolean (GLAPIENTRYP IsProgramNV)(GLuint program); /* 687 */
+ void (GLAPIENTRYP LoadProgramNV)(GLenum target, GLuint id, GLsizei len, const GLubyte * program); /* 688 */
+ void (GLAPIENTRYP ProgramParameters4dvNV)(GLenum target, GLuint index, GLuint num, const GLdouble * params); /* 689 */
+ void (GLAPIENTRYP ProgramParameters4fvNV)(GLenum target, GLuint index, GLuint num, const GLfloat * params); /* 690 */
+ void (GLAPIENTRYP RequestResidentProgramsNV)(GLsizei n, const GLuint * ids); /* 691 */
+ void (GLAPIENTRYP TrackMatrixNV)(GLenum target, GLuint address, GLenum matrix, GLenum transform); /* 692 */
+ void (GLAPIENTRYP VertexAttrib1dNV)(GLuint index, GLdouble x); /* 693 */
+ void (GLAPIENTRYP VertexAttrib1dvNV)(GLuint index, const GLdouble * v); /* 694 */
+ void (GLAPIENTRYP VertexAttrib1fNV)(GLuint index, GLfloat x); /* 695 */
+ void (GLAPIENTRYP VertexAttrib1fvNV)(GLuint index, const GLfloat * v); /* 696 */
+ void (GLAPIENTRYP VertexAttrib1sNV)(GLuint index, GLshort x); /* 697 */
+ void (GLAPIENTRYP VertexAttrib1svNV)(GLuint index, const GLshort * v); /* 698 */
+ void (GLAPIENTRYP VertexAttrib2dNV)(GLuint index, GLdouble x, GLdouble y); /* 699 */
+ void (GLAPIENTRYP VertexAttrib2dvNV)(GLuint index, const GLdouble * v); /* 700 */
+ void (GLAPIENTRYP VertexAttrib2fNV)(GLuint index, GLfloat x, GLfloat y); /* 701 */
+ void (GLAPIENTRYP VertexAttrib2fvNV)(GLuint index, const GLfloat * v); /* 702 */
+ void (GLAPIENTRYP VertexAttrib2sNV)(GLuint index, GLshort x, GLshort y); /* 703 */
+ void (GLAPIENTRYP VertexAttrib2svNV)(GLuint index, const GLshort * v); /* 704 */
+ void (GLAPIENTRYP VertexAttrib3dNV)(GLuint index, GLdouble x, GLdouble y, GLdouble z); /* 705 */
+ void (GLAPIENTRYP VertexAttrib3dvNV)(GLuint index, const GLdouble * v); /* 706 */
+ void (GLAPIENTRYP VertexAttrib3fNV)(GLuint index, GLfloat x, GLfloat y, GLfloat z); /* 707 */
+ void (GLAPIENTRYP VertexAttrib3fvNV)(GLuint index, const GLfloat * v); /* 708 */
+ void (GLAPIENTRYP VertexAttrib3sNV)(GLuint index, GLshort x, GLshort y, GLshort z); /* 709 */
+ void (GLAPIENTRYP VertexAttrib3svNV)(GLuint index, const GLshort * v); /* 710 */
+ void (GLAPIENTRYP VertexAttrib4dNV)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); /* 711 */
+ void (GLAPIENTRYP VertexAttrib4dvNV)(GLuint index, const GLdouble * v); /* 712 */
+ void (GLAPIENTRYP VertexAttrib4fNV)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); /* 713 */
+ void (GLAPIENTRYP VertexAttrib4fvNV)(GLuint index, const GLfloat * v); /* 714 */
+ void (GLAPIENTRYP VertexAttrib4sNV)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); /* 715 */
+ void (GLAPIENTRYP VertexAttrib4svNV)(GLuint index, const GLshort * v); /* 716 */
+ void (GLAPIENTRYP VertexAttrib4ubNV)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); /* 717 */
+ void (GLAPIENTRYP VertexAttrib4ubvNV)(GLuint index, const GLubyte * v); /* 718 */
+ void (GLAPIENTRYP VertexAttribPointerNV)(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid * pointer); /* 719 */
+ void (GLAPIENTRYP VertexAttribs1dvNV)(GLuint index, GLsizei n, const GLdouble * v); /* 720 */
+ void (GLAPIENTRYP VertexAttribs1fvNV)(GLuint index, GLsizei n, const GLfloat * v); /* 721 */
+ void (GLAPIENTRYP VertexAttribs1svNV)(GLuint index, GLsizei n, const GLshort * v); /* 722 */
+ void (GLAPIENTRYP VertexAttribs2dvNV)(GLuint index, GLsizei n, const GLdouble * v); /* 723 */
+ void (GLAPIENTRYP VertexAttribs2fvNV)(GLuint index, GLsizei n, const GLfloat * v); /* 724 */
+ void (GLAPIENTRYP VertexAttribs2svNV)(GLuint index, GLsizei n, const GLshort * v); /* 725 */
+ void (GLAPIENTRYP VertexAttribs3dvNV)(GLuint index, GLsizei n, const GLdouble * v); /* 726 */
+ void (GLAPIENTRYP VertexAttribs3fvNV)(GLuint index, GLsizei n, const GLfloat * v); /* 727 */
+ void (GLAPIENTRYP VertexAttribs3svNV)(GLuint index, GLsizei n, const GLshort * v); /* 728 */
+ void (GLAPIENTRYP VertexAttribs4dvNV)(GLuint index, GLsizei n, const GLdouble * v); /* 729 */
+ void (GLAPIENTRYP VertexAttribs4fvNV)(GLuint index, GLsizei n, const GLfloat * v); /* 730 */
+ void (GLAPIENTRYP VertexAttribs4svNV)(GLuint index, GLsizei n, const GLshort * v); /* 731 */
+ void (GLAPIENTRYP VertexAttribs4ubvNV)(GLuint index, GLsizei n, const GLubyte * v); /* 732 */
+ void (GLAPIENTRYP GetTexBumpParameterfvATI)(GLenum pname, GLfloat * param); /* 733 */
+ void (GLAPIENTRYP GetTexBumpParameterivATI)(GLenum pname, GLint * param); /* 734 */
+ void (GLAPIENTRYP TexBumpParameterfvATI)(GLenum pname, const GLfloat * param); /* 735 */
+ void (GLAPIENTRYP TexBumpParameterivATI)(GLenum pname, const GLint * param); /* 736 */
+ void (GLAPIENTRYP AlphaFragmentOp1ATI)(GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod); /* 737 */
+ void (GLAPIENTRYP AlphaFragmentOp2ATI)(GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod); /* 738 */
+ void (GLAPIENTRYP AlphaFragmentOp3ATI)(GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod); /* 739 */
+ void (GLAPIENTRYP BeginFragmentShaderATI)(void); /* 740 */
+ void (GLAPIENTRYP BindFragmentShaderATI)(GLuint id); /* 741 */
+ void (GLAPIENTRYP ColorFragmentOp1ATI)(GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod); /* 742 */
+ void (GLAPIENTRYP ColorFragmentOp2ATI)(GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod); /* 743 */
+ void (GLAPIENTRYP ColorFragmentOp3ATI)(GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod); /* 744 */
+ void (GLAPIENTRYP DeleteFragmentShaderATI)(GLuint id); /* 745 */
+ void (GLAPIENTRYP EndFragmentShaderATI)(void); /* 746 */
+ GLuint (GLAPIENTRYP GenFragmentShadersATI)(GLuint range); /* 747 */
+ void (GLAPIENTRYP PassTexCoordATI)(GLuint dst, GLuint coord, GLenum swizzle); /* 748 */
+ void (GLAPIENTRYP SampleMapATI)(GLuint dst, GLuint interp, GLenum swizzle); /* 749 */
+ void (GLAPIENTRYP SetFragmentShaderConstantATI)(GLuint dst, const GLfloat * value); /* 750 */
+ void (GLAPIENTRYP PointParameteriNV)(GLenum pname, GLint param); /* 751 */
+ void (GLAPIENTRYP PointParameterivNV)(GLenum pname, const GLint * params); /* 752 */
+ void (GLAPIENTRYP ActiveStencilFaceEXT)(GLenum face); /* 753 */
+ void (GLAPIENTRYP BindVertexArrayAPPLE)(GLuint array); /* 754 */
+ void (GLAPIENTRYP DeleteVertexArraysAPPLE)(GLsizei n, const GLuint * arrays); /* 755 */
+ void (GLAPIENTRYP GenVertexArraysAPPLE)(GLsizei n, GLuint * arrays); /* 756 */
+ GLboolean (GLAPIENTRYP IsVertexArrayAPPLE)(GLuint array); /* 757 */
+ void (GLAPIENTRYP GetProgramNamedParameterdvNV)(GLuint id, GLsizei len, const GLubyte * name, GLdouble * params); /* 758 */
+ void (GLAPIENTRYP GetProgramNamedParameterfvNV)(GLuint id, GLsizei len, const GLubyte * name, GLfloat * params); /* 759 */
+ void (GLAPIENTRYP ProgramNamedParameter4dNV)(GLuint id, GLsizei len, const GLubyte * name, GLdouble x, GLdouble y, GLdouble z, GLdouble w); /* 760 */
+ void (GLAPIENTRYP ProgramNamedParameter4dvNV)(GLuint id, GLsizei len, const GLubyte * name, const GLdouble * v); /* 761 */
+ void (GLAPIENTRYP ProgramNamedParameter4fNV)(GLuint id, GLsizei len, const GLubyte * name, GLfloat x, GLfloat y, GLfloat z, GLfloat w); /* 762 */
+ void (GLAPIENTRYP ProgramNamedParameter4fvNV)(GLuint id, GLsizei len, const GLubyte * name, const GLfloat * v); /* 763 */
+ void (GLAPIENTRYP DepthBoundsEXT)(GLclampd zmin, GLclampd zmax); /* 764 */
+ void (GLAPIENTRYP BlendEquationSeparateEXT)(GLenum modeRGB, GLenum modeA); /* 765 */
+ void (GLAPIENTRYP BindFramebufferEXT)(GLenum target, GLuint framebuffer); /* 766 */
+ void (GLAPIENTRYP BindRenderbufferEXT)(GLenum target, GLuint renderbuffer); /* 767 */
+ GLenum (GLAPIENTRYP CheckFramebufferStatusEXT)(GLenum target); /* 768 */
+ void (GLAPIENTRYP DeleteFramebuffersEXT)(GLsizei n, const GLuint * framebuffers); /* 769 */
+ void (GLAPIENTRYP DeleteRenderbuffersEXT)(GLsizei n, const GLuint * renderbuffers); /* 770 */
+ void (GLAPIENTRYP FramebufferRenderbufferEXT)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); /* 771 */
+ void (GLAPIENTRYP FramebufferTexture1DEXT)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); /* 772 */
+ void (GLAPIENTRYP FramebufferTexture2DEXT)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); /* 773 */
+ void (GLAPIENTRYP FramebufferTexture3DEXT)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); /* 774 */
+ void (GLAPIENTRYP GenFramebuffersEXT)(GLsizei n, GLuint * framebuffers); /* 775 */
+ void (GLAPIENTRYP GenRenderbuffersEXT)(GLsizei n, GLuint * renderbuffers); /* 776 */
+ void (GLAPIENTRYP GenerateMipmapEXT)(GLenum target); /* 777 */
+ void (GLAPIENTRYP GetFramebufferAttachmentParameterivEXT)(GLenum target, GLenum attachment, GLenum pname, GLint * params); /* 778 */
+ void (GLAPIENTRYP GetRenderbufferParameterivEXT)(GLenum target, GLenum pname, GLint * params); /* 779 */
+ GLboolean (GLAPIENTRYP IsFramebufferEXT)(GLuint framebuffer); /* 780 */
+ GLboolean (GLAPIENTRYP IsRenderbufferEXT)(GLuint renderbuffer); /* 781 */
+ void (GLAPIENTRYP RenderbufferStorageEXT)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height); /* 782 */
+ void (GLAPIENTRYP BlitFramebufferEXT)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); /* 783 */
+ void (GLAPIENTRYP BufferParameteriAPPLE)(GLenum target, GLenum pname, GLint param); /* 784 */
+ void (GLAPIENTRYP FlushMappedBufferRangeAPPLE)(GLenum target, GLintptr offset, GLsizeiptr size); /* 785 */
+ void (GLAPIENTRYP FramebufferTextureLayerEXT)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); /* 786 */
+ void (GLAPIENTRYP ProvokingVertexEXT)(GLenum mode); /* 787 */
+ void (GLAPIENTRYP GetTexParameterPointervAPPLE)(GLenum target, GLenum pname, GLvoid ** params); /* 788 */
+ void (GLAPIENTRYP TextureRangeAPPLE)(GLenum target, GLsizei length, GLvoid * pointer); /* 789 */
+ void (GLAPIENTRYP StencilFuncSeparateATI)(GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask); /* 790 */
+ void (GLAPIENTRYP ProgramEnvParameters4fvEXT)(GLenum target, GLuint index, GLsizei count, const GLfloat * params); /* 791 */
+ void (GLAPIENTRYP ProgramLocalParameters4fvEXT)(GLenum target, GLuint index, GLsizei count, const GLfloat * params); /* 792 */
+ void (GLAPIENTRYP GetQueryObjecti64vEXT)(GLuint id, GLenum pname, GLint64EXT * params); /* 793 */
+ void (GLAPIENTRYP GetQueryObjectui64vEXT)(GLuint id, GLenum pname, GLuint64EXT * params); /* 794 */
};
#endif /* !defined( _GLAPI_TABLE_H_ ) */
DISPATCH(WaitSync, (sync, flags, timeout), (F, "glWaitSync(%d, %d, %d);\n", sync, flags, timeout));
}
+KEYWORD1 void KEYWORD2 NAME(DrawElementsBaseVertex)(GLenum mode, GLsizei count, GLenum type, const GLvoid * indices, GLint basevertex)
+{
+ DISPATCH(DrawElementsBaseVertex, (mode, count, type, indices, basevertex), (F, "glDrawElementsBaseVertex(0x%x, %d, 0x%x, %p, %d);\n", mode, count, type, (const void *) indices, basevertex));
+}
+
+KEYWORD1 void KEYWORD2 NAME(DrawRangeElementsBaseVertex)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid * indices, GLint basevertex)
+{
+ DISPATCH(DrawRangeElementsBaseVertex, (mode, start, end, count, type, indices, basevertex), (F, "glDrawRangeElementsBaseVertex(0x%x, %d, %d, %d, 0x%x, %p, %d);\n", mode, start, end, count, type, (const void *) indices, basevertex));
+}
+
+KEYWORD1 void KEYWORD2 NAME(MultiDrawElementsBaseVertex)(GLenum mode, const GLsizei * count, GLenum type, const GLvoid ** indices, GLsizei primcount, const GLint * basevertex)
+{
+ DISPATCH(MultiDrawElementsBaseVertex, (mode, count, type, indices, primcount, basevertex), (F, "glMultiDrawElementsBaseVertex(0x%x, %p, 0x%x, %p, %d, %p);\n", mode, (const void *) count, type, (const void *) indices, primcount, (const void *) basevertex));
+}
+
KEYWORD1 void KEYWORD2 NAME(PolygonOffsetEXT)(GLfloat factor, GLfloat bias)
{
DISPATCH(PolygonOffsetEXT, (factor, bias), (F, "glPolygonOffsetEXT(%f, %f);\n", factor, bias));
}
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_575)(GLenum pname, GLfloat * params);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_578)(GLenum pname, GLfloat * params);
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_575)(GLenum pname, GLfloat * params)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_578)(GLenum pname, GLfloat * params)
{
DISPATCH(GetPixelTexGenParameterfvSGIS, (pname, params), (F, "glGetPixelTexGenParameterfvSGIS(0x%x, %p);\n", pname, (const void *) params));
}
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_576)(GLenum pname, GLint * params);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_579)(GLenum pname, GLint * params);
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_576)(GLenum pname, GLint * params)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_579)(GLenum pname, GLint * params)
{
DISPATCH(GetPixelTexGenParameterivSGIS, (pname, params), (F, "glGetPixelTexGenParameterivSGIS(0x%x, %p);\n", pname, (const void *) params));
}
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_577)(GLenum pname, GLfloat param);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_580)(GLenum pname, GLfloat param);
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_577)(GLenum pname, GLfloat param)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_580)(GLenum pname, GLfloat param)
{
DISPATCH(PixelTexGenParameterfSGIS, (pname, param), (F, "glPixelTexGenParameterfSGIS(0x%x, %f);\n", pname, param));
}
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_578)(GLenum pname, const GLfloat * params);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_581)(GLenum pname, const GLfloat * params);
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_578)(GLenum pname, const GLfloat * params)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_581)(GLenum pname, const GLfloat * params)
{
DISPATCH(PixelTexGenParameterfvSGIS, (pname, params), (F, "glPixelTexGenParameterfvSGIS(0x%x, %p);\n", pname, (const void *) params));
}
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_579)(GLenum pname, GLint param);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_582)(GLenum pname, GLint param);
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_579)(GLenum pname, GLint param)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_582)(GLenum pname, GLint param)
{
DISPATCH(PixelTexGenParameteriSGIS, (pname, param), (F, "glPixelTexGenParameteriSGIS(0x%x, %d);\n", pname, param));
}
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_580)(GLenum pname, const GLint * params);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_583)(GLenum pname, const GLint * params);
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_580)(GLenum pname, const GLint * params)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_583)(GLenum pname, const GLint * params)
{
DISPATCH(PixelTexGenParameterivSGIS, (pname, params), (F, "glPixelTexGenParameterivSGIS(0x%x, %p);\n", pname, (const void *) params));
}
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_581)(GLclampf value, GLboolean invert);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_584)(GLclampf value, GLboolean invert);
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_581)(GLclampf value, GLboolean invert)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_584)(GLclampf value, GLboolean invert)
{
DISPATCH(SampleMaskSGIS, (value, invert), (F, "glSampleMaskSGIS(%f, %d);\n", value, invert));
}
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_582)(GLenum pattern);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_585)(GLenum pattern);
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_582)(GLenum pattern)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_585)(GLenum pattern)
{
DISPATCH(SamplePatternSGIS, (pattern), (F, "glSamplePatternSGIS(0x%x);\n", pattern));
}
DISPATCH(PointParameterfEXT, (pname, param), (F, "glPointParameterfEXT(0x%x, %f);\n", pname, param));
}
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_589)(GLenum pname, GLfloat param);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_592)(GLenum pname, GLfloat param);
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_589)(GLenum pname, GLfloat param)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_592)(GLenum pname, GLfloat param)
{
DISPATCH(PointParameterfEXT, (pname, param), (F, "glPointParameterfSGIS(0x%x, %f);\n", pname, param));
}
DISPATCH(PointParameterfvEXT, (pname, params), (F, "glPointParameterfvEXT(0x%x, %p);\n", pname, (const void *) params));
}
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_590)(GLenum pname, const GLfloat * params);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_593)(GLenum pname, const GLfloat * params);
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_590)(GLenum pname, const GLfloat * params)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_593)(GLenum pname, const GLfloat * params)
{
DISPATCH(PointParameterfvEXT, (pname, params), (F, "glPointParameterfvSGIS(0x%x, %p);\n", pname, (const void *) params));
}
DISPATCH(UnlockArraysEXT, (), (F, "glUnlockArraysEXT();\n"));
}
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_593)(GLenum pname, GLdouble * params);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_596)(GLenum pname, GLdouble * params);
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_593)(GLenum pname, GLdouble * params)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_596)(GLenum pname, GLdouble * params)
{
DISPATCH(CullParameterdvEXT, (pname, params), (F, "glCullParameterdvEXT(0x%x, %p);\n", pname, (const void *) params));
}
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_594)(GLenum pname, GLfloat * params);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_597)(GLenum pname, GLfloat * params);
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_594)(GLenum pname, GLfloat * params)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_597)(GLenum pname, GLfloat * params)
{
DISPATCH(CullParameterfvEXT, (pname, params), (F, "glCullParameterfvEXT(0x%x, %p);\n", pname, (const void *) params));
}
DISPATCH(FogCoordfvEXT, (coord), (F, "glFogCoordfvEXT(%p);\n", (const void *) coord));
}
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_619)(GLenum mode);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_622)(GLenum mode);
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_619)(GLenum mode)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_622)(GLenum mode)
{
DISPATCH(PixelTexGenSGIX, (mode), (F, "glPixelTexGenSGIX(0x%x);\n", mode));
}
DISPATCH(BlendFuncSeparateEXT, (sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha), (F, "glBlendFuncSeparateEXT(0x%x, 0x%x, 0x%x, 0x%x);\n", sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha));
}
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_620)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_623)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_620)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_623)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
{
DISPATCH(BlendFuncSeparateEXT, (sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha), (F, "glBlendFuncSeparateINGR(0x%x, 0x%x, 0x%x, 0x%x);\n", sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha));
}
DISPATCH(WindowPos4svMESA, (v), (F, "glWindowPos4svMESA(%p);\n", (const void *) v));
}
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_661)(const GLenum * mode, const GLint * first, const GLsizei * count, GLsizei primcount, GLint modestride);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_664)(const GLenum * mode, const GLint * first, const GLsizei * count, GLsizei primcount, GLint modestride);
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_661)(const GLenum * mode, const GLint * first, const GLsizei * count, GLsizei primcount, GLint modestride)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_664)(const GLenum * mode, const GLint * first, const GLsizei * count, GLsizei primcount, GLint modestride)
{
DISPATCH(MultiModeDrawArraysIBM, (mode, first, count, primcount, modestride), (F, "glMultiModeDrawArraysIBM(%p, %p, %p, %d, %d);\n", (const void *) mode, (const void *) first, (const void *) count, primcount, modestride));
}
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_662)(const GLenum * mode, const GLsizei * count, GLenum type, const GLvoid * const * indices, GLsizei primcount, GLint modestride);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_665)(const GLenum * mode, const GLsizei * count, GLenum type, const GLvoid * const * indices, GLsizei primcount, GLint modestride);
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_662)(const GLenum * mode, const GLsizei * count, GLenum type, const GLvoid * const * indices, GLsizei primcount, GLint modestride)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_665)(const GLenum * mode, const GLsizei * count, GLenum type, const GLvoid * const * indices, GLsizei primcount, GLint modestride)
{
DISPATCH(MultiModeDrawElementsIBM, (mode, count, type, indices, primcount, modestride), (F, "glMultiModeDrawElementsIBM(%p, %p, 0x%x, %p, %d, %d);\n", (const void *) mode, (const void *) count, type, (const void *) indices, primcount, modestride));
}
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_663)(GLsizei n, const GLuint * fences);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_666)(GLsizei n, const GLuint * fences);
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_663)(GLsizei n, const GLuint * fences)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_666)(GLsizei n, const GLuint * fences)
{
DISPATCH(DeleteFencesNV, (n, fences), (F, "glDeleteFencesNV(%d, %p);\n", n, (const void *) fences));
}
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_664)(GLuint fence);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_667)(GLuint fence);
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_664)(GLuint fence)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_667)(GLuint fence)
{
DISPATCH(FinishFenceNV, (fence), (F, "glFinishFenceNV(%d);\n", fence));
}
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_665)(GLsizei n, GLuint * fences);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_668)(GLsizei n, GLuint * fences);
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_665)(GLsizei n, GLuint * fences)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_668)(GLsizei n, GLuint * fences)
{
DISPATCH(GenFencesNV, (n, fences), (F, "glGenFencesNV(%d, %p);\n", n, (const void *) fences));
}
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_666)(GLuint fence, GLenum pname, GLint * params);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_669)(GLuint fence, GLenum pname, GLint * params);
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_666)(GLuint fence, GLenum pname, GLint * params)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_669)(GLuint fence, GLenum pname, GLint * params)
{
DISPATCH(GetFenceivNV, (fence, pname, params), (F, "glGetFenceivNV(%d, 0x%x, %p);\n", fence, pname, (const void *) params));
}
-KEYWORD1_ALT GLboolean KEYWORD2 NAME(_dispatch_stub_667)(GLuint fence);
+KEYWORD1_ALT GLboolean KEYWORD2 NAME(_dispatch_stub_670)(GLuint fence);
-KEYWORD1_ALT GLboolean KEYWORD2 NAME(_dispatch_stub_667)(GLuint fence)
+KEYWORD1_ALT GLboolean KEYWORD2 NAME(_dispatch_stub_670)(GLuint fence)
{
RETURN_DISPATCH(IsFenceNV, (fence), (F, "glIsFenceNV(%d);\n", fence));
}
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_668)(GLuint fence, GLenum condition);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_671)(GLuint fence, GLenum condition);
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_668)(GLuint fence, GLenum condition)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_671)(GLuint fence, GLenum condition)
{
DISPATCH(SetFenceNV, (fence, condition), (F, "glSetFenceNV(%d, 0x%x);\n", fence, condition));
}
-KEYWORD1_ALT GLboolean KEYWORD2 NAME(_dispatch_stub_669)(GLuint fence);
+KEYWORD1_ALT GLboolean KEYWORD2 NAME(_dispatch_stub_672)(GLuint fence);
-KEYWORD1_ALT GLboolean KEYWORD2 NAME(_dispatch_stub_669)(GLuint fence)
+KEYWORD1_ALT GLboolean KEYWORD2 NAME(_dispatch_stub_672)(GLuint fence)
{
RETURN_DISPATCH(TestFenceNV, (fence), (F, "glTestFenceNV(%d);\n", fence));
}
DISPATCH(PointParameterivNV, (pname, params), (F, "glPointParameterivNV(0x%x, %p);\n", pname, (const void *) params));
}
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_750)(GLenum face);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_753)(GLenum face);
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_750)(GLenum face)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_753)(GLenum face)
{
DISPATCH(ActiveStencilFaceEXT, (face), (F, "glActiveStencilFaceEXT(0x%x);\n", face));
}
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_751)(GLuint array);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_754)(GLuint array);
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_751)(GLuint array)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_754)(GLuint array)
{
DISPATCH(BindVertexArrayAPPLE, (array), (F, "glBindVertexArrayAPPLE(%d);\n", array));
}
DISPATCH(DeleteVertexArraysAPPLE, (n, arrays), (F, "glDeleteVertexArrays(%d, %p);\n", n, (const void *) arrays));
}
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_752)(GLsizei n, const GLuint * arrays);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_755)(GLsizei n, const GLuint * arrays);
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_752)(GLsizei n, const GLuint * arrays)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_755)(GLsizei n, const GLuint * arrays)
{
DISPATCH(DeleteVertexArraysAPPLE, (n, arrays), (F, "glDeleteVertexArraysAPPLE(%d, %p);\n", n, (const void *) arrays));
}
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_753)(GLsizei n, GLuint * arrays);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_756)(GLsizei n, GLuint * arrays);
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_753)(GLsizei n, GLuint * arrays)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_756)(GLsizei n, GLuint * arrays)
{
DISPATCH(GenVertexArraysAPPLE, (n, arrays), (F, "glGenVertexArraysAPPLE(%d, %p);\n", n, (const void *) arrays));
}
RETURN_DISPATCH(IsVertexArrayAPPLE, (array), (F, "glIsVertexArray(%d);\n", array));
}
-KEYWORD1_ALT GLboolean KEYWORD2 NAME(_dispatch_stub_754)(GLuint array);
+KEYWORD1_ALT GLboolean KEYWORD2 NAME(_dispatch_stub_757)(GLuint array);
-KEYWORD1_ALT GLboolean KEYWORD2 NAME(_dispatch_stub_754)(GLuint array)
+KEYWORD1_ALT GLboolean KEYWORD2 NAME(_dispatch_stub_757)(GLuint array)
{
RETURN_DISPATCH(IsVertexArrayAPPLE, (array), (F, "glIsVertexArrayAPPLE(%d);\n", array));
}
DISPATCH(ProgramNamedParameter4fvNV, (id, len, name, v), (F, "glProgramNamedParameter4fvNV(%d, %d, %p, %p);\n", id, len, (const void *) name, (const void *) v));
}
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_761)(GLclampd zmin, GLclampd zmax);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_764)(GLclampd zmin, GLclampd zmax);
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_761)(GLclampd zmin, GLclampd zmax)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_764)(GLclampd zmin, GLclampd zmax)
{
DISPATCH(DepthBoundsEXT, (zmin, zmax), (F, "glDepthBoundsEXT(%f, %f);\n", zmin, zmax));
}
DISPATCH(BlendEquationSeparateEXT, (modeRGB, modeA), (F, "glBlendEquationSeparate(0x%x, 0x%x);\n", modeRGB, modeA));
}
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_762)(GLenum modeRGB, GLenum modeA);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_765)(GLenum modeRGB, GLenum modeA);
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_762)(GLenum modeRGB, GLenum modeA)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_765)(GLenum modeRGB, GLenum modeA)
{
DISPATCH(BlendEquationSeparateEXT, (modeRGB, modeA), (F, "glBlendEquationSeparateEXT(0x%x, 0x%x);\n", modeRGB, modeA));
}
DISPATCH(BlitFramebufferEXT, (srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter), (F, "glBlitFramebuffer(%d, %d, %d, %d, %d, %d, %d, %d, %d, 0x%x);\n", srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter));
}
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_780)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_783)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_780)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_783)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
{
DISPATCH(BlitFramebufferEXT, (srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter), (F, "glBlitFramebufferEXT(%d, %d, %d, %d, %d, %d, %d, %d, %d, 0x%x);\n", srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter));
}
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_781)(GLenum target, GLenum pname, GLint param);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_784)(GLenum target, GLenum pname, GLint param);
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_781)(GLenum target, GLenum pname, GLint param)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_784)(GLenum target, GLenum pname, GLint param)
{
DISPATCH(BufferParameteriAPPLE, (target, pname, param), (F, "glBufferParameteriAPPLE(0x%x, 0x%x, %d);\n", target, pname, param));
}
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_782)(GLenum target, GLintptr offset, GLsizeiptr size);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_785)(GLenum target, GLintptr offset, GLsizeiptr size);
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_782)(GLenum target, GLintptr offset, GLsizeiptr size)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_785)(GLenum target, GLintptr offset, GLsizeiptr size)
{
DISPATCH(FlushMappedBufferRangeAPPLE, (target, offset, size), (F, "glFlushMappedBufferRangeAPPLE(0x%x, %d, %d);\n", target, offset, size));
}
DISPATCH(ProvokingVertexEXT, (mode), (F, "glProvokingVertexEXT(0x%x);\n", mode));
}
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_785)(GLenum target, GLenum pname, GLvoid ** params);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_788)(GLenum target, GLenum pname, GLvoid ** params);
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_785)(GLenum target, GLenum pname, GLvoid ** params)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_788)(GLenum target, GLenum pname, GLvoid ** params)
{
DISPATCH(GetTexParameterPointervAPPLE, (target, pname, params), (F, "glGetTexParameterPointervAPPLE(0x%x, 0x%x, %p);\n", target, pname, (const void *) params));
}
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_786)(GLenum target, GLsizei length, GLvoid * pointer);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_789)(GLenum target, GLsizei length, GLvoid * pointer);
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_786)(GLenum target, GLsizei length, GLvoid * pointer)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_789)(GLenum target, GLsizei length, GLvoid * pointer)
{
DISPATCH(TextureRangeAPPLE, (target, length, pointer), (F, "glTextureRangeAPPLE(0x%x, %d, %p);\n", target, length, (const void *) pointer));
}
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_787)(GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_790)(GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask);
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_787)(GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_790)(GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask)
{
DISPATCH(StencilFuncSeparateATI, (frontfunc, backfunc, ref, mask), (F, "glStencilFuncSeparateATI(0x%x, 0x%x, %d, %d);\n", frontfunc, backfunc, ref, mask));
}
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_788)(GLenum target, GLuint index, GLsizei count, const GLfloat * params);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_791)(GLenum target, GLuint index, GLsizei count, const GLfloat * params);
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_788)(GLenum target, GLuint index, GLsizei count, const GLfloat * params)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_791)(GLenum target, GLuint index, GLsizei count, const GLfloat * params)
{
DISPATCH(ProgramEnvParameters4fvEXT, (target, index, count, params), (F, "glProgramEnvParameters4fvEXT(0x%x, %d, %d, %p);\n", target, index, count, (const void *) params));
}
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_789)(GLenum target, GLuint index, GLsizei count, const GLfloat * params);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_792)(GLenum target, GLuint index, GLsizei count, const GLfloat * params);
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_789)(GLenum target, GLuint index, GLsizei count, const GLfloat * params)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_792)(GLenum target, GLuint index, GLsizei count, const GLfloat * params)
{
DISPATCH(ProgramLocalParameters4fvEXT, (target, index, count, params), (F, "glProgramLocalParameters4fvEXT(0x%x, %d, %d, %p);\n", target, index, count, (const void *) params));
}
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_790)(GLuint id, GLenum pname, GLint64EXT * params);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_793)(GLuint id, GLenum pname, GLint64EXT * params);
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_790)(GLuint id, GLenum pname, GLint64EXT * params)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_793)(GLuint id, GLenum pname, GLint64EXT * params)
{
DISPATCH(GetQueryObjecti64vEXT, (id, pname, params), (F, "glGetQueryObjecti64vEXT(%d, 0x%x, %p);\n", id, pname, (const void *) params));
}
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_791)(GLuint id, GLenum pname, GLuint64EXT * params);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_794)(GLuint id, GLenum pname, GLuint64EXT * params);
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_791)(GLuint id, GLenum pname, GLuint64EXT * params)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_794)(GLuint id, GLenum pname, GLuint64EXT * params)
{
DISPATCH(GetQueryObjectui64vEXT, (id, pname, params), (F, "glGetQueryObjectui64vEXT(%d, 0x%x, %p);\n", id, pname, (const void *) params));
}
TABLE_ENTRY(GetSynciv),
TABLE_ENTRY(IsSync),
TABLE_ENTRY(WaitSync),
+ TABLE_ENTRY(DrawElementsBaseVertex),
+ TABLE_ENTRY(DrawRangeElementsBaseVertex),
+ TABLE_ENTRY(MultiDrawElementsBaseVertex),
TABLE_ENTRY(PolygonOffsetEXT),
- TABLE_ENTRY(_dispatch_stub_575),
- TABLE_ENTRY(_dispatch_stub_576),
- TABLE_ENTRY(_dispatch_stub_577),
TABLE_ENTRY(_dispatch_stub_578),
TABLE_ENTRY(_dispatch_stub_579),
TABLE_ENTRY(_dispatch_stub_580),
TABLE_ENTRY(_dispatch_stub_581),
TABLE_ENTRY(_dispatch_stub_582),
+ TABLE_ENTRY(_dispatch_stub_583),
+ TABLE_ENTRY(_dispatch_stub_584),
+ TABLE_ENTRY(_dispatch_stub_585),
TABLE_ENTRY(ColorPointerEXT),
TABLE_ENTRY(EdgeFlagPointerEXT),
TABLE_ENTRY(IndexPointerEXT),
TABLE_ENTRY(PointParameterfvEXT),
TABLE_ENTRY(LockArraysEXT),
TABLE_ENTRY(UnlockArraysEXT),
- TABLE_ENTRY(_dispatch_stub_593),
- TABLE_ENTRY(_dispatch_stub_594),
+ TABLE_ENTRY(_dispatch_stub_596),
+ TABLE_ENTRY(_dispatch_stub_597),
TABLE_ENTRY(SecondaryColor3bEXT),
TABLE_ENTRY(SecondaryColor3bvEXT),
TABLE_ENTRY(SecondaryColor3dEXT),
TABLE_ENTRY(FogCoorddvEXT),
TABLE_ENTRY(FogCoordfEXT),
TABLE_ENTRY(FogCoordfvEXT),
- TABLE_ENTRY(_dispatch_stub_619),
+ TABLE_ENTRY(_dispatch_stub_622),
TABLE_ENTRY(BlendFuncSeparateEXT),
TABLE_ENTRY(FlushVertexArrayRangeNV),
TABLE_ENTRY(VertexArrayRangeNV),
TABLE_ENTRY(WindowPos4ivMESA),
TABLE_ENTRY(WindowPos4sMESA),
TABLE_ENTRY(WindowPos4svMESA),
- TABLE_ENTRY(_dispatch_stub_661),
- TABLE_ENTRY(_dispatch_stub_662),
- TABLE_ENTRY(_dispatch_stub_663),
TABLE_ENTRY(_dispatch_stub_664),
TABLE_ENTRY(_dispatch_stub_665),
TABLE_ENTRY(_dispatch_stub_666),
TABLE_ENTRY(_dispatch_stub_667),
TABLE_ENTRY(_dispatch_stub_668),
TABLE_ENTRY(_dispatch_stub_669),
+ TABLE_ENTRY(_dispatch_stub_670),
+ TABLE_ENTRY(_dispatch_stub_671),
+ TABLE_ENTRY(_dispatch_stub_672),
TABLE_ENTRY(AreProgramsResidentNV),
TABLE_ENTRY(BindProgramNV),
TABLE_ENTRY(DeleteProgramsNV),
TABLE_ENTRY(SetFragmentShaderConstantATI),
TABLE_ENTRY(PointParameteriNV),
TABLE_ENTRY(PointParameterivNV),
- TABLE_ENTRY(_dispatch_stub_750),
- TABLE_ENTRY(_dispatch_stub_751),
- TABLE_ENTRY(_dispatch_stub_752),
TABLE_ENTRY(_dispatch_stub_753),
TABLE_ENTRY(_dispatch_stub_754),
+ TABLE_ENTRY(_dispatch_stub_755),
+ TABLE_ENTRY(_dispatch_stub_756),
+ TABLE_ENTRY(_dispatch_stub_757),
TABLE_ENTRY(GetProgramNamedParameterdvNV),
TABLE_ENTRY(GetProgramNamedParameterfvNV),
TABLE_ENTRY(ProgramNamedParameter4dNV),
TABLE_ENTRY(ProgramNamedParameter4dvNV),
TABLE_ENTRY(ProgramNamedParameter4fNV),
TABLE_ENTRY(ProgramNamedParameter4fvNV),
- TABLE_ENTRY(_dispatch_stub_761),
- TABLE_ENTRY(_dispatch_stub_762),
+ TABLE_ENTRY(_dispatch_stub_764),
+ TABLE_ENTRY(_dispatch_stub_765),
TABLE_ENTRY(BindFramebufferEXT),
TABLE_ENTRY(BindRenderbufferEXT),
TABLE_ENTRY(CheckFramebufferStatusEXT),
TABLE_ENTRY(IsFramebufferEXT),
TABLE_ENTRY(IsRenderbufferEXT),
TABLE_ENTRY(RenderbufferStorageEXT),
- TABLE_ENTRY(_dispatch_stub_780),
- TABLE_ENTRY(_dispatch_stub_781),
- TABLE_ENTRY(_dispatch_stub_782),
+ TABLE_ENTRY(_dispatch_stub_783),
+ TABLE_ENTRY(_dispatch_stub_784),
+ TABLE_ENTRY(_dispatch_stub_785),
TABLE_ENTRY(FramebufferTextureLayerEXT),
TABLE_ENTRY(ProvokingVertexEXT),
- TABLE_ENTRY(_dispatch_stub_785),
- TABLE_ENTRY(_dispatch_stub_786),
- TABLE_ENTRY(_dispatch_stub_787),
TABLE_ENTRY(_dispatch_stub_788),
TABLE_ENTRY(_dispatch_stub_789),
TABLE_ENTRY(_dispatch_stub_790),
TABLE_ENTRY(_dispatch_stub_791),
+ TABLE_ENTRY(_dispatch_stub_792),
+ TABLE_ENTRY(_dispatch_stub_793),
+ TABLE_ENTRY(_dispatch_stub_794),
/* A whole bunch of no-op functions. These might be called
* when someone tries to call a dynamically-registered
* extension function without a current rendering context.
"glGetSynciv\0"
"glIsSync\0"
"glWaitSync\0"
+ "glDrawElementsBaseVertex\0"
+ "glDrawRangeElementsBaseVertex\0"
+ "glMultiDrawElementsBaseVertex\0"
"glPolygonOffsetEXT\0"
"glGetPixelTexGenParameterfvSGIS\0"
"glGetPixelTexGenParameterivSGIS\0"
#define gl_dispatch_stub_364 mgl_dispatch_stub_364
#define gl_dispatch_stub_365 mgl_dispatch_stub_365
#define gl_dispatch_stub_366 mgl_dispatch_stub_366
-#define gl_dispatch_stub_575 mgl_dispatch_stub_575
-#define gl_dispatch_stub_576 mgl_dispatch_stub_576
-#define gl_dispatch_stub_577 mgl_dispatch_stub_577
#define gl_dispatch_stub_578 mgl_dispatch_stub_578
#define gl_dispatch_stub_579 mgl_dispatch_stub_579
#define gl_dispatch_stub_580 mgl_dispatch_stub_580
#define gl_dispatch_stub_581 mgl_dispatch_stub_581
#define gl_dispatch_stub_582 mgl_dispatch_stub_582
-#define gl_dispatch_stub_593 mgl_dispatch_stub_593
-#define gl_dispatch_stub_594 mgl_dispatch_stub_594
-#define gl_dispatch_stub_619 mgl_dispatch_stub_619
-#define gl_dispatch_stub_661 mgl_dispatch_stub_661
-#define gl_dispatch_stub_662 mgl_dispatch_stub_662
-#define gl_dispatch_stub_663 mgl_dispatch_stub_663
+#define gl_dispatch_stub_583 mgl_dispatch_stub_583
+#define gl_dispatch_stub_584 mgl_dispatch_stub_584
+#define gl_dispatch_stub_585 mgl_dispatch_stub_585
+#define gl_dispatch_stub_596 mgl_dispatch_stub_596
+#define gl_dispatch_stub_597 mgl_dispatch_stub_597
+#define gl_dispatch_stub_622 mgl_dispatch_stub_622
#define gl_dispatch_stub_664 mgl_dispatch_stub_664
#define gl_dispatch_stub_665 mgl_dispatch_stub_665
#define gl_dispatch_stub_666 mgl_dispatch_stub_666
#define gl_dispatch_stub_667 mgl_dispatch_stub_667
#define gl_dispatch_stub_668 mgl_dispatch_stub_668
#define gl_dispatch_stub_669 mgl_dispatch_stub_669
-#define gl_dispatch_stub_750 mgl_dispatch_stub_750
-#define gl_dispatch_stub_751 mgl_dispatch_stub_751
-#define gl_dispatch_stub_752 mgl_dispatch_stub_752
+#define gl_dispatch_stub_670 mgl_dispatch_stub_670
+#define gl_dispatch_stub_671 mgl_dispatch_stub_671
+#define gl_dispatch_stub_672 mgl_dispatch_stub_672
#define gl_dispatch_stub_753 mgl_dispatch_stub_753
#define gl_dispatch_stub_754 mgl_dispatch_stub_754
-#define gl_dispatch_stub_761 mgl_dispatch_stub_761
-#define gl_dispatch_stub_762 mgl_dispatch_stub_762
-#define gl_dispatch_stub_780 mgl_dispatch_stub_780
-#define gl_dispatch_stub_781 mgl_dispatch_stub_781
-#define gl_dispatch_stub_782 mgl_dispatch_stub_782
+#define gl_dispatch_stub_755 mgl_dispatch_stub_755
+#define gl_dispatch_stub_756 mgl_dispatch_stub_756
+#define gl_dispatch_stub_757 mgl_dispatch_stub_757
+#define gl_dispatch_stub_764 mgl_dispatch_stub_764
+#define gl_dispatch_stub_765 mgl_dispatch_stub_765
+#define gl_dispatch_stub_783 mgl_dispatch_stub_783
+#define gl_dispatch_stub_784 mgl_dispatch_stub_784
#define gl_dispatch_stub_785 mgl_dispatch_stub_785
-#define gl_dispatch_stub_786 mgl_dispatch_stub_786
-#define gl_dispatch_stub_787 mgl_dispatch_stub_787
#define gl_dispatch_stub_788 mgl_dispatch_stub_788
#define gl_dispatch_stub_789 mgl_dispatch_stub_789
#define gl_dispatch_stub_790 mgl_dispatch_stub_790
#define gl_dispatch_stub_791 mgl_dispatch_stub_791
+#define gl_dispatch_stub_792 mgl_dispatch_stub_792
+#define gl_dispatch_stub_793 mgl_dispatch_stub_793
+#define gl_dispatch_stub_794 mgl_dispatch_stub_794
#endif /* USE_MGL_NAMESPACE */
void GLAPIENTRY gl_dispatch_stub_364(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values);
void GLAPIENTRY gl_dispatch_stub_365(GLenum target, GLenum pname, GLfloat * params);
void GLAPIENTRY gl_dispatch_stub_366(GLenum target, GLenum pname, GLint * params);
-void GLAPIENTRY gl_dispatch_stub_575(GLenum pname, GLfloat * params);
-void GLAPIENTRY gl_dispatch_stub_576(GLenum pname, GLint * params);
-void GLAPIENTRY gl_dispatch_stub_577(GLenum pname, GLfloat param);
-void GLAPIENTRY gl_dispatch_stub_578(GLenum pname, const GLfloat * params);
-void GLAPIENTRY gl_dispatch_stub_579(GLenum pname, GLint param);
-void GLAPIENTRY gl_dispatch_stub_580(GLenum pname, const GLint * params);
-void GLAPIENTRY gl_dispatch_stub_581(GLclampf value, GLboolean invert);
-void GLAPIENTRY gl_dispatch_stub_582(GLenum pattern);
-void GLAPIENTRY gl_dispatch_stub_593(GLenum pname, GLdouble * params);
-void GLAPIENTRY gl_dispatch_stub_594(GLenum pname, GLfloat * params);
-void GLAPIENTRY gl_dispatch_stub_619(GLenum mode);
-void GLAPIENTRY gl_dispatch_stub_661(const GLenum * mode, const GLint * first, const GLsizei * count, GLsizei primcount, GLint modestride);
-void GLAPIENTRY gl_dispatch_stub_662(const GLenum * mode, const GLsizei * count, GLenum type, const GLvoid * const * indices, GLsizei primcount, GLint modestride);
-void GLAPIENTRY gl_dispatch_stub_663(GLsizei n, const GLuint * fences);
-void GLAPIENTRY gl_dispatch_stub_664(GLuint fence);
-void GLAPIENTRY gl_dispatch_stub_665(GLsizei n, GLuint * fences);
-void GLAPIENTRY gl_dispatch_stub_666(GLuint fence, GLenum pname, GLint * params);
-GLboolean GLAPIENTRY gl_dispatch_stub_667(GLuint fence);
-void GLAPIENTRY gl_dispatch_stub_668(GLuint fence, GLenum condition);
-GLboolean GLAPIENTRY gl_dispatch_stub_669(GLuint fence);
-void GLAPIENTRY gl_dispatch_stub_750(GLenum face);
-void GLAPIENTRY gl_dispatch_stub_751(GLuint array);
-void GLAPIENTRY gl_dispatch_stub_752(GLsizei n, const GLuint * arrays);
-void GLAPIENTRY gl_dispatch_stub_753(GLsizei n, GLuint * arrays);
-GLboolean GLAPIENTRY gl_dispatch_stub_754(GLuint array);
-void GLAPIENTRY gl_dispatch_stub_761(GLclampd zmin, GLclampd zmax);
-void GLAPIENTRY gl_dispatch_stub_762(GLenum modeRGB, GLenum modeA);
-void GLAPIENTRY gl_dispatch_stub_780(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
-void GLAPIENTRY gl_dispatch_stub_781(GLenum target, GLenum pname, GLint param);
-void GLAPIENTRY gl_dispatch_stub_782(GLenum target, GLintptr offset, GLsizeiptr size);
-void GLAPIENTRY gl_dispatch_stub_785(GLenum target, GLenum pname, GLvoid ** params);
-void GLAPIENTRY gl_dispatch_stub_786(GLenum target, GLsizei length, GLvoid * pointer);
-void GLAPIENTRY gl_dispatch_stub_787(GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask);
-void GLAPIENTRY gl_dispatch_stub_788(GLenum target, GLuint index, GLsizei count, const GLfloat * params);
-void GLAPIENTRY gl_dispatch_stub_789(GLenum target, GLuint index, GLsizei count, const GLfloat * params);
-void GLAPIENTRY gl_dispatch_stub_790(GLuint id, GLenum pname, GLint64EXT * params);
-void GLAPIENTRY gl_dispatch_stub_791(GLuint id, GLenum pname, GLuint64EXT * params);
+void GLAPIENTRY gl_dispatch_stub_578(GLenum pname, GLfloat * params);
+void GLAPIENTRY gl_dispatch_stub_579(GLenum pname, GLint * params);
+void GLAPIENTRY gl_dispatch_stub_580(GLenum pname, GLfloat param);
+void GLAPIENTRY gl_dispatch_stub_581(GLenum pname, const GLfloat * params);
+void GLAPIENTRY gl_dispatch_stub_582(GLenum pname, GLint param);
+void GLAPIENTRY gl_dispatch_stub_583(GLenum pname, const GLint * params);
+void GLAPIENTRY gl_dispatch_stub_584(GLclampf value, GLboolean invert);
+void GLAPIENTRY gl_dispatch_stub_585(GLenum pattern);
+void GLAPIENTRY gl_dispatch_stub_596(GLenum pname, GLdouble * params);
+void GLAPIENTRY gl_dispatch_stub_597(GLenum pname, GLfloat * params);
+void GLAPIENTRY gl_dispatch_stub_622(GLenum mode);
+void GLAPIENTRY gl_dispatch_stub_664(const GLenum * mode, const GLint * first, const GLsizei * count, GLsizei primcount, GLint modestride);
+void GLAPIENTRY gl_dispatch_stub_665(const GLenum * mode, const GLsizei * count, GLenum type, const GLvoid * const * indices, GLsizei primcount, GLint modestride);
+void GLAPIENTRY gl_dispatch_stub_666(GLsizei n, const GLuint * fences);
+void GLAPIENTRY gl_dispatch_stub_667(GLuint fence);
+void GLAPIENTRY gl_dispatch_stub_668(GLsizei n, GLuint * fences);
+void GLAPIENTRY gl_dispatch_stub_669(GLuint fence, GLenum pname, GLint * params);
+GLboolean GLAPIENTRY gl_dispatch_stub_670(GLuint fence);
+void GLAPIENTRY gl_dispatch_stub_671(GLuint fence, GLenum condition);
+GLboolean GLAPIENTRY gl_dispatch_stub_672(GLuint fence);
+void GLAPIENTRY gl_dispatch_stub_753(GLenum face);
+void GLAPIENTRY gl_dispatch_stub_754(GLuint array);
+void GLAPIENTRY gl_dispatch_stub_755(GLsizei n, const GLuint * arrays);
+void GLAPIENTRY gl_dispatch_stub_756(GLsizei n, GLuint * arrays);
+GLboolean GLAPIENTRY gl_dispatch_stub_757(GLuint array);
+void GLAPIENTRY gl_dispatch_stub_764(GLclampd zmin, GLclampd zmax);
+void GLAPIENTRY gl_dispatch_stub_765(GLenum modeRGB, GLenum modeA);
+void GLAPIENTRY gl_dispatch_stub_783(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
+void GLAPIENTRY gl_dispatch_stub_784(GLenum target, GLenum pname, GLint param);
+void GLAPIENTRY gl_dispatch_stub_785(GLenum target, GLintptr offset, GLsizeiptr size);
+void GLAPIENTRY gl_dispatch_stub_788(GLenum target, GLenum pname, GLvoid ** params);
+void GLAPIENTRY gl_dispatch_stub_789(GLenum target, GLsizei length, GLvoid * pointer);
+void GLAPIENTRY gl_dispatch_stub_790(GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask);
+void GLAPIENTRY gl_dispatch_stub_791(GLenum target, GLuint index, GLsizei count, const GLfloat * params);
+void GLAPIENTRY gl_dispatch_stub_792(GLenum target, GLuint index, GLsizei count, const GLfloat * params);
+void GLAPIENTRY gl_dispatch_stub_793(GLuint id, GLenum pname, GLint64EXT * params);
+void GLAPIENTRY gl_dispatch_stub_794(GLuint id, GLenum pname, GLuint64EXT * params);
#endif /* defined(NEED_FUNCTION_POINTER) || defined(GLX_INDIRECT_RENDERING) */
static const glprocs_table_t static_functions[] = {
NAME_FUNC_OFFSET( 9140, glGetSynciv, glGetSynciv, NULL, _gloffset_GetSynciv),
NAME_FUNC_OFFSET( 9152, glIsSync, glIsSync, NULL, _gloffset_IsSync),
NAME_FUNC_OFFSET( 9161, glWaitSync, glWaitSync, NULL, _gloffset_WaitSync),
- NAME_FUNC_OFFSET( 9172, glPolygonOffsetEXT, glPolygonOffsetEXT, NULL, _gloffset_PolygonOffsetEXT),
- NAME_FUNC_OFFSET( 9191, gl_dispatch_stub_575, gl_dispatch_stub_575, NULL, _gloffset_GetPixelTexGenParameterfvSGIS),
- NAME_FUNC_OFFSET( 9223, gl_dispatch_stub_576, gl_dispatch_stub_576, NULL, _gloffset_GetPixelTexGenParameterivSGIS),
- NAME_FUNC_OFFSET( 9255, gl_dispatch_stub_577, gl_dispatch_stub_577, NULL, _gloffset_PixelTexGenParameterfSGIS),
- NAME_FUNC_OFFSET( 9283, gl_dispatch_stub_578, gl_dispatch_stub_578, NULL, _gloffset_PixelTexGenParameterfvSGIS),
- NAME_FUNC_OFFSET( 9312, gl_dispatch_stub_579, gl_dispatch_stub_579, NULL, _gloffset_PixelTexGenParameteriSGIS),
- NAME_FUNC_OFFSET( 9340, gl_dispatch_stub_580, gl_dispatch_stub_580, NULL, _gloffset_PixelTexGenParameterivSGIS),
- NAME_FUNC_OFFSET( 9369, gl_dispatch_stub_581, gl_dispatch_stub_581, NULL, _gloffset_SampleMaskSGIS),
- NAME_FUNC_OFFSET( 9386, gl_dispatch_stub_582, gl_dispatch_stub_582, NULL, _gloffset_SamplePatternSGIS),
- NAME_FUNC_OFFSET( 9406, glColorPointerEXT, glColorPointerEXT, NULL, _gloffset_ColorPointerEXT),
- NAME_FUNC_OFFSET( 9424, glEdgeFlagPointerEXT, glEdgeFlagPointerEXT, NULL, _gloffset_EdgeFlagPointerEXT),
- NAME_FUNC_OFFSET( 9445, glIndexPointerEXT, glIndexPointerEXT, NULL, _gloffset_IndexPointerEXT),
- NAME_FUNC_OFFSET( 9463, glNormalPointerEXT, glNormalPointerEXT, NULL, _gloffset_NormalPointerEXT),
- NAME_FUNC_OFFSET( 9482, glTexCoordPointerEXT, glTexCoordPointerEXT, NULL, _gloffset_TexCoordPointerEXT),
- NAME_FUNC_OFFSET( 9503, glVertexPointerEXT, glVertexPointerEXT, NULL, _gloffset_VertexPointerEXT),
- NAME_FUNC_OFFSET( 9522, glPointParameterfEXT, glPointParameterfEXT, NULL, _gloffset_PointParameterfEXT),
- NAME_FUNC_OFFSET( 9543, glPointParameterfvEXT, glPointParameterfvEXT, NULL, _gloffset_PointParameterfvEXT),
- NAME_FUNC_OFFSET( 9565, glLockArraysEXT, glLockArraysEXT, NULL, _gloffset_LockArraysEXT),
- NAME_FUNC_OFFSET( 9581, glUnlockArraysEXT, glUnlockArraysEXT, NULL, _gloffset_UnlockArraysEXT),
- NAME_FUNC_OFFSET( 9599, gl_dispatch_stub_593, gl_dispatch_stub_593, NULL, _gloffset_CullParameterdvEXT),
- NAME_FUNC_OFFSET( 9620, gl_dispatch_stub_594, gl_dispatch_stub_594, NULL, _gloffset_CullParameterfvEXT),
- NAME_FUNC_OFFSET( 9641, glSecondaryColor3bEXT, glSecondaryColor3bEXT, NULL, _gloffset_SecondaryColor3bEXT),
- NAME_FUNC_OFFSET( 9663, glSecondaryColor3bvEXT, glSecondaryColor3bvEXT, NULL, _gloffset_SecondaryColor3bvEXT),
- NAME_FUNC_OFFSET( 9686, glSecondaryColor3dEXT, glSecondaryColor3dEXT, NULL, _gloffset_SecondaryColor3dEXT),
- NAME_FUNC_OFFSET( 9708, glSecondaryColor3dvEXT, glSecondaryColor3dvEXT, NULL, _gloffset_SecondaryColor3dvEXT),
- NAME_FUNC_OFFSET( 9731, glSecondaryColor3fEXT, glSecondaryColor3fEXT, NULL, _gloffset_SecondaryColor3fEXT),
- NAME_FUNC_OFFSET( 9753, glSecondaryColor3fvEXT, glSecondaryColor3fvEXT, NULL, _gloffset_SecondaryColor3fvEXT),
- NAME_FUNC_OFFSET( 9776, glSecondaryColor3iEXT, glSecondaryColor3iEXT, NULL, _gloffset_SecondaryColor3iEXT),
- NAME_FUNC_OFFSET( 9798, glSecondaryColor3ivEXT, glSecondaryColor3ivEXT, NULL, _gloffset_SecondaryColor3ivEXT),
- NAME_FUNC_OFFSET( 9821, glSecondaryColor3sEXT, glSecondaryColor3sEXT, NULL, _gloffset_SecondaryColor3sEXT),
- NAME_FUNC_OFFSET( 9843, glSecondaryColor3svEXT, glSecondaryColor3svEXT, NULL, _gloffset_SecondaryColor3svEXT),
- NAME_FUNC_OFFSET( 9866, glSecondaryColor3ubEXT, glSecondaryColor3ubEXT, NULL, _gloffset_SecondaryColor3ubEXT),
- NAME_FUNC_OFFSET( 9889, glSecondaryColor3ubvEXT, glSecondaryColor3ubvEXT, NULL, _gloffset_SecondaryColor3ubvEXT),
- NAME_FUNC_OFFSET( 9913, glSecondaryColor3uiEXT, glSecondaryColor3uiEXT, NULL, _gloffset_SecondaryColor3uiEXT),
- NAME_FUNC_OFFSET( 9936, glSecondaryColor3uivEXT, glSecondaryColor3uivEXT, NULL, _gloffset_SecondaryColor3uivEXT),
- NAME_FUNC_OFFSET( 9960, glSecondaryColor3usEXT, glSecondaryColor3usEXT, NULL, _gloffset_SecondaryColor3usEXT),
- NAME_FUNC_OFFSET( 9983, glSecondaryColor3usvEXT, glSecondaryColor3usvEXT, NULL, _gloffset_SecondaryColor3usvEXT),
- NAME_FUNC_OFFSET(10007, glSecondaryColorPointerEXT, glSecondaryColorPointerEXT, NULL, _gloffset_SecondaryColorPointerEXT),
- NAME_FUNC_OFFSET(10034, glMultiDrawArraysEXT, glMultiDrawArraysEXT, NULL, _gloffset_MultiDrawArraysEXT),
- NAME_FUNC_OFFSET(10055, glMultiDrawElementsEXT, glMultiDrawElementsEXT, NULL, _gloffset_MultiDrawElementsEXT),
- NAME_FUNC_OFFSET(10078, glFogCoordPointerEXT, glFogCoordPointerEXT, NULL, _gloffset_FogCoordPointerEXT),
- NAME_FUNC_OFFSET(10099, glFogCoorddEXT, glFogCoorddEXT, NULL, _gloffset_FogCoorddEXT),
- NAME_FUNC_OFFSET(10114, glFogCoorddvEXT, glFogCoorddvEXT, NULL, _gloffset_FogCoorddvEXT),
- NAME_FUNC_OFFSET(10130, glFogCoordfEXT, glFogCoordfEXT, NULL, _gloffset_FogCoordfEXT),
- NAME_FUNC_OFFSET(10145, glFogCoordfvEXT, glFogCoordfvEXT, NULL, _gloffset_FogCoordfvEXT),
- NAME_FUNC_OFFSET(10161, gl_dispatch_stub_619, gl_dispatch_stub_619, NULL, _gloffset_PixelTexGenSGIX),
- NAME_FUNC_OFFSET(10179, glBlendFuncSeparateEXT, glBlendFuncSeparateEXT, NULL, _gloffset_BlendFuncSeparateEXT),
- NAME_FUNC_OFFSET(10202, glFlushVertexArrayRangeNV, glFlushVertexArrayRangeNV, NULL, _gloffset_FlushVertexArrayRangeNV),
- NAME_FUNC_OFFSET(10228, glVertexArrayRangeNV, glVertexArrayRangeNV, NULL, _gloffset_VertexArrayRangeNV),
- NAME_FUNC_OFFSET(10249, glCombinerInputNV, glCombinerInputNV, NULL, _gloffset_CombinerInputNV),
- NAME_FUNC_OFFSET(10267, glCombinerOutputNV, glCombinerOutputNV, NULL, _gloffset_CombinerOutputNV),
- NAME_FUNC_OFFSET(10286, glCombinerParameterfNV, glCombinerParameterfNV, NULL, _gloffset_CombinerParameterfNV),
- NAME_FUNC_OFFSET(10309, glCombinerParameterfvNV, glCombinerParameterfvNV, NULL, _gloffset_CombinerParameterfvNV),
- NAME_FUNC_OFFSET(10333, glCombinerParameteriNV, glCombinerParameteriNV, NULL, _gloffset_CombinerParameteriNV),
- NAME_FUNC_OFFSET(10356, glCombinerParameterivNV, glCombinerParameterivNV, NULL, _gloffset_CombinerParameterivNV),
- NAME_FUNC_OFFSET(10380, glFinalCombinerInputNV, glFinalCombinerInputNV, NULL, _gloffset_FinalCombinerInputNV),
- NAME_FUNC_OFFSET(10403, glGetCombinerInputParameterfvNV, glGetCombinerInputParameterfvNV, NULL, _gloffset_GetCombinerInputParameterfvNV),
- NAME_FUNC_OFFSET(10435, glGetCombinerInputParameterivNV, glGetCombinerInputParameterivNV, NULL, _gloffset_GetCombinerInputParameterivNV),
- NAME_FUNC_OFFSET(10467, glGetCombinerOutputParameterfvNV, glGetCombinerOutputParameterfvNV, NULL, _gloffset_GetCombinerOutputParameterfvNV),
- NAME_FUNC_OFFSET(10500, glGetCombinerOutputParameterivNV, glGetCombinerOutputParameterivNV, NULL, _gloffset_GetCombinerOutputParameterivNV),
- NAME_FUNC_OFFSET(10533, glGetFinalCombinerInputParameterfvNV, glGetFinalCombinerInputParameterfvNV, NULL, _gloffset_GetFinalCombinerInputParameterfvNV),
- NAME_FUNC_OFFSET(10570, glGetFinalCombinerInputParameterivNV, glGetFinalCombinerInputParameterivNV, NULL, _gloffset_GetFinalCombinerInputParameterivNV),
- NAME_FUNC_OFFSET(10607, glResizeBuffersMESA, glResizeBuffersMESA, NULL, _gloffset_ResizeBuffersMESA),
- NAME_FUNC_OFFSET(10627, glWindowPos2dMESA, glWindowPos2dMESA, NULL, _gloffset_WindowPos2dMESA),
- NAME_FUNC_OFFSET(10645, glWindowPos2dvMESA, glWindowPos2dvMESA, NULL, _gloffset_WindowPos2dvMESA),
- NAME_FUNC_OFFSET(10664, glWindowPos2fMESA, glWindowPos2fMESA, NULL, _gloffset_WindowPos2fMESA),
- NAME_FUNC_OFFSET(10682, glWindowPos2fvMESA, glWindowPos2fvMESA, NULL, _gloffset_WindowPos2fvMESA),
- NAME_FUNC_OFFSET(10701, glWindowPos2iMESA, glWindowPos2iMESA, NULL, _gloffset_WindowPos2iMESA),
- NAME_FUNC_OFFSET(10719, glWindowPos2ivMESA, glWindowPos2ivMESA, NULL, _gloffset_WindowPos2ivMESA),
- NAME_FUNC_OFFSET(10738, glWindowPos2sMESA, glWindowPos2sMESA, NULL, _gloffset_WindowPos2sMESA),
- NAME_FUNC_OFFSET(10756, glWindowPos2svMESA, glWindowPos2svMESA, NULL, _gloffset_WindowPos2svMESA),
- NAME_FUNC_OFFSET(10775, glWindowPos3dMESA, glWindowPos3dMESA, NULL, _gloffset_WindowPos3dMESA),
- NAME_FUNC_OFFSET(10793, glWindowPos3dvMESA, glWindowPos3dvMESA, NULL, _gloffset_WindowPos3dvMESA),
- NAME_FUNC_OFFSET(10812, glWindowPos3fMESA, glWindowPos3fMESA, NULL, _gloffset_WindowPos3fMESA),
- NAME_FUNC_OFFSET(10830, glWindowPos3fvMESA, glWindowPos3fvMESA, NULL, _gloffset_WindowPos3fvMESA),
- NAME_FUNC_OFFSET(10849, glWindowPos3iMESA, glWindowPos3iMESA, NULL, _gloffset_WindowPos3iMESA),
- NAME_FUNC_OFFSET(10867, glWindowPos3ivMESA, glWindowPos3ivMESA, NULL, _gloffset_WindowPos3ivMESA),
- NAME_FUNC_OFFSET(10886, glWindowPos3sMESA, glWindowPos3sMESA, NULL, _gloffset_WindowPos3sMESA),
- NAME_FUNC_OFFSET(10904, glWindowPos3svMESA, glWindowPos3svMESA, NULL, _gloffset_WindowPos3svMESA),
- NAME_FUNC_OFFSET(10923, glWindowPos4dMESA, glWindowPos4dMESA, NULL, _gloffset_WindowPos4dMESA),
- NAME_FUNC_OFFSET(10941, glWindowPos4dvMESA, glWindowPos4dvMESA, NULL, _gloffset_WindowPos4dvMESA),
- NAME_FUNC_OFFSET(10960, glWindowPos4fMESA, glWindowPos4fMESA, NULL, _gloffset_WindowPos4fMESA),
- NAME_FUNC_OFFSET(10978, glWindowPos4fvMESA, glWindowPos4fvMESA, NULL, _gloffset_WindowPos4fvMESA),
- NAME_FUNC_OFFSET(10997, glWindowPos4iMESA, glWindowPos4iMESA, NULL, _gloffset_WindowPos4iMESA),
- NAME_FUNC_OFFSET(11015, glWindowPos4ivMESA, glWindowPos4ivMESA, NULL, _gloffset_WindowPos4ivMESA),
- NAME_FUNC_OFFSET(11034, glWindowPos4sMESA, glWindowPos4sMESA, NULL, _gloffset_WindowPos4sMESA),
- NAME_FUNC_OFFSET(11052, glWindowPos4svMESA, glWindowPos4svMESA, NULL, _gloffset_WindowPos4svMESA),
- NAME_FUNC_OFFSET(11071, gl_dispatch_stub_661, gl_dispatch_stub_661, NULL, _gloffset_MultiModeDrawArraysIBM),
- NAME_FUNC_OFFSET(11096, gl_dispatch_stub_662, gl_dispatch_stub_662, NULL, _gloffset_MultiModeDrawElementsIBM),
- NAME_FUNC_OFFSET(11123, gl_dispatch_stub_663, gl_dispatch_stub_663, NULL, _gloffset_DeleteFencesNV),
- NAME_FUNC_OFFSET(11140, gl_dispatch_stub_664, gl_dispatch_stub_664, NULL, _gloffset_FinishFenceNV),
- NAME_FUNC_OFFSET(11156, gl_dispatch_stub_665, gl_dispatch_stub_665, NULL, _gloffset_GenFencesNV),
- NAME_FUNC_OFFSET(11170, gl_dispatch_stub_666, gl_dispatch_stub_666, NULL, _gloffset_GetFenceivNV),
- NAME_FUNC_OFFSET(11185, gl_dispatch_stub_667, gl_dispatch_stub_667, NULL, _gloffset_IsFenceNV),
- NAME_FUNC_OFFSET(11197, gl_dispatch_stub_668, gl_dispatch_stub_668, NULL, _gloffset_SetFenceNV),
- NAME_FUNC_OFFSET(11210, gl_dispatch_stub_669, gl_dispatch_stub_669, NULL, _gloffset_TestFenceNV),
- NAME_FUNC_OFFSET(11224, glAreProgramsResidentNV, glAreProgramsResidentNV, NULL, _gloffset_AreProgramsResidentNV),
- NAME_FUNC_OFFSET(11248, glBindProgramNV, glBindProgramNV, NULL, _gloffset_BindProgramNV),
- NAME_FUNC_OFFSET(11264, glDeleteProgramsNV, glDeleteProgramsNV, NULL, _gloffset_DeleteProgramsNV),
- NAME_FUNC_OFFSET(11283, glExecuteProgramNV, glExecuteProgramNV, NULL, _gloffset_ExecuteProgramNV),
- NAME_FUNC_OFFSET(11302, glGenProgramsNV, glGenProgramsNV, NULL, _gloffset_GenProgramsNV),
- NAME_FUNC_OFFSET(11318, glGetProgramParameterdvNV, glGetProgramParameterdvNV, NULL, _gloffset_GetProgramParameterdvNV),
- NAME_FUNC_OFFSET(11344, glGetProgramParameterfvNV, glGetProgramParameterfvNV, NULL, _gloffset_GetProgramParameterfvNV),
- NAME_FUNC_OFFSET(11370, glGetProgramStringNV, glGetProgramStringNV, NULL, _gloffset_GetProgramStringNV),
- NAME_FUNC_OFFSET(11391, glGetProgramivNV, glGetProgramivNV, NULL, _gloffset_GetProgramivNV),
- NAME_FUNC_OFFSET(11408, glGetTrackMatrixivNV, glGetTrackMatrixivNV, NULL, _gloffset_GetTrackMatrixivNV),
- NAME_FUNC_OFFSET(11429, glGetVertexAttribPointervNV, glGetVertexAttribPointervNV, NULL, _gloffset_GetVertexAttribPointervNV),
- NAME_FUNC_OFFSET(11457, glGetVertexAttribdvNV, glGetVertexAttribdvNV, NULL, _gloffset_GetVertexAttribdvNV),
- NAME_FUNC_OFFSET(11479, glGetVertexAttribfvNV, glGetVertexAttribfvNV, NULL, _gloffset_GetVertexAttribfvNV),
- NAME_FUNC_OFFSET(11501, glGetVertexAttribivNV, glGetVertexAttribivNV, NULL, _gloffset_GetVertexAttribivNV),
- NAME_FUNC_OFFSET(11523, glIsProgramNV, glIsProgramNV, NULL, _gloffset_IsProgramNV),
- NAME_FUNC_OFFSET(11537, glLoadProgramNV, glLoadProgramNV, NULL, _gloffset_LoadProgramNV),
- NAME_FUNC_OFFSET(11553, glProgramParameters4dvNV, glProgramParameters4dvNV, NULL, _gloffset_ProgramParameters4dvNV),
- NAME_FUNC_OFFSET(11578, glProgramParameters4fvNV, glProgramParameters4fvNV, NULL, _gloffset_ProgramParameters4fvNV),
- NAME_FUNC_OFFSET(11603, glRequestResidentProgramsNV, glRequestResidentProgramsNV, NULL, _gloffset_RequestResidentProgramsNV),
- NAME_FUNC_OFFSET(11631, glTrackMatrixNV, glTrackMatrixNV, NULL, _gloffset_TrackMatrixNV),
- NAME_FUNC_OFFSET(11647, glVertexAttrib1dNV, glVertexAttrib1dNV, NULL, _gloffset_VertexAttrib1dNV),
- NAME_FUNC_OFFSET(11666, glVertexAttrib1dvNV, glVertexAttrib1dvNV, NULL, _gloffset_VertexAttrib1dvNV),
- NAME_FUNC_OFFSET(11686, glVertexAttrib1fNV, glVertexAttrib1fNV, NULL, _gloffset_VertexAttrib1fNV),
- NAME_FUNC_OFFSET(11705, glVertexAttrib1fvNV, glVertexAttrib1fvNV, NULL, _gloffset_VertexAttrib1fvNV),
- NAME_FUNC_OFFSET(11725, glVertexAttrib1sNV, glVertexAttrib1sNV, NULL, _gloffset_VertexAttrib1sNV),
- NAME_FUNC_OFFSET(11744, glVertexAttrib1svNV, glVertexAttrib1svNV, NULL, _gloffset_VertexAttrib1svNV),
- NAME_FUNC_OFFSET(11764, glVertexAttrib2dNV, glVertexAttrib2dNV, NULL, _gloffset_VertexAttrib2dNV),
- NAME_FUNC_OFFSET(11783, glVertexAttrib2dvNV, glVertexAttrib2dvNV, NULL, _gloffset_VertexAttrib2dvNV),
- NAME_FUNC_OFFSET(11803, glVertexAttrib2fNV, glVertexAttrib2fNV, NULL, _gloffset_VertexAttrib2fNV),
- NAME_FUNC_OFFSET(11822, glVertexAttrib2fvNV, glVertexAttrib2fvNV, NULL, _gloffset_VertexAttrib2fvNV),
- NAME_FUNC_OFFSET(11842, glVertexAttrib2sNV, glVertexAttrib2sNV, NULL, _gloffset_VertexAttrib2sNV),
- NAME_FUNC_OFFSET(11861, glVertexAttrib2svNV, glVertexAttrib2svNV, NULL, _gloffset_VertexAttrib2svNV),
- NAME_FUNC_OFFSET(11881, glVertexAttrib3dNV, glVertexAttrib3dNV, NULL, _gloffset_VertexAttrib3dNV),
- NAME_FUNC_OFFSET(11900, glVertexAttrib3dvNV, glVertexAttrib3dvNV, NULL, _gloffset_VertexAttrib3dvNV),
- NAME_FUNC_OFFSET(11920, glVertexAttrib3fNV, glVertexAttrib3fNV, NULL, _gloffset_VertexAttrib3fNV),
- NAME_FUNC_OFFSET(11939, glVertexAttrib3fvNV, glVertexAttrib3fvNV, NULL, _gloffset_VertexAttrib3fvNV),
- NAME_FUNC_OFFSET(11959, glVertexAttrib3sNV, glVertexAttrib3sNV, NULL, _gloffset_VertexAttrib3sNV),
- NAME_FUNC_OFFSET(11978, glVertexAttrib3svNV, glVertexAttrib3svNV, NULL, _gloffset_VertexAttrib3svNV),
- NAME_FUNC_OFFSET(11998, glVertexAttrib4dNV, glVertexAttrib4dNV, NULL, _gloffset_VertexAttrib4dNV),
- NAME_FUNC_OFFSET(12017, glVertexAttrib4dvNV, glVertexAttrib4dvNV, NULL, _gloffset_VertexAttrib4dvNV),
- NAME_FUNC_OFFSET(12037, glVertexAttrib4fNV, glVertexAttrib4fNV, NULL, _gloffset_VertexAttrib4fNV),
- NAME_FUNC_OFFSET(12056, glVertexAttrib4fvNV, glVertexAttrib4fvNV, NULL, _gloffset_VertexAttrib4fvNV),
- NAME_FUNC_OFFSET(12076, glVertexAttrib4sNV, glVertexAttrib4sNV, NULL, _gloffset_VertexAttrib4sNV),
- NAME_FUNC_OFFSET(12095, glVertexAttrib4svNV, glVertexAttrib4svNV, NULL, _gloffset_VertexAttrib4svNV),
- NAME_FUNC_OFFSET(12115, glVertexAttrib4ubNV, glVertexAttrib4ubNV, NULL, _gloffset_VertexAttrib4ubNV),
- NAME_FUNC_OFFSET(12135, glVertexAttrib4ubvNV, glVertexAttrib4ubvNV, NULL, _gloffset_VertexAttrib4ubvNV),
- NAME_FUNC_OFFSET(12156, glVertexAttribPointerNV, glVertexAttribPointerNV, NULL, _gloffset_VertexAttribPointerNV),
- NAME_FUNC_OFFSET(12180, glVertexAttribs1dvNV, glVertexAttribs1dvNV, NULL, _gloffset_VertexAttribs1dvNV),
- NAME_FUNC_OFFSET(12201, glVertexAttribs1fvNV, glVertexAttribs1fvNV, NULL, _gloffset_VertexAttribs1fvNV),
- NAME_FUNC_OFFSET(12222, glVertexAttribs1svNV, glVertexAttribs1svNV, NULL, _gloffset_VertexAttribs1svNV),
- NAME_FUNC_OFFSET(12243, glVertexAttribs2dvNV, glVertexAttribs2dvNV, NULL, _gloffset_VertexAttribs2dvNV),
- NAME_FUNC_OFFSET(12264, glVertexAttribs2fvNV, glVertexAttribs2fvNV, NULL, _gloffset_VertexAttribs2fvNV),
- NAME_FUNC_OFFSET(12285, glVertexAttribs2svNV, glVertexAttribs2svNV, NULL, _gloffset_VertexAttribs2svNV),
- NAME_FUNC_OFFSET(12306, glVertexAttribs3dvNV, glVertexAttribs3dvNV, NULL, _gloffset_VertexAttribs3dvNV),
- NAME_FUNC_OFFSET(12327, glVertexAttribs3fvNV, glVertexAttribs3fvNV, NULL, _gloffset_VertexAttribs3fvNV),
- NAME_FUNC_OFFSET(12348, glVertexAttribs3svNV, glVertexAttribs3svNV, NULL, _gloffset_VertexAttribs3svNV),
- NAME_FUNC_OFFSET(12369, glVertexAttribs4dvNV, glVertexAttribs4dvNV, NULL, _gloffset_VertexAttribs4dvNV),
- NAME_FUNC_OFFSET(12390, glVertexAttribs4fvNV, glVertexAttribs4fvNV, NULL, _gloffset_VertexAttribs4fvNV),
- NAME_FUNC_OFFSET(12411, glVertexAttribs4svNV, glVertexAttribs4svNV, NULL, _gloffset_VertexAttribs4svNV),
- NAME_FUNC_OFFSET(12432, glVertexAttribs4ubvNV, glVertexAttribs4ubvNV, NULL, _gloffset_VertexAttribs4ubvNV),
- NAME_FUNC_OFFSET(12454, glGetTexBumpParameterfvATI, glGetTexBumpParameterfvATI, NULL, _gloffset_GetTexBumpParameterfvATI),
- NAME_FUNC_OFFSET(12481, glGetTexBumpParameterivATI, glGetTexBumpParameterivATI, NULL, _gloffset_GetTexBumpParameterivATI),
- NAME_FUNC_OFFSET(12508, glTexBumpParameterfvATI, glTexBumpParameterfvATI, NULL, _gloffset_TexBumpParameterfvATI),
- NAME_FUNC_OFFSET(12532, glTexBumpParameterivATI, glTexBumpParameterivATI, NULL, _gloffset_TexBumpParameterivATI),
- NAME_FUNC_OFFSET(12556, glAlphaFragmentOp1ATI, glAlphaFragmentOp1ATI, NULL, _gloffset_AlphaFragmentOp1ATI),
- NAME_FUNC_OFFSET(12578, glAlphaFragmentOp2ATI, glAlphaFragmentOp2ATI, NULL, _gloffset_AlphaFragmentOp2ATI),
- NAME_FUNC_OFFSET(12600, glAlphaFragmentOp3ATI, glAlphaFragmentOp3ATI, NULL, _gloffset_AlphaFragmentOp3ATI),
- NAME_FUNC_OFFSET(12622, glBeginFragmentShaderATI, glBeginFragmentShaderATI, NULL, _gloffset_BeginFragmentShaderATI),
- NAME_FUNC_OFFSET(12647, glBindFragmentShaderATI, glBindFragmentShaderATI, NULL, _gloffset_BindFragmentShaderATI),
- NAME_FUNC_OFFSET(12671, glColorFragmentOp1ATI, glColorFragmentOp1ATI, NULL, _gloffset_ColorFragmentOp1ATI),
- NAME_FUNC_OFFSET(12693, glColorFragmentOp2ATI, glColorFragmentOp2ATI, NULL, _gloffset_ColorFragmentOp2ATI),
- NAME_FUNC_OFFSET(12715, glColorFragmentOp3ATI, glColorFragmentOp3ATI, NULL, _gloffset_ColorFragmentOp3ATI),
- NAME_FUNC_OFFSET(12737, glDeleteFragmentShaderATI, glDeleteFragmentShaderATI, NULL, _gloffset_DeleteFragmentShaderATI),
- NAME_FUNC_OFFSET(12763, glEndFragmentShaderATI, glEndFragmentShaderATI, NULL, _gloffset_EndFragmentShaderATI),
- NAME_FUNC_OFFSET(12786, glGenFragmentShadersATI, glGenFragmentShadersATI, NULL, _gloffset_GenFragmentShadersATI),
- NAME_FUNC_OFFSET(12810, glPassTexCoordATI, glPassTexCoordATI, NULL, _gloffset_PassTexCoordATI),
- NAME_FUNC_OFFSET(12828, glSampleMapATI, glSampleMapATI, NULL, _gloffset_SampleMapATI),
- NAME_FUNC_OFFSET(12843, glSetFragmentShaderConstantATI, glSetFragmentShaderConstantATI, NULL, _gloffset_SetFragmentShaderConstantATI),
- NAME_FUNC_OFFSET(12874, glPointParameteriNV, glPointParameteriNV, NULL, _gloffset_PointParameteriNV),
- NAME_FUNC_OFFSET(12894, glPointParameterivNV, glPointParameterivNV, NULL, _gloffset_PointParameterivNV),
- NAME_FUNC_OFFSET(12915, gl_dispatch_stub_750, gl_dispatch_stub_750, NULL, _gloffset_ActiveStencilFaceEXT),
- NAME_FUNC_OFFSET(12938, gl_dispatch_stub_751, gl_dispatch_stub_751, NULL, _gloffset_BindVertexArrayAPPLE),
- NAME_FUNC_OFFSET(12961, gl_dispatch_stub_752, gl_dispatch_stub_752, NULL, _gloffset_DeleteVertexArraysAPPLE),
- NAME_FUNC_OFFSET(12987, gl_dispatch_stub_753, gl_dispatch_stub_753, NULL, _gloffset_GenVertexArraysAPPLE),
- NAME_FUNC_OFFSET(13010, gl_dispatch_stub_754, gl_dispatch_stub_754, NULL, _gloffset_IsVertexArrayAPPLE),
- NAME_FUNC_OFFSET(13031, glGetProgramNamedParameterdvNV, glGetProgramNamedParameterdvNV, NULL, _gloffset_GetProgramNamedParameterdvNV),
- NAME_FUNC_OFFSET(13062, glGetProgramNamedParameterfvNV, glGetProgramNamedParameterfvNV, NULL, _gloffset_GetProgramNamedParameterfvNV),
- NAME_FUNC_OFFSET(13093, glProgramNamedParameter4dNV, glProgramNamedParameter4dNV, NULL, _gloffset_ProgramNamedParameter4dNV),
- NAME_FUNC_OFFSET(13121, glProgramNamedParameter4dvNV, glProgramNamedParameter4dvNV, NULL, _gloffset_ProgramNamedParameter4dvNV),
- NAME_FUNC_OFFSET(13150, glProgramNamedParameter4fNV, glProgramNamedParameter4fNV, NULL, _gloffset_ProgramNamedParameter4fNV),
- NAME_FUNC_OFFSET(13178, glProgramNamedParameter4fvNV, glProgramNamedParameter4fvNV, NULL, _gloffset_ProgramNamedParameter4fvNV),
- NAME_FUNC_OFFSET(13207, gl_dispatch_stub_761, gl_dispatch_stub_761, NULL, _gloffset_DepthBoundsEXT),
- NAME_FUNC_OFFSET(13224, gl_dispatch_stub_762, gl_dispatch_stub_762, NULL, _gloffset_BlendEquationSeparateEXT),
- NAME_FUNC_OFFSET(13251, glBindFramebufferEXT, glBindFramebufferEXT, NULL, _gloffset_BindFramebufferEXT),
- NAME_FUNC_OFFSET(13272, glBindRenderbufferEXT, glBindRenderbufferEXT, NULL, _gloffset_BindRenderbufferEXT),
- NAME_FUNC_OFFSET(13294, glCheckFramebufferStatusEXT, glCheckFramebufferStatusEXT, NULL, _gloffset_CheckFramebufferStatusEXT),
- NAME_FUNC_OFFSET(13322, glDeleteFramebuffersEXT, glDeleteFramebuffersEXT, NULL, _gloffset_DeleteFramebuffersEXT),
- NAME_FUNC_OFFSET(13346, glDeleteRenderbuffersEXT, glDeleteRenderbuffersEXT, NULL, _gloffset_DeleteRenderbuffersEXT),
- NAME_FUNC_OFFSET(13371, glFramebufferRenderbufferEXT, glFramebufferRenderbufferEXT, NULL, _gloffset_FramebufferRenderbufferEXT),
- NAME_FUNC_OFFSET(13400, glFramebufferTexture1DEXT, glFramebufferTexture1DEXT, NULL, _gloffset_FramebufferTexture1DEXT),
- NAME_FUNC_OFFSET(13426, glFramebufferTexture2DEXT, glFramebufferTexture2DEXT, NULL, _gloffset_FramebufferTexture2DEXT),
- NAME_FUNC_OFFSET(13452, glFramebufferTexture3DEXT, glFramebufferTexture3DEXT, NULL, _gloffset_FramebufferTexture3DEXT),
- NAME_FUNC_OFFSET(13478, glGenFramebuffersEXT, glGenFramebuffersEXT, NULL, _gloffset_GenFramebuffersEXT),
- NAME_FUNC_OFFSET(13499, glGenRenderbuffersEXT, glGenRenderbuffersEXT, NULL, _gloffset_GenRenderbuffersEXT),
- NAME_FUNC_OFFSET(13521, glGenerateMipmapEXT, glGenerateMipmapEXT, NULL, _gloffset_GenerateMipmapEXT),
- NAME_FUNC_OFFSET(13541, glGetFramebufferAttachmentParameterivEXT, glGetFramebufferAttachmentParameterivEXT, NULL, _gloffset_GetFramebufferAttachmentParameterivEXT),
- NAME_FUNC_OFFSET(13582, glGetRenderbufferParameterivEXT, glGetRenderbufferParameterivEXT, NULL, _gloffset_GetRenderbufferParameterivEXT),
- NAME_FUNC_OFFSET(13614, glIsFramebufferEXT, glIsFramebufferEXT, NULL, _gloffset_IsFramebufferEXT),
- NAME_FUNC_OFFSET(13633, glIsRenderbufferEXT, glIsRenderbufferEXT, NULL, _gloffset_IsRenderbufferEXT),
- NAME_FUNC_OFFSET(13653, glRenderbufferStorageEXT, glRenderbufferStorageEXT, NULL, _gloffset_RenderbufferStorageEXT),
- NAME_FUNC_OFFSET(13678, gl_dispatch_stub_780, gl_dispatch_stub_780, NULL, _gloffset_BlitFramebufferEXT),
- NAME_FUNC_OFFSET(13699, gl_dispatch_stub_781, gl_dispatch_stub_781, NULL, _gloffset_BufferParameteriAPPLE),
- NAME_FUNC_OFFSET(13723, gl_dispatch_stub_782, gl_dispatch_stub_782, NULL, _gloffset_FlushMappedBufferRangeAPPLE),
- NAME_FUNC_OFFSET(13753, glFramebufferTextureLayerEXT, glFramebufferTextureLayerEXT, NULL, _gloffset_FramebufferTextureLayerEXT),
- NAME_FUNC_OFFSET(13782, glProvokingVertexEXT, glProvokingVertexEXT, NULL, _gloffset_ProvokingVertexEXT),
- NAME_FUNC_OFFSET(13803, gl_dispatch_stub_785, gl_dispatch_stub_785, NULL, _gloffset_GetTexParameterPointervAPPLE),
- NAME_FUNC_OFFSET(13834, gl_dispatch_stub_786, gl_dispatch_stub_786, NULL, _gloffset_TextureRangeAPPLE),
- NAME_FUNC_OFFSET(13854, gl_dispatch_stub_787, gl_dispatch_stub_787, NULL, _gloffset_StencilFuncSeparateATI),
- NAME_FUNC_OFFSET(13879, gl_dispatch_stub_788, gl_dispatch_stub_788, NULL, _gloffset_ProgramEnvParameters4fvEXT),
- NAME_FUNC_OFFSET(13908, gl_dispatch_stub_789, gl_dispatch_stub_789, NULL, _gloffset_ProgramLocalParameters4fvEXT),
- NAME_FUNC_OFFSET(13939, gl_dispatch_stub_790, gl_dispatch_stub_790, NULL, _gloffset_GetQueryObjecti64vEXT),
- NAME_FUNC_OFFSET(13963, gl_dispatch_stub_791, gl_dispatch_stub_791, NULL, _gloffset_GetQueryObjectui64vEXT),
- NAME_FUNC_OFFSET(13988, glArrayElement, glArrayElement, NULL, _gloffset_ArrayElement),
- NAME_FUNC_OFFSET(14006, glBindTexture, glBindTexture, NULL, _gloffset_BindTexture),
- NAME_FUNC_OFFSET(14023, glDrawArrays, glDrawArrays, NULL, _gloffset_DrawArrays),
- NAME_FUNC_OFFSET(14039, glAreTexturesResident, glAreTexturesResidentEXT, glAreTexturesResidentEXT, _gloffset_AreTexturesResident),
- NAME_FUNC_OFFSET(14064, glCopyTexImage1D, glCopyTexImage1D, NULL, _gloffset_CopyTexImage1D),
- NAME_FUNC_OFFSET(14084, glCopyTexImage2D, glCopyTexImage2D, NULL, _gloffset_CopyTexImage2D),
- NAME_FUNC_OFFSET(14104, glCopyTexSubImage1D, glCopyTexSubImage1D, NULL, _gloffset_CopyTexSubImage1D),
- NAME_FUNC_OFFSET(14127, glCopyTexSubImage2D, glCopyTexSubImage2D, NULL, _gloffset_CopyTexSubImage2D),
- NAME_FUNC_OFFSET(14150, glDeleteTextures, glDeleteTexturesEXT, glDeleteTexturesEXT, _gloffset_DeleteTextures),
- NAME_FUNC_OFFSET(14170, glGenTextures, glGenTexturesEXT, glGenTexturesEXT, _gloffset_GenTextures),
- NAME_FUNC_OFFSET(14187, glGetPointerv, glGetPointerv, NULL, _gloffset_GetPointerv),
- NAME_FUNC_OFFSET(14204, glIsTexture, glIsTextureEXT, glIsTextureEXT, _gloffset_IsTexture),
- NAME_FUNC_OFFSET(14219, glPrioritizeTextures, glPrioritizeTextures, NULL, _gloffset_PrioritizeTextures),
- NAME_FUNC_OFFSET(14243, glTexSubImage1D, glTexSubImage1D, NULL, _gloffset_TexSubImage1D),
- NAME_FUNC_OFFSET(14262, glTexSubImage2D, glTexSubImage2D, NULL, _gloffset_TexSubImage2D),
- NAME_FUNC_OFFSET(14281, glBlendColor, glBlendColor, NULL, _gloffset_BlendColor),
- NAME_FUNC_OFFSET(14297, glBlendEquation, glBlendEquation, NULL, _gloffset_BlendEquation),
- NAME_FUNC_OFFSET(14316, glDrawRangeElements, glDrawRangeElements, NULL, _gloffset_DrawRangeElements),
- NAME_FUNC_OFFSET(14339, glColorTable, glColorTable, NULL, _gloffset_ColorTable),
- NAME_FUNC_OFFSET(14355, glColorTable, glColorTable, NULL, _gloffset_ColorTable),
- NAME_FUNC_OFFSET(14371, glColorTableParameterfv, glColorTableParameterfv, NULL, _gloffset_ColorTableParameterfv),
- NAME_FUNC_OFFSET(14398, glColorTableParameteriv, glColorTableParameteriv, NULL, _gloffset_ColorTableParameteriv),
- NAME_FUNC_OFFSET(14425, glCopyColorTable, glCopyColorTable, NULL, _gloffset_CopyColorTable),
- NAME_FUNC_OFFSET(14445, glGetColorTable, glGetColorTableEXT, glGetColorTableEXT, _gloffset_GetColorTable),
- NAME_FUNC_OFFSET(14464, glGetColorTable, glGetColorTableEXT, glGetColorTableEXT, _gloffset_GetColorTable),
- NAME_FUNC_OFFSET(14483, glGetColorTableParameterfv, glGetColorTableParameterfvEXT, glGetColorTableParameterfvEXT, _gloffset_GetColorTableParameterfv),
- NAME_FUNC_OFFSET(14513, glGetColorTableParameterfv, glGetColorTableParameterfvEXT, glGetColorTableParameterfvEXT, _gloffset_GetColorTableParameterfv),
- NAME_FUNC_OFFSET(14543, glGetColorTableParameteriv, glGetColorTableParameterivEXT, glGetColorTableParameterivEXT, _gloffset_GetColorTableParameteriv),
- NAME_FUNC_OFFSET(14573, glGetColorTableParameteriv, glGetColorTableParameterivEXT, glGetColorTableParameterivEXT, _gloffset_GetColorTableParameteriv),
- NAME_FUNC_OFFSET(14603, glColorSubTable, glColorSubTable, NULL, _gloffset_ColorSubTable),
- NAME_FUNC_OFFSET(14622, glCopyColorSubTable, glCopyColorSubTable, NULL, _gloffset_CopyColorSubTable),
- NAME_FUNC_OFFSET(14645, glConvolutionFilter1D, glConvolutionFilter1D, NULL, _gloffset_ConvolutionFilter1D),
- NAME_FUNC_OFFSET(14670, glConvolutionFilter2D, glConvolutionFilter2D, NULL, _gloffset_ConvolutionFilter2D),
- NAME_FUNC_OFFSET(14695, glConvolutionParameterf, glConvolutionParameterf, NULL, _gloffset_ConvolutionParameterf),
- NAME_FUNC_OFFSET(14722, glConvolutionParameterfv, glConvolutionParameterfv, NULL, _gloffset_ConvolutionParameterfv),
- NAME_FUNC_OFFSET(14750, glConvolutionParameteri, glConvolutionParameteri, NULL, _gloffset_ConvolutionParameteri),
- NAME_FUNC_OFFSET(14777, glConvolutionParameteriv, glConvolutionParameteriv, NULL, _gloffset_ConvolutionParameteriv),
- NAME_FUNC_OFFSET(14805, glCopyConvolutionFilter1D, glCopyConvolutionFilter1D, NULL, _gloffset_CopyConvolutionFilter1D),
- NAME_FUNC_OFFSET(14834, glCopyConvolutionFilter2D, glCopyConvolutionFilter2D, NULL, _gloffset_CopyConvolutionFilter2D),
- NAME_FUNC_OFFSET(14863, glGetConvolutionFilter, gl_dispatch_stub_356, gl_dispatch_stub_356, _gloffset_GetConvolutionFilter),
- NAME_FUNC_OFFSET(14889, glGetConvolutionParameterfv, gl_dispatch_stub_357, gl_dispatch_stub_357, _gloffset_GetConvolutionParameterfv),
- NAME_FUNC_OFFSET(14920, glGetConvolutionParameteriv, gl_dispatch_stub_358, gl_dispatch_stub_358, _gloffset_GetConvolutionParameteriv),
- NAME_FUNC_OFFSET(14951, glGetSeparableFilter, gl_dispatch_stub_359, gl_dispatch_stub_359, _gloffset_GetSeparableFilter),
- NAME_FUNC_OFFSET(14975, glSeparableFilter2D, glSeparableFilter2D, NULL, _gloffset_SeparableFilter2D),
- NAME_FUNC_OFFSET(14998, glGetHistogram, gl_dispatch_stub_361, gl_dispatch_stub_361, _gloffset_GetHistogram),
- NAME_FUNC_OFFSET(15016, glGetHistogramParameterfv, gl_dispatch_stub_362, gl_dispatch_stub_362, _gloffset_GetHistogramParameterfv),
- NAME_FUNC_OFFSET(15045, glGetHistogramParameteriv, gl_dispatch_stub_363, gl_dispatch_stub_363, _gloffset_GetHistogramParameteriv),
- NAME_FUNC_OFFSET(15074, glGetMinmax, gl_dispatch_stub_364, gl_dispatch_stub_364, _gloffset_GetMinmax),
- NAME_FUNC_OFFSET(15089, glGetMinmaxParameterfv, gl_dispatch_stub_365, gl_dispatch_stub_365, _gloffset_GetMinmaxParameterfv),
- NAME_FUNC_OFFSET(15115, glGetMinmaxParameteriv, gl_dispatch_stub_366, gl_dispatch_stub_366, _gloffset_GetMinmaxParameteriv),
- NAME_FUNC_OFFSET(15141, glHistogram, glHistogram, NULL, _gloffset_Histogram),
- NAME_FUNC_OFFSET(15156, glMinmax, glMinmax, NULL, _gloffset_Minmax),
- NAME_FUNC_OFFSET(15168, glResetHistogram, glResetHistogram, NULL, _gloffset_ResetHistogram),
- NAME_FUNC_OFFSET(15188, glResetMinmax, glResetMinmax, NULL, _gloffset_ResetMinmax),
- NAME_FUNC_OFFSET(15205, glTexImage3D, glTexImage3D, NULL, _gloffset_TexImage3D),
- NAME_FUNC_OFFSET(15221, glTexSubImage3D, glTexSubImage3D, NULL, _gloffset_TexSubImage3D),
- NAME_FUNC_OFFSET(15240, glCopyTexSubImage3D, glCopyTexSubImage3D, NULL, _gloffset_CopyTexSubImage3D),
- NAME_FUNC_OFFSET(15263, glActiveTextureARB, glActiveTextureARB, NULL, _gloffset_ActiveTextureARB),
- NAME_FUNC_OFFSET(15279, glClientActiveTextureARB, glClientActiveTextureARB, NULL, _gloffset_ClientActiveTextureARB),
- NAME_FUNC_OFFSET(15301, glMultiTexCoord1dARB, glMultiTexCoord1dARB, NULL, _gloffset_MultiTexCoord1dARB),
- NAME_FUNC_OFFSET(15319, glMultiTexCoord1dvARB, glMultiTexCoord1dvARB, NULL, _gloffset_MultiTexCoord1dvARB),
- NAME_FUNC_OFFSET(15338, glMultiTexCoord1fARB, glMultiTexCoord1fARB, NULL, _gloffset_MultiTexCoord1fARB),
- NAME_FUNC_OFFSET(15356, glMultiTexCoord1fvARB, glMultiTexCoord1fvARB, NULL, _gloffset_MultiTexCoord1fvARB),
- NAME_FUNC_OFFSET(15375, glMultiTexCoord1iARB, glMultiTexCoord1iARB, NULL, _gloffset_MultiTexCoord1iARB),
- NAME_FUNC_OFFSET(15393, glMultiTexCoord1ivARB, glMultiTexCoord1ivARB, NULL, _gloffset_MultiTexCoord1ivARB),
- NAME_FUNC_OFFSET(15412, glMultiTexCoord1sARB, glMultiTexCoord1sARB, NULL, _gloffset_MultiTexCoord1sARB),
- NAME_FUNC_OFFSET(15430, glMultiTexCoord1svARB, glMultiTexCoord1svARB, NULL, _gloffset_MultiTexCoord1svARB),
- NAME_FUNC_OFFSET(15449, glMultiTexCoord2dARB, glMultiTexCoord2dARB, NULL, _gloffset_MultiTexCoord2dARB),
- NAME_FUNC_OFFSET(15467, glMultiTexCoord2dvARB, glMultiTexCoord2dvARB, NULL, _gloffset_MultiTexCoord2dvARB),
- NAME_FUNC_OFFSET(15486, glMultiTexCoord2fARB, glMultiTexCoord2fARB, NULL, _gloffset_MultiTexCoord2fARB),
- NAME_FUNC_OFFSET(15504, glMultiTexCoord2fvARB, glMultiTexCoord2fvARB, NULL, _gloffset_MultiTexCoord2fvARB),
- NAME_FUNC_OFFSET(15523, glMultiTexCoord2iARB, glMultiTexCoord2iARB, NULL, _gloffset_MultiTexCoord2iARB),
- NAME_FUNC_OFFSET(15541, glMultiTexCoord2ivARB, glMultiTexCoord2ivARB, NULL, _gloffset_MultiTexCoord2ivARB),
- NAME_FUNC_OFFSET(15560, glMultiTexCoord2sARB, glMultiTexCoord2sARB, NULL, _gloffset_MultiTexCoord2sARB),
- NAME_FUNC_OFFSET(15578, glMultiTexCoord2svARB, glMultiTexCoord2svARB, NULL, _gloffset_MultiTexCoord2svARB),
- NAME_FUNC_OFFSET(15597, glMultiTexCoord3dARB, glMultiTexCoord3dARB, NULL, _gloffset_MultiTexCoord3dARB),
- NAME_FUNC_OFFSET(15615, glMultiTexCoord3dvARB, glMultiTexCoord3dvARB, NULL, _gloffset_MultiTexCoord3dvARB),
- NAME_FUNC_OFFSET(15634, glMultiTexCoord3fARB, glMultiTexCoord3fARB, NULL, _gloffset_MultiTexCoord3fARB),
- NAME_FUNC_OFFSET(15652, glMultiTexCoord3fvARB, glMultiTexCoord3fvARB, NULL, _gloffset_MultiTexCoord3fvARB),
- NAME_FUNC_OFFSET(15671, glMultiTexCoord3iARB, glMultiTexCoord3iARB, NULL, _gloffset_MultiTexCoord3iARB),
- NAME_FUNC_OFFSET(15689, glMultiTexCoord3ivARB, glMultiTexCoord3ivARB, NULL, _gloffset_MultiTexCoord3ivARB),
- NAME_FUNC_OFFSET(15708, glMultiTexCoord3sARB, glMultiTexCoord3sARB, NULL, _gloffset_MultiTexCoord3sARB),
- NAME_FUNC_OFFSET(15726, glMultiTexCoord3svARB, glMultiTexCoord3svARB, NULL, _gloffset_MultiTexCoord3svARB),
- NAME_FUNC_OFFSET(15745, glMultiTexCoord4dARB, glMultiTexCoord4dARB, NULL, _gloffset_MultiTexCoord4dARB),
- NAME_FUNC_OFFSET(15763, glMultiTexCoord4dvARB, glMultiTexCoord4dvARB, NULL, _gloffset_MultiTexCoord4dvARB),
- NAME_FUNC_OFFSET(15782, glMultiTexCoord4fARB, glMultiTexCoord4fARB, NULL, _gloffset_MultiTexCoord4fARB),
- NAME_FUNC_OFFSET(15800, glMultiTexCoord4fvARB, glMultiTexCoord4fvARB, NULL, _gloffset_MultiTexCoord4fvARB),
- NAME_FUNC_OFFSET(15819, glMultiTexCoord4iARB, glMultiTexCoord4iARB, NULL, _gloffset_MultiTexCoord4iARB),
- NAME_FUNC_OFFSET(15837, glMultiTexCoord4ivARB, glMultiTexCoord4ivARB, NULL, _gloffset_MultiTexCoord4ivARB),
- NAME_FUNC_OFFSET(15856, glMultiTexCoord4sARB, glMultiTexCoord4sARB, NULL, _gloffset_MultiTexCoord4sARB),
- NAME_FUNC_OFFSET(15874, glMultiTexCoord4svARB, glMultiTexCoord4svARB, NULL, _gloffset_MultiTexCoord4svARB),
- NAME_FUNC_OFFSET(15893, glStencilOpSeparate, glStencilOpSeparate, NULL, _gloffset_StencilOpSeparate),
- NAME_FUNC_OFFSET(15916, glLoadTransposeMatrixdARB, glLoadTransposeMatrixdARB, NULL, _gloffset_LoadTransposeMatrixdARB),
- NAME_FUNC_OFFSET(15939, glLoadTransposeMatrixfARB, glLoadTransposeMatrixfARB, NULL, _gloffset_LoadTransposeMatrixfARB),
- NAME_FUNC_OFFSET(15962, glMultTransposeMatrixdARB, glMultTransposeMatrixdARB, NULL, _gloffset_MultTransposeMatrixdARB),
- NAME_FUNC_OFFSET(15985, glMultTransposeMatrixfARB, glMultTransposeMatrixfARB, NULL, _gloffset_MultTransposeMatrixfARB),
- NAME_FUNC_OFFSET(16008, glSampleCoverageARB, glSampleCoverageARB, NULL, _gloffset_SampleCoverageARB),
- NAME_FUNC_OFFSET(16025, glCompressedTexImage1DARB, glCompressedTexImage1DARB, NULL, _gloffset_CompressedTexImage1DARB),
- NAME_FUNC_OFFSET(16048, glCompressedTexImage2DARB, glCompressedTexImage2DARB, NULL, _gloffset_CompressedTexImage2DARB),
- NAME_FUNC_OFFSET(16071, glCompressedTexImage3DARB, glCompressedTexImage3DARB, NULL, _gloffset_CompressedTexImage3DARB),
- NAME_FUNC_OFFSET(16094, glCompressedTexSubImage1DARB, glCompressedTexSubImage1DARB, NULL, _gloffset_CompressedTexSubImage1DARB),
- NAME_FUNC_OFFSET(16120, glCompressedTexSubImage2DARB, glCompressedTexSubImage2DARB, NULL, _gloffset_CompressedTexSubImage2DARB),
- NAME_FUNC_OFFSET(16146, glCompressedTexSubImage3DARB, glCompressedTexSubImage3DARB, NULL, _gloffset_CompressedTexSubImage3DARB),
- NAME_FUNC_OFFSET(16172, glGetCompressedTexImageARB, glGetCompressedTexImageARB, NULL, _gloffset_GetCompressedTexImageARB),
- NAME_FUNC_OFFSET(16196, glDisableVertexAttribArrayARB, glDisableVertexAttribArrayARB, NULL, _gloffset_DisableVertexAttribArrayARB),
- NAME_FUNC_OFFSET(16223, glEnableVertexAttribArrayARB, glEnableVertexAttribArrayARB, NULL, _gloffset_EnableVertexAttribArrayARB),
- NAME_FUNC_OFFSET(16249, glGetVertexAttribdvARB, glGetVertexAttribdvARB, NULL, _gloffset_GetVertexAttribdvARB),
- NAME_FUNC_OFFSET(16269, glGetVertexAttribfvARB, glGetVertexAttribfvARB, NULL, _gloffset_GetVertexAttribfvARB),
- NAME_FUNC_OFFSET(16289, glGetVertexAttribivARB, glGetVertexAttribivARB, NULL, _gloffset_GetVertexAttribivARB),
- NAME_FUNC_OFFSET(16309, glProgramEnvParameter4dARB, glProgramEnvParameter4dARB, NULL, _gloffset_ProgramEnvParameter4dARB),
- NAME_FUNC_OFFSET(16332, glProgramEnvParameter4dvARB, glProgramEnvParameter4dvARB, NULL, _gloffset_ProgramEnvParameter4dvARB),
- NAME_FUNC_OFFSET(16356, glProgramEnvParameter4fARB, glProgramEnvParameter4fARB, NULL, _gloffset_ProgramEnvParameter4fARB),
- NAME_FUNC_OFFSET(16379, glProgramEnvParameter4fvARB, glProgramEnvParameter4fvARB, NULL, _gloffset_ProgramEnvParameter4fvARB),
- NAME_FUNC_OFFSET(16403, glVertexAttrib1dARB, glVertexAttrib1dARB, NULL, _gloffset_VertexAttrib1dARB),
- NAME_FUNC_OFFSET(16420, glVertexAttrib1dvARB, glVertexAttrib1dvARB, NULL, _gloffset_VertexAttrib1dvARB),
- NAME_FUNC_OFFSET(16438, glVertexAttrib1fARB, glVertexAttrib1fARB, NULL, _gloffset_VertexAttrib1fARB),
- NAME_FUNC_OFFSET(16455, glVertexAttrib1fvARB, glVertexAttrib1fvARB, NULL, _gloffset_VertexAttrib1fvARB),
- NAME_FUNC_OFFSET(16473, glVertexAttrib1sARB, glVertexAttrib1sARB, NULL, _gloffset_VertexAttrib1sARB),
- NAME_FUNC_OFFSET(16490, glVertexAttrib1svARB, glVertexAttrib1svARB, NULL, _gloffset_VertexAttrib1svARB),
- NAME_FUNC_OFFSET(16508, glVertexAttrib2dARB, glVertexAttrib2dARB, NULL, _gloffset_VertexAttrib2dARB),
- NAME_FUNC_OFFSET(16525, glVertexAttrib2dvARB, glVertexAttrib2dvARB, NULL, _gloffset_VertexAttrib2dvARB),
- NAME_FUNC_OFFSET(16543, glVertexAttrib2fARB, glVertexAttrib2fARB, NULL, _gloffset_VertexAttrib2fARB),
- NAME_FUNC_OFFSET(16560, glVertexAttrib2fvARB, glVertexAttrib2fvARB, NULL, _gloffset_VertexAttrib2fvARB),
- NAME_FUNC_OFFSET(16578, glVertexAttrib2sARB, glVertexAttrib2sARB, NULL, _gloffset_VertexAttrib2sARB),
- NAME_FUNC_OFFSET(16595, glVertexAttrib2svARB, glVertexAttrib2svARB, NULL, _gloffset_VertexAttrib2svARB),
- NAME_FUNC_OFFSET(16613, glVertexAttrib3dARB, glVertexAttrib3dARB, NULL, _gloffset_VertexAttrib3dARB),
- NAME_FUNC_OFFSET(16630, glVertexAttrib3dvARB, glVertexAttrib3dvARB, NULL, _gloffset_VertexAttrib3dvARB),
- NAME_FUNC_OFFSET(16648, glVertexAttrib3fARB, glVertexAttrib3fARB, NULL, _gloffset_VertexAttrib3fARB),
- NAME_FUNC_OFFSET(16665, glVertexAttrib3fvARB, glVertexAttrib3fvARB, NULL, _gloffset_VertexAttrib3fvARB),
- NAME_FUNC_OFFSET(16683, glVertexAttrib3sARB, glVertexAttrib3sARB, NULL, _gloffset_VertexAttrib3sARB),
- NAME_FUNC_OFFSET(16700, glVertexAttrib3svARB, glVertexAttrib3svARB, NULL, _gloffset_VertexAttrib3svARB),
- NAME_FUNC_OFFSET(16718, glVertexAttrib4NbvARB, glVertexAttrib4NbvARB, NULL, _gloffset_VertexAttrib4NbvARB),
- NAME_FUNC_OFFSET(16737, glVertexAttrib4NivARB, glVertexAttrib4NivARB, NULL, _gloffset_VertexAttrib4NivARB),
- NAME_FUNC_OFFSET(16756, glVertexAttrib4NsvARB, glVertexAttrib4NsvARB, NULL, _gloffset_VertexAttrib4NsvARB),
- NAME_FUNC_OFFSET(16775, glVertexAttrib4NubARB, glVertexAttrib4NubARB, NULL, _gloffset_VertexAttrib4NubARB),
- NAME_FUNC_OFFSET(16794, glVertexAttrib4NubvARB, glVertexAttrib4NubvARB, NULL, _gloffset_VertexAttrib4NubvARB),
- NAME_FUNC_OFFSET(16814, glVertexAttrib4NuivARB, glVertexAttrib4NuivARB, NULL, _gloffset_VertexAttrib4NuivARB),
- NAME_FUNC_OFFSET(16834, glVertexAttrib4NusvARB, glVertexAttrib4NusvARB, NULL, _gloffset_VertexAttrib4NusvARB),
- NAME_FUNC_OFFSET(16854, glVertexAttrib4bvARB, glVertexAttrib4bvARB, NULL, _gloffset_VertexAttrib4bvARB),
- NAME_FUNC_OFFSET(16872, glVertexAttrib4dARB, glVertexAttrib4dARB, NULL, _gloffset_VertexAttrib4dARB),
- NAME_FUNC_OFFSET(16889, glVertexAttrib4dvARB, glVertexAttrib4dvARB, NULL, _gloffset_VertexAttrib4dvARB),
- NAME_FUNC_OFFSET(16907, glVertexAttrib4fARB, glVertexAttrib4fARB, NULL, _gloffset_VertexAttrib4fARB),
- NAME_FUNC_OFFSET(16924, glVertexAttrib4fvARB, glVertexAttrib4fvARB, NULL, _gloffset_VertexAttrib4fvARB),
- NAME_FUNC_OFFSET(16942, glVertexAttrib4ivARB, glVertexAttrib4ivARB, NULL, _gloffset_VertexAttrib4ivARB),
- NAME_FUNC_OFFSET(16960, glVertexAttrib4sARB, glVertexAttrib4sARB, NULL, _gloffset_VertexAttrib4sARB),
- NAME_FUNC_OFFSET(16977, glVertexAttrib4svARB, glVertexAttrib4svARB, NULL, _gloffset_VertexAttrib4svARB),
- NAME_FUNC_OFFSET(16995, glVertexAttrib4ubvARB, glVertexAttrib4ubvARB, NULL, _gloffset_VertexAttrib4ubvARB),
- NAME_FUNC_OFFSET(17014, glVertexAttrib4uivARB, glVertexAttrib4uivARB, NULL, _gloffset_VertexAttrib4uivARB),
- NAME_FUNC_OFFSET(17033, glVertexAttrib4usvARB, glVertexAttrib4usvARB, NULL, _gloffset_VertexAttrib4usvARB),
- NAME_FUNC_OFFSET(17052, glVertexAttribPointerARB, glVertexAttribPointerARB, NULL, _gloffset_VertexAttribPointerARB),
- NAME_FUNC_OFFSET(17074, glBindBufferARB, glBindBufferARB, NULL, _gloffset_BindBufferARB),
- NAME_FUNC_OFFSET(17087, glBufferDataARB, glBufferDataARB, NULL, _gloffset_BufferDataARB),
- NAME_FUNC_OFFSET(17100, glBufferSubDataARB, glBufferSubDataARB, NULL, _gloffset_BufferSubDataARB),
- NAME_FUNC_OFFSET(17116, glDeleteBuffersARB, glDeleteBuffersARB, NULL, _gloffset_DeleteBuffersARB),
- NAME_FUNC_OFFSET(17132, glGenBuffersARB, glGenBuffersARB, NULL, _gloffset_GenBuffersARB),
- NAME_FUNC_OFFSET(17145, glGetBufferParameterivARB, glGetBufferParameterivARB, NULL, _gloffset_GetBufferParameterivARB),
- NAME_FUNC_OFFSET(17168, glGetBufferPointervARB, glGetBufferPointervARB, NULL, _gloffset_GetBufferPointervARB),
- NAME_FUNC_OFFSET(17188, glGetBufferSubDataARB, glGetBufferSubDataARB, NULL, _gloffset_GetBufferSubDataARB),
- NAME_FUNC_OFFSET(17207, glIsBufferARB, glIsBufferARB, NULL, _gloffset_IsBufferARB),
- NAME_FUNC_OFFSET(17218, glMapBufferARB, glMapBufferARB, NULL, _gloffset_MapBufferARB),
- NAME_FUNC_OFFSET(17230, glUnmapBufferARB, glUnmapBufferARB, NULL, _gloffset_UnmapBufferARB),
- NAME_FUNC_OFFSET(17244, glBeginQueryARB, glBeginQueryARB, NULL, _gloffset_BeginQueryARB),
- NAME_FUNC_OFFSET(17257, glDeleteQueriesARB, glDeleteQueriesARB, NULL, _gloffset_DeleteQueriesARB),
- NAME_FUNC_OFFSET(17273, glEndQueryARB, glEndQueryARB, NULL, _gloffset_EndQueryARB),
- NAME_FUNC_OFFSET(17284, glGenQueriesARB, glGenQueriesARB, NULL, _gloffset_GenQueriesARB),
- NAME_FUNC_OFFSET(17297, glGetQueryObjectivARB, glGetQueryObjectivARB, NULL, _gloffset_GetQueryObjectivARB),
- NAME_FUNC_OFFSET(17316, glGetQueryObjectuivARB, glGetQueryObjectuivARB, NULL, _gloffset_GetQueryObjectuivARB),
- NAME_FUNC_OFFSET(17336, glGetQueryivARB, glGetQueryivARB, NULL, _gloffset_GetQueryivARB),
- NAME_FUNC_OFFSET(17349, glIsQueryARB, glIsQueryARB, NULL, _gloffset_IsQueryARB),
- NAME_FUNC_OFFSET(17359, glCompileShaderARB, glCompileShaderARB, NULL, _gloffset_CompileShaderARB),
- NAME_FUNC_OFFSET(17375, glGetActiveUniformARB, glGetActiveUniformARB, NULL, _gloffset_GetActiveUniformARB),
- NAME_FUNC_OFFSET(17394, glGetShaderSourceARB, glGetShaderSourceARB, NULL, _gloffset_GetShaderSourceARB),
- NAME_FUNC_OFFSET(17412, glGetUniformLocationARB, glGetUniformLocationARB, NULL, _gloffset_GetUniformLocationARB),
- NAME_FUNC_OFFSET(17433, glGetUniformfvARB, glGetUniformfvARB, NULL, _gloffset_GetUniformfvARB),
- NAME_FUNC_OFFSET(17448, glGetUniformivARB, glGetUniformivARB, NULL, _gloffset_GetUniformivARB),
- NAME_FUNC_OFFSET(17463, glLinkProgramARB, glLinkProgramARB, NULL, _gloffset_LinkProgramARB),
- NAME_FUNC_OFFSET(17477, glShaderSourceARB, glShaderSourceARB, NULL, _gloffset_ShaderSourceARB),
- NAME_FUNC_OFFSET(17492, glUniform1fARB, glUniform1fARB, NULL, _gloffset_Uniform1fARB),
- NAME_FUNC_OFFSET(17504, glUniform1fvARB, glUniform1fvARB, NULL, _gloffset_Uniform1fvARB),
- NAME_FUNC_OFFSET(17517, glUniform1iARB, glUniform1iARB, NULL, _gloffset_Uniform1iARB),
- NAME_FUNC_OFFSET(17529, glUniform1ivARB, glUniform1ivARB, NULL, _gloffset_Uniform1ivARB),
- NAME_FUNC_OFFSET(17542, glUniform2fARB, glUniform2fARB, NULL, _gloffset_Uniform2fARB),
- NAME_FUNC_OFFSET(17554, glUniform2fvARB, glUniform2fvARB, NULL, _gloffset_Uniform2fvARB),
- NAME_FUNC_OFFSET(17567, glUniform2iARB, glUniform2iARB, NULL, _gloffset_Uniform2iARB),
- NAME_FUNC_OFFSET(17579, glUniform2ivARB, glUniform2ivARB, NULL, _gloffset_Uniform2ivARB),
- NAME_FUNC_OFFSET(17592, glUniform3fARB, glUniform3fARB, NULL, _gloffset_Uniform3fARB),
- NAME_FUNC_OFFSET(17604, glUniform3fvARB, glUniform3fvARB, NULL, _gloffset_Uniform3fvARB),
- NAME_FUNC_OFFSET(17617, glUniform3iARB, glUniform3iARB, NULL, _gloffset_Uniform3iARB),
- NAME_FUNC_OFFSET(17629, glUniform3ivARB, glUniform3ivARB, NULL, _gloffset_Uniform3ivARB),
- NAME_FUNC_OFFSET(17642, glUniform4fARB, glUniform4fARB, NULL, _gloffset_Uniform4fARB),
- NAME_FUNC_OFFSET(17654, glUniform4fvARB, glUniform4fvARB, NULL, _gloffset_Uniform4fvARB),
- NAME_FUNC_OFFSET(17667, glUniform4iARB, glUniform4iARB, NULL, _gloffset_Uniform4iARB),
- NAME_FUNC_OFFSET(17679, glUniform4ivARB, glUniform4ivARB, NULL, _gloffset_Uniform4ivARB),
- NAME_FUNC_OFFSET(17692, glUniformMatrix2fvARB, glUniformMatrix2fvARB, NULL, _gloffset_UniformMatrix2fvARB),
- NAME_FUNC_OFFSET(17711, glUniformMatrix3fvARB, glUniformMatrix3fvARB, NULL, _gloffset_UniformMatrix3fvARB),
- NAME_FUNC_OFFSET(17730, glUniformMatrix4fvARB, glUniformMatrix4fvARB, NULL, _gloffset_UniformMatrix4fvARB),
- NAME_FUNC_OFFSET(17749, glUseProgramObjectARB, glUseProgramObjectARB, NULL, _gloffset_UseProgramObjectARB),
- NAME_FUNC_OFFSET(17762, glValidateProgramARB, glValidateProgramARB, NULL, _gloffset_ValidateProgramARB),
- NAME_FUNC_OFFSET(17780, glBindAttribLocationARB, glBindAttribLocationARB, NULL, _gloffset_BindAttribLocationARB),
- NAME_FUNC_OFFSET(17801, glGetActiveAttribARB, glGetActiveAttribARB, NULL, _gloffset_GetActiveAttribARB),
- NAME_FUNC_OFFSET(17819, glGetAttribLocationARB, glGetAttribLocationARB, NULL, _gloffset_GetAttribLocationARB),
- NAME_FUNC_OFFSET(17839, glDrawBuffersARB, glDrawBuffersARB, NULL, _gloffset_DrawBuffersARB),
- NAME_FUNC_OFFSET(17853, glDrawBuffersARB, glDrawBuffersARB, NULL, _gloffset_DrawBuffersARB),
- NAME_FUNC_OFFSET(17870, gl_dispatch_stub_581, gl_dispatch_stub_581, NULL, _gloffset_SampleMaskSGIS),
- NAME_FUNC_OFFSET(17886, gl_dispatch_stub_582, gl_dispatch_stub_582, NULL, _gloffset_SamplePatternSGIS),
- NAME_FUNC_OFFSET(17905, glPointParameterfEXT, glPointParameterfEXT, NULL, _gloffset_PointParameterfEXT),
- NAME_FUNC_OFFSET(17923, glPointParameterfEXT, glPointParameterfEXT, NULL, _gloffset_PointParameterfEXT),
- NAME_FUNC_OFFSET(17944, glPointParameterfEXT, glPointParameterfEXT, NULL, _gloffset_PointParameterfEXT),
- NAME_FUNC_OFFSET(17966, glPointParameterfvEXT, glPointParameterfvEXT, NULL, _gloffset_PointParameterfvEXT),
- NAME_FUNC_OFFSET(17985, glPointParameterfvEXT, glPointParameterfvEXT, NULL, _gloffset_PointParameterfvEXT),
- NAME_FUNC_OFFSET(18007, glPointParameterfvEXT, glPointParameterfvEXT, NULL, _gloffset_PointParameterfvEXT),
- NAME_FUNC_OFFSET(18030, glSecondaryColor3bEXT, glSecondaryColor3bEXT, NULL, _gloffset_SecondaryColor3bEXT),
- NAME_FUNC_OFFSET(18049, glSecondaryColor3bvEXT, glSecondaryColor3bvEXT, NULL, _gloffset_SecondaryColor3bvEXT),
- NAME_FUNC_OFFSET(18069, glSecondaryColor3dEXT, glSecondaryColor3dEXT, NULL, _gloffset_SecondaryColor3dEXT),
- NAME_FUNC_OFFSET(18088, glSecondaryColor3dvEXT, glSecondaryColor3dvEXT, NULL, _gloffset_SecondaryColor3dvEXT),
- NAME_FUNC_OFFSET(18108, glSecondaryColor3fEXT, glSecondaryColor3fEXT, NULL, _gloffset_SecondaryColor3fEXT),
- NAME_FUNC_OFFSET(18127, glSecondaryColor3fvEXT, glSecondaryColor3fvEXT, NULL, _gloffset_SecondaryColor3fvEXT),
- NAME_FUNC_OFFSET(18147, glSecondaryColor3iEXT, glSecondaryColor3iEXT, NULL, _gloffset_SecondaryColor3iEXT),
- NAME_FUNC_OFFSET(18166, glSecondaryColor3ivEXT, glSecondaryColor3ivEXT, NULL, _gloffset_SecondaryColor3ivEXT),
- NAME_FUNC_OFFSET(18186, glSecondaryColor3sEXT, glSecondaryColor3sEXT, NULL, _gloffset_SecondaryColor3sEXT),
- NAME_FUNC_OFFSET(18205, glSecondaryColor3svEXT, glSecondaryColor3svEXT, NULL, _gloffset_SecondaryColor3svEXT),
- NAME_FUNC_OFFSET(18225, glSecondaryColor3ubEXT, glSecondaryColor3ubEXT, NULL, _gloffset_SecondaryColor3ubEXT),
- NAME_FUNC_OFFSET(18245, glSecondaryColor3ubvEXT, glSecondaryColor3ubvEXT, NULL, _gloffset_SecondaryColor3ubvEXT),
- NAME_FUNC_OFFSET(18266, glSecondaryColor3uiEXT, glSecondaryColor3uiEXT, NULL, _gloffset_SecondaryColor3uiEXT),
- NAME_FUNC_OFFSET(18286, glSecondaryColor3uivEXT, glSecondaryColor3uivEXT, NULL, _gloffset_SecondaryColor3uivEXT),
- NAME_FUNC_OFFSET(18307, glSecondaryColor3usEXT, glSecondaryColor3usEXT, NULL, _gloffset_SecondaryColor3usEXT),
- NAME_FUNC_OFFSET(18327, glSecondaryColor3usvEXT, glSecondaryColor3usvEXT, NULL, _gloffset_SecondaryColor3usvEXT),
- NAME_FUNC_OFFSET(18348, glSecondaryColorPointerEXT, glSecondaryColorPointerEXT, NULL, _gloffset_SecondaryColorPointerEXT),
- NAME_FUNC_OFFSET(18372, glMultiDrawArraysEXT, glMultiDrawArraysEXT, NULL, _gloffset_MultiDrawArraysEXT),
- NAME_FUNC_OFFSET(18390, glMultiDrawElementsEXT, glMultiDrawElementsEXT, NULL, _gloffset_MultiDrawElementsEXT),
- NAME_FUNC_OFFSET(18410, glFogCoordPointerEXT, glFogCoordPointerEXT, NULL, _gloffset_FogCoordPointerEXT),
- NAME_FUNC_OFFSET(18428, glFogCoorddEXT, glFogCoorddEXT, NULL, _gloffset_FogCoorddEXT),
- NAME_FUNC_OFFSET(18440, glFogCoorddvEXT, glFogCoorddvEXT, NULL, _gloffset_FogCoorddvEXT),
- NAME_FUNC_OFFSET(18453, glFogCoordfEXT, glFogCoordfEXT, NULL, _gloffset_FogCoordfEXT),
- NAME_FUNC_OFFSET(18465, glFogCoordfvEXT, glFogCoordfvEXT, NULL, _gloffset_FogCoordfvEXT),
- NAME_FUNC_OFFSET(18478, glBlendFuncSeparateEXT, glBlendFuncSeparateEXT, NULL, _gloffset_BlendFuncSeparateEXT),
- NAME_FUNC_OFFSET(18498, glBlendFuncSeparateEXT, glBlendFuncSeparateEXT, NULL, _gloffset_BlendFuncSeparateEXT),
- NAME_FUNC_OFFSET(18522, glWindowPos2dMESA, glWindowPos2dMESA, NULL, _gloffset_WindowPos2dMESA),
- NAME_FUNC_OFFSET(18536, glWindowPos2dMESA, glWindowPos2dMESA, NULL, _gloffset_WindowPos2dMESA),
- NAME_FUNC_OFFSET(18553, glWindowPos2dvMESA, glWindowPos2dvMESA, NULL, _gloffset_WindowPos2dvMESA),
- NAME_FUNC_OFFSET(18568, glWindowPos2dvMESA, glWindowPos2dvMESA, NULL, _gloffset_WindowPos2dvMESA),
- NAME_FUNC_OFFSET(18586, glWindowPos2fMESA, glWindowPos2fMESA, NULL, _gloffset_WindowPos2fMESA),
- NAME_FUNC_OFFSET(18600, glWindowPos2fMESA, glWindowPos2fMESA, NULL, _gloffset_WindowPos2fMESA),
- NAME_FUNC_OFFSET(18617, glWindowPos2fvMESA, glWindowPos2fvMESA, NULL, _gloffset_WindowPos2fvMESA),
- NAME_FUNC_OFFSET(18632, glWindowPos2fvMESA, glWindowPos2fvMESA, NULL, _gloffset_WindowPos2fvMESA),
- NAME_FUNC_OFFSET(18650, glWindowPos2iMESA, glWindowPos2iMESA, NULL, _gloffset_WindowPos2iMESA),
- NAME_FUNC_OFFSET(18664, glWindowPos2iMESA, glWindowPos2iMESA, NULL, _gloffset_WindowPos2iMESA),
- NAME_FUNC_OFFSET(18681, glWindowPos2ivMESA, glWindowPos2ivMESA, NULL, _gloffset_WindowPos2ivMESA),
- NAME_FUNC_OFFSET(18696, glWindowPos2ivMESA, glWindowPos2ivMESA, NULL, _gloffset_WindowPos2ivMESA),
- NAME_FUNC_OFFSET(18714, glWindowPos2sMESA, glWindowPos2sMESA, NULL, _gloffset_WindowPos2sMESA),
- NAME_FUNC_OFFSET(18728, glWindowPos2sMESA, glWindowPos2sMESA, NULL, _gloffset_WindowPos2sMESA),
- NAME_FUNC_OFFSET(18745, glWindowPos2svMESA, glWindowPos2svMESA, NULL, _gloffset_WindowPos2svMESA),
- NAME_FUNC_OFFSET(18760, glWindowPos2svMESA, glWindowPos2svMESA, NULL, _gloffset_WindowPos2svMESA),
- NAME_FUNC_OFFSET(18778, glWindowPos3dMESA, glWindowPos3dMESA, NULL, _gloffset_WindowPos3dMESA),
- NAME_FUNC_OFFSET(18792, glWindowPos3dMESA, glWindowPos3dMESA, NULL, _gloffset_WindowPos3dMESA),
- NAME_FUNC_OFFSET(18809, glWindowPos3dvMESA, glWindowPos3dvMESA, NULL, _gloffset_WindowPos3dvMESA),
- NAME_FUNC_OFFSET(18824, glWindowPos3dvMESA, glWindowPos3dvMESA, NULL, _gloffset_WindowPos3dvMESA),
- NAME_FUNC_OFFSET(18842, glWindowPos3fMESA, glWindowPos3fMESA, NULL, _gloffset_WindowPos3fMESA),
- NAME_FUNC_OFFSET(18856, glWindowPos3fMESA, glWindowPos3fMESA, NULL, _gloffset_WindowPos3fMESA),
- NAME_FUNC_OFFSET(18873, glWindowPos3fvMESA, glWindowPos3fvMESA, NULL, _gloffset_WindowPos3fvMESA),
- NAME_FUNC_OFFSET(18888, glWindowPos3fvMESA, glWindowPos3fvMESA, NULL, _gloffset_WindowPos3fvMESA),
- NAME_FUNC_OFFSET(18906, glWindowPos3iMESA, glWindowPos3iMESA, NULL, _gloffset_WindowPos3iMESA),
- NAME_FUNC_OFFSET(18920, glWindowPos3iMESA, glWindowPos3iMESA, NULL, _gloffset_WindowPos3iMESA),
- NAME_FUNC_OFFSET(18937, glWindowPos3ivMESA, glWindowPos3ivMESA, NULL, _gloffset_WindowPos3ivMESA),
- NAME_FUNC_OFFSET(18952, glWindowPos3ivMESA, glWindowPos3ivMESA, NULL, _gloffset_WindowPos3ivMESA),
- NAME_FUNC_OFFSET(18970, glWindowPos3sMESA, glWindowPos3sMESA, NULL, _gloffset_WindowPos3sMESA),
- NAME_FUNC_OFFSET(18984, glWindowPos3sMESA, glWindowPos3sMESA, NULL, _gloffset_WindowPos3sMESA),
- NAME_FUNC_OFFSET(19001, glWindowPos3svMESA, glWindowPos3svMESA, NULL, _gloffset_WindowPos3svMESA),
- NAME_FUNC_OFFSET(19016, glWindowPos3svMESA, glWindowPos3svMESA, NULL, _gloffset_WindowPos3svMESA),
- NAME_FUNC_OFFSET(19034, glBindProgramNV, glBindProgramNV, NULL, _gloffset_BindProgramNV),
- NAME_FUNC_OFFSET(19051, glDeleteProgramsNV, glDeleteProgramsNV, NULL, _gloffset_DeleteProgramsNV),
- NAME_FUNC_OFFSET(19071, glGenProgramsNV, glGenProgramsNV, NULL, _gloffset_GenProgramsNV),
- NAME_FUNC_OFFSET(19088, glGetVertexAttribPointervNV, glGetVertexAttribPointervNV, NULL, _gloffset_GetVertexAttribPointervNV),
- NAME_FUNC_OFFSET(19114, glGetVertexAttribPointervNV, glGetVertexAttribPointervNV, NULL, _gloffset_GetVertexAttribPointervNV),
- NAME_FUNC_OFFSET(19143, glIsProgramNV, glIsProgramNV, NULL, _gloffset_IsProgramNV),
- NAME_FUNC_OFFSET(19158, glPointParameteriNV, glPointParameteriNV, NULL, _gloffset_PointParameteriNV),
- NAME_FUNC_OFFSET(19176, glPointParameterivNV, glPointParameterivNV, NULL, _gloffset_PointParameterivNV),
- NAME_FUNC_OFFSET(19195, gl_dispatch_stub_752, gl_dispatch_stub_752, NULL, _gloffset_DeleteVertexArraysAPPLE),
- NAME_FUNC_OFFSET(19216, gl_dispatch_stub_754, gl_dispatch_stub_754, NULL, _gloffset_IsVertexArrayAPPLE),
- NAME_FUNC_OFFSET(19232, gl_dispatch_stub_762, gl_dispatch_stub_762, NULL, _gloffset_BlendEquationSeparateEXT),
- NAME_FUNC_OFFSET(19256, gl_dispatch_stub_762, gl_dispatch_stub_762, NULL, _gloffset_BlendEquationSeparateEXT),
- NAME_FUNC_OFFSET(19283, glBindFramebufferEXT, glBindFramebufferEXT, NULL, _gloffset_BindFramebufferEXT),
- NAME_FUNC_OFFSET(19301, glBindRenderbufferEXT, glBindRenderbufferEXT, NULL, _gloffset_BindRenderbufferEXT),
- NAME_FUNC_OFFSET(19320, glCheckFramebufferStatusEXT, glCheckFramebufferStatusEXT, NULL, _gloffset_CheckFramebufferStatusEXT),
- NAME_FUNC_OFFSET(19345, glDeleteFramebuffersEXT, glDeleteFramebuffersEXT, NULL, _gloffset_DeleteFramebuffersEXT),
- NAME_FUNC_OFFSET(19366, glDeleteRenderbuffersEXT, glDeleteRenderbuffersEXT, NULL, _gloffset_DeleteRenderbuffersEXT),
- NAME_FUNC_OFFSET(19388, glFramebufferRenderbufferEXT, glFramebufferRenderbufferEXT, NULL, _gloffset_FramebufferRenderbufferEXT),
- NAME_FUNC_OFFSET(19414, glFramebufferTexture1DEXT, glFramebufferTexture1DEXT, NULL, _gloffset_FramebufferTexture1DEXT),
- NAME_FUNC_OFFSET(19437, glFramebufferTexture2DEXT, glFramebufferTexture2DEXT, NULL, _gloffset_FramebufferTexture2DEXT),
- NAME_FUNC_OFFSET(19460, glFramebufferTexture3DEXT, glFramebufferTexture3DEXT, NULL, _gloffset_FramebufferTexture3DEXT),
- NAME_FUNC_OFFSET(19483, glGenFramebuffersEXT, glGenFramebuffersEXT, NULL, _gloffset_GenFramebuffersEXT),
- NAME_FUNC_OFFSET(19501, glGenRenderbuffersEXT, glGenRenderbuffersEXT, NULL, _gloffset_GenRenderbuffersEXT),
- NAME_FUNC_OFFSET(19520, glGenerateMipmapEXT, glGenerateMipmapEXT, NULL, _gloffset_GenerateMipmapEXT),
- NAME_FUNC_OFFSET(19537, glGetFramebufferAttachmentParameterivEXT, glGetFramebufferAttachmentParameterivEXT, NULL, _gloffset_GetFramebufferAttachmentParameterivEXT),
- NAME_FUNC_OFFSET(19575, glGetRenderbufferParameterivEXT, glGetRenderbufferParameterivEXT, NULL, _gloffset_GetRenderbufferParameterivEXT),
- NAME_FUNC_OFFSET(19604, glIsFramebufferEXT, glIsFramebufferEXT, NULL, _gloffset_IsFramebufferEXT),
- NAME_FUNC_OFFSET(19620, glIsRenderbufferEXT, glIsRenderbufferEXT, NULL, _gloffset_IsRenderbufferEXT),
- NAME_FUNC_OFFSET(19637, glRenderbufferStorageEXT, glRenderbufferStorageEXT, NULL, _gloffset_RenderbufferStorageEXT),
- NAME_FUNC_OFFSET(19659, gl_dispatch_stub_780, gl_dispatch_stub_780, NULL, _gloffset_BlitFramebufferEXT),
- NAME_FUNC_OFFSET(19677, glFramebufferTextureLayerEXT, glFramebufferTextureLayerEXT, NULL, _gloffset_FramebufferTextureLayerEXT),
+ NAME_FUNC_OFFSET( 9172, glDrawElementsBaseVertex, glDrawElementsBaseVertex, NULL, _gloffset_DrawElementsBaseVertex),
+ NAME_FUNC_OFFSET( 9197, glDrawRangeElementsBaseVertex, glDrawRangeElementsBaseVertex, NULL, _gloffset_DrawRangeElementsBaseVertex),
+ NAME_FUNC_OFFSET( 9227, glMultiDrawElementsBaseVertex, glMultiDrawElementsBaseVertex, NULL, _gloffset_MultiDrawElementsBaseVertex),
+ NAME_FUNC_OFFSET( 9257, glPolygonOffsetEXT, glPolygonOffsetEXT, NULL, _gloffset_PolygonOffsetEXT),
+ NAME_FUNC_OFFSET( 9276, gl_dispatch_stub_578, gl_dispatch_stub_578, NULL, _gloffset_GetPixelTexGenParameterfvSGIS),
+ NAME_FUNC_OFFSET( 9308, gl_dispatch_stub_579, gl_dispatch_stub_579, NULL, _gloffset_GetPixelTexGenParameterivSGIS),
+ NAME_FUNC_OFFSET( 9340, gl_dispatch_stub_580, gl_dispatch_stub_580, NULL, _gloffset_PixelTexGenParameterfSGIS),
+ NAME_FUNC_OFFSET( 9368, gl_dispatch_stub_581, gl_dispatch_stub_581, NULL, _gloffset_PixelTexGenParameterfvSGIS),
+ NAME_FUNC_OFFSET( 9397, gl_dispatch_stub_582, gl_dispatch_stub_582, NULL, _gloffset_PixelTexGenParameteriSGIS),
+ NAME_FUNC_OFFSET( 9425, gl_dispatch_stub_583, gl_dispatch_stub_583, NULL, _gloffset_PixelTexGenParameterivSGIS),
+ NAME_FUNC_OFFSET( 9454, gl_dispatch_stub_584, gl_dispatch_stub_584, NULL, _gloffset_SampleMaskSGIS),
+ NAME_FUNC_OFFSET( 9471, gl_dispatch_stub_585, gl_dispatch_stub_585, NULL, _gloffset_SamplePatternSGIS),
+ NAME_FUNC_OFFSET( 9491, glColorPointerEXT, glColorPointerEXT, NULL, _gloffset_ColorPointerEXT),
+ NAME_FUNC_OFFSET( 9509, glEdgeFlagPointerEXT, glEdgeFlagPointerEXT, NULL, _gloffset_EdgeFlagPointerEXT),
+ NAME_FUNC_OFFSET( 9530, glIndexPointerEXT, glIndexPointerEXT, NULL, _gloffset_IndexPointerEXT),
+ NAME_FUNC_OFFSET( 9548, glNormalPointerEXT, glNormalPointerEXT, NULL, _gloffset_NormalPointerEXT),
+ NAME_FUNC_OFFSET( 9567, glTexCoordPointerEXT, glTexCoordPointerEXT, NULL, _gloffset_TexCoordPointerEXT),
+ NAME_FUNC_OFFSET( 9588, glVertexPointerEXT, glVertexPointerEXT, NULL, _gloffset_VertexPointerEXT),
+ NAME_FUNC_OFFSET( 9607, glPointParameterfEXT, glPointParameterfEXT, NULL, _gloffset_PointParameterfEXT),
+ NAME_FUNC_OFFSET( 9628, glPointParameterfvEXT, glPointParameterfvEXT, NULL, _gloffset_PointParameterfvEXT),
+ NAME_FUNC_OFFSET( 9650, glLockArraysEXT, glLockArraysEXT, NULL, _gloffset_LockArraysEXT),
+ NAME_FUNC_OFFSET( 9666, glUnlockArraysEXT, glUnlockArraysEXT, NULL, _gloffset_UnlockArraysEXT),
+ NAME_FUNC_OFFSET( 9684, gl_dispatch_stub_596, gl_dispatch_stub_596, NULL, _gloffset_CullParameterdvEXT),
+ NAME_FUNC_OFFSET( 9705, gl_dispatch_stub_597, gl_dispatch_stub_597, NULL, _gloffset_CullParameterfvEXT),
+ NAME_FUNC_OFFSET( 9726, glSecondaryColor3bEXT, glSecondaryColor3bEXT, NULL, _gloffset_SecondaryColor3bEXT),
+ NAME_FUNC_OFFSET( 9748, glSecondaryColor3bvEXT, glSecondaryColor3bvEXT, NULL, _gloffset_SecondaryColor3bvEXT),
+ NAME_FUNC_OFFSET( 9771, glSecondaryColor3dEXT, glSecondaryColor3dEXT, NULL, _gloffset_SecondaryColor3dEXT),
+ NAME_FUNC_OFFSET( 9793, glSecondaryColor3dvEXT, glSecondaryColor3dvEXT, NULL, _gloffset_SecondaryColor3dvEXT),
+ NAME_FUNC_OFFSET( 9816, glSecondaryColor3fEXT, glSecondaryColor3fEXT, NULL, _gloffset_SecondaryColor3fEXT),
+ NAME_FUNC_OFFSET( 9838, glSecondaryColor3fvEXT, glSecondaryColor3fvEXT, NULL, _gloffset_SecondaryColor3fvEXT),
+ NAME_FUNC_OFFSET( 9861, glSecondaryColor3iEXT, glSecondaryColor3iEXT, NULL, _gloffset_SecondaryColor3iEXT),
+ NAME_FUNC_OFFSET( 9883, glSecondaryColor3ivEXT, glSecondaryColor3ivEXT, NULL, _gloffset_SecondaryColor3ivEXT),
+ NAME_FUNC_OFFSET( 9906, glSecondaryColor3sEXT, glSecondaryColor3sEXT, NULL, _gloffset_SecondaryColor3sEXT),
+ NAME_FUNC_OFFSET( 9928, glSecondaryColor3svEXT, glSecondaryColor3svEXT, NULL, _gloffset_SecondaryColor3svEXT),
+ NAME_FUNC_OFFSET( 9951, glSecondaryColor3ubEXT, glSecondaryColor3ubEXT, NULL, _gloffset_SecondaryColor3ubEXT),
+ NAME_FUNC_OFFSET( 9974, glSecondaryColor3ubvEXT, glSecondaryColor3ubvEXT, NULL, _gloffset_SecondaryColor3ubvEXT),
+ NAME_FUNC_OFFSET( 9998, glSecondaryColor3uiEXT, glSecondaryColor3uiEXT, NULL, _gloffset_SecondaryColor3uiEXT),
+ NAME_FUNC_OFFSET(10021, glSecondaryColor3uivEXT, glSecondaryColor3uivEXT, NULL, _gloffset_SecondaryColor3uivEXT),
+ NAME_FUNC_OFFSET(10045, glSecondaryColor3usEXT, glSecondaryColor3usEXT, NULL, _gloffset_SecondaryColor3usEXT),
+ NAME_FUNC_OFFSET(10068, glSecondaryColor3usvEXT, glSecondaryColor3usvEXT, NULL, _gloffset_SecondaryColor3usvEXT),
+ NAME_FUNC_OFFSET(10092, glSecondaryColorPointerEXT, glSecondaryColorPointerEXT, NULL, _gloffset_SecondaryColorPointerEXT),
+ NAME_FUNC_OFFSET(10119, glMultiDrawArraysEXT, glMultiDrawArraysEXT, NULL, _gloffset_MultiDrawArraysEXT),
+ NAME_FUNC_OFFSET(10140, glMultiDrawElementsEXT, glMultiDrawElementsEXT, NULL, _gloffset_MultiDrawElementsEXT),
+ NAME_FUNC_OFFSET(10163, glFogCoordPointerEXT, glFogCoordPointerEXT, NULL, _gloffset_FogCoordPointerEXT),
+ NAME_FUNC_OFFSET(10184, glFogCoorddEXT, glFogCoorddEXT, NULL, _gloffset_FogCoorddEXT),
+ NAME_FUNC_OFFSET(10199, glFogCoorddvEXT, glFogCoorddvEXT, NULL, _gloffset_FogCoorddvEXT),
+ NAME_FUNC_OFFSET(10215, glFogCoordfEXT, glFogCoordfEXT, NULL, _gloffset_FogCoordfEXT),
+ NAME_FUNC_OFFSET(10230, glFogCoordfvEXT, glFogCoordfvEXT, NULL, _gloffset_FogCoordfvEXT),
+ NAME_FUNC_OFFSET(10246, gl_dispatch_stub_622, gl_dispatch_stub_622, NULL, _gloffset_PixelTexGenSGIX),
+ NAME_FUNC_OFFSET(10264, glBlendFuncSeparateEXT, glBlendFuncSeparateEXT, NULL, _gloffset_BlendFuncSeparateEXT),
+ NAME_FUNC_OFFSET(10287, glFlushVertexArrayRangeNV, glFlushVertexArrayRangeNV, NULL, _gloffset_FlushVertexArrayRangeNV),
+ NAME_FUNC_OFFSET(10313, glVertexArrayRangeNV, glVertexArrayRangeNV, NULL, _gloffset_VertexArrayRangeNV),
+ NAME_FUNC_OFFSET(10334, glCombinerInputNV, glCombinerInputNV, NULL, _gloffset_CombinerInputNV),
+ NAME_FUNC_OFFSET(10352, glCombinerOutputNV, glCombinerOutputNV, NULL, _gloffset_CombinerOutputNV),
+ NAME_FUNC_OFFSET(10371, glCombinerParameterfNV, glCombinerParameterfNV, NULL, _gloffset_CombinerParameterfNV),
+ NAME_FUNC_OFFSET(10394, glCombinerParameterfvNV, glCombinerParameterfvNV, NULL, _gloffset_CombinerParameterfvNV),
+ NAME_FUNC_OFFSET(10418, glCombinerParameteriNV, glCombinerParameteriNV, NULL, _gloffset_CombinerParameteriNV),
+ NAME_FUNC_OFFSET(10441, glCombinerParameterivNV, glCombinerParameterivNV, NULL, _gloffset_CombinerParameterivNV),
+ NAME_FUNC_OFFSET(10465, glFinalCombinerInputNV, glFinalCombinerInputNV, NULL, _gloffset_FinalCombinerInputNV),
+ NAME_FUNC_OFFSET(10488, glGetCombinerInputParameterfvNV, glGetCombinerInputParameterfvNV, NULL, _gloffset_GetCombinerInputParameterfvNV),
+ NAME_FUNC_OFFSET(10520, glGetCombinerInputParameterivNV, glGetCombinerInputParameterivNV, NULL, _gloffset_GetCombinerInputParameterivNV),
+ NAME_FUNC_OFFSET(10552, glGetCombinerOutputParameterfvNV, glGetCombinerOutputParameterfvNV, NULL, _gloffset_GetCombinerOutputParameterfvNV),
+ NAME_FUNC_OFFSET(10585, glGetCombinerOutputParameterivNV, glGetCombinerOutputParameterivNV, NULL, _gloffset_GetCombinerOutputParameterivNV),
+ NAME_FUNC_OFFSET(10618, glGetFinalCombinerInputParameterfvNV, glGetFinalCombinerInputParameterfvNV, NULL, _gloffset_GetFinalCombinerInputParameterfvNV),
+ NAME_FUNC_OFFSET(10655, glGetFinalCombinerInputParameterivNV, glGetFinalCombinerInputParameterivNV, NULL, _gloffset_GetFinalCombinerInputParameterivNV),
+ NAME_FUNC_OFFSET(10692, glResizeBuffersMESA, glResizeBuffersMESA, NULL, _gloffset_ResizeBuffersMESA),
+ NAME_FUNC_OFFSET(10712, glWindowPos2dMESA, glWindowPos2dMESA, NULL, _gloffset_WindowPos2dMESA),
+ NAME_FUNC_OFFSET(10730, glWindowPos2dvMESA, glWindowPos2dvMESA, NULL, _gloffset_WindowPos2dvMESA),
+ NAME_FUNC_OFFSET(10749, glWindowPos2fMESA, glWindowPos2fMESA, NULL, _gloffset_WindowPos2fMESA),
+ NAME_FUNC_OFFSET(10767, glWindowPos2fvMESA, glWindowPos2fvMESA, NULL, _gloffset_WindowPos2fvMESA),
+ NAME_FUNC_OFFSET(10786, glWindowPos2iMESA, glWindowPos2iMESA, NULL, _gloffset_WindowPos2iMESA),
+ NAME_FUNC_OFFSET(10804, glWindowPos2ivMESA, glWindowPos2ivMESA, NULL, _gloffset_WindowPos2ivMESA),
+ NAME_FUNC_OFFSET(10823, glWindowPos2sMESA, glWindowPos2sMESA, NULL, _gloffset_WindowPos2sMESA),
+ NAME_FUNC_OFFSET(10841, glWindowPos2svMESA, glWindowPos2svMESA, NULL, _gloffset_WindowPos2svMESA),
+ NAME_FUNC_OFFSET(10860, glWindowPos3dMESA, glWindowPos3dMESA, NULL, _gloffset_WindowPos3dMESA),
+ NAME_FUNC_OFFSET(10878, glWindowPos3dvMESA, glWindowPos3dvMESA, NULL, _gloffset_WindowPos3dvMESA),
+ NAME_FUNC_OFFSET(10897, glWindowPos3fMESA, glWindowPos3fMESA, NULL, _gloffset_WindowPos3fMESA),
+ NAME_FUNC_OFFSET(10915, glWindowPos3fvMESA, glWindowPos3fvMESA, NULL, _gloffset_WindowPos3fvMESA),
+ NAME_FUNC_OFFSET(10934, glWindowPos3iMESA, glWindowPos3iMESA, NULL, _gloffset_WindowPos3iMESA),
+ NAME_FUNC_OFFSET(10952, glWindowPos3ivMESA, glWindowPos3ivMESA, NULL, _gloffset_WindowPos3ivMESA),
+ NAME_FUNC_OFFSET(10971, glWindowPos3sMESA, glWindowPos3sMESA, NULL, _gloffset_WindowPos3sMESA),
+ NAME_FUNC_OFFSET(10989, glWindowPos3svMESA, glWindowPos3svMESA, NULL, _gloffset_WindowPos3svMESA),
+ NAME_FUNC_OFFSET(11008, glWindowPos4dMESA, glWindowPos4dMESA, NULL, _gloffset_WindowPos4dMESA),
+ NAME_FUNC_OFFSET(11026, glWindowPos4dvMESA, glWindowPos4dvMESA, NULL, _gloffset_WindowPos4dvMESA),
+ NAME_FUNC_OFFSET(11045, glWindowPos4fMESA, glWindowPos4fMESA, NULL, _gloffset_WindowPos4fMESA),
+ NAME_FUNC_OFFSET(11063, glWindowPos4fvMESA, glWindowPos4fvMESA, NULL, _gloffset_WindowPos4fvMESA),
+ NAME_FUNC_OFFSET(11082, glWindowPos4iMESA, glWindowPos4iMESA, NULL, _gloffset_WindowPos4iMESA),
+ NAME_FUNC_OFFSET(11100, glWindowPos4ivMESA, glWindowPos4ivMESA, NULL, _gloffset_WindowPos4ivMESA),
+ NAME_FUNC_OFFSET(11119, glWindowPos4sMESA, glWindowPos4sMESA, NULL, _gloffset_WindowPos4sMESA),
+ NAME_FUNC_OFFSET(11137, glWindowPos4svMESA, glWindowPos4svMESA, NULL, _gloffset_WindowPos4svMESA),
+ NAME_FUNC_OFFSET(11156, gl_dispatch_stub_664, gl_dispatch_stub_664, NULL, _gloffset_MultiModeDrawArraysIBM),
+ NAME_FUNC_OFFSET(11181, gl_dispatch_stub_665, gl_dispatch_stub_665, NULL, _gloffset_MultiModeDrawElementsIBM),
+ NAME_FUNC_OFFSET(11208, gl_dispatch_stub_666, gl_dispatch_stub_666, NULL, _gloffset_DeleteFencesNV),
+ NAME_FUNC_OFFSET(11225, gl_dispatch_stub_667, gl_dispatch_stub_667, NULL, _gloffset_FinishFenceNV),
+ NAME_FUNC_OFFSET(11241, gl_dispatch_stub_668, gl_dispatch_stub_668, NULL, _gloffset_GenFencesNV),
+ NAME_FUNC_OFFSET(11255, gl_dispatch_stub_669, gl_dispatch_stub_669, NULL, _gloffset_GetFenceivNV),
+ NAME_FUNC_OFFSET(11270, gl_dispatch_stub_670, gl_dispatch_stub_670, NULL, _gloffset_IsFenceNV),
+ NAME_FUNC_OFFSET(11282, gl_dispatch_stub_671, gl_dispatch_stub_671, NULL, _gloffset_SetFenceNV),
+ NAME_FUNC_OFFSET(11295, gl_dispatch_stub_672, gl_dispatch_stub_672, NULL, _gloffset_TestFenceNV),
+ NAME_FUNC_OFFSET(11309, glAreProgramsResidentNV, glAreProgramsResidentNV, NULL, _gloffset_AreProgramsResidentNV),
+ NAME_FUNC_OFFSET(11333, glBindProgramNV, glBindProgramNV, NULL, _gloffset_BindProgramNV),
+ NAME_FUNC_OFFSET(11349, glDeleteProgramsNV, glDeleteProgramsNV, NULL, _gloffset_DeleteProgramsNV),
+ NAME_FUNC_OFFSET(11368, glExecuteProgramNV, glExecuteProgramNV, NULL, _gloffset_ExecuteProgramNV),
+ NAME_FUNC_OFFSET(11387, glGenProgramsNV, glGenProgramsNV, NULL, _gloffset_GenProgramsNV),
+ NAME_FUNC_OFFSET(11403, glGetProgramParameterdvNV, glGetProgramParameterdvNV, NULL, _gloffset_GetProgramParameterdvNV),
+ NAME_FUNC_OFFSET(11429, glGetProgramParameterfvNV, glGetProgramParameterfvNV, NULL, _gloffset_GetProgramParameterfvNV),
+ NAME_FUNC_OFFSET(11455, glGetProgramStringNV, glGetProgramStringNV, NULL, _gloffset_GetProgramStringNV),
+ NAME_FUNC_OFFSET(11476, glGetProgramivNV, glGetProgramivNV, NULL, _gloffset_GetProgramivNV),
+ NAME_FUNC_OFFSET(11493, glGetTrackMatrixivNV, glGetTrackMatrixivNV, NULL, _gloffset_GetTrackMatrixivNV),
+ NAME_FUNC_OFFSET(11514, glGetVertexAttribPointervNV, glGetVertexAttribPointervNV, NULL, _gloffset_GetVertexAttribPointervNV),
+ NAME_FUNC_OFFSET(11542, glGetVertexAttribdvNV, glGetVertexAttribdvNV, NULL, _gloffset_GetVertexAttribdvNV),
+ NAME_FUNC_OFFSET(11564, glGetVertexAttribfvNV, glGetVertexAttribfvNV, NULL, _gloffset_GetVertexAttribfvNV),
+ NAME_FUNC_OFFSET(11586, glGetVertexAttribivNV, glGetVertexAttribivNV, NULL, _gloffset_GetVertexAttribivNV),
+ NAME_FUNC_OFFSET(11608, glIsProgramNV, glIsProgramNV, NULL, _gloffset_IsProgramNV),
+ NAME_FUNC_OFFSET(11622, glLoadProgramNV, glLoadProgramNV, NULL, _gloffset_LoadProgramNV),
+ NAME_FUNC_OFFSET(11638, glProgramParameters4dvNV, glProgramParameters4dvNV, NULL, _gloffset_ProgramParameters4dvNV),
+ NAME_FUNC_OFFSET(11663, glProgramParameters4fvNV, glProgramParameters4fvNV, NULL, _gloffset_ProgramParameters4fvNV),
+ NAME_FUNC_OFFSET(11688, glRequestResidentProgramsNV, glRequestResidentProgramsNV, NULL, _gloffset_RequestResidentProgramsNV),
+ NAME_FUNC_OFFSET(11716, glTrackMatrixNV, glTrackMatrixNV, NULL, _gloffset_TrackMatrixNV),
+ NAME_FUNC_OFFSET(11732, glVertexAttrib1dNV, glVertexAttrib1dNV, NULL, _gloffset_VertexAttrib1dNV),
+ NAME_FUNC_OFFSET(11751, glVertexAttrib1dvNV, glVertexAttrib1dvNV, NULL, _gloffset_VertexAttrib1dvNV),
+ NAME_FUNC_OFFSET(11771, glVertexAttrib1fNV, glVertexAttrib1fNV, NULL, _gloffset_VertexAttrib1fNV),
+ NAME_FUNC_OFFSET(11790, glVertexAttrib1fvNV, glVertexAttrib1fvNV, NULL, _gloffset_VertexAttrib1fvNV),
+ NAME_FUNC_OFFSET(11810, glVertexAttrib1sNV, glVertexAttrib1sNV, NULL, _gloffset_VertexAttrib1sNV),
+ NAME_FUNC_OFFSET(11829, glVertexAttrib1svNV, glVertexAttrib1svNV, NULL, _gloffset_VertexAttrib1svNV),
+ NAME_FUNC_OFFSET(11849, glVertexAttrib2dNV, glVertexAttrib2dNV, NULL, _gloffset_VertexAttrib2dNV),
+ NAME_FUNC_OFFSET(11868, glVertexAttrib2dvNV, glVertexAttrib2dvNV, NULL, _gloffset_VertexAttrib2dvNV),
+ NAME_FUNC_OFFSET(11888, glVertexAttrib2fNV, glVertexAttrib2fNV, NULL, _gloffset_VertexAttrib2fNV),
+ NAME_FUNC_OFFSET(11907, glVertexAttrib2fvNV, glVertexAttrib2fvNV, NULL, _gloffset_VertexAttrib2fvNV),
+ NAME_FUNC_OFFSET(11927, glVertexAttrib2sNV, glVertexAttrib2sNV, NULL, _gloffset_VertexAttrib2sNV),
+ NAME_FUNC_OFFSET(11946, glVertexAttrib2svNV, glVertexAttrib2svNV, NULL, _gloffset_VertexAttrib2svNV),
+ NAME_FUNC_OFFSET(11966, glVertexAttrib3dNV, glVertexAttrib3dNV, NULL, _gloffset_VertexAttrib3dNV),
+ NAME_FUNC_OFFSET(11985, glVertexAttrib3dvNV, glVertexAttrib3dvNV, NULL, _gloffset_VertexAttrib3dvNV),
+ NAME_FUNC_OFFSET(12005, glVertexAttrib3fNV, glVertexAttrib3fNV, NULL, _gloffset_VertexAttrib3fNV),
+ NAME_FUNC_OFFSET(12024, glVertexAttrib3fvNV, glVertexAttrib3fvNV, NULL, _gloffset_VertexAttrib3fvNV),
+ NAME_FUNC_OFFSET(12044, glVertexAttrib3sNV, glVertexAttrib3sNV, NULL, _gloffset_VertexAttrib3sNV),
+ NAME_FUNC_OFFSET(12063, glVertexAttrib3svNV, glVertexAttrib3svNV, NULL, _gloffset_VertexAttrib3svNV),
+ NAME_FUNC_OFFSET(12083, glVertexAttrib4dNV, glVertexAttrib4dNV, NULL, _gloffset_VertexAttrib4dNV),
+ NAME_FUNC_OFFSET(12102, glVertexAttrib4dvNV, glVertexAttrib4dvNV, NULL, _gloffset_VertexAttrib4dvNV),
+ NAME_FUNC_OFFSET(12122, glVertexAttrib4fNV, glVertexAttrib4fNV, NULL, _gloffset_VertexAttrib4fNV),
+ NAME_FUNC_OFFSET(12141, glVertexAttrib4fvNV, glVertexAttrib4fvNV, NULL, _gloffset_VertexAttrib4fvNV),
+ NAME_FUNC_OFFSET(12161, glVertexAttrib4sNV, glVertexAttrib4sNV, NULL, _gloffset_VertexAttrib4sNV),
+ NAME_FUNC_OFFSET(12180, glVertexAttrib4svNV, glVertexAttrib4svNV, NULL, _gloffset_VertexAttrib4svNV),
+ NAME_FUNC_OFFSET(12200, glVertexAttrib4ubNV, glVertexAttrib4ubNV, NULL, _gloffset_VertexAttrib4ubNV),
+ NAME_FUNC_OFFSET(12220, glVertexAttrib4ubvNV, glVertexAttrib4ubvNV, NULL, _gloffset_VertexAttrib4ubvNV),
+ NAME_FUNC_OFFSET(12241, glVertexAttribPointerNV, glVertexAttribPointerNV, NULL, _gloffset_VertexAttribPointerNV),
+ NAME_FUNC_OFFSET(12265, glVertexAttribs1dvNV, glVertexAttribs1dvNV, NULL, _gloffset_VertexAttribs1dvNV),
+ NAME_FUNC_OFFSET(12286, glVertexAttribs1fvNV, glVertexAttribs1fvNV, NULL, _gloffset_VertexAttribs1fvNV),
+ NAME_FUNC_OFFSET(12307, glVertexAttribs1svNV, glVertexAttribs1svNV, NULL, _gloffset_VertexAttribs1svNV),
+ NAME_FUNC_OFFSET(12328, glVertexAttribs2dvNV, glVertexAttribs2dvNV, NULL, _gloffset_VertexAttribs2dvNV),
+ NAME_FUNC_OFFSET(12349, glVertexAttribs2fvNV, glVertexAttribs2fvNV, NULL, _gloffset_VertexAttribs2fvNV),
+ NAME_FUNC_OFFSET(12370, glVertexAttribs2svNV, glVertexAttribs2svNV, NULL, _gloffset_VertexAttribs2svNV),
+ NAME_FUNC_OFFSET(12391, glVertexAttribs3dvNV, glVertexAttribs3dvNV, NULL, _gloffset_VertexAttribs3dvNV),
+ NAME_FUNC_OFFSET(12412, glVertexAttribs3fvNV, glVertexAttribs3fvNV, NULL, _gloffset_VertexAttribs3fvNV),
+ NAME_FUNC_OFFSET(12433, glVertexAttribs3svNV, glVertexAttribs3svNV, NULL, _gloffset_VertexAttribs3svNV),
+ NAME_FUNC_OFFSET(12454, glVertexAttribs4dvNV, glVertexAttribs4dvNV, NULL, _gloffset_VertexAttribs4dvNV),
+ NAME_FUNC_OFFSET(12475, glVertexAttribs4fvNV, glVertexAttribs4fvNV, NULL, _gloffset_VertexAttribs4fvNV),
+ NAME_FUNC_OFFSET(12496, glVertexAttribs4svNV, glVertexAttribs4svNV, NULL, _gloffset_VertexAttribs4svNV),
+ NAME_FUNC_OFFSET(12517, glVertexAttribs4ubvNV, glVertexAttribs4ubvNV, NULL, _gloffset_VertexAttribs4ubvNV),
+ NAME_FUNC_OFFSET(12539, glGetTexBumpParameterfvATI, glGetTexBumpParameterfvATI, NULL, _gloffset_GetTexBumpParameterfvATI),
+ NAME_FUNC_OFFSET(12566, glGetTexBumpParameterivATI, glGetTexBumpParameterivATI, NULL, _gloffset_GetTexBumpParameterivATI),
+ NAME_FUNC_OFFSET(12593, glTexBumpParameterfvATI, glTexBumpParameterfvATI, NULL, _gloffset_TexBumpParameterfvATI),
+ NAME_FUNC_OFFSET(12617, glTexBumpParameterivATI, glTexBumpParameterivATI, NULL, _gloffset_TexBumpParameterivATI),
+ NAME_FUNC_OFFSET(12641, glAlphaFragmentOp1ATI, glAlphaFragmentOp1ATI, NULL, _gloffset_AlphaFragmentOp1ATI),
+ NAME_FUNC_OFFSET(12663, glAlphaFragmentOp2ATI, glAlphaFragmentOp2ATI, NULL, _gloffset_AlphaFragmentOp2ATI),
+ NAME_FUNC_OFFSET(12685, glAlphaFragmentOp3ATI, glAlphaFragmentOp3ATI, NULL, _gloffset_AlphaFragmentOp3ATI),
+ NAME_FUNC_OFFSET(12707, glBeginFragmentShaderATI, glBeginFragmentShaderATI, NULL, _gloffset_BeginFragmentShaderATI),
+ NAME_FUNC_OFFSET(12732, glBindFragmentShaderATI, glBindFragmentShaderATI, NULL, _gloffset_BindFragmentShaderATI),
+ NAME_FUNC_OFFSET(12756, glColorFragmentOp1ATI, glColorFragmentOp1ATI, NULL, _gloffset_ColorFragmentOp1ATI),
+ NAME_FUNC_OFFSET(12778, glColorFragmentOp2ATI, glColorFragmentOp2ATI, NULL, _gloffset_ColorFragmentOp2ATI),
+ NAME_FUNC_OFFSET(12800, glColorFragmentOp3ATI, glColorFragmentOp3ATI, NULL, _gloffset_ColorFragmentOp3ATI),
+ NAME_FUNC_OFFSET(12822, glDeleteFragmentShaderATI, glDeleteFragmentShaderATI, NULL, _gloffset_DeleteFragmentShaderATI),
+ NAME_FUNC_OFFSET(12848, glEndFragmentShaderATI, glEndFragmentShaderATI, NULL, _gloffset_EndFragmentShaderATI),
+ NAME_FUNC_OFFSET(12871, glGenFragmentShadersATI, glGenFragmentShadersATI, NULL, _gloffset_GenFragmentShadersATI),
+ NAME_FUNC_OFFSET(12895, glPassTexCoordATI, glPassTexCoordATI, NULL, _gloffset_PassTexCoordATI),
+ NAME_FUNC_OFFSET(12913, glSampleMapATI, glSampleMapATI, NULL, _gloffset_SampleMapATI),
+ NAME_FUNC_OFFSET(12928, glSetFragmentShaderConstantATI, glSetFragmentShaderConstantATI, NULL, _gloffset_SetFragmentShaderConstantATI),
+ NAME_FUNC_OFFSET(12959, glPointParameteriNV, glPointParameteriNV, NULL, _gloffset_PointParameteriNV),
+ NAME_FUNC_OFFSET(12979, glPointParameterivNV, glPointParameterivNV, NULL, _gloffset_PointParameterivNV),
+ NAME_FUNC_OFFSET(13000, gl_dispatch_stub_753, gl_dispatch_stub_753, NULL, _gloffset_ActiveStencilFaceEXT),
+ NAME_FUNC_OFFSET(13023, gl_dispatch_stub_754, gl_dispatch_stub_754, NULL, _gloffset_BindVertexArrayAPPLE),
+ NAME_FUNC_OFFSET(13046, gl_dispatch_stub_755, gl_dispatch_stub_755, NULL, _gloffset_DeleteVertexArraysAPPLE),
+ NAME_FUNC_OFFSET(13072, gl_dispatch_stub_756, gl_dispatch_stub_756, NULL, _gloffset_GenVertexArraysAPPLE),
+ NAME_FUNC_OFFSET(13095, gl_dispatch_stub_757, gl_dispatch_stub_757, NULL, _gloffset_IsVertexArrayAPPLE),
+ NAME_FUNC_OFFSET(13116, glGetProgramNamedParameterdvNV, glGetProgramNamedParameterdvNV, NULL, _gloffset_GetProgramNamedParameterdvNV),
+ NAME_FUNC_OFFSET(13147, glGetProgramNamedParameterfvNV, glGetProgramNamedParameterfvNV, NULL, _gloffset_GetProgramNamedParameterfvNV),
+ NAME_FUNC_OFFSET(13178, glProgramNamedParameter4dNV, glProgramNamedParameter4dNV, NULL, _gloffset_ProgramNamedParameter4dNV),
+ NAME_FUNC_OFFSET(13206, glProgramNamedParameter4dvNV, glProgramNamedParameter4dvNV, NULL, _gloffset_ProgramNamedParameter4dvNV),
+ NAME_FUNC_OFFSET(13235, glProgramNamedParameter4fNV, glProgramNamedParameter4fNV, NULL, _gloffset_ProgramNamedParameter4fNV),
+ NAME_FUNC_OFFSET(13263, glProgramNamedParameter4fvNV, glProgramNamedParameter4fvNV, NULL, _gloffset_ProgramNamedParameter4fvNV),
+ NAME_FUNC_OFFSET(13292, gl_dispatch_stub_764, gl_dispatch_stub_764, NULL, _gloffset_DepthBoundsEXT),
+ NAME_FUNC_OFFSET(13309, gl_dispatch_stub_765, gl_dispatch_stub_765, NULL, _gloffset_BlendEquationSeparateEXT),
+ NAME_FUNC_OFFSET(13336, glBindFramebufferEXT, glBindFramebufferEXT, NULL, _gloffset_BindFramebufferEXT),
+ NAME_FUNC_OFFSET(13357, glBindRenderbufferEXT, glBindRenderbufferEXT, NULL, _gloffset_BindRenderbufferEXT),
+ NAME_FUNC_OFFSET(13379, glCheckFramebufferStatusEXT, glCheckFramebufferStatusEXT, NULL, _gloffset_CheckFramebufferStatusEXT),
+ NAME_FUNC_OFFSET(13407, glDeleteFramebuffersEXT, glDeleteFramebuffersEXT, NULL, _gloffset_DeleteFramebuffersEXT),
+ NAME_FUNC_OFFSET(13431, glDeleteRenderbuffersEXT, glDeleteRenderbuffersEXT, NULL, _gloffset_DeleteRenderbuffersEXT),
+ NAME_FUNC_OFFSET(13456, glFramebufferRenderbufferEXT, glFramebufferRenderbufferEXT, NULL, _gloffset_FramebufferRenderbufferEXT),
+ NAME_FUNC_OFFSET(13485, glFramebufferTexture1DEXT, glFramebufferTexture1DEXT, NULL, _gloffset_FramebufferTexture1DEXT),
+ NAME_FUNC_OFFSET(13511, glFramebufferTexture2DEXT, glFramebufferTexture2DEXT, NULL, _gloffset_FramebufferTexture2DEXT),
+ NAME_FUNC_OFFSET(13537, glFramebufferTexture3DEXT, glFramebufferTexture3DEXT, NULL, _gloffset_FramebufferTexture3DEXT),
+ NAME_FUNC_OFFSET(13563, glGenFramebuffersEXT, glGenFramebuffersEXT, NULL, _gloffset_GenFramebuffersEXT),
+ NAME_FUNC_OFFSET(13584, glGenRenderbuffersEXT, glGenRenderbuffersEXT, NULL, _gloffset_GenRenderbuffersEXT),
+ NAME_FUNC_OFFSET(13606, glGenerateMipmapEXT, glGenerateMipmapEXT, NULL, _gloffset_GenerateMipmapEXT),
+ NAME_FUNC_OFFSET(13626, glGetFramebufferAttachmentParameterivEXT, glGetFramebufferAttachmentParameterivEXT, NULL, _gloffset_GetFramebufferAttachmentParameterivEXT),
+ NAME_FUNC_OFFSET(13667, glGetRenderbufferParameterivEXT, glGetRenderbufferParameterivEXT, NULL, _gloffset_GetRenderbufferParameterivEXT),
+ NAME_FUNC_OFFSET(13699, glIsFramebufferEXT, glIsFramebufferEXT, NULL, _gloffset_IsFramebufferEXT),
+ NAME_FUNC_OFFSET(13718, glIsRenderbufferEXT, glIsRenderbufferEXT, NULL, _gloffset_IsRenderbufferEXT),
+ NAME_FUNC_OFFSET(13738, glRenderbufferStorageEXT, glRenderbufferStorageEXT, NULL, _gloffset_RenderbufferStorageEXT),
+ NAME_FUNC_OFFSET(13763, gl_dispatch_stub_783, gl_dispatch_stub_783, NULL, _gloffset_BlitFramebufferEXT),
+ NAME_FUNC_OFFSET(13784, gl_dispatch_stub_784, gl_dispatch_stub_784, NULL, _gloffset_BufferParameteriAPPLE),
+ NAME_FUNC_OFFSET(13808, gl_dispatch_stub_785, gl_dispatch_stub_785, NULL, _gloffset_FlushMappedBufferRangeAPPLE),
+ NAME_FUNC_OFFSET(13838, glFramebufferTextureLayerEXT, glFramebufferTextureLayerEXT, NULL, _gloffset_FramebufferTextureLayerEXT),
+ NAME_FUNC_OFFSET(13867, glProvokingVertexEXT, glProvokingVertexEXT, NULL, _gloffset_ProvokingVertexEXT),
+ NAME_FUNC_OFFSET(13888, gl_dispatch_stub_788, gl_dispatch_stub_788, NULL, _gloffset_GetTexParameterPointervAPPLE),
+ NAME_FUNC_OFFSET(13919, gl_dispatch_stub_789, gl_dispatch_stub_789, NULL, _gloffset_TextureRangeAPPLE),
+ NAME_FUNC_OFFSET(13939, gl_dispatch_stub_790, gl_dispatch_stub_790, NULL, _gloffset_StencilFuncSeparateATI),
+ NAME_FUNC_OFFSET(13964, gl_dispatch_stub_791, gl_dispatch_stub_791, NULL, _gloffset_ProgramEnvParameters4fvEXT),
+ NAME_FUNC_OFFSET(13993, gl_dispatch_stub_792, gl_dispatch_stub_792, NULL, _gloffset_ProgramLocalParameters4fvEXT),
+ NAME_FUNC_OFFSET(14024, gl_dispatch_stub_793, gl_dispatch_stub_793, NULL, _gloffset_GetQueryObjecti64vEXT),
+ NAME_FUNC_OFFSET(14048, gl_dispatch_stub_794, gl_dispatch_stub_794, NULL, _gloffset_GetQueryObjectui64vEXT),
+ NAME_FUNC_OFFSET(14073, glArrayElement, glArrayElement, NULL, _gloffset_ArrayElement),
+ NAME_FUNC_OFFSET(14091, glBindTexture, glBindTexture, NULL, _gloffset_BindTexture),
+ NAME_FUNC_OFFSET(14108, glDrawArrays, glDrawArrays, NULL, _gloffset_DrawArrays),
+ NAME_FUNC_OFFSET(14124, glAreTexturesResident, glAreTexturesResidentEXT, glAreTexturesResidentEXT, _gloffset_AreTexturesResident),
+ NAME_FUNC_OFFSET(14149, glCopyTexImage1D, glCopyTexImage1D, NULL, _gloffset_CopyTexImage1D),
+ NAME_FUNC_OFFSET(14169, glCopyTexImage2D, glCopyTexImage2D, NULL, _gloffset_CopyTexImage2D),
+ NAME_FUNC_OFFSET(14189, glCopyTexSubImage1D, glCopyTexSubImage1D, NULL, _gloffset_CopyTexSubImage1D),
+ NAME_FUNC_OFFSET(14212, glCopyTexSubImage2D, glCopyTexSubImage2D, NULL, _gloffset_CopyTexSubImage2D),
+ NAME_FUNC_OFFSET(14235, glDeleteTextures, glDeleteTexturesEXT, glDeleteTexturesEXT, _gloffset_DeleteTextures),
+ NAME_FUNC_OFFSET(14255, glGenTextures, glGenTexturesEXT, glGenTexturesEXT, _gloffset_GenTextures),
+ NAME_FUNC_OFFSET(14272, glGetPointerv, glGetPointerv, NULL, _gloffset_GetPointerv),
+ NAME_FUNC_OFFSET(14289, glIsTexture, glIsTextureEXT, glIsTextureEXT, _gloffset_IsTexture),
+ NAME_FUNC_OFFSET(14304, glPrioritizeTextures, glPrioritizeTextures, NULL, _gloffset_PrioritizeTextures),
+ NAME_FUNC_OFFSET(14328, glTexSubImage1D, glTexSubImage1D, NULL, _gloffset_TexSubImage1D),
+ NAME_FUNC_OFFSET(14347, glTexSubImage2D, glTexSubImage2D, NULL, _gloffset_TexSubImage2D),
+ NAME_FUNC_OFFSET(14366, glBlendColor, glBlendColor, NULL, _gloffset_BlendColor),
+ NAME_FUNC_OFFSET(14382, glBlendEquation, glBlendEquation, NULL, _gloffset_BlendEquation),
+ NAME_FUNC_OFFSET(14401, glDrawRangeElements, glDrawRangeElements, NULL, _gloffset_DrawRangeElements),
+ NAME_FUNC_OFFSET(14424, glColorTable, glColorTable, NULL, _gloffset_ColorTable),
+ NAME_FUNC_OFFSET(14440, glColorTable, glColorTable, NULL, _gloffset_ColorTable),
+ NAME_FUNC_OFFSET(14456, glColorTableParameterfv, glColorTableParameterfv, NULL, _gloffset_ColorTableParameterfv),
+ NAME_FUNC_OFFSET(14483, glColorTableParameteriv, glColorTableParameteriv, NULL, _gloffset_ColorTableParameteriv),
+ NAME_FUNC_OFFSET(14510, glCopyColorTable, glCopyColorTable, NULL, _gloffset_CopyColorTable),
+ NAME_FUNC_OFFSET(14530, glGetColorTable, glGetColorTableEXT, glGetColorTableEXT, _gloffset_GetColorTable),
+ NAME_FUNC_OFFSET(14549, glGetColorTable, glGetColorTableEXT, glGetColorTableEXT, _gloffset_GetColorTable),
+ NAME_FUNC_OFFSET(14568, glGetColorTableParameterfv, glGetColorTableParameterfvEXT, glGetColorTableParameterfvEXT, _gloffset_GetColorTableParameterfv),
+ NAME_FUNC_OFFSET(14598, glGetColorTableParameterfv, glGetColorTableParameterfvEXT, glGetColorTableParameterfvEXT, _gloffset_GetColorTableParameterfv),
+ NAME_FUNC_OFFSET(14628, glGetColorTableParameteriv, glGetColorTableParameterivEXT, glGetColorTableParameterivEXT, _gloffset_GetColorTableParameteriv),
+ NAME_FUNC_OFFSET(14658, glGetColorTableParameteriv, glGetColorTableParameterivEXT, glGetColorTableParameterivEXT, _gloffset_GetColorTableParameteriv),
+ NAME_FUNC_OFFSET(14688, glColorSubTable, glColorSubTable, NULL, _gloffset_ColorSubTable),
+ NAME_FUNC_OFFSET(14707, glCopyColorSubTable, glCopyColorSubTable, NULL, _gloffset_CopyColorSubTable),
+ NAME_FUNC_OFFSET(14730, glConvolutionFilter1D, glConvolutionFilter1D, NULL, _gloffset_ConvolutionFilter1D),
+ NAME_FUNC_OFFSET(14755, glConvolutionFilter2D, glConvolutionFilter2D, NULL, _gloffset_ConvolutionFilter2D),
+ NAME_FUNC_OFFSET(14780, glConvolutionParameterf, glConvolutionParameterf, NULL, _gloffset_ConvolutionParameterf),
+ NAME_FUNC_OFFSET(14807, glConvolutionParameterfv, glConvolutionParameterfv, NULL, _gloffset_ConvolutionParameterfv),
+ NAME_FUNC_OFFSET(14835, glConvolutionParameteri, glConvolutionParameteri, NULL, _gloffset_ConvolutionParameteri),
+ NAME_FUNC_OFFSET(14862, glConvolutionParameteriv, glConvolutionParameteriv, NULL, _gloffset_ConvolutionParameteriv),
+ NAME_FUNC_OFFSET(14890, glCopyConvolutionFilter1D, glCopyConvolutionFilter1D, NULL, _gloffset_CopyConvolutionFilter1D),
+ NAME_FUNC_OFFSET(14919, glCopyConvolutionFilter2D, glCopyConvolutionFilter2D, NULL, _gloffset_CopyConvolutionFilter2D),
+ NAME_FUNC_OFFSET(14948, glGetConvolutionFilter, gl_dispatch_stub_356, gl_dispatch_stub_356, _gloffset_GetConvolutionFilter),
+ NAME_FUNC_OFFSET(14974, glGetConvolutionParameterfv, gl_dispatch_stub_357, gl_dispatch_stub_357, _gloffset_GetConvolutionParameterfv),
+ NAME_FUNC_OFFSET(15005, glGetConvolutionParameteriv, gl_dispatch_stub_358, gl_dispatch_stub_358, _gloffset_GetConvolutionParameteriv),
+ NAME_FUNC_OFFSET(15036, glGetSeparableFilter, gl_dispatch_stub_359, gl_dispatch_stub_359, _gloffset_GetSeparableFilter),
+ NAME_FUNC_OFFSET(15060, glSeparableFilter2D, glSeparableFilter2D, NULL, _gloffset_SeparableFilter2D),
+ NAME_FUNC_OFFSET(15083, glGetHistogram, gl_dispatch_stub_361, gl_dispatch_stub_361, _gloffset_GetHistogram),
+ NAME_FUNC_OFFSET(15101, glGetHistogramParameterfv, gl_dispatch_stub_362, gl_dispatch_stub_362, _gloffset_GetHistogramParameterfv),
+ NAME_FUNC_OFFSET(15130, glGetHistogramParameteriv, gl_dispatch_stub_363, gl_dispatch_stub_363, _gloffset_GetHistogramParameteriv),
+ NAME_FUNC_OFFSET(15159, glGetMinmax, gl_dispatch_stub_364, gl_dispatch_stub_364, _gloffset_GetMinmax),
+ NAME_FUNC_OFFSET(15174, glGetMinmaxParameterfv, gl_dispatch_stub_365, gl_dispatch_stub_365, _gloffset_GetMinmaxParameterfv),
+ NAME_FUNC_OFFSET(15200, glGetMinmaxParameteriv, gl_dispatch_stub_366, gl_dispatch_stub_366, _gloffset_GetMinmaxParameteriv),
+ NAME_FUNC_OFFSET(15226, glHistogram, glHistogram, NULL, _gloffset_Histogram),
+ NAME_FUNC_OFFSET(15241, glMinmax, glMinmax, NULL, _gloffset_Minmax),
+ NAME_FUNC_OFFSET(15253, glResetHistogram, glResetHistogram, NULL, _gloffset_ResetHistogram),
+ NAME_FUNC_OFFSET(15273, glResetMinmax, glResetMinmax, NULL, _gloffset_ResetMinmax),
+ NAME_FUNC_OFFSET(15290, glTexImage3D, glTexImage3D, NULL, _gloffset_TexImage3D),
+ NAME_FUNC_OFFSET(15306, glTexSubImage3D, glTexSubImage3D, NULL, _gloffset_TexSubImage3D),
+ NAME_FUNC_OFFSET(15325, glCopyTexSubImage3D, glCopyTexSubImage3D, NULL, _gloffset_CopyTexSubImage3D),
+ NAME_FUNC_OFFSET(15348, glActiveTextureARB, glActiveTextureARB, NULL, _gloffset_ActiveTextureARB),
+ NAME_FUNC_OFFSET(15364, glClientActiveTextureARB, glClientActiveTextureARB, NULL, _gloffset_ClientActiveTextureARB),
+ NAME_FUNC_OFFSET(15386, glMultiTexCoord1dARB, glMultiTexCoord1dARB, NULL, _gloffset_MultiTexCoord1dARB),
+ NAME_FUNC_OFFSET(15404, glMultiTexCoord1dvARB, glMultiTexCoord1dvARB, NULL, _gloffset_MultiTexCoord1dvARB),
+ NAME_FUNC_OFFSET(15423, glMultiTexCoord1fARB, glMultiTexCoord1fARB, NULL, _gloffset_MultiTexCoord1fARB),
+ NAME_FUNC_OFFSET(15441, glMultiTexCoord1fvARB, glMultiTexCoord1fvARB, NULL, _gloffset_MultiTexCoord1fvARB),
+ NAME_FUNC_OFFSET(15460, glMultiTexCoord1iARB, glMultiTexCoord1iARB, NULL, _gloffset_MultiTexCoord1iARB),
+ NAME_FUNC_OFFSET(15478, glMultiTexCoord1ivARB, glMultiTexCoord1ivARB, NULL, _gloffset_MultiTexCoord1ivARB),
+ NAME_FUNC_OFFSET(15497, glMultiTexCoord1sARB, glMultiTexCoord1sARB, NULL, _gloffset_MultiTexCoord1sARB),
+ NAME_FUNC_OFFSET(15515, glMultiTexCoord1svARB, glMultiTexCoord1svARB, NULL, _gloffset_MultiTexCoord1svARB),
+ NAME_FUNC_OFFSET(15534, glMultiTexCoord2dARB, glMultiTexCoord2dARB, NULL, _gloffset_MultiTexCoord2dARB),
+ NAME_FUNC_OFFSET(15552, glMultiTexCoord2dvARB, glMultiTexCoord2dvARB, NULL, _gloffset_MultiTexCoord2dvARB),
+ NAME_FUNC_OFFSET(15571, glMultiTexCoord2fARB, glMultiTexCoord2fARB, NULL, _gloffset_MultiTexCoord2fARB),
+ NAME_FUNC_OFFSET(15589, glMultiTexCoord2fvARB, glMultiTexCoord2fvARB, NULL, _gloffset_MultiTexCoord2fvARB),
+ NAME_FUNC_OFFSET(15608, glMultiTexCoord2iARB, glMultiTexCoord2iARB, NULL, _gloffset_MultiTexCoord2iARB),
+ NAME_FUNC_OFFSET(15626, glMultiTexCoord2ivARB, glMultiTexCoord2ivARB, NULL, _gloffset_MultiTexCoord2ivARB),
+ NAME_FUNC_OFFSET(15645, glMultiTexCoord2sARB, glMultiTexCoord2sARB, NULL, _gloffset_MultiTexCoord2sARB),
+ NAME_FUNC_OFFSET(15663, glMultiTexCoord2svARB, glMultiTexCoord2svARB, NULL, _gloffset_MultiTexCoord2svARB),
+ NAME_FUNC_OFFSET(15682, glMultiTexCoord3dARB, glMultiTexCoord3dARB, NULL, _gloffset_MultiTexCoord3dARB),
+ NAME_FUNC_OFFSET(15700, glMultiTexCoord3dvARB, glMultiTexCoord3dvARB, NULL, _gloffset_MultiTexCoord3dvARB),
+ NAME_FUNC_OFFSET(15719, glMultiTexCoord3fARB, glMultiTexCoord3fARB, NULL, _gloffset_MultiTexCoord3fARB),
+ NAME_FUNC_OFFSET(15737, glMultiTexCoord3fvARB, glMultiTexCoord3fvARB, NULL, _gloffset_MultiTexCoord3fvARB),
+ NAME_FUNC_OFFSET(15756, glMultiTexCoord3iARB, glMultiTexCoord3iARB, NULL, _gloffset_MultiTexCoord3iARB),
+ NAME_FUNC_OFFSET(15774, glMultiTexCoord3ivARB, glMultiTexCoord3ivARB, NULL, _gloffset_MultiTexCoord3ivARB),
+ NAME_FUNC_OFFSET(15793, glMultiTexCoord3sARB, glMultiTexCoord3sARB, NULL, _gloffset_MultiTexCoord3sARB),
+ NAME_FUNC_OFFSET(15811, glMultiTexCoord3svARB, glMultiTexCoord3svARB, NULL, _gloffset_MultiTexCoord3svARB),
+ NAME_FUNC_OFFSET(15830, glMultiTexCoord4dARB, glMultiTexCoord4dARB, NULL, _gloffset_MultiTexCoord4dARB),
+ NAME_FUNC_OFFSET(15848, glMultiTexCoord4dvARB, glMultiTexCoord4dvARB, NULL, _gloffset_MultiTexCoord4dvARB),
+ NAME_FUNC_OFFSET(15867, glMultiTexCoord4fARB, glMultiTexCoord4fARB, NULL, _gloffset_MultiTexCoord4fARB),
+ NAME_FUNC_OFFSET(15885, glMultiTexCoord4fvARB, glMultiTexCoord4fvARB, NULL, _gloffset_MultiTexCoord4fvARB),
+ NAME_FUNC_OFFSET(15904, glMultiTexCoord4iARB, glMultiTexCoord4iARB, NULL, _gloffset_MultiTexCoord4iARB),
+ NAME_FUNC_OFFSET(15922, glMultiTexCoord4ivARB, glMultiTexCoord4ivARB, NULL, _gloffset_MultiTexCoord4ivARB),
+ NAME_FUNC_OFFSET(15941, glMultiTexCoord4sARB, glMultiTexCoord4sARB, NULL, _gloffset_MultiTexCoord4sARB),
+ NAME_FUNC_OFFSET(15959, glMultiTexCoord4svARB, glMultiTexCoord4svARB, NULL, _gloffset_MultiTexCoord4svARB),
+ NAME_FUNC_OFFSET(15978, glStencilOpSeparate, glStencilOpSeparate, NULL, _gloffset_StencilOpSeparate),
+ NAME_FUNC_OFFSET(16001, glLoadTransposeMatrixdARB, glLoadTransposeMatrixdARB, NULL, _gloffset_LoadTransposeMatrixdARB),
+ NAME_FUNC_OFFSET(16024, glLoadTransposeMatrixfARB, glLoadTransposeMatrixfARB, NULL, _gloffset_LoadTransposeMatrixfARB),
+ NAME_FUNC_OFFSET(16047, glMultTransposeMatrixdARB, glMultTransposeMatrixdARB, NULL, _gloffset_MultTransposeMatrixdARB),
+ NAME_FUNC_OFFSET(16070, glMultTransposeMatrixfARB, glMultTransposeMatrixfARB, NULL, _gloffset_MultTransposeMatrixfARB),
+ NAME_FUNC_OFFSET(16093, glSampleCoverageARB, glSampleCoverageARB, NULL, _gloffset_SampleCoverageARB),
+ NAME_FUNC_OFFSET(16110, glCompressedTexImage1DARB, glCompressedTexImage1DARB, NULL, _gloffset_CompressedTexImage1DARB),
+ NAME_FUNC_OFFSET(16133, glCompressedTexImage2DARB, glCompressedTexImage2DARB, NULL, _gloffset_CompressedTexImage2DARB),
+ NAME_FUNC_OFFSET(16156, glCompressedTexImage3DARB, glCompressedTexImage3DARB, NULL, _gloffset_CompressedTexImage3DARB),
+ NAME_FUNC_OFFSET(16179, glCompressedTexSubImage1DARB, glCompressedTexSubImage1DARB, NULL, _gloffset_CompressedTexSubImage1DARB),
+ NAME_FUNC_OFFSET(16205, glCompressedTexSubImage2DARB, glCompressedTexSubImage2DARB, NULL, _gloffset_CompressedTexSubImage2DARB),
+ NAME_FUNC_OFFSET(16231, glCompressedTexSubImage3DARB, glCompressedTexSubImage3DARB, NULL, _gloffset_CompressedTexSubImage3DARB),
+ NAME_FUNC_OFFSET(16257, glGetCompressedTexImageARB, glGetCompressedTexImageARB, NULL, _gloffset_GetCompressedTexImageARB),
+ NAME_FUNC_OFFSET(16281, glDisableVertexAttribArrayARB, glDisableVertexAttribArrayARB, NULL, _gloffset_DisableVertexAttribArrayARB),
+ NAME_FUNC_OFFSET(16308, glEnableVertexAttribArrayARB, glEnableVertexAttribArrayARB, NULL, _gloffset_EnableVertexAttribArrayARB),
+ NAME_FUNC_OFFSET(16334, glGetVertexAttribdvARB, glGetVertexAttribdvARB, NULL, _gloffset_GetVertexAttribdvARB),
+ NAME_FUNC_OFFSET(16354, glGetVertexAttribfvARB, glGetVertexAttribfvARB, NULL, _gloffset_GetVertexAttribfvARB),
+ NAME_FUNC_OFFSET(16374, glGetVertexAttribivARB, glGetVertexAttribivARB, NULL, _gloffset_GetVertexAttribivARB),
+ NAME_FUNC_OFFSET(16394, glProgramEnvParameter4dARB, glProgramEnvParameter4dARB, NULL, _gloffset_ProgramEnvParameter4dARB),
+ NAME_FUNC_OFFSET(16417, glProgramEnvParameter4dvARB, glProgramEnvParameter4dvARB, NULL, _gloffset_ProgramEnvParameter4dvARB),
+ NAME_FUNC_OFFSET(16441, glProgramEnvParameter4fARB, glProgramEnvParameter4fARB, NULL, _gloffset_ProgramEnvParameter4fARB),
+ NAME_FUNC_OFFSET(16464, glProgramEnvParameter4fvARB, glProgramEnvParameter4fvARB, NULL, _gloffset_ProgramEnvParameter4fvARB),
+ NAME_FUNC_OFFSET(16488, glVertexAttrib1dARB, glVertexAttrib1dARB, NULL, _gloffset_VertexAttrib1dARB),
+ NAME_FUNC_OFFSET(16505, glVertexAttrib1dvARB, glVertexAttrib1dvARB, NULL, _gloffset_VertexAttrib1dvARB),
+ NAME_FUNC_OFFSET(16523, glVertexAttrib1fARB, glVertexAttrib1fARB, NULL, _gloffset_VertexAttrib1fARB),
+ NAME_FUNC_OFFSET(16540, glVertexAttrib1fvARB, glVertexAttrib1fvARB, NULL, _gloffset_VertexAttrib1fvARB),
+ NAME_FUNC_OFFSET(16558, glVertexAttrib1sARB, glVertexAttrib1sARB, NULL, _gloffset_VertexAttrib1sARB),
+ NAME_FUNC_OFFSET(16575, glVertexAttrib1svARB, glVertexAttrib1svARB, NULL, _gloffset_VertexAttrib1svARB),
+ NAME_FUNC_OFFSET(16593, glVertexAttrib2dARB, glVertexAttrib2dARB, NULL, _gloffset_VertexAttrib2dARB),
+ NAME_FUNC_OFFSET(16610, glVertexAttrib2dvARB, glVertexAttrib2dvARB, NULL, _gloffset_VertexAttrib2dvARB),
+ NAME_FUNC_OFFSET(16628, glVertexAttrib2fARB, glVertexAttrib2fARB, NULL, _gloffset_VertexAttrib2fARB),
+ NAME_FUNC_OFFSET(16645, glVertexAttrib2fvARB, glVertexAttrib2fvARB, NULL, _gloffset_VertexAttrib2fvARB),
+ NAME_FUNC_OFFSET(16663, glVertexAttrib2sARB, glVertexAttrib2sARB, NULL, _gloffset_VertexAttrib2sARB),
+ NAME_FUNC_OFFSET(16680, glVertexAttrib2svARB, glVertexAttrib2svARB, NULL, _gloffset_VertexAttrib2svARB),
+ NAME_FUNC_OFFSET(16698, glVertexAttrib3dARB, glVertexAttrib3dARB, NULL, _gloffset_VertexAttrib3dARB),
+ NAME_FUNC_OFFSET(16715, glVertexAttrib3dvARB, glVertexAttrib3dvARB, NULL, _gloffset_VertexAttrib3dvARB),
+ NAME_FUNC_OFFSET(16733, glVertexAttrib3fARB, glVertexAttrib3fARB, NULL, _gloffset_VertexAttrib3fARB),
+ NAME_FUNC_OFFSET(16750, glVertexAttrib3fvARB, glVertexAttrib3fvARB, NULL, _gloffset_VertexAttrib3fvARB),
+ NAME_FUNC_OFFSET(16768, glVertexAttrib3sARB, glVertexAttrib3sARB, NULL, _gloffset_VertexAttrib3sARB),
+ NAME_FUNC_OFFSET(16785, glVertexAttrib3svARB, glVertexAttrib3svARB, NULL, _gloffset_VertexAttrib3svARB),
+ NAME_FUNC_OFFSET(16803, glVertexAttrib4NbvARB, glVertexAttrib4NbvARB, NULL, _gloffset_VertexAttrib4NbvARB),
+ NAME_FUNC_OFFSET(16822, glVertexAttrib4NivARB, glVertexAttrib4NivARB, NULL, _gloffset_VertexAttrib4NivARB),
+ NAME_FUNC_OFFSET(16841, glVertexAttrib4NsvARB, glVertexAttrib4NsvARB, NULL, _gloffset_VertexAttrib4NsvARB),
+ NAME_FUNC_OFFSET(16860, glVertexAttrib4NubARB, glVertexAttrib4NubARB, NULL, _gloffset_VertexAttrib4NubARB),
+ NAME_FUNC_OFFSET(16879, glVertexAttrib4NubvARB, glVertexAttrib4NubvARB, NULL, _gloffset_VertexAttrib4NubvARB),
+ NAME_FUNC_OFFSET(16899, glVertexAttrib4NuivARB, glVertexAttrib4NuivARB, NULL, _gloffset_VertexAttrib4NuivARB),
+ NAME_FUNC_OFFSET(16919, glVertexAttrib4NusvARB, glVertexAttrib4NusvARB, NULL, _gloffset_VertexAttrib4NusvARB),
+ NAME_FUNC_OFFSET(16939, glVertexAttrib4bvARB, glVertexAttrib4bvARB, NULL, _gloffset_VertexAttrib4bvARB),
+ NAME_FUNC_OFFSET(16957, glVertexAttrib4dARB, glVertexAttrib4dARB, NULL, _gloffset_VertexAttrib4dARB),
+ NAME_FUNC_OFFSET(16974, glVertexAttrib4dvARB, glVertexAttrib4dvARB, NULL, _gloffset_VertexAttrib4dvARB),
+ NAME_FUNC_OFFSET(16992, glVertexAttrib4fARB, glVertexAttrib4fARB, NULL, _gloffset_VertexAttrib4fARB),
+ NAME_FUNC_OFFSET(17009, glVertexAttrib4fvARB, glVertexAttrib4fvARB, NULL, _gloffset_VertexAttrib4fvARB),
+ NAME_FUNC_OFFSET(17027, glVertexAttrib4ivARB, glVertexAttrib4ivARB, NULL, _gloffset_VertexAttrib4ivARB),
+ NAME_FUNC_OFFSET(17045, glVertexAttrib4sARB, glVertexAttrib4sARB, NULL, _gloffset_VertexAttrib4sARB),
+ NAME_FUNC_OFFSET(17062, glVertexAttrib4svARB, glVertexAttrib4svARB, NULL, _gloffset_VertexAttrib4svARB),
+ NAME_FUNC_OFFSET(17080, glVertexAttrib4ubvARB, glVertexAttrib4ubvARB, NULL, _gloffset_VertexAttrib4ubvARB),
+ NAME_FUNC_OFFSET(17099, glVertexAttrib4uivARB, glVertexAttrib4uivARB, NULL, _gloffset_VertexAttrib4uivARB),
+ NAME_FUNC_OFFSET(17118, glVertexAttrib4usvARB, glVertexAttrib4usvARB, NULL, _gloffset_VertexAttrib4usvARB),
+ NAME_FUNC_OFFSET(17137, glVertexAttribPointerARB, glVertexAttribPointerARB, NULL, _gloffset_VertexAttribPointerARB),
+ NAME_FUNC_OFFSET(17159, glBindBufferARB, glBindBufferARB, NULL, _gloffset_BindBufferARB),
+ NAME_FUNC_OFFSET(17172, glBufferDataARB, glBufferDataARB, NULL, _gloffset_BufferDataARB),
+ NAME_FUNC_OFFSET(17185, glBufferSubDataARB, glBufferSubDataARB, NULL, _gloffset_BufferSubDataARB),
+ NAME_FUNC_OFFSET(17201, glDeleteBuffersARB, glDeleteBuffersARB, NULL, _gloffset_DeleteBuffersARB),
+ NAME_FUNC_OFFSET(17217, glGenBuffersARB, glGenBuffersARB, NULL, _gloffset_GenBuffersARB),
+ NAME_FUNC_OFFSET(17230, glGetBufferParameterivARB, glGetBufferParameterivARB, NULL, _gloffset_GetBufferParameterivARB),
+ NAME_FUNC_OFFSET(17253, glGetBufferPointervARB, glGetBufferPointervARB, NULL, _gloffset_GetBufferPointervARB),
+ NAME_FUNC_OFFSET(17273, glGetBufferSubDataARB, glGetBufferSubDataARB, NULL, _gloffset_GetBufferSubDataARB),
+ NAME_FUNC_OFFSET(17292, glIsBufferARB, glIsBufferARB, NULL, _gloffset_IsBufferARB),
+ NAME_FUNC_OFFSET(17303, glMapBufferARB, glMapBufferARB, NULL, _gloffset_MapBufferARB),
+ NAME_FUNC_OFFSET(17315, glUnmapBufferARB, glUnmapBufferARB, NULL, _gloffset_UnmapBufferARB),
+ NAME_FUNC_OFFSET(17329, glBeginQueryARB, glBeginQueryARB, NULL, _gloffset_BeginQueryARB),
+ NAME_FUNC_OFFSET(17342, glDeleteQueriesARB, glDeleteQueriesARB, NULL, _gloffset_DeleteQueriesARB),
+ NAME_FUNC_OFFSET(17358, glEndQueryARB, glEndQueryARB, NULL, _gloffset_EndQueryARB),
+ NAME_FUNC_OFFSET(17369, glGenQueriesARB, glGenQueriesARB, NULL, _gloffset_GenQueriesARB),
+ NAME_FUNC_OFFSET(17382, glGetQueryObjectivARB, glGetQueryObjectivARB, NULL, _gloffset_GetQueryObjectivARB),
+ NAME_FUNC_OFFSET(17401, glGetQueryObjectuivARB, glGetQueryObjectuivARB, NULL, _gloffset_GetQueryObjectuivARB),
+ NAME_FUNC_OFFSET(17421, glGetQueryivARB, glGetQueryivARB, NULL, _gloffset_GetQueryivARB),
+ NAME_FUNC_OFFSET(17434, glIsQueryARB, glIsQueryARB, NULL, _gloffset_IsQueryARB),
+ NAME_FUNC_OFFSET(17444, glCompileShaderARB, glCompileShaderARB, NULL, _gloffset_CompileShaderARB),
+ NAME_FUNC_OFFSET(17460, glGetActiveUniformARB, glGetActiveUniformARB, NULL, _gloffset_GetActiveUniformARB),
+ NAME_FUNC_OFFSET(17479, glGetShaderSourceARB, glGetShaderSourceARB, NULL, _gloffset_GetShaderSourceARB),
+ NAME_FUNC_OFFSET(17497, glGetUniformLocationARB, glGetUniformLocationARB, NULL, _gloffset_GetUniformLocationARB),
+ NAME_FUNC_OFFSET(17518, glGetUniformfvARB, glGetUniformfvARB, NULL, _gloffset_GetUniformfvARB),
+ NAME_FUNC_OFFSET(17533, glGetUniformivARB, glGetUniformivARB, NULL, _gloffset_GetUniformivARB),
+ NAME_FUNC_OFFSET(17548, glLinkProgramARB, glLinkProgramARB, NULL, _gloffset_LinkProgramARB),
+ NAME_FUNC_OFFSET(17562, glShaderSourceARB, glShaderSourceARB, NULL, _gloffset_ShaderSourceARB),
+ NAME_FUNC_OFFSET(17577, glUniform1fARB, glUniform1fARB, NULL, _gloffset_Uniform1fARB),
+ NAME_FUNC_OFFSET(17589, glUniform1fvARB, glUniform1fvARB, NULL, _gloffset_Uniform1fvARB),
+ NAME_FUNC_OFFSET(17602, glUniform1iARB, glUniform1iARB, NULL, _gloffset_Uniform1iARB),
+ NAME_FUNC_OFFSET(17614, glUniform1ivARB, glUniform1ivARB, NULL, _gloffset_Uniform1ivARB),
+ NAME_FUNC_OFFSET(17627, glUniform2fARB, glUniform2fARB, NULL, _gloffset_Uniform2fARB),
+ NAME_FUNC_OFFSET(17639, glUniform2fvARB, glUniform2fvARB, NULL, _gloffset_Uniform2fvARB),
+ NAME_FUNC_OFFSET(17652, glUniform2iARB, glUniform2iARB, NULL, _gloffset_Uniform2iARB),
+ NAME_FUNC_OFFSET(17664, glUniform2ivARB, glUniform2ivARB, NULL, _gloffset_Uniform2ivARB),
+ NAME_FUNC_OFFSET(17677, glUniform3fARB, glUniform3fARB, NULL, _gloffset_Uniform3fARB),
+ NAME_FUNC_OFFSET(17689, glUniform3fvARB, glUniform3fvARB, NULL, _gloffset_Uniform3fvARB),
+ NAME_FUNC_OFFSET(17702, glUniform3iARB, glUniform3iARB, NULL, _gloffset_Uniform3iARB),
+ NAME_FUNC_OFFSET(17714, glUniform3ivARB, glUniform3ivARB, NULL, _gloffset_Uniform3ivARB),
+ NAME_FUNC_OFFSET(17727, glUniform4fARB, glUniform4fARB, NULL, _gloffset_Uniform4fARB),
+ NAME_FUNC_OFFSET(17739, glUniform4fvARB, glUniform4fvARB, NULL, _gloffset_Uniform4fvARB),
+ NAME_FUNC_OFFSET(17752, glUniform4iARB, glUniform4iARB, NULL, _gloffset_Uniform4iARB),
+ NAME_FUNC_OFFSET(17764, glUniform4ivARB, glUniform4ivARB, NULL, _gloffset_Uniform4ivARB),
+ NAME_FUNC_OFFSET(17777, glUniformMatrix2fvARB, glUniformMatrix2fvARB, NULL, _gloffset_UniformMatrix2fvARB),
+ NAME_FUNC_OFFSET(17796, glUniformMatrix3fvARB, glUniformMatrix3fvARB, NULL, _gloffset_UniformMatrix3fvARB),
+ NAME_FUNC_OFFSET(17815, glUniformMatrix4fvARB, glUniformMatrix4fvARB, NULL, _gloffset_UniformMatrix4fvARB),
+ NAME_FUNC_OFFSET(17834, glUseProgramObjectARB, glUseProgramObjectARB, NULL, _gloffset_UseProgramObjectARB),
+ NAME_FUNC_OFFSET(17847, glValidateProgramARB, glValidateProgramARB, NULL, _gloffset_ValidateProgramARB),
+ NAME_FUNC_OFFSET(17865, glBindAttribLocationARB, glBindAttribLocationARB, NULL, _gloffset_BindAttribLocationARB),
+ NAME_FUNC_OFFSET(17886, glGetActiveAttribARB, glGetActiveAttribARB, NULL, _gloffset_GetActiveAttribARB),
+ NAME_FUNC_OFFSET(17904, glGetAttribLocationARB, glGetAttribLocationARB, NULL, _gloffset_GetAttribLocationARB),
+ NAME_FUNC_OFFSET(17924, glDrawBuffersARB, glDrawBuffersARB, NULL, _gloffset_DrawBuffersARB),
+ NAME_FUNC_OFFSET(17938, glDrawBuffersARB, glDrawBuffersARB, NULL, _gloffset_DrawBuffersARB),
+ NAME_FUNC_OFFSET(17955, gl_dispatch_stub_584, gl_dispatch_stub_584, NULL, _gloffset_SampleMaskSGIS),
+ NAME_FUNC_OFFSET(17971, gl_dispatch_stub_585, gl_dispatch_stub_585, NULL, _gloffset_SamplePatternSGIS),
+ NAME_FUNC_OFFSET(17990, glPointParameterfEXT, glPointParameterfEXT, NULL, _gloffset_PointParameterfEXT),
+ NAME_FUNC_OFFSET(18008, glPointParameterfEXT, glPointParameterfEXT, NULL, _gloffset_PointParameterfEXT),
+ NAME_FUNC_OFFSET(18029, glPointParameterfEXT, glPointParameterfEXT, NULL, _gloffset_PointParameterfEXT),
+ NAME_FUNC_OFFSET(18051, glPointParameterfvEXT, glPointParameterfvEXT, NULL, _gloffset_PointParameterfvEXT),
+ NAME_FUNC_OFFSET(18070, glPointParameterfvEXT, glPointParameterfvEXT, NULL, _gloffset_PointParameterfvEXT),
+ NAME_FUNC_OFFSET(18092, glPointParameterfvEXT, glPointParameterfvEXT, NULL, _gloffset_PointParameterfvEXT),
+ NAME_FUNC_OFFSET(18115, glSecondaryColor3bEXT, glSecondaryColor3bEXT, NULL, _gloffset_SecondaryColor3bEXT),
+ NAME_FUNC_OFFSET(18134, glSecondaryColor3bvEXT, glSecondaryColor3bvEXT, NULL, _gloffset_SecondaryColor3bvEXT),
+ NAME_FUNC_OFFSET(18154, glSecondaryColor3dEXT, glSecondaryColor3dEXT, NULL, _gloffset_SecondaryColor3dEXT),
+ NAME_FUNC_OFFSET(18173, glSecondaryColor3dvEXT, glSecondaryColor3dvEXT, NULL, _gloffset_SecondaryColor3dvEXT),
+ NAME_FUNC_OFFSET(18193, glSecondaryColor3fEXT, glSecondaryColor3fEXT, NULL, _gloffset_SecondaryColor3fEXT),
+ NAME_FUNC_OFFSET(18212, glSecondaryColor3fvEXT, glSecondaryColor3fvEXT, NULL, _gloffset_SecondaryColor3fvEXT),
+ NAME_FUNC_OFFSET(18232, glSecondaryColor3iEXT, glSecondaryColor3iEXT, NULL, _gloffset_SecondaryColor3iEXT),
+ NAME_FUNC_OFFSET(18251, glSecondaryColor3ivEXT, glSecondaryColor3ivEXT, NULL, _gloffset_SecondaryColor3ivEXT),
+ NAME_FUNC_OFFSET(18271, glSecondaryColor3sEXT, glSecondaryColor3sEXT, NULL, _gloffset_SecondaryColor3sEXT),
+ NAME_FUNC_OFFSET(18290, glSecondaryColor3svEXT, glSecondaryColor3svEXT, NULL, _gloffset_SecondaryColor3svEXT),
+ NAME_FUNC_OFFSET(18310, glSecondaryColor3ubEXT, glSecondaryColor3ubEXT, NULL, _gloffset_SecondaryColor3ubEXT),
+ NAME_FUNC_OFFSET(18330, glSecondaryColor3ubvEXT, glSecondaryColor3ubvEXT, NULL, _gloffset_SecondaryColor3ubvEXT),
+ NAME_FUNC_OFFSET(18351, glSecondaryColor3uiEXT, glSecondaryColor3uiEXT, NULL, _gloffset_SecondaryColor3uiEXT),
+ NAME_FUNC_OFFSET(18371, glSecondaryColor3uivEXT, glSecondaryColor3uivEXT, NULL, _gloffset_SecondaryColor3uivEXT),
+ NAME_FUNC_OFFSET(18392, glSecondaryColor3usEXT, glSecondaryColor3usEXT, NULL, _gloffset_SecondaryColor3usEXT),
+ NAME_FUNC_OFFSET(18412, glSecondaryColor3usvEXT, glSecondaryColor3usvEXT, NULL, _gloffset_SecondaryColor3usvEXT),
+ NAME_FUNC_OFFSET(18433, glSecondaryColorPointerEXT, glSecondaryColorPointerEXT, NULL, _gloffset_SecondaryColorPointerEXT),
+ NAME_FUNC_OFFSET(18457, glMultiDrawArraysEXT, glMultiDrawArraysEXT, NULL, _gloffset_MultiDrawArraysEXT),
+ NAME_FUNC_OFFSET(18475, glMultiDrawElementsEXT, glMultiDrawElementsEXT, NULL, _gloffset_MultiDrawElementsEXT),
+ NAME_FUNC_OFFSET(18495, glFogCoordPointerEXT, glFogCoordPointerEXT, NULL, _gloffset_FogCoordPointerEXT),
+ NAME_FUNC_OFFSET(18513, glFogCoorddEXT, glFogCoorddEXT, NULL, _gloffset_FogCoorddEXT),
+ NAME_FUNC_OFFSET(18525, glFogCoorddvEXT, glFogCoorddvEXT, NULL, _gloffset_FogCoorddvEXT),
+ NAME_FUNC_OFFSET(18538, glFogCoordfEXT, glFogCoordfEXT, NULL, _gloffset_FogCoordfEXT),
+ NAME_FUNC_OFFSET(18550, glFogCoordfvEXT, glFogCoordfvEXT, NULL, _gloffset_FogCoordfvEXT),
+ NAME_FUNC_OFFSET(18563, glBlendFuncSeparateEXT, glBlendFuncSeparateEXT, NULL, _gloffset_BlendFuncSeparateEXT),
+ NAME_FUNC_OFFSET(18583, glBlendFuncSeparateEXT, glBlendFuncSeparateEXT, NULL, _gloffset_BlendFuncSeparateEXT),
+ NAME_FUNC_OFFSET(18607, glWindowPos2dMESA, glWindowPos2dMESA, NULL, _gloffset_WindowPos2dMESA),
+ NAME_FUNC_OFFSET(18621, glWindowPos2dMESA, glWindowPos2dMESA, NULL, _gloffset_WindowPos2dMESA),
+ NAME_FUNC_OFFSET(18638, glWindowPos2dvMESA, glWindowPos2dvMESA, NULL, _gloffset_WindowPos2dvMESA),
+ NAME_FUNC_OFFSET(18653, glWindowPos2dvMESA, glWindowPos2dvMESA, NULL, _gloffset_WindowPos2dvMESA),
+ NAME_FUNC_OFFSET(18671, glWindowPos2fMESA, glWindowPos2fMESA, NULL, _gloffset_WindowPos2fMESA),
+ NAME_FUNC_OFFSET(18685, glWindowPos2fMESA, glWindowPos2fMESA, NULL, _gloffset_WindowPos2fMESA),
+ NAME_FUNC_OFFSET(18702, glWindowPos2fvMESA, glWindowPos2fvMESA, NULL, _gloffset_WindowPos2fvMESA),
+ NAME_FUNC_OFFSET(18717, glWindowPos2fvMESA, glWindowPos2fvMESA, NULL, _gloffset_WindowPos2fvMESA),
+ NAME_FUNC_OFFSET(18735, glWindowPos2iMESA, glWindowPos2iMESA, NULL, _gloffset_WindowPos2iMESA),
+ NAME_FUNC_OFFSET(18749, glWindowPos2iMESA, glWindowPos2iMESA, NULL, _gloffset_WindowPos2iMESA),
+ NAME_FUNC_OFFSET(18766, glWindowPos2ivMESA, glWindowPos2ivMESA, NULL, _gloffset_WindowPos2ivMESA),
+ NAME_FUNC_OFFSET(18781, glWindowPos2ivMESA, glWindowPos2ivMESA, NULL, _gloffset_WindowPos2ivMESA),
+ NAME_FUNC_OFFSET(18799, glWindowPos2sMESA, glWindowPos2sMESA, NULL, _gloffset_WindowPos2sMESA),
+ NAME_FUNC_OFFSET(18813, glWindowPos2sMESA, glWindowPos2sMESA, NULL, _gloffset_WindowPos2sMESA),
+ NAME_FUNC_OFFSET(18830, glWindowPos2svMESA, glWindowPos2svMESA, NULL, _gloffset_WindowPos2svMESA),
+ NAME_FUNC_OFFSET(18845, glWindowPos2svMESA, glWindowPos2svMESA, NULL, _gloffset_WindowPos2svMESA),
+ NAME_FUNC_OFFSET(18863, glWindowPos3dMESA, glWindowPos3dMESA, NULL, _gloffset_WindowPos3dMESA),
+ NAME_FUNC_OFFSET(18877, glWindowPos3dMESA, glWindowPos3dMESA, NULL, _gloffset_WindowPos3dMESA),
+ NAME_FUNC_OFFSET(18894, glWindowPos3dvMESA, glWindowPos3dvMESA, NULL, _gloffset_WindowPos3dvMESA),
+ NAME_FUNC_OFFSET(18909, glWindowPos3dvMESA, glWindowPos3dvMESA, NULL, _gloffset_WindowPos3dvMESA),
+ NAME_FUNC_OFFSET(18927, glWindowPos3fMESA, glWindowPos3fMESA, NULL, _gloffset_WindowPos3fMESA),
+ NAME_FUNC_OFFSET(18941, glWindowPos3fMESA, glWindowPos3fMESA, NULL, _gloffset_WindowPos3fMESA),
+ NAME_FUNC_OFFSET(18958, glWindowPos3fvMESA, glWindowPos3fvMESA, NULL, _gloffset_WindowPos3fvMESA),
+ NAME_FUNC_OFFSET(18973, glWindowPos3fvMESA, glWindowPos3fvMESA, NULL, _gloffset_WindowPos3fvMESA),
+ NAME_FUNC_OFFSET(18991, glWindowPos3iMESA, glWindowPos3iMESA, NULL, _gloffset_WindowPos3iMESA),
+ NAME_FUNC_OFFSET(19005, glWindowPos3iMESA, glWindowPos3iMESA, NULL, _gloffset_WindowPos3iMESA),
+ NAME_FUNC_OFFSET(19022, glWindowPos3ivMESA, glWindowPos3ivMESA, NULL, _gloffset_WindowPos3ivMESA),
+ NAME_FUNC_OFFSET(19037, glWindowPos3ivMESA, glWindowPos3ivMESA, NULL, _gloffset_WindowPos3ivMESA),
+ NAME_FUNC_OFFSET(19055, glWindowPos3sMESA, glWindowPos3sMESA, NULL, _gloffset_WindowPos3sMESA),
+ NAME_FUNC_OFFSET(19069, glWindowPos3sMESA, glWindowPos3sMESA, NULL, _gloffset_WindowPos3sMESA),
+ NAME_FUNC_OFFSET(19086, glWindowPos3svMESA, glWindowPos3svMESA, NULL, _gloffset_WindowPos3svMESA),
+ NAME_FUNC_OFFSET(19101, glWindowPos3svMESA, glWindowPos3svMESA, NULL, _gloffset_WindowPos3svMESA),
+ NAME_FUNC_OFFSET(19119, glBindProgramNV, glBindProgramNV, NULL, _gloffset_BindProgramNV),
+ NAME_FUNC_OFFSET(19136, glDeleteProgramsNV, glDeleteProgramsNV, NULL, _gloffset_DeleteProgramsNV),
+ NAME_FUNC_OFFSET(19156, glGenProgramsNV, glGenProgramsNV, NULL, _gloffset_GenProgramsNV),
+ NAME_FUNC_OFFSET(19173, glGetVertexAttribPointervNV, glGetVertexAttribPointervNV, NULL, _gloffset_GetVertexAttribPointervNV),
+ NAME_FUNC_OFFSET(19199, glGetVertexAttribPointervNV, glGetVertexAttribPointervNV, NULL, _gloffset_GetVertexAttribPointervNV),
+ NAME_FUNC_OFFSET(19228, glIsProgramNV, glIsProgramNV, NULL, _gloffset_IsProgramNV),
+ NAME_FUNC_OFFSET(19243, glPointParameteriNV, glPointParameteriNV, NULL, _gloffset_PointParameteriNV),
+ NAME_FUNC_OFFSET(19261, glPointParameterivNV, glPointParameterivNV, NULL, _gloffset_PointParameterivNV),
+ NAME_FUNC_OFFSET(19280, gl_dispatch_stub_755, gl_dispatch_stub_755, NULL, _gloffset_DeleteVertexArraysAPPLE),
+ NAME_FUNC_OFFSET(19301, gl_dispatch_stub_757, gl_dispatch_stub_757, NULL, _gloffset_IsVertexArrayAPPLE),
+ NAME_FUNC_OFFSET(19317, gl_dispatch_stub_765, gl_dispatch_stub_765, NULL, _gloffset_BlendEquationSeparateEXT),
+ NAME_FUNC_OFFSET(19341, gl_dispatch_stub_765, gl_dispatch_stub_765, NULL, _gloffset_BlendEquationSeparateEXT),
+ NAME_FUNC_OFFSET(19368, glBindFramebufferEXT, glBindFramebufferEXT, NULL, _gloffset_BindFramebufferEXT),
+ NAME_FUNC_OFFSET(19386, glBindRenderbufferEXT, glBindRenderbufferEXT, NULL, _gloffset_BindRenderbufferEXT),
+ NAME_FUNC_OFFSET(19405, glCheckFramebufferStatusEXT, glCheckFramebufferStatusEXT, NULL, _gloffset_CheckFramebufferStatusEXT),
+ NAME_FUNC_OFFSET(19430, glDeleteFramebuffersEXT, glDeleteFramebuffersEXT, NULL, _gloffset_DeleteFramebuffersEXT),
+ NAME_FUNC_OFFSET(19451, glDeleteRenderbuffersEXT, glDeleteRenderbuffersEXT, NULL, _gloffset_DeleteRenderbuffersEXT),
+ NAME_FUNC_OFFSET(19473, glFramebufferRenderbufferEXT, glFramebufferRenderbufferEXT, NULL, _gloffset_FramebufferRenderbufferEXT),
+ NAME_FUNC_OFFSET(19499, glFramebufferTexture1DEXT, glFramebufferTexture1DEXT, NULL, _gloffset_FramebufferTexture1DEXT),
+ NAME_FUNC_OFFSET(19522, glFramebufferTexture2DEXT, glFramebufferTexture2DEXT, NULL, _gloffset_FramebufferTexture2DEXT),
+ NAME_FUNC_OFFSET(19545, glFramebufferTexture3DEXT, glFramebufferTexture3DEXT, NULL, _gloffset_FramebufferTexture3DEXT),
+ NAME_FUNC_OFFSET(19568, glGenFramebuffersEXT, glGenFramebuffersEXT, NULL, _gloffset_GenFramebuffersEXT),
+ NAME_FUNC_OFFSET(19586, glGenRenderbuffersEXT, glGenRenderbuffersEXT, NULL, _gloffset_GenRenderbuffersEXT),
+ NAME_FUNC_OFFSET(19605, glGenerateMipmapEXT, glGenerateMipmapEXT, NULL, _gloffset_GenerateMipmapEXT),
+ NAME_FUNC_OFFSET(19622, glGetFramebufferAttachmentParameterivEXT, glGetFramebufferAttachmentParameterivEXT, NULL, _gloffset_GetFramebufferAttachmentParameterivEXT),
+ NAME_FUNC_OFFSET(19660, glGetRenderbufferParameterivEXT, glGetRenderbufferParameterivEXT, NULL, _gloffset_GetRenderbufferParameterivEXT),
+ NAME_FUNC_OFFSET(19689, glIsFramebufferEXT, glIsFramebufferEXT, NULL, _gloffset_IsFramebufferEXT),
+ NAME_FUNC_OFFSET(19705, glIsRenderbufferEXT, glIsRenderbufferEXT, NULL, _gloffset_IsRenderbufferEXT),
+ NAME_FUNC_OFFSET(19722, glRenderbufferStorageEXT, glRenderbufferStorageEXT, NULL, _gloffset_RenderbufferStorageEXT),
+ NAME_FUNC_OFFSET(19744, gl_dispatch_stub_783, gl_dispatch_stub_783, NULL, _gloffset_BlitFramebufferEXT),
+ NAME_FUNC_OFFSET(19762, glFramebufferTextureLayerEXT, glFramebufferTextureLayerEXT, NULL, _gloffset_FramebufferTextureLayerEXT),
NAME_FUNC_OFFSET(-1, NULL, NULL, NULL, 0)
};
GET_CURRENT_CONTEXT(ctx);
GLint i;
- if (!_mesa_validate_DrawElements( ctx, mode, count, type, indices ))
+ if (!_mesa_validate_DrawElements( ctx, mode, count, type, indices, 0 ))
return;
CALL_Begin(GET_DISPATCH(), (mode));
CALL_End(GET_DISPATCH(), ());
}
+static void GLAPIENTRY
+_mesa_noop_DrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type,
+ const GLvoid *indices, GLint basevertex)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ GLint i;
+
+ if (!_mesa_validate_DrawElements( ctx, mode, count, type, indices,
+ basevertex ))
+ return;
+
+ CALL_Begin(GET_DISPATCH(), (mode));
+
+ switch (type) {
+ case GL_UNSIGNED_BYTE:
+ for (i = 0 ; i < count ; i++)
+ CALL_ArrayElement(GET_DISPATCH(), ( ((GLubyte *)indices)[i] +
+ basevertex));
+ break;
+ case GL_UNSIGNED_SHORT:
+ for (i = 0 ; i < count ; i++)
+ CALL_ArrayElement(GET_DISPATCH(), ( ((GLushort *)indices)[i] +
+ basevertex ));
+ break;
+ case GL_UNSIGNED_INT:
+ for (i = 0 ; i < count ; i++)
+ CALL_ArrayElement(GET_DISPATCH(), ( ((GLuint *)indices)[i] +
+ basevertex ));
+ break;
+ default:
+ _mesa_error( ctx, GL_INVALID_ENUM, "glDrawElementsBaseVertex(type)" );
+ break;
+ }
+
+ CALL_End(GET_DISPATCH(), ());
+}
+
static void GLAPIENTRY
_mesa_noop_DrawRangeElements(GLenum mode,
if (_mesa_validate_DrawRangeElements( ctx, mode,
start, end,
- count, type, indices ))
+ count, type, indices, 0 ))
CALL_DrawElements(GET_DISPATCH(), (mode, count, type, indices));
}
}
}
+static void GLAPIENTRY
+_mesa_noop_DrawRangeElementsBaseVertex(GLenum mode,
+ GLuint start, GLuint end,
+ GLsizei count, GLenum type,
+ const GLvoid *indices, GLint basevertex)
+{
+ GET_CURRENT_CONTEXT(ctx);
+
+ if (_mesa_validate_DrawRangeElements( ctx, mode,
+ start, end,
+ count, type, indices, basevertex ))
+ CALL_DrawElementsBaseVertex(GET_DISPATCH(), (mode, count, type, indices,
+ basevertex));
+}
+
+/* GL_EXT_multi_draw_arrays */
+void GLAPIENTRY
+_mesa_noop_MultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count,
+ GLenum type,
+ const GLvoid **indices,
+ GLsizei primcount,
+ const GLint *basevertex)
+{
+ GLsizei i;
+
+ for (i = 0; i < primcount; i++) {
+ if (count[i] > 0) {
+ CALL_DrawElementsBaseVertex(GET_DISPATCH(), (mode, count[i], type,
+ indices[i],
+ basevertex[i]));
+ }
+ }
+}
+
/*
* Eval Mesh
*/
vfmt->DrawElements = _mesa_noop_DrawElements;
vfmt->DrawRangeElements = _mesa_noop_DrawRangeElements;
vfmt->MultiDrawElementsEXT = _mesa_noop_MultiDrawElements;
+ vfmt->DrawElementsBaseVertex = _mesa_noop_DrawElementsBaseVertex;
+ vfmt->DrawRangeElementsBaseVertex = _mesa_noop_DrawRangeElementsBaseVertex;
+ vfmt->MultiDrawElementsBaseVertex = _mesa_noop_MultiDrawElementsBaseVertex;
vfmt->EvalMesh1 = _mesa_noop_EvalMesh1;
vfmt->EvalMesh2 = _mesa_noop_EvalMesh2;
}
_mesa_noop_MultiDrawElements(GLenum mode, const GLsizei *count, GLenum type,
const GLvoid **indices, GLsizei primcount);
+extern void GLAPIENTRY
+_mesa_noop_MultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count,
+ GLenum type,
+ const GLvoid **indices,
+ GLsizei primcount,
+ const GLint *basevertex);
+
extern void
_mesa_noop_vtxfmt_init(GLvertexformat *vfmt);
#include "imports.h"
#include "mtypes.h"
#include "state.h"
-
+#include "vbo/vbo.h"
/**
}
-/**
- * Find the max index in the given element/index buffer
- */
-static GLuint
-max_buffer_index(GLcontext *ctx, GLuint count, GLenum type,
- const void *indices,
- struct gl_buffer_object *elementBuf)
-{
- const GLubyte *map = NULL;
- GLuint max = 0;
- GLuint i;
-
- if (_mesa_is_bufferobj(elementBuf)) {
- /* elements are in a user-defined buffer object. need to map it */
- map = ctx->Driver.MapBuffer(ctx, GL_ELEMENT_ARRAY_BUFFER,
- GL_READ_ONLY, elementBuf);
- /* Actual address is the sum of pointers */
- indices = (const GLvoid *) ADD_POINTERS(map, (const GLubyte *) indices);
- }
-
- if (type == GL_UNSIGNED_INT) {
- for (i = 0; i < count; i++)
- if (((GLuint *) indices)[i] > max)
- max = ((GLuint *) indices)[i];
- }
- else if (type == GL_UNSIGNED_SHORT) {
- for (i = 0; i < count; i++)
- if (((GLushort *) indices)[i] > max)
- max = ((GLushort *) indices)[i];
- }
- else {
- ASSERT(type == GL_UNSIGNED_BYTE);
- for (i = 0; i < count; i++)
- if (((GLubyte *) indices)[i] > max)
- max = ((GLubyte *) indices)[i];
- }
-
- if (map) {
- ctx->Driver.UnmapBuffer(ctx, GL_ELEMENT_ARRAY_BUFFER_ARB, elementBuf);
- }
-
- return max;
-}
-
-
/**
* Check if OK to draw arrays/elements.
*/
return GL_TRUE;
}
+static GLboolean
+check_index_bounds(GLcontext *ctx, GLsizei count, GLenum type,
+ const GLvoid *indices, GLint basevertex)
+{
+ struct _mesa_prim prim;
+ struct _mesa_index_buffer ib;
+ GLuint min, max;
+
+ /* Only the X Server needs to do this -- otherwise, accessing outside
+ * array/BO bounds allows application termination.
+ */
+ if (!ctx->Const.CheckArrayBounds)
+ return GL_TRUE;
+
+ memset(&prim, 0, sizeof(prim));
+ prim.count = count;
+
+ memset(&ib, 0, sizeof(ib));
+ ib.type = type;
+ ib.ptr = indices;
+ ib.obj = ctx->Array.ElementArrayBufferObj;
+
+ vbo_get_minmax_index(ctx, &prim, &ib, &min, &max);
+
+ if (min + basevertex < 0 ||
+ max + basevertex > ctx->Array.ArrayObj->_MaxElement) {
+ /* the max element is out of bounds of one or more enabled arrays */
+ _mesa_warning(ctx, "glDrawElements() index=%u is "
+ "out of bounds (max=%u)", max, ctx->Array.ArrayObj->_MaxElement);
+ return GL_FALSE;
+ }
+
+ return GL_TRUE;
+}
/**
* Error checking for glDrawElements(). Includes parameter checking
GLboolean
_mesa_validate_DrawElements(GLcontext *ctx,
GLenum mode, GLsizei count, GLenum type,
- const GLvoid *indices)
+ const GLvoid *indices, GLint basevertex)
{
ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
return GL_FALSE;
}
- if (ctx->Const.CheckArrayBounds) {
- /* find max array index */
- GLuint max = max_buffer_index(ctx, count, type, indices,
- ctx->Array.ElementArrayBufferObj);
- if (max >= ctx->Array.ArrayObj->_MaxElement) {
- /* the max element is out of bounds of one or more enabled arrays */
- _mesa_warning(ctx, "glDrawElements() index=%u is "
- "out of bounds (max=%u)", max, ctx->Array.ArrayObj->_MaxElement);
- return GL_FALSE;
- }
- }
+ if (!check_index_bounds(ctx, count, type, indices, basevertex))
+ return GL_FALSE;
return GL_TRUE;
}
_mesa_validate_DrawRangeElements(GLcontext *ctx, GLenum mode,
GLuint start, GLuint end,
GLsizei count, GLenum type,
- const GLvoid *indices)
+ const GLvoid *indices, GLint basevertex)
{
ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
return GL_FALSE;
}
- if (ctx->Const.CheckArrayBounds) {
- GLuint max = max_buffer_index(ctx, count, type, indices,
- ctx->Array.ElementArrayBufferObj);
- if (max >= ctx->Array.ArrayObj->_MaxElement) {
- /* the max element is out of bounds of one or more enabled arrays */
- return GL_FALSE;
- }
- }
+ if (!check_index_bounds(ctx, count, type, indices, basevertex))
+ return GL_FALSE;
return GL_TRUE;
}
extern GLboolean
_mesa_validate_DrawElements(GLcontext *ctx,
GLenum mode, GLsizei count, GLenum type,
- const GLvoid *indices);
+ const GLvoid *indices, GLint basevertex);
extern GLboolean
_mesa_validate_DrawRangeElements(GLcontext *ctx, GLenum mode,
GLuint start, GLuint end,
GLsizei count, GLenum type,
- const GLvoid *indices);
+ const GLvoid *indices, GLint basevertex);
#endif
GLboolean Convolution2D;
GLboolean Separable2D;
GLboolean CullFace;
+ GLboolean DepthClamp;
GLboolean DepthTest;
GLboolean Dither;
GLboolean Fog;
attr->Convolution2D = ctx->Pixel.Convolution2DEnabled;
attr->Separable2D = ctx->Pixel.Separable2DEnabled;
attr->CullFace = ctx->Polygon.CullFlag;
+ attr->DepthClamp = ctx->Transform.DepthClamp;
attr->DepthTest = ctx->Depth.Test;
attr->Dither = ctx->Color.DitherFlag;
attr->Fog = ctx->Fog.Enabled;
enable->ColorTable[COLORTABLE_POSTCOLORMATRIX],
GL_POST_COLOR_MATRIX_COLOR_TABLE);
TEST_AND_UPDATE(ctx->Polygon.CullFlag, enable->CullFace, GL_CULL_FACE);
+ TEST_AND_UPDATE(ctx->Transform.DepthClamp, enable->DepthClamp,
+ GL_DEPTH_CLAMP);
TEST_AND_UPDATE(ctx->Depth.Test, enable->DepthTest, GL_DEPTH_TEST);
TEST_AND_UPDATE(ctx->Color.DitherFlag, enable->Dither, GL_DITHER);
TEST_AND_UPDATE(ctx->Pixel.Convolution1DEnabled, enable->Convolution1D,
if (xform->RescaleNormals != ctx->Transform.RescaleNormals)
_mesa_set_enable(ctx, GL_RESCALE_NORMAL_EXT,
ctx->Transform.RescaleNormals);
+ if (xform->DepthClamp != ctx->Transform.DepthClamp)
+ _mesa_set_enable(ctx, GL_DEPTH_CLAMP,
+ ctx->Transform.DepthClamp);
}
break;
case GL_TEXTURE_BIT:
GLenum type,
const GLvoid **indices,
GLsizei primcount);
- /*@}*/
+ void (GLAPIENTRYP DrawElementsBaseVertex)( GLenum mode, GLsizei count,
+ GLenum type,
+ const GLvoid *indices,
+ GLint basevertex );
+ void (GLAPIENTRYP DrawRangeElementsBaseVertex)( GLenum mode, GLuint start,
+ GLuint end, GLsizei count,
+ GLenum type,
+ const GLvoid *indices,
+ GLint basevertex);
+ void (GLAPIENTRYP MultiDrawElementsBaseVertex)( GLenum mode,
+ const GLsizei *count,
+ GLenum type,
+ const GLvoid **indices,
+ GLsizei primcount,
+ const GLint *basevertex);
+ /*@}*/
/**
* \name Eval
vfmt->DrawElements = 0;
vfmt->DrawRangeElements = 0;
vfmt->MultiDrawElemementsEXT = 0;
+ vfmt->DrawElementsBaseVertex = 0;
+ vfmt->DrawRangeElementsBaseVertex = 0;
+ vfmt->MultiDrawElemementsBaseVertex = 0;
#endif
}
#include "simple_list.h"
#include "mtypes.h"
#include "enums.h"
-#include "math/m_matrix.h"
#include "api_arrayelt.h"
ctx->Depth.BoundsTest = state;
break;
+ case GL_DEPTH_CLAMP:
+ if (ctx->Transform.DepthClamp == state)
+ return;
+ CHECK_EXTENSION(ARB_depth_clamp, cap);
+ FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
+ ctx->Transform.DepthClamp = state;
+ break;
+
#if FEATURE_ATI_fragment_shader
case GL_FRAGMENT_SHADER_ATI:
CHECK_EXTENSION(ATI_fragment_shader, cap);
CHECK_EXTENSION(EXT_depth_bounds_test);
return ctx->Depth.BoundsTest;
+ /* GL_ARB_depth_clamp */
+ case GL_DEPTH_CLAMP:
+ CHECK_EXTENSION(ARB_depth_clamp);
+ return ctx->Transform.DepthClamp;
+
#if FEATURE_ATI_fragment_shader
case GL_FRAGMENT_SHADER_ATI:
CHECK_EXTENSION(ATI_fragment_shader);
"GL_DEPTH_BOUNDS_EXT\0"
"GL_DEPTH_BOUNDS_TEST_EXT\0"
"GL_DEPTH_BUFFER_BIT\0"
+ "GL_DEPTH_CLAMP\0"
"GL_DEPTH_CLAMP_NV\0"
"GL_DEPTH_CLEAR_VALUE\0"
"GL_DEPTH_COMPONENT\0"
"GL_ZOOM_Y\0"
;
-static const enum_elt all_enums[1857] =
+static const enum_elt all_enums[1858] =
{
{ 0, 0x00000600 }, /* GL_2D */
{ 6, 0x00001407 }, /* GL_2_BYTES */
{ 7262, 0x00008891 }, /* GL_DEPTH_BOUNDS_EXT */
{ 7282, 0x00008890 }, /* GL_DEPTH_BOUNDS_TEST_EXT */
{ 7307, 0x00000100 }, /* GL_DEPTH_BUFFER_BIT */
- { 7327, 0x0000864F }, /* GL_DEPTH_CLAMP_NV */
- { 7345, 0x00000B73 }, /* GL_DEPTH_CLEAR_VALUE */
- { 7366, 0x00001902 }, /* GL_DEPTH_COMPONENT */
- { 7385, 0x000081A5 }, /* GL_DEPTH_COMPONENT16 */
- { 7406, 0x000081A5 }, /* GL_DEPTH_COMPONENT16_ARB */
- { 7431, 0x000081A5 }, /* GL_DEPTH_COMPONENT16_SGIX */
- { 7457, 0x000081A6 }, /* GL_DEPTH_COMPONENT24 */
- { 7478, 0x000081A6 }, /* GL_DEPTH_COMPONENT24_ARB */
- { 7503, 0x000081A6 }, /* GL_DEPTH_COMPONENT24_SGIX */
- { 7529, 0x000081A7 }, /* GL_DEPTH_COMPONENT32 */
- { 7550, 0x000081A7 }, /* GL_DEPTH_COMPONENT32_ARB */
- { 7575, 0x000081A7 }, /* GL_DEPTH_COMPONENT32_SGIX */
- { 7601, 0x00000B74 }, /* GL_DEPTH_FUNC */
- { 7615, 0x00000B70 }, /* GL_DEPTH_RANGE */
- { 7630, 0x00000D1E }, /* GL_DEPTH_SCALE */
- { 7645, 0x000084F9 }, /* GL_DEPTH_STENCIL */
- { 7662, 0x0000821A }, /* GL_DEPTH_STENCIL_ATTACHMENT */
- { 7690, 0x000084F9 }, /* GL_DEPTH_STENCIL_NV */
- { 7710, 0x0000886F }, /* GL_DEPTH_STENCIL_TO_BGRA_NV */
- { 7738, 0x0000886E }, /* GL_DEPTH_STENCIL_TO_RGBA_NV */
- { 7766, 0x00000B71 }, /* GL_DEPTH_TEST */
- { 7780, 0x0000884B }, /* GL_DEPTH_TEXTURE_MODE */
- { 7802, 0x0000884B }, /* GL_DEPTH_TEXTURE_MODE_ARB */
- { 7828, 0x00000B72 }, /* GL_DEPTH_WRITEMASK */
- { 7847, 0x00001201 }, /* GL_DIFFUSE */
- { 7858, 0x00000BD0 }, /* GL_DITHER */
- { 7868, 0x00000A02 }, /* GL_DOMAIN */
- { 7878, 0x00001100 }, /* GL_DONT_CARE */
- { 7891, 0x000086AE }, /* GL_DOT3_RGB */
- { 7903, 0x000086AF }, /* GL_DOT3_RGBA */
- { 7916, 0x000086AF }, /* GL_DOT3_RGBA_ARB */
- { 7933, 0x00008741 }, /* GL_DOT3_RGBA_EXT */
- { 7950, 0x000086AE }, /* GL_DOT3_RGB_ARB */
- { 7966, 0x00008740 }, /* GL_DOT3_RGB_EXT */
- { 7982, 0x0000140A }, /* GL_DOUBLE */
- { 7992, 0x00000C32 }, /* GL_DOUBLEBUFFER */
- { 8008, 0x00000C01 }, /* GL_DRAW_BUFFER */
- { 8023, 0x00008825 }, /* GL_DRAW_BUFFER0 */
- { 8039, 0x00008825 }, /* GL_DRAW_BUFFER0_ARB */
- { 8059, 0x00008825 }, /* GL_DRAW_BUFFER0_ATI */
- { 8079, 0x00008826 }, /* GL_DRAW_BUFFER1 */
- { 8095, 0x0000882F }, /* GL_DRAW_BUFFER10 */
- { 8112, 0x0000882F }, /* GL_DRAW_BUFFER10_ARB */
- { 8133, 0x0000882F }, /* GL_DRAW_BUFFER10_ATI */
- { 8154, 0x00008830 }, /* GL_DRAW_BUFFER11 */
- { 8171, 0x00008830 }, /* GL_DRAW_BUFFER11_ARB */
- { 8192, 0x00008830 }, /* GL_DRAW_BUFFER11_ATI */
- { 8213, 0x00008831 }, /* GL_DRAW_BUFFER12 */
- { 8230, 0x00008831 }, /* GL_DRAW_BUFFER12_ARB */
- { 8251, 0x00008831 }, /* GL_DRAW_BUFFER12_ATI */
- { 8272, 0x00008832 }, /* GL_DRAW_BUFFER13 */
- { 8289, 0x00008832 }, /* GL_DRAW_BUFFER13_ARB */
- { 8310, 0x00008832 }, /* GL_DRAW_BUFFER13_ATI */
- { 8331, 0x00008833 }, /* GL_DRAW_BUFFER14 */
- { 8348, 0x00008833 }, /* GL_DRAW_BUFFER14_ARB */
- { 8369, 0x00008833 }, /* GL_DRAW_BUFFER14_ATI */
- { 8390, 0x00008834 }, /* GL_DRAW_BUFFER15 */
- { 8407, 0x00008834 }, /* GL_DRAW_BUFFER15_ARB */
- { 8428, 0x00008834 }, /* GL_DRAW_BUFFER15_ATI */
- { 8449, 0x00008826 }, /* GL_DRAW_BUFFER1_ARB */
- { 8469, 0x00008826 }, /* GL_DRAW_BUFFER1_ATI */
- { 8489, 0x00008827 }, /* GL_DRAW_BUFFER2 */
- { 8505, 0x00008827 }, /* GL_DRAW_BUFFER2_ARB */
- { 8525, 0x00008827 }, /* GL_DRAW_BUFFER2_ATI */
- { 8545, 0x00008828 }, /* GL_DRAW_BUFFER3 */
- { 8561, 0x00008828 }, /* GL_DRAW_BUFFER3_ARB */
- { 8581, 0x00008828 }, /* GL_DRAW_BUFFER3_ATI */
- { 8601, 0x00008829 }, /* GL_DRAW_BUFFER4 */
- { 8617, 0x00008829 }, /* GL_DRAW_BUFFER4_ARB */
- { 8637, 0x00008829 }, /* GL_DRAW_BUFFER4_ATI */
- { 8657, 0x0000882A }, /* GL_DRAW_BUFFER5 */
- { 8673, 0x0000882A }, /* GL_DRAW_BUFFER5_ARB */
- { 8693, 0x0000882A }, /* GL_DRAW_BUFFER5_ATI */
- { 8713, 0x0000882B }, /* GL_DRAW_BUFFER6 */
- { 8729, 0x0000882B }, /* GL_DRAW_BUFFER6_ARB */
- { 8749, 0x0000882B }, /* GL_DRAW_BUFFER6_ATI */
- { 8769, 0x0000882C }, /* GL_DRAW_BUFFER7 */
- { 8785, 0x0000882C }, /* GL_DRAW_BUFFER7_ARB */
- { 8805, 0x0000882C }, /* GL_DRAW_BUFFER7_ATI */
- { 8825, 0x0000882D }, /* GL_DRAW_BUFFER8 */
- { 8841, 0x0000882D }, /* GL_DRAW_BUFFER8_ARB */
- { 8861, 0x0000882D }, /* GL_DRAW_BUFFER8_ATI */
- { 8881, 0x0000882E }, /* GL_DRAW_BUFFER9 */
- { 8897, 0x0000882E }, /* GL_DRAW_BUFFER9_ARB */
- { 8917, 0x0000882E }, /* GL_DRAW_BUFFER9_ATI */
- { 8937, 0x00008CA9 }, /* GL_DRAW_FRAMEBUFFER */
- { 8957, 0x00008CA6 }, /* GL_DRAW_FRAMEBUFFER_BINDING_EXT */
- { 8989, 0x00008CA9 }, /* GL_DRAW_FRAMEBUFFER_EXT */
- { 9013, 0x00000705 }, /* GL_DRAW_PIXEL_TOKEN */
- { 9033, 0x00000304 }, /* GL_DST_ALPHA */
- { 9046, 0x00000306 }, /* GL_DST_COLOR */
- { 9059, 0x0000877A }, /* GL_DU8DV8_ATI */
- { 9073, 0x00008779 }, /* GL_DUDV_ATI */
- { 9085, 0x000088EA }, /* GL_DYNAMIC_COPY */
- { 9101, 0x000088EA }, /* GL_DYNAMIC_COPY_ARB */
- { 9121, 0x000088E8 }, /* GL_DYNAMIC_DRAW */
- { 9137, 0x000088E8 }, /* GL_DYNAMIC_DRAW_ARB */
- { 9157, 0x000088E9 }, /* GL_DYNAMIC_READ */
- { 9173, 0x000088E9 }, /* GL_DYNAMIC_READ_ARB */
- { 9193, 0x00000B43 }, /* GL_EDGE_FLAG */
- { 9206, 0x00008079 }, /* GL_EDGE_FLAG_ARRAY */
- { 9225, 0x0000889B }, /* GL_EDGE_FLAG_ARRAY_BUFFER_BINDING */
- { 9259, 0x0000889B }, /* GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB */
- { 9297, 0x00008093 }, /* GL_EDGE_FLAG_ARRAY_POINTER */
- { 9324, 0x0000808C }, /* GL_EDGE_FLAG_ARRAY_STRIDE */
- { 9350, 0x00008893 }, /* GL_ELEMENT_ARRAY_BUFFER */
- { 9374, 0x00008895 }, /* GL_ELEMENT_ARRAY_BUFFER_BINDING */
- { 9406, 0x00008895 }, /* GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB */
- { 9442, 0x00001600 }, /* GL_EMISSION */
- { 9454, 0x00002000 }, /* GL_ENABLE_BIT */
- { 9468, 0x00000202 }, /* GL_EQUAL */
- { 9477, 0x00001509 }, /* GL_EQUIV */
- { 9486, 0x00010000 }, /* GL_EVAL_BIT */
- { 9498, 0x00000800 }, /* GL_EXP */
- { 9505, 0x00000801 }, /* GL_EXP2 */
- { 9513, 0x00001F03 }, /* GL_EXTENSIONS */
- { 9527, 0x00002400 }, /* GL_EYE_LINEAR */
- { 9541, 0x00002502 }, /* GL_EYE_PLANE */
- { 9554, 0x0000855C }, /* GL_EYE_PLANE_ABSOLUTE_NV */
- { 9579, 0x0000855B }, /* GL_EYE_RADIAL_NV */
- { 9596, 0x00000000 }, /* GL_FALSE */
- { 9605, 0x00001101 }, /* GL_FASTEST */
- { 9616, 0x00001C01 }, /* GL_FEEDBACK */
- { 9628, 0x00000DF0 }, /* GL_FEEDBACK_BUFFER_POINTER */
- { 9655, 0x00000DF1 }, /* GL_FEEDBACK_BUFFER_SIZE */
- { 9679, 0x00000DF2 }, /* GL_FEEDBACK_BUFFER_TYPE */
- { 9703, 0x00001B02 }, /* GL_FILL */
- { 9711, 0x00008E4D }, /* GL_FIRST_VERTEX_CONVENTION_EXT */
- { 9742, 0x00001D00 }, /* GL_FLAT */
- { 9750, 0x00001406 }, /* GL_FLOAT */
- { 9759, 0x00008B5A }, /* GL_FLOAT_MAT2 */
- { 9773, 0x00008B5A }, /* GL_FLOAT_MAT2_ARB */
- { 9791, 0x00008B65 }, /* GL_FLOAT_MAT2x3 */
- { 9807, 0x00008B66 }, /* GL_FLOAT_MAT2x4 */
- { 9823, 0x00008B5B }, /* GL_FLOAT_MAT3 */
- { 9837, 0x00008B5B }, /* GL_FLOAT_MAT3_ARB */
- { 9855, 0x00008B67 }, /* GL_FLOAT_MAT3x2 */
- { 9871, 0x00008B68 }, /* GL_FLOAT_MAT3x4 */
- { 9887, 0x00008B5C }, /* GL_FLOAT_MAT4 */
- { 9901, 0x00008B5C }, /* GL_FLOAT_MAT4_ARB */
- { 9919, 0x00008B69 }, /* GL_FLOAT_MAT4x2 */
- { 9935, 0x00008B6A }, /* GL_FLOAT_MAT4x3 */
- { 9951, 0x00008B50 }, /* GL_FLOAT_VEC2 */
- { 9965, 0x00008B50 }, /* GL_FLOAT_VEC2_ARB */
- { 9983, 0x00008B51 }, /* GL_FLOAT_VEC3 */
- { 9997, 0x00008B51 }, /* GL_FLOAT_VEC3_ARB */
- { 10015, 0x00008B52 }, /* GL_FLOAT_VEC4 */
- { 10029, 0x00008B52 }, /* GL_FLOAT_VEC4_ARB */
- { 10047, 0x00000B60 }, /* GL_FOG */
- { 10054, 0x00000080 }, /* GL_FOG_BIT */
- { 10065, 0x00000B66 }, /* GL_FOG_COLOR */
- { 10078, 0x00008451 }, /* GL_FOG_COORD */
- { 10091, 0x00008451 }, /* GL_FOG_COORDINATE */
- { 10109, 0x00008457 }, /* GL_FOG_COORDINATE_ARRAY */
- { 10133, 0x0000889D }, /* GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING */
- { 10172, 0x0000889D }, /* GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB */
- { 10215, 0x00008456 }, /* GL_FOG_COORDINATE_ARRAY_POINTER */
- { 10247, 0x00008455 }, /* GL_FOG_COORDINATE_ARRAY_STRIDE */
- { 10278, 0x00008454 }, /* GL_FOG_COORDINATE_ARRAY_TYPE */
- { 10307, 0x00008450 }, /* GL_FOG_COORDINATE_SOURCE */
- { 10332, 0x00008457 }, /* GL_FOG_COORD_ARRAY */
- { 10351, 0x0000889D }, /* GL_FOG_COORD_ARRAY_BUFFER_BINDING */
- { 10385, 0x00008456 }, /* GL_FOG_COORD_ARRAY_POINTER */
- { 10412, 0x00008455 }, /* GL_FOG_COORD_ARRAY_STRIDE */
- { 10438, 0x00008454 }, /* GL_FOG_COORD_ARRAY_TYPE */
- { 10462, 0x00008450 }, /* GL_FOG_COORD_SRC */
- { 10479, 0x00000B62 }, /* GL_FOG_DENSITY */
- { 10494, 0x0000855A }, /* GL_FOG_DISTANCE_MODE_NV */
- { 10518, 0x00000B64 }, /* GL_FOG_END */
- { 10529, 0x00000C54 }, /* GL_FOG_HINT */
- { 10541, 0x00000B61 }, /* GL_FOG_INDEX */
- { 10554, 0x00000B65 }, /* GL_FOG_MODE */
- { 10566, 0x00008198 }, /* GL_FOG_OFFSET_SGIX */
- { 10585, 0x00008199 }, /* GL_FOG_OFFSET_VALUE_SGIX */
- { 10610, 0x00000B63 }, /* GL_FOG_START */
- { 10623, 0x00008452 }, /* GL_FRAGMENT_DEPTH */
- { 10641, 0x00008804 }, /* GL_FRAGMENT_PROGRAM_ARB */
- { 10665, 0x00008B30 }, /* GL_FRAGMENT_SHADER */
- { 10684, 0x00008B30 }, /* GL_FRAGMENT_SHADER_ARB */
- { 10707, 0x00008B8B }, /* GL_FRAGMENT_SHADER_DERIVATIVE_HINT */
- { 10742, 0x00008D40 }, /* GL_FRAMEBUFFER */
- { 10757, 0x00008215 }, /* GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE */
- { 10794, 0x00008214 }, /* GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE */
- { 10830, 0x00008210 }, /* GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING */
- { 10871, 0x00008211 }, /* GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE */
- { 10912, 0x00008216 }, /* GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE */
- { 10949, 0x00008213 }, /* GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE */
- { 10986, 0x00008CD1 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME */
- { 11024, 0x00008CD1 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT */
- { 11066, 0x00008CD0 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE */
- { 11104, 0x00008CD0 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT */
- { 11146, 0x00008212 }, /* GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE */
- { 11181, 0x00008217 }, /* GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE */
- { 11220, 0x00008CD4 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT */
- { 11269, 0x00008CD3 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE */
- { 11317, 0x00008CD3 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT */
- { 11369, 0x00008CD4 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER */
- { 11409, 0x00008CD4 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT */
- { 11453, 0x00008CD2 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL */
- { 11493, 0x00008CD2 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT */
- { 11537, 0x00008CA6 }, /* GL_FRAMEBUFFER_BINDING_EXT */
- { 11564, 0x00008CD5 }, /* GL_FRAMEBUFFER_COMPLETE */
- { 11588, 0x00008CD5 }, /* GL_FRAMEBUFFER_COMPLETE_EXT */
- { 11616, 0x00008218 }, /* GL_FRAMEBUFFER_DEFAULT */
- { 11639, 0x00008D40 }, /* GL_FRAMEBUFFER_EXT */
- { 11658, 0x00008CD6 }, /* GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT */
- { 11695, 0x00008CD6 }, /* GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT */
- { 11736, 0x00008CD9 }, /* GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT */
- { 11777, 0x00008CDB }, /* GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT */
- { 11819, 0x00008CD8 }, /* GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT */
- { 11870, 0x00008CDA }, /* GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT */
- { 11908, 0x00008CD7 }, /* GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT */
- { 11953, 0x00008CD7 }, /* GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT */
- { 12002, 0x00008D56 }, /* GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE */
- { 12040, 0x00008CDC }, /* GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT */
- { 12082, 0x00008CDE }, /* GL_FRAMEBUFFER_STATUS_ERROR_EXT */
- { 12114, 0x00008219 }, /* GL_FRAMEBUFFER_UNDEFINED */
- { 12139, 0x00008CDD }, /* GL_FRAMEBUFFER_UNSUPPORTED */
- { 12166, 0x00008CDD }, /* GL_FRAMEBUFFER_UNSUPPORTED_EXT */
- { 12197, 0x00000404 }, /* GL_FRONT */
- { 12206, 0x00000408 }, /* GL_FRONT_AND_BACK */
- { 12224, 0x00000B46 }, /* GL_FRONT_FACE */
- { 12238, 0x00000400 }, /* GL_FRONT_LEFT */
- { 12252, 0x00000401 }, /* GL_FRONT_RIGHT */
- { 12267, 0x00008006 }, /* GL_FUNC_ADD */
- { 12279, 0x00008006 }, /* GL_FUNC_ADD_EXT */
- { 12295, 0x0000800B }, /* GL_FUNC_REVERSE_SUBTRACT */
- { 12320, 0x0000800B }, /* GL_FUNC_REVERSE_SUBTRACT_EXT */
- { 12349, 0x0000800A }, /* GL_FUNC_SUBTRACT */
- { 12366, 0x0000800A }, /* GL_FUNC_SUBTRACT_EXT */
- { 12387, 0x00008191 }, /* GL_GENERATE_MIPMAP */
- { 12406, 0x00008192 }, /* GL_GENERATE_MIPMAP_HINT */
- { 12430, 0x00008192 }, /* GL_GENERATE_MIPMAP_HINT_SGIS */
- { 12459, 0x00008191 }, /* GL_GENERATE_MIPMAP_SGIS */
- { 12483, 0x00000206 }, /* GL_GEQUAL */
- { 12493, 0x00000204 }, /* GL_GREATER */
- { 12504, 0x00001904 }, /* GL_GREEN */
- { 12513, 0x00000D19 }, /* GL_GREEN_BIAS */
- { 12527, 0x00000D53 }, /* GL_GREEN_BITS */
- { 12541, 0x00000D18 }, /* GL_GREEN_SCALE */
- { 12556, 0x00008000 }, /* GL_HINT_BIT */
- { 12568, 0x00008024 }, /* GL_HISTOGRAM */
- { 12581, 0x0000802B }, /* GL_HISTOGRAM_ALPHA_SIZE */
- { 12605, 0x0000802B }, /* GL_HISTOGRAM_ALPHA_SIZE_EXT */
- { 12633, 0x0000802A }, /* GL_HISTOGRAM_BLUE_SIZE */
- { 12656, 0x0000802A }, /* GL_HISTOGRAM_BLUE_SIZE_EXT */
- { 12683, 0x00008024 }, /* GL_HISTOGRAM_EXT */
- { 12700, 0x00008027 }, /* GL_HISTOGRAM_FORMAT */
- { 12720, 0x00008027 }, /* GL_HISTOGRAM_FORMAT_EXT */
- { 12744, 0x00008029 }, /* GL_HISTOGRAM_GREEN_SIZE */
- { 12768, 0x00008029 }, /* GL_HISTOGRAM_GREEN_SIZE_EXT */
- { 12796, 0x0000802C }, /* GL_HISTOGRAM_LUMINANCE_SIZE */
- { 12824, 0x0000802C }, /* GL_HISTOGRAM_LUMINANCE_SIZE_EXT */
- { 12856, 0x00008028 }, /* GL_HISTOGRAM_RED_SIZE */
- { 12878, 0x00008028 }, /* GL_HISTOGRAM_RED_SIZE_EXT */
- { 12904, 0x0000802D }, /* GL_HISTOGRAM_SINK */
- { 12922, 0x0000802D }, /* GL_HISTOGRAM_SINK_EXT */
- { 12944, 0x00008026 }, /* GL_HISTOGRAM_WIDTH */
- { 12963, 0x00008026 }, /* GL_HISTOGRAM_WIDTH_EXT */
- { 12986, 0x0000862A }, /* GL_IDENTITY_NV */
- { 13001, 0x00008150 }, /* GL_IGNORE_BORDER_HP */
- { 13021, 0x00008B9B }, /* GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES */
- { 13061, 0x00008B9A }, /* GL_IMPLEMENTATION_COLOR_READ_TYPE_OES */
- { 13099, 0x00001E02 }, /* GL_INCR */
- { 13107, 0x00008507 }, /* GL_INCR_WRAP */
- { 13120, 0x00008507 }, /* GL_INCR_WRAP_EXT */
- { 13137, 0x00008222 }, /* GL_INDEX */
- { 13146, 0x00008077 }, /* GL_INDEX_ARRAY */
- { 13161, 0x00008899 }, /* GL_INDEX_ARRAY_BUFFER_BINDING */
- { 13191, 0x00008899 }, /* GL_INDEX_ARRAY_BUFFER_BINDING_ARB */
- { 13225, 0x00008091 }, /* GL_INDEX_ARRAY_POINTER */
- { 13248, 0x00008086 }, /* GL_INDEX_ARRAY_STRIDE */
- { 13270, 0x00008085 }, /* GL_INDEX_ARRAY_TYPE */
- { 13290, 0x00000D51 }, /* GL_INDEX_BITS */
- { 13304, 0x00000C20 }, /* GL_INDEX_CLEAR_VALUE */
- { 13325, 0x00000BF1 }, /* GL_INDEX_LOGIC_OP */
- { 13343, 0x00000C30 }, /* GL_INDEX_MODE */
- { 13357, 0x00000D13 }, /* GL_INDEX_OFFSET */
- { 13373, 0x00000D12 }, /* GL_INDEX_SHIFT */
- { 13388, 0x00000C21 }, /* GL_INDEX_WRITEMASK */
- { 13407, 0x00008B84 }, /* GL_INFO_LOG_LENGTH */
- { 13426, 0x00001404 }, /* GL_INT */
- { 13433, 0x00008049 }, /* GL_INTENSITY */
- { 13446, 0x0000804C }, /* GL_INTENSITY12 */
- { 13461, 0x0000804C }, /* GL_INTENSITY12_EXT */
- { 13480, 0x0000804D }, /* GL_INTENSITY16 */
- { 13495, 0x0000804D }, /* GL_INTENSITY16_EXT */
- { 13514, 0x0000804A }, /* GL_INTENSITY4 */
- { 13528, 0x0000804A }, /* GL_INTENSITY4_EXT */
- { 13546, 0x0000804B }, /* GL_INTENSITY8 */
- { 13560, 0x0000804B }, /* GL_INTENSITY8_EXT */
- { 13578, 0x00008049 }, /* GL_INTENSITY_EXT */
- { 13595, 0x00008575 }, /* GL_INTERPOLATE */
- { 13610, 0x00008575 }, /* GL_INTERPOLATE_ARB */
- { 13629, 0x00008575 }, /* GL_INTERPOLATE_EXT */
- { 13648, 0x00008B53 }, /* GL_INT_VEC2 */
- { 13660, 0x00008B53 }, /* GL_INT_VEC2_ARB */
- { 13676, 0x00008B54 }, /* GL_INT_VEC3 */
- { 13688, 0x00008B54 }, /* GL_INT_VEC3_ARB */
- { 13704, 0x00008B55 }, /* GL_INT_VEC4 */
- { 13716, 0x00008B55 }, /* GL_INT_VEC4_ARB */
- { 13732, 0x00000500 }, /* GL_INVALID_ENUM */
- { 13748, 0x00000506 }, /* GL_INVALID_FRAMEBUFFER_OPERATION */
- { 13781, 0x00000506 }, /* GL_INVALID_FRAMEBUFFER_OPERATION_EXT */
- { 13818, 0x00000502 }, /* GL_INVALID_OPERATION */
- { 13839, 0x00000501 }, /* GL_INVALID_VALUE */
- { 13856, 0x0000862B }, /* GL_INVERSE_NV */
- { 13870, 0x0000862D }, /* GL_INVERSE_TRANSPOSE_NV */
- { 13894, 0x0000150A }, /* GL_INVERT */
- { 13904, 0x00001E00 }, /* GL_KEEP */
- { 13912, 0x00008E4E }, /* GL_LAST_VERTEX_CONVENTION_EXT */
- { 13942, 0x00000406 }, /* GL_LEFT */
- { 13950, 0x00000203 }, /* GL_LEQUAL */
- { 13960, 0x00000201 }, /* GL_LESS */
- { 13968, 0x00004000 }, /* GL_LIGHT0 */
- { 13978, 0x00004001 }, /* GL_LIGHT1 */
- { 13988, 0x00004002 }, /* GL_LIGHT2 */
- { 13998, 0x00004003 }, /* GL_LIGHT3 */
- { 14008, 0x00004004 }, /* GL_LIGHT4 */
- { 14018, 0x00004005 }, /* GL_LIGHT5 */
- { 14028, 0x00004006 }, /* GL_LIGHT6 */
- { 14038, 0x00004007 }, /* GL_LIGHT7 */
- { 14048, 0x00000B50 }, /* GL_LIGHTING */
- { 14060, 0x00000040 }, /* GL_LIGHTING_BIT */
- { 14076, 0x00000B53 }, /* GL_LIGHT_MODEL_AMBIENT */
- { 14099, 0x000081F8 }, /* GL_LIGHT_MODEL_COLOR_CONTROL */
- { 14128, 0x000081F8 }, /* GL_LIGHT_MODEL_COLOR_CONTROL_EXT */
- { 14161, 0x00000B51 }, /* GL_LIGHT_MODEL_LOCAL_VIEWER */
- { 14189, 0x00000B52 }, /* GL_LIGHT_MODEL_TWO_SIDE */
- { 14213, 0x00001B01 }, /* GL_LINE */
- { 14221, 0x00002601 }, /* GL_LINEAR */
- { 14231, 0x00001208 }, /* GL_LINEAR_ATTENUATION */
- { 14253, 0x00008170 }, /* GL_LINEAR_CLIPMAP_LINEAR_SGIX */
- { 14283, 0x0000844F }, /* GL_LINEAR_CLIPMAP_NEAREST_SGIX */
- { 14314, 0x00002703 }, /* GL_LINEAR_MIPMAP_LINEAR */
- { 14338, 0x00002701 }, /* GL_LINEAR_MIPMAP_NEAREST */
- { 14363, 0x00000001 }, /* GL_LINES */
- { 14372, 0x00000004 }, /* GL_LINE_BIT */
- { 14384, 0x00000002 }, /* GL_LINE_LOOP */
- { 14397, 0x00000707 }, /* GL_LINE_RESET_TOKEN */
- { 14417, 0x00000B20 }, /* GL_LINE_SMOOTH */
- { 14432, 0x00000C52 }, /* GL_LINE_SMOOTH_HINT */
- { 14452, 0x00000B24 }, /* GL_LINE_STIPPLE */
- { 14468, 0x00000B25 }, /* GL_LINE_STIPPLE_PATTERN */
- { 14492, 0x00000B26 }, /* GL_LINE_STIPPLE_REPEAT */
- { 14515, 0x00000003 }, /* GL_LINE_STRIP */
- { 14529, 0x00000702 }, /* GL_LINE_TOKEN */
- { 14543, 0x00000B21 }, /* GL_LINE_WIDTH */
- { 14557, 0x00000B23 }, /* GL_LINE_WIDTH_GRANULARITY */
- { 14583, 0x00000B22 }, /* GL_LINE_WIDTH_RANGE */
- { 14603, 0x00008B82 }, /* GL_LINK_STATUS */
- { 14618, 0x00000B32 }, /* GL_LIST_BASE */
- { 14631, 0x00020000 }, /* GL_LIST_BIT */
- { 14643, 0x00000B33 }, /* GL_LIST_INDEX */
- { 14657, 0x00000B30 }, /* GL_LIST_MODE */
- { 14670, 0x00000101 }, /* GL_LOAD */
- { 14678, 0x00000BF1 }, /* GL_LOGIC_OP */
- { 14690, 0x00000BF0 }, /* GL_LOGIC_OP_MODE */
- { 14707, 0x00008CA1 }, /* GL_LOWER_LEFT */
- { 14721, 0x00001909 }, /* GL_LUMINANCE */
- { 14734, 0x00008041 }, /* GL_LUMINANCE12 */
- { 14749, 0x00008047 }, /* GL_LUMINANCE12_ALPHA12 */
- { 14772, 0x00008047 }, /* GL_LUMINANCE12_ALPHA12_EXT */
- { 14799, 0x00008046 }, /* GL_LUMINANCE12_ALPHA4 */
- { 14821, 0x00008046 }, /* GL_LUMINANCE12_ALPHA4_EXT */
- { 14847, 0x00008041 }, /* GL_LUMINANCE12_EXT */
- { 14866, 0x00008042 }, /* GL_LUMINANCE16 */
- { 14881, 0x00008048 }, /* GL_LUMINANCE16_ALPHA16 */
- { 14904, 0x00008048 }, /* GL_LUMINANCE16_ALPHA16_EXT */
- { 14931, 0x00008042 }, /* GL_LUMINANCE16_EXT */
- { 14950, 0x0000803F }, /* GL_LUMINANCE4 */
- { 14964, 0x00008043 }, /* GL_LUMINANCE4_ALPHA4 */
- { 14985, 0x00008043 }, /* GL_LUMINANCE4_ALPHA4_EXT */
- { 15010, 0x0000803F }, /* GL_LUMINANCE4_EXT */
- { 15028, 0x00008044 }, /* GL_LUMINANCE6_ALPHA2 */
- { 15049, 0x00008044 }, /* GL_LUMINANCE6_ALPHA2_EXT */
- { 15074, 0x00008040 }, /* GL_LUMINANCE8 */
- { 15088, 0x00008045 }, /* GL_LUMINANCE8_ALPHA8 */
- { 15109, 0x00008045 }, /* GL_LUMINANCE8_ALPHA8_EXT */
- { 15134, 0x00008040 }, /* GL_LUMINANCE8_EXT */
- { 15152, 0x0000190A }, /* GL_LUMINANCE_ALPHA */
- { 15171, 0x00000D90 }, /* GL_MAP1_COLOR_4 */
- { 15187, 0x00000DD0 }, /* GL_MAP1_GRID_DOMAIN */
- { 15207, 0x00000DD1 }, /* GL_MAP1_GRID_SEGMENTS */
- { 15229, 0x00000D91 }, /* GL_MAP1_INDEX */
- { 15243, 0x00000D92 }, /* GL_MAP1_NORMAL */
- { 15258, 0x00000D93 }, /* GL_MAP1_TEXTURE_COORD_1 */
- { 15282, 0x00000D94 }, /* GL_MAP1_TEXTURE_COORD_2 */
- { 15306, 0x00000D95 }, /* GL_MAP1_TEXTURE_COORD_3 */
- { 15330, 0x00000D96 }, /* GL_MAP1_TEXTURE_COORD_4 */
- { 15354, 0x00000D97 }, /* GL_MAP1_VERTEX_3 */
- { 15371, 0x00000D98 }, /* GL_MAP1_VERTEX_4 */
- { 15388, 0x00008660 }, /* GL_MAP1_VERTEX_ATTRIB0_4_NV */
- { 15416, 0x0000866A }, /* GL_MAP1_VERTEX_ATTRIB10_4_NV */
- { 15445, 0x0000866B }, /* GL_MAP1_VERTEX_ATTRIB11_4_NV */
- { 15474, 0x0000866C }, /* GL_MAP1_VERTEX_ATTRIB12_4_NV */
- { 15503, 0x0000866D }, /* GL_MAP1_VERTEX_ATTRIB13_4_NV */
- { 15532, 0x0000866E }, /* GL_MAP1_VERTEX_ATTRIB14_4_NV */
- { 15561, 0x0000866F }, /* GL_MAP1_VERTEX_ATTRIB15_4_NV */
- { 15590, 0x00008661 }, /* GL_MAP1_VERTEX_ATTRIB1_4_NV */
- { 15618, 0x00008662 }, /* GL_MAP1_VERTEX_ATTRIB2_4_NV */
- { 15646, 0x00008663 }, /* GL_MAP1_VERTEX_ATTRIB3_4_NV */
- { 15674, 0x00008664 }, /* GL_MAP1_VERTEX_ATTRIB4_4_NV */
- { 15702, 0x00008665 }, /* GL_MAP1_VERTEX_ATTRIB5_4_NV */
- { 15730, 0x00008666 }, /* GL_MAP1_VERTEX_ATTRIB6_4_NV */
- { 15758, 0x00008667 }, /* GL_MAP1_VERTEX_ATTRIB7_4_NV */
- { 15786, 0x00008668 }, /* GL_MAP1_VERTEX_ATTRIB8_4_NV */
- { 15814, 0x00008669 }, /* GL_MAP1_VERTEX_ATTRIB9_4_NV */
- { 15842, 0x00000DB0 }, /* GL_MAP2_COLOR_4 */
- { 15858, 0x00000DD2 }, /* GL_MAP2_GRID_DOMAIN */
- { 15878, 0x00000DD3 }, /* GL_MAP2_GRID_SEGMENTS */
- { 15900, 0x00000DB1 }, /* GL_MAP2_INDEX */
- { 15914, 0x00000DB2 }, /* GL_MAP2_NORMAL */
- { 15929, 0x00000DB3 }, /* GL_MAP2_TEXTURE_COORD_1 */
- { 15953, 0x00000DB4 }, /* GL_MAP2_TEXTURE_COORD_2 */
- { 15977, 0x00000DB5 }, /* GL_MAP2_TEXTURE_COORD_3 */
- { 16001, 0x00000DB6 }, /* GL_MAP2_TEXTURE_COORD_4 */
- { 16025, 0x00000DB7 }, /* GL_MAP2_VERTEX_3 */
- { 16042, 0x00000DB8 }, /* GL_MAP2_VERTEX_4 */
- { 16059, 0x00008670 }, /* GL_MAP2_VERTEX_ATTRIB0_4_NV */
- { 16087, 0x0000867A }, /* GL_MAP2_VERTEX_ATTRIB10_4_NV */
- { 16116, 0x0000867B }, /* GL_MAP2_VERTEX_ATTRIB11_4_NV */
- { 16145, 0x0000867C }, /* GL_MAP2_VERTEX_ATTRIB12_4_NV */
- { 16174, 0x0000867D }, /* GL_MAP2_VERTEX_ATTRIB13_4_NV */
- { 16203, 0x0000867E }, /* GL_MAP2_VERTEX_ATTRIB14_4_NV */
- { 16232, 0x0000867F }, /* GL_MAP2_VERTEX_ATTRIB15_4_NV */
- { 16261, 0x00008671 }, /* GL_MAP2_VERTEX_ATTRIB1_4_NV */
- { 16289, 0x00008672 }, /* GL_MAP2_VERTEX_ATTRIB2_4_NV */
- { 16317, 0x00008673 }, /* GL_MAP2_VERTEX_ATTRIB3_4_NV */
- { 16345, 0x00008674 }, /* GL_MAP2_VERTEX_ATTRIB4_4_NV */
- { 16373, 0x00008675 }, /* GL_MAP2_VERTEX_ATTRIB5_4_NV */
- { 16401, 0x00008676 }, /* GL_MAP2_VERTEX_ATTRIB6_4_NV */
- { 16429, 0x00008677 }, /* GL_MAP2_VERTEX_ATTRIB7_4_NV */
- { 16457, 0x00008678 }, /* GL_MAP2_VERTEX_ATTRIB8_4_NV */
- { 16485, 0x00008679 }, /* GL_MAP2_VERTEX_ATTRIB9_4_NV */
- { 16513, 0x00000D10 }, /* GL_MAP_COLOR */
- { 16526, 0x00000010 }, /* GL_MAP_FLUSH_EXPLICIT_BIT */
- { 16552, 0x00000008 }, /* GL_MAP_INVALIDATE_BUFFER_BIT */
- { 16581, 0x00000004 }, /* GL_MAP_INVALIDATE_RANGE_BIT */
- { 16609, 0x00000001 }, /* GL_MAP_READ_BIT */
- { 16625, 0x00000D11 }, /* GL_MAP_STENCIL */
- { 16640, 0x00000020 }, /* GL_MAP_UNSYNCHRONIZED_BIT */
- { 16666, 0x00000002 }, /* GL_MAP_WRITE_BIT */
- { 16683, 0x000088C0 }, /* GL_MATRIX0_ARB */
- { 16698, 0x00008630 }, /* GL_MATRIX0_NV */
- { 16712, 0x000088CA }, /* GL_MATRIX10_ARB */
- { 16728, 0x000088CB }, /* GL_MATRIX11_ARB */
- { 16744, 0x000088CC }, /* GL_MATRIX12_ARB */
- { 16760, 0x000088CD }, /* GL_MATRIX13_ARB */
- { 16776, 0x000088CE }, /* GL_MATRIX14_ARB */
- { 16792, 0x000088CF }, /* GL_MATRIX15_ARB */
- { 16808, 0x000088D0 }, /* GL_MATRIX16_ARB */
- { 16824, 0x000088D1 }, /* GL_MATRIX17_ARB */
- { 16840, 0x000088D2 }, /* GL_MATRIX18_ARB */
- { 16856, 0x000088D3 }, /* GL_MATRIX19_ARB */
- { 16872, 0x000088C1 }, /* GL_MATRIX1_ARB */
- { 16887, 0x00008631 }, /* GL_MATRIX1_NV */
- { 16901, 0x000088D4 }, /* GL_MATRIX20_ARB */
- { 16917, 0x000088D5 }, /* GL_MATRIX21_ARB */
- { 16933, 0x000088D6 }, /* GL_MATRIX22_ARB */
- { 16949, 0x000088D7 }, /* GL_MATRIX23_ARB */
- { 16965, 0x000088D8 }, /* GL_MATRIX24_ARB */
- { 16981, 0x000088D9 }, /* GL_MATRIX25_ARB */
- { 16997, 0x000088DA }, /* GL_MATRIX26_ARB */
- { 17013, 0x000088DB }, /* GL_MATRIX27_ARB */
- { 17029, 0x000088DC }, /* GL_MATRIX28_ARB */
- { 17045, 0x000088DD }, /* GL_MATRIX29_ARB */
- { 17061, 0x000088C2 }, /* GL_MATRIX2_ARB */
- { 17076, 0x00008632 }, /* GL_MATRIX2_NV */
- { 17090, 0x000088DE }, /* GL_MATRIX30_ARB */
- { 17106, 0x000088DF }, /* GL_MATRIX31_ARB */
- { 17122, 0x000088C3 }, /* GL_MATRIX3_ARB */
- { 17137, 0x00008633 }, /* GL_MATRIX3_NV */
- { 17151, 0x000088C4 }, /* GL_MATRIX4_ARB */
- { 17166, 0x00008634 }, /* GL_MATRIX4_NV */
- { 17180, 0x000088C5 }, /* GL_MATRIX5_ARB */
- { 17195, 0x00008635 }, /* GL_MATRIX5_NV */
- { 17209, 0x000088C6 }, /* GL_MATRIX6_ARB */
- { 17224, 0x00008636 }, /* GL_MATRIX6_NV */
- { 17238, 0x000088C7 }, /* GL_MATRIX7_ARB */
- { 17253, 0x00008637 }, /* GL_MATRIX7_NV */
- { 17267, 0x000088C8 }, /* GL_MATRIX8_ARB */
- { 17282, 0x000088C9 }, /* GL_MATRIX9_ARB */
- { 17297, 0x00008844 }, /* GL_MATRIX_INDEX_ARRAY_ARB */
- { 17323, 0x00008849 }, /* GL_MATRIX_INDEX_ARRAY_POINTER_ARB */
- { 17357, 0x00008846 }, /* GL_MATRIX_INDEX_ARRAY_SIZE_ARB */
- { 17388, 0x00008848 }, /* GL_MATRIX_INDEX_ARRAY_STRIDE_ARB */
- { 17421, 0x00008847 }, /* GL_MATRIX_INDEX_ARRAY_TYPE_ARB */
- { 17452, 0x00000BA0 }, /* GL_MATRIX_MODE */
- { 17467, 0x00008840 }, /* GL_MATRIX_PALETTE_ARB */
- { 17489, 0x00008008 }, /* GL_MAX */
- { 17496, 0x00008073 }, /* GL_MAX_3D_TEXTURE_SIZE */
- { 17519, 0x000088FF }, /* GL_MAX_ARRAY_TEXTURE_LAYERS_EXT */
- { 17551, 0x00000D35 }, /* GL_MAX_ATTRIB_STACK_DEPTH */
- { 17577, 0x00000D3B }, /* GL_MAX_CLIENT_ATTRIB_STACK_DEPTH */
- { 17610, 0x00008177 }, /* GL_MAX_CLIPMAP_DEPTH_SGIX */
- { 17636, 0x00008178 }, /* GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX */
- { 17670, 0x00000D32 }, /* GL_MAX_CLIP_PLANES */
- { 17689, 0x00008CDF }, /* GL_MAX_COLOR_ATTACHMENTS_EXT */
- { 17718, 0x000080B3 }, /* GL_MAX_COLOR_MATRIX_STACK_DEPTH */
- { 17750, 0x000080B3 }, /* GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI */
- { 17786, 0x00008B4D }, /* GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS */
- { 17822, 0x00008B4D }, /* GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB */
- { 17862, 0x0000801B }, /* GL_MAX_CONVOLUTION_HEIGHT */
- { 17888, 0x0000801B }, /* GL_MAX_CONVOLUTION_HEIGHT_EXT */
- { 17918, 0x0000801A }, /* GL_MAX_CONVOLUTION_WIDTH */
- { 17943, 0x0000801A }, /* GL_MAX_CONVOLUTION_WIDTH_EXT */
- { 17972, 0x0000851C }, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE */
- { 18001, 0x0000851C }, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB */
- { 18034, 0x00008824 }, /* GL_MAX_DRAW_BUFFERS */
- { 18054, 0x00008824 }, /* GL_MAX_DRAW_BUFFERS_ARB */
- { 18078, 0x00008824 }, /* GL_MAX_DRAW_BUFFERS_ATI */
- { 18102, 0x000080E9 }, /* GL_MAX_ELEMENTS_INDICES */
- { 18126, 0x000080E8 }, /* GL_MAX_ELEMENTS_VERTICES */
- { 18151, 0x00000D30 }, /* GL_MAX_EVAL_ORDER */
- { 18169, 0x00008008 }, /* GL_MAX_EXT */
- { 18180, 0x00008B49 }, /* GL_MAX_FRAGMENT_UNIFORM_COMPONENTS */
- { 18215, 0x00008B49 }, /* GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB */
- { 18254, 0x00000D31 }, /* GL_MAX_LIGHTS */
- { 18268, 0x00000B31 }, /* GL_MAX_LIST_NESTING */
- { 18288, 0x00008841 }, /* GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB */
- { 18326, 0x00000D36 }, /* GL_MAX_MODELVIEW_STACK_DEPTH */
- { 18355, 0x00000D37 }, /* GL_MAX_NAME_STACK_DEPTH */
- { 18379, 0x00008842 }, /* GL_MAX_PALETTE_MATRICES_ARB */
- { 18407, 0x00000D34 }, /* GL_MAX_PIXEL_MAP_TABLE */
- { 18430, 0x000088B1 }, /* GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB */
- { 18467, 0x0000880B }, /* GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB */
- { 18503, 0x000088AD }, /* GL_MAX_PROGRAM_ATTRIBS_ARB */
- { 18530, 0x000088F5 }, /* GL_MAX_PROGRAM_CALL_DEPTH_NV */
- { 18559, 0x000088B5 }, /* GL_MAX_PROGRAM_ENV_PARAMETERS_ARB */
- { 18593, 0x000088F4 }, /* GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV */
- { 18629, 0x000088F6 }, /* GL_MAX_PROGRAM_IF_DEPTH_NV */
- { 18656, 0x000088A1 }, /* GL_MAX_PROGRAM_INSTRUCTIONS_ARB */
- { 18688, 0x000088B4 }, /* GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB */
- { 18724, 0x000088F8 }, /* GL_MAX_PROGRAM_LOOP_COUNT_NV */
- { 18753, 0x000088F7 }, /* GL_MAX_PROGRAM_LOOP_DEPTH_NV */
- { 18782, 0x0000862F }, /* GL_MAX_PROGRAM_MATRICES_ARB */
- { 18810, 0x0000862E }, /* GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB */
- { 18848, 0x000088B3 }, /* GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */
- { 18892, 0x0000880E }, /* GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */
- { 18935, 0x000088AF }, /* GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB */
- { 18969, 0x000088A3 }, /* GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB */
- { 19008, 0x000088AB }, /* GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB */
- { 19045, 0x000088A7 }, /* GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB */
- { 19083, 0x00008810 }, /* GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */
- { 19126, 0x0000880F }, /* GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */
- { 19169, 0x000088A9 }, /* GL_MAX_PROGRAM_PARAMETERS_ARB */
- { 19199, 0x000088A5 }, /* GL_MAX_PROGRAM_TEMPORARIES_ARB */
- { 19230, 0x0000880D }, /* GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB */
- { 19266, 0x0000880C }, /* GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB */
- { 19302, 0x00000D38 }, /* GL_MAX_PROJECTION_STACK_DEPTH */
- { 19332, 0x000084F8 }, /* GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB */
- { 19366, 0x000084F8 }, /* GL_MAX_RECTANGLE_TEXTURE_SIZE_NV */
- { 19399, 0x000084E8 }, /* GL_MAX_RENDERBUFFER_SIZE_EXT */
- { 19428, 0x00008D57 }, /* GL_MAX_SAMPLES */
- { 19443, 0x00009111 }, /* GL_MAX_SERVER_WAIT_TIMEOUT */
- { 19470, 0x00008504 }, /* GL_MAX_SHININESS_NV */
- { 19490, 0x00008505 }, /* GL_MAX_SPOT_EXPONENT_NV */
- { 19514, 0x00008871 }, /* GL_MAX_TEXTURE_COORDS */
- { 19536, 0x00008871 }, /* GL_MAX_TEXTURE_COORDS_ARB */
- { 19562, 0x00008872 }, /* GL_MAX_TEXTURE_IMAGE_UNITS */
- { 19589, 0x00008872 }, /* GL_MAX_TEXTURE_IMAGE_UNITS_ARB */
- { 19620, 0x000084FD }, /* GL_MAX_TEXTURE_LOD_BIAS */
- { 19644, 0x000084FF }, /* GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT */
- { 19678, 0x00000D33 }, /* GL_MAX_TEXTURE_SIZE */
- { 19698, 0x00000D39 }, /* GL_MAX_TEXTURE_STACK_DEPTH */
- { 19725, 0x000084E2 }, /* GL_MAX_TEXTURE_UNITS */
- { 19746, 0x000084E2 }, /* GL_MAX_TEXTURE_UNITS_ARB */
- { 19771, 0x0000862F }, /* GL_MAX_TRACK_MATRICES_NV */
- { 19796, 0x0000862E }, /* GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV */
- { 19831, 0x00008B4B }, /* GL_MAX_VARYING_FLOATS */
- { 19853, 0x00008B4B }, /* GL_MAX_VARYING_FLOATS_ARB */
- { 19879, 0x00008869 }, /* GL_MAX_VERTEX_ATTRIBS */
- { 19901, 0x00008869 }, /* GL_MAX_VERTEX_ATTRIBS_ARB */
- { 19927, 0x00008B4C }, /* GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS */
- { 19961, 0x00008B4C }, /* GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB */
- { 19999, 0x00008B4A }, /* GL_MAX_VERTEX_UNIFORM_COMPONENTS */
- { 20032, 0x00008B4A }, /* GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB */
- { 20069, 0x000086A4 }, /* GL_MAX_VERTEX_UNITS_ARB */
- { 20093, 0x00000D3A }, /* GL_MAX_VIEWPORT_DIMS */
- { 20114, 0x00008007 }, /* GL_MIN */
- { 20121, 0x0000802E }, /* GL_MINMAX */
- { 20131, 0x0000802E }, /* GL_MINMAX_EXT */
- { 20145, 0x0000802F }, /* GL_MINMAX_FORMAT */
- { 20162, 0x0000802F }, /* GL_MINMAX_FORMAT_EXT */
- { 20183, 0x00008030 }, /* GL_MINMAX_SINK */
- { 20198, 0x00008030 }, /* GL_MINMAX_SINK_EXT */
- { 20217, 0x00008007 }, /* GL_MIN_EXT */
- { 20228, 0x00008370 }, /* GL_MIRRORED_REPEAT */
- { 20247, 0x00008370 }, /* GL_MIRRORED_REPEAT_ARB */
- { 20270, 0x00008370 }, /* GL_MIRRORED_REPEAT_IBM */
- { 20293, 0x00008742 }, /* GL_MIRROR_CLAMP_ATI */
- { 20313, 0x00008742 }, /* GL_MIRROR_CLAMP_EXT */
- { 20333, 0x00008912 }, /* GL_MIRROR_CLAMP_TO_BORDER_EXT */
- { 20363, 0x00008743 }, /* GL_MIRROR_CLAMP_TO_EDGE_ATI */
- { 20391, 0x00008743 }, /* GL_MIRROR_CLAMP_TO_EDGE_EXT */
- { 20419, 0x00001700 }, /* GL_MODELVIEW */
- { 20432, 0x00001700 }, /* GL_MODELVIEW0_ARB */
- { 20450, 0x0000872A }, /* GL_MODELVIEW10_ARB */
- { 20469, 0x0000872B }, /* GL_MODELVIEW11_ARB */
- { 20488, 0x0000872C }, /* GL_MODELVIEW12_ARB */
- { 20507, 0x0000872D }, /* GL_MODELVIEW13_ARB */
- { 20526, 0x0000872E }, /* GL_MODELVIEW14_ARB */
- { 20545, 0x0000872F }, /* GL_MODELVIEW15_ARB */
- { 20564, 0x00008730 }, /* GL_MODELVIEW16_ARB */
- { 20583, 0x00008731 }, /* GL_MODELVIEW17_ARB */
- { 20602, 0x00008732 }, /* GL_MODELVIEW18_ARB */
- { 20621, 0x00008733 }, /* GL_MODELVIEW19_ARB */
- { 20640, 0x0000850A }, /* GL_MODELVIEW1_ARB */
- { 20658, 0x00008734 }, /* GL_MODELVIEW20_ARB */
- { 20677, 0x00008735 }, /* GL_MODELVIEW21_ARB */
- { 20696, 0x00008736 }, /* GL_MODELVIEW22_ARB */
- { 20715, 0x00008737 }, /* GL_MODELVIEW23_ARB */
- { 20734, 0x00008738 }, /* GL_MODELVIEW24_ARB */
- { 20753, 0x00008739 }, /* GL_MODELVIEW25_ARB */
- { 20772, 0x0000873A }, /* GL_MODELVIEW26_ARB */
- { 20791, 0x0000873B }, /* GL_MODELVIEW27_ARB */
- { 20810, 0x0000873C }, /* GL_MODELVIEW28_ARB */
- { 20829, 0x0000873D }, /* GL_MODELVIEW29_ARB */
- { 20848, 0x00008722 }, /* GL_MODELVIEW2_ARB */
- { 20866, 0x0000873E }, /* GL_MODELVIEW30_ARB */
- { 20885, 0x0000873F }, /* GL_MODELVIEW31_ARB */
- { 20904, 0x00008723 }, /* GL_MODELVIEW3_ARB */
- { 20922, 0x00008724 }, /* GL_MODELVIEW4_ARB */
- { 20940, 0x00008725 }, /* GL_MODELVIEW5_ARB */
- { 20958, 0x00008726 }, /* GL_MODELVIEW6_ARB */
- { 20976, 0x00008727 }, /* GL_MODELVIEW7_ARB */
- { 20994, 0x00008728 }, /* GL_MODELVIEW8_ARB */
- { 21012, 0x00008729 }, /* GL_MODELVIEW9_ARB */
- { 21030, 0x00000BA6 }, /* GL_MODELVIEW_MATRIX */
- { 21050, 0x00008629 }, /* GL_MODELVIEW_PROJECTION_NV */
- { 21077, 0x00000BA3 }, /* GL_MODELVIEW_STACK_DEPTH */
- { 21102, 0x00002100 }, /* GL_MODULATE */
- { 21114, 0x00008744 }, /* GL_MODULATE_ADD_ATI */
- { 21134, 0x00008745 }, /* GL_MODULATE_SIGNED_ADD_ATI */
- { 21161, 0x00008746 }, /* GL_MODULATE_SUBTRACT_ATI */
- { 21186, 0x00000103 }, /* GL_MULT */
- { 21194, 0x0000809D }, /* GL_MULTISAMPLE */
- { 21209, 0x000086B2 }, /* GL_MULTISAMPLE_3DFX */
- { 21229, 0x0000809D }, /* GL_MULTISAMPLE_ARB */
- { 21248, 0x20000000 }, /* GL_MULTISAMPLE_BIT */
- { 21267, 0x20000000 }, /* GL_MULTISAMPLE_BIT_3DFX */
- { 21291, 0x20000000 }, /* GL_MULTISAMPLE_BIT_ARB */
- { 21314, 0x00008534 }, /* GL_MULTISAMPLE_FILTER_HINT_NV */
- { 21344, 0x00002A25 }, /* GL_N3F_V3F */
- { 21355, 0x00000D70 }, /* GL_NAME_STACK_DEPTH */
- { 21375, 0x0000150E }, /* GL_NAND */
- { 21383, 0x00002600 }, /* GL_NEAREST */
- { 21394, 0x0000844E }, /* GL_NEAREST_CLIPMAP_LINEAR_SGIX */
- { 21425, 0x0000844D }, /* GL_NEAREST_CLIPMAP_NEAREST_SGIX */
- { 21457, 0x00002702 }, /* GL_NEAREST_MIPMAP_LINEAR */
- { 21482, 0x00002700 }, /* GL_NEAREST_MIPMAP_NEAREST */
- { 21508, 0x00000200 }, /* GL_NEVER */
- { 21517, 0x00001102 }, /* GL_NICEST */
- { 21527, 0x00000000 }, /* GL_NONE */
- { 21535, 0x00001505 }, /* GL_NOOP */
- { 21543, 0x00001508 }, /* GL_NOR */
- { 21550, 0x00000BA1 }, /* GL_NORMALIZE */
- { 21563, 0x00008075 }, /* GL_NORMAL_ARRAY */
- { 21579, 0x00008897 }, /* GL_NORMAL_ARRAY_BUFFER_BINDING */
- { 21610, 0x00008897 }, /* GL_NORMAL_ARRAY_BUFFER_BINDING_ARB */
- { 21645, 0x0000808F }, /* GL_NORMAL_ARRAY_POINTER */
- { 21669, 0x0000807F }, /* GL_NORMAL_ARRAY_STRIDE */
- { 21692, 0x0000807E }, /* GL_NORMAL_ARRAY_TYPE */
- { 21713, 0x00008511 }, /* GL_NORMAL_MAP */
- { 21727, 0x00008511 }, /* GL_NORMAL_MAP_ARB */
- { 21745, 0x00008511 }, /* GL_NORMAL_MAP_NV */
- { 21762, 0x00000205 }, /* GL_NOTEQUAL */
- { 21774, 0x00000000 }, /* GL_NO_ERROR */
- { 21786, 0x000086A2 }, /* GL_NUM_COMPRESSED_TEXTURE_FORMATS */
- { 21820, 0x000086A2 }, /* GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB */
- { 21858, 0x00008B89 }, /* GL_OBJECT_ACTIVE_ATTRIBUTES_ARB */
- { 21890, 0x00008B8A }, /* GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB */
- { 21932, 0x00008B86 }, /* GL_OBJECT_ACTIVE_UNIFORMS_ARB */
- { 21962, 0x00008B87 }, /* GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB */
- { 22002, 0x00008B85 }, /* GL_OBJECT_ATTACHED_OBJECTS_ARB */
- { 22033, 0x00008B81 }, /* GL_OBJECT_COMPILE_STATUS_ARB */
- { 22062, 0x00008B80 }, /* GL_OBJECT_DELETE_STATUS_ARB */
- { 22090, 0x00008B84 }, /* GL_OBJECT_INFO_LOG_LENGTH_ARB */
- { 22120, 0x00002401 }, /* GL_OBJECT_LINEAR */
- { 22137, 0x00008B82 }, /* GL_OBJECT_LINK_STATUS_ARB */
- { 22163, 0x00002501 }, /* GL_OBJECT_PLANE */
- { 22179, 0x00008B88 }, /* GL_OBJECT_SHADER_SOURCE_LENGTH_ARB */
- { 22214, 0x00008B4F }, /* GL_OBJECT_SUBTYPE_ARB */
- { 22236, 0x00009112 }, /* GL_OBJECT_TYPE */
- { 22251, 0x00008B4E }, /* GL_OBJECT_TYPE_ARB */
- { 22270, 0x00008B83 }, /* GL_OBJECT_VALIDATE_STATUS_ARB */
- { 22300, 0x00008165 }, /* GL_OCCLUSION_TEST_HP */
- { 22321, 0x00008166 }, /* GL_OCCLUSION_TEST_RESULT_HP */
- { 22349, 0x00000001 }, /* GL_ONE */
- { 22356, 0x00008004 }, /* GL_ONE_MINUS_CONSTANT_ALPHA */
- { 22384, 0x00008004 }, /* GL_ONE_MINUS_CONSTANT_ALPHA_EXT */
- { 22416, 0x00008002 }, /* GL_ONE_MINUS_CONSTANT_COLOR */
- { 22444, 0x00008002 }, /* GL_ONE_MINUS_CONSTANT_COLOR_EXT */
- { 22476, 0x00000305 }, /* GL_ONE_MINUS_DST_ALPHA */
- { 22499, 0x00000307 }, /* GL_ONE_MINUS_DST_COLOR */
- { 22522, 0x00000303 }, /* GL_ONE_MINUS_SRC_ALPHA */
- { 22545, 0x00000301 }, /* GL_ONE_MINUS_SRC_COLOR */
- { 22568, 0x00008598 }, /* GL_OPERAND0_ALPHA */
- { 22586, 0x00008598 }, /* GL_OPERAND0_ALPHA_ARB */
- { 22608, 0x00008598 }, /* GL_OPERAND0_ALPHA_EXT */
- { 22630, 0x00008590 }, /* GL_OPERAND0_RGB */
- { 22646, 0x00008590 }, /* GL_OPERAND0_RGB_ARB */
- { 22666, 0x00008590 }, /* GL_OPERAND0_RGB_EXT */
- { 22686, 0x00008599 }, /* GL_OPERAND1_ALPHA */
- { 22704, 0x00008599 }, /* GL_OPERAND1_ALPHA_ARB */
- { 22726, 0x00008599 }, /* GL_OPERAND1_ALPHA_EXT */
- { 22748, 0x00008591 }, /* GL_OPERAND1_RGB */
- { 22764, 0x00008591 }, /* GL_OPERAND1_RGB_ARB */
- { 22784, 0x00008591 }, /* GL_OPERAND1_RGB_EXT */
- { 22804, 0x0000859A }, /* GL_OPERAND2_ALPHA */
- { 22822, 0x0000859A }, /* GL_OPERAND2_ALPHA_ARB */
- { 22844, 0x0000859A }, /* GL_OPERAND2_ALPHA_EXT */
- { 22866, 0x00008592 }, /* GL_OPERAND2_RGB */
- { 22882, 0x00008592 }, /* GL_OPERAND2_RGB_ARB */
- { 22902, 0x00008592 }, /* GL_OPERAND2_RGB_EXT */
- { 22922, 0x0000859B }, /* GL_OPERAND3_ALPHA_NV */
- { 22943, 0x00008593 }, /* GL_OPERAND3_RGB_NV */
- { 22962, 0x00001507 }, /* GL_OR */
- { 22968, 0x00000A01 }, /* GL_ORDER */
- { 22977, 0x0000150D }, /* GL_OR_INVERTED */
- { 22992, 0x0000150B }, /* GL_OR_REVERSE */
- { 23006, 0x00000505 }, /* GL_OUT_OF_MEMORY */
- { 23023, 0x00000D05 }, /* GL_PACK_ALIGNMENT */
- { 23041, 0x0000806C }, /* GL_PACK_IMAGE_HEIGHT */
- { 23062, 0x00008758 }, /* GL_PACK_INVERT_MESA */
- { 23082, 0x00000D01 }, /* GL_PACK_LSB_FIRST */
- { 23100, 0x00000D02 }, /* GL_PACK_ROW_LENGTH */
- { 23119, 0x0000806B }, /* GL_PACK_SKIP_IMAGES */
- { 23139, 0x00000D04 }, /* GL_PACK_SKIP_PIXELS */
- { 23159, 0x00000D03 }, /* GL_PACK_SKIP_ROWS */
- { 23177, 0x00000D00 }, /* GL_PACK_SWAP_BYTES */
- { 23196, 0x00008B92 }, /* GL_PALETTE4_R5_G6_B5_OES */
- { 23221, 0x00008B94 }, /* GL_PALETTE4_RGB5_A1_OES */
- { 23245, 0x00008B90 }, /* GL_PALETTE4_RGB8_OES */
- { 23266, 0x00008B93 }, /* GL_PALETTE4_RGBA4_OES */
- { 23288, 0x00008B91 }, /* GL_PALETTE4_RGBA8_OES */
- { 23310, 0x00008B97 }, /* GL_PALETTE8_R5_G6_B5_OES */
- { 23335, 0x00008B99 }, /* GL_PALETTE8_RGB5_A1_OES */
- { 23359, 0x00008B95 }, /* GL_PALETTE8_RGB8_OES */
- { 23380, 0x00008B98 }, /* GL_PALETTE8_RGBA4_OES */
- { 23402, 0x00008B96 }, /* GL_PALETTE8_RGBA8_OES */
- { 23424, 0x00000700 }, /* GL_PASS_THROUGH_TOKEN */
- { 23446, 0x00000C50 }, /* GL_PERSPECTIVE_CORRECTION_HINT */
- { 23477, 0x00000C79 }, /* GL_PIXEL_MAP_A_TO_A */
- { 23497, 0x00000CB9 }, /* GL_PIXEL_MAP_A_TO_A_SIZE */
- { 23522, 0x00000C78 }, /* GL_PIXEL_MAP_B_TO_B */
- { 23542, 0x00000CB8 }, /* GL_PIXEL_MAP_B_TO_B_SIZE */
- { 23567, 0x00000C77 }, /* GL_PIXEL_MAP_G_TO_G */
- { 23587, 0x00000CB7 }, /* GL_PIXEL_MAP_G_TO_G_SIZE */
- { 23612, 0x00000C75 }, /* GL_PIXEL_MAP_I_TO_A */
- { 23632, 0x00000CB5 }, /* GL_PIXEL_MAP_I_TO_A_SIZE */
- { 23657, 0x00000C74 }, /* GL_PIXEL_MAP_I_TO_B */
- { 23677, 0x00000CB4 }, /* GL_PIXEL_MAP_I_TO_B_SIZE */
- { 23702, 0x00000C73 }, /* GL_PIXEL_MAP_I_TO_G */
- { 23722, 0x00000CB3 }, /* GL_PIXEL_MAP_I_TO_G_SIZE */
- { 23747, 0x00000C70 }, /* GL_PIXEL_MAP_I_TO_I */
- { 23767, 0x00000CB0 }, /* GL_PIXEL_MAP_I_TO_I_SIZE */
- { 23792, 0x00000C72 }, /* GL_PIXEL_MAP_I_TO_R */
- { 23812, 0x00000CB2 }, /* GL_PIXEL_MAP_I_TO_R_SIZE */
- { 23837, 0x00000C76 }, /* GL_PIXEL_MAP_R_TO_R */
- { 23857, 0x00000CB6 }, /* GL_PIXEL_MAP_R_TO_R_SIZE */
- { 23882, 0x00000C71 }, /* GL_PIXEL_MAP_S_TO_S */
- { 23902, 0x00000CB1 }, /* GL_PIXEL_MAP_S_TO_S_SIZE */
- { 23927, 0x00000020 }, /* GL_PIXEL_MODE_BIT */
- { 23945, 0x000088EB }, /* GL_PIXEL_PACK_BUFFER */
- { 23966, 0x000088ED }, /* GL_PIXEL_PACK_BUFFER_BINDING */
- { 23995, 0x000088ED }, /* GL_PIXEL_PACK_BUFFER_BINDING_EXT */
- { 24028, 0x000088EB }, /* GL_PIXEL_PACK_BUFFER_EXT */
- { 24053, 0x000088EC }, /* GL_PIXEL_UNPACK_BUFFER */
- { 24076, 0x000088EF }, /* GL_PIXEL_UNPACK_BUFFER_BINDING */
- { 24107, 0x000088EF }, /* GL_PIXEL_UNPACK_BUFFER_BINDING_EXT */
- { 24142, 0x000088EC }, /* GL_PIXEL_UNPACK_BUFFER_EXT */
- { 24169, 0x00001B00 }, /* GL_POINT */
- { 24178, 0x00000000 }, /* GL_POINTS */
- { 24188, 0x00000002 }, /* GL_POINT_BIT */
- { 24201, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION */
- { 24231, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_ARB */
- { 24265, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_EXT */
- { 24299, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_SGIS */
- { 24334, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE */
- { 24363, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_ARB */
- { 24396, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_EXT */
- { 24429, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_SGIS */
- { 24463, 0x00000B11 }, /* GL_POINT_SIZE */
- { 24477, 0x00000B13 }, /* GL_POINT_SIZE_GRANULARITY */
- { 24503, 0x00008127 }, /* GL_POINT_SIZE_MAX */
- { 24521, 0x00008127 }, /* GL_POINT_SIZE_MAX_ARB */
- { 24543, 0x00008127 }, /* GL_POINT_SIZE_MAX_EXT */
- { 24565, 0x00008127 }, /* GL_POINT_SIZE_MAX_SGIS */
- { 24588, 0x00008126 }, /* GL_POINT_SIZE_MIN */
- { 24606, 0x00008126 }, /* GL_POINT_SIZE_MIN_ARB */
- { 24628, 0x00008126 }, /* GL_POINT_SIZE_MIN_EXT */
- { 24650, 0x00008126 }, /* GL_POINT_SIZE_MIN_SGIS */
- { 24673, 0x00000B12 }, /* GL_POINT_SIZE_RANGE */
- { 24693, 0x00000B10 }, /* GL_POINT_SMOOTH */
- { 24709, 0x00000C51 }, /* GL_POINT_SMOOTH_HINT */
- { 24730, 0x00008861 }, /* GL_POINT_SPRITE */
- { 24746, 0x00008861 }, /* GL_POINT_SPRITE_ARB */
- { 24766, 0x00008CA0 }, /* GL_POINT_SPRITE_COORD_ORIGIN */
- { 24795, 0x00008861 }, /* GL_POINT_SPRITE_NV */
- { 24814, 0x00008863 }, /* GL_POINT_SPRITE_R_MODE_NV */
- { 24840, 0x00000701 }, /* GL_POINT_TOKEN */
- { 24855, 0x00000009 }, /* GL_POLYGON */
- { 24866, 0x00000008 }, /* GL_POLYGON_BIT */
- { 24881, 0x00000B40 }, /* GL_POLYGON_MODE */
- { 24897, 0x00008039 }, /* GL_POLYGON_OFFSET_BIAS */
- { 24920, 0x00008038 }, /* GL_POLYGON_OFFSET_FACTOR */
- { 24945, 0x00008037 }, /* GL_POLYGON_OFFSET_FILL */
- { 24968, 0x00002A02 }, /* GL_POLYGON_OFFSET_LINE */
- { 24991, 0x00002A01 }, /* GL_POLYGON_OFFSET_POINT */
- { 25015, 0x00002A00 }, /* GL_POLYGON_OFFSET_UNITS */
- { 25039, 0x00000B41 }, /* GL_POLYGON_SMOOTH */
- { 25057, 0x00000C53 }, /* GL_POLYGON_SMOOTH_HINT */
- { 25080, 0x00000B42 }, /* GL_POLYGON_STIPPLE */
- { 25099, 0x00000010 }, /* GL_POLYGON_STIPPLE_BIT */
- { 25122, 0x00000703 }, /* GL_POLYGON_TOKEN */
- { 25139, 0x00001203 }, /* GL_POSITION */
- { 25151, 0x000080BB }, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS */
- { 25183, 0x000080BB }, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI */
- { 25219, 0x000080B7 }, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE */
- { 25252, 0x000080B7 }, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI */
- { 25289, 0x000080BA }, /* GL_POST_COLOR_MATRIX_BLUE_BIAS */
- { 25320, 0x000080BA }, /* GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI */
- { 25355, 0x000080B6 }, /* GL_POST_COLOR_MATRIX_BLUE_SCALE */
- { 25387, 0x000080B6 }, /* GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI */
- { 25423, 0x000080D2 }, /* GL_POST_COLOR_MATRIX_COLOR_TABLE */
- { 25456, 0x000080B9 }, /* GL_POST_COLOR_MATRIX_GREEN_BIAS */
- { 25488, 0x000080B9 }, /* GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI */
- { 25524, 0x000080B5 }, /* GL_POST_COLOR_MATRIX_GREEN_SCALE */
- { 25557, 0x000080B5 }, /* GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI */
- { 25594, 0x000080B8 }, /* GL_POST_COLOR_MATRIX_RED_BIAS */
- { 25624, 0x000080B8 }, /* GL_POST_COLOR_MATRIX_RED_BIAS_SGI */
- { 25658, 0x000080B4 }, /* GL_POST_COLOR_MATRIX_RED_SCALE */
- { 25689, 0x000080B4 }, /* GL_POST_COLOR_MATRIX_RED_SCALE_SGI */
- { 25724, 0x00008023 }, /* GL_POST_CONVOLUTION_ALPHA_BIAS */
- { 25755, 0x00008023 }, /* GL_POST_CONVOLUTION_ALPHA_BIAS_EXT */
- { 25790, 0x0000801F }, /* GL_POST_CONVOLUTION_ALPHA_SCALE */
- { 25822, 0x0000801F }, /* GL_POST_CONVOLUTION_ALPHA_SCALE_EXT */
- { 25858, 0x00008022 }, /* GL_POST_CONVOLUTION_BLUE_BIAS */
- { 25888, 0x00008022 }, /* GL_POST_CONVOLUTION_BLUE_BIAS_EXT */
- { 25922, 0x0000801E }, /* GL_POST_CONVOLUTION_BLUE_SCALE */
- { 25953, 0x0000801E }, /* GL_POST_CONVOLUTION_BLUE_SCALE_EXT */
- { 25988, 0x000080D1 }, /* GL_POST_CONVOLUTION_COLOR_TABLE */
- { 26020, 0x00008021 }, /* GL_POST_CONVOLUTION_GREEN_BIAS */
- { 26051, 0x00008021 }, /* GL_POST_CONVOLUTION_GREEN_BIAS_EXT */
- { 26086, 0x0000801D }, /* GL_POST_CONVOLUTION_GREEN_SCALE */
- { 26118, 0x0000801D }, /* GL_POST_CONVOLUTION_GREEN_SCALE_EXT */
- { 26154, 0x00008020 }, /* GL_POST_CONVOLUTION_RED_BIAS */
- { 26183, 0x00008020 }, /* GL_POST_CONVOLUTION_RED_BIAS_EXT */
- { 26216, 0x0000801C }, /* GL_POST_CONVOLUTION_RED_SCALE */
- { 26246, 0x0000801C }, /* GL_POST_CONVOLUTION_RED_SCALE_EXT */
- { 26280, 0x0000817B }, /* GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX */
- { 26319, 0x00008179 }, /* GL_POST_TEXTURE_FILTER_BIAS_SGIX */
- { 26352, 0x0000817C }, /* GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX */
- { 26392, 0x0000817A }, /* GL_POST_TEXTURE_FILTER_SCALE_SGIX */
- { 26426, 0x00008578 }, /* GL_PREVIOUS */
- { 26438, 0x00008578 }, /* GL_PREVIOUS_ARB */
- { 26454, 0x00008578 }, /* GL_PREVIOUS_EXT */
- { 26470, 0x00008577 }, /* GL_PRIMARY_COLOR */
- { 26487, 0x00008577 }, /* GL_PRIMARY_COLOR_ARB */
- { 26508, 0x00008577 }, /* GL_PRIMARY_COLOR_EXT */
- { 26529, 0x000088B0 }, /* GL_PROGRAM_ADDRESS_REGISTERS_ARB */
- { 26562, 0x00008805 }, /* GL_PROGRAM_ALU_INSTRUCTIONS_ARB */
- { 26594, 0x000088AC }, /* GL_PROGRAM_ATTRIBS_ARB */
- { 26617, 0x00008677 }, /* GL_PROGRAM_BINDING_ARB */
- { 26640, 0x0000864B }, /* GL_PROGRAM_ERROR_POSITION_ARB */
- { 26670, 0x0000864B }, /* GL_PROGRAM_ERROR_POSITION_NV */
- { 26699, 0x00008874 }, /* GL_PROGRAM_ERROR_STRING_ARB */
- { 26727, 0x00008876 }, /* GL_PROGRAM_FORMAT_ARB */
- { 26749, 0x00008875 }, /* GL_PROGRAM_FORMAT_ASCII_ARB */
- { 26777, 0x000088A0 }, /* GL_PROGRAM_INSTRUCTIONS_ARB */
- { 26805, 0x00008627 }, /* GL_PROGRAM_LENGTH_ARB */
- { 26827, 0x00008627 }, /* GL_PROGRAM_LENGTH_NV */
- { 26848, 0x000088B2 }, /* GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */
- { 26888, 0x00008808 }, /* GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */
- { 26927, 0x000088AE }, /* GL_PROGRAM_NATIVE_ATTRIBS_ARB */
- { 26957, 0x000088A2 }, /* GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB */
- { 26992, 0x000088AA }, /* GL_PROGRAM_NATIVE_PARAMETERS_ARB */
- { 27025, 0x000088A6 }, /* GL_PROGRAM_NATIVE_TEMPORARIES_ARB */
- { 27059, 0x0000880A }, /* GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */
- { 27098, 0x00008809 }, /* GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */
- { 27137, 0x00008B40 }, /* GL_PROGRAM_OBJECT_ARB */
- { 27159, 0x000088A8 }, /* GL_PROGRAM_PARAMETERS_ARB */
- { 27185, 0x00008644 }, /* GL_PROGRAM_PARAMETER_NV */
- { 27209, 0x00008647 }, /* GL_PROGRAM_RESIDENT_NV */
- { 27232, 0x00008628 }, /* GL_PROGRAM_STRING_ARB */
- { 27254, 0x00008628 }, /* GL_PROGRAM_STRING_NV */
- { 27275, 0x00008646 }, /* GL_PROGRAM_TARGET_NV */
- { 27296, 0x000088A4 }, /* GL_PROGRAM_TEMPORARIES_ARB */
- { 27323, 0x00008807 }, /* GL_PROGRAM_TEX_INDIRECTIONS_ARB */
- { 27355, 0x00008806 }, /* GL_PROGRAM_TEX_INSTRUCTIONS_ARB */
- { 27387, 0x000088B6 }, /* GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB */
- { 27422, 0x00001701 }, /* GL_PROJECTION */
- { 27436, 0x00000BA7 }, /* GL_PROJECTION_MATRIX */
- { 27457, 0x00000BA4 }, /* GL_PROJECTION_STACK_DEPTH */
- { 27483, 0x00008E4F }, /* GL_PROVOKING_VERTEX_EXT */
- { 27507, 0x000080D3 }, /* GL_PROXY_COLOR_TABLE */
- { 27528, 0x00008025 }, /* GL_PROXY_HISTOGRAM */
- { 27547, 0x00008025 }, /* GL_PROXY_HISTOGRAM_EXT */
- { 27570, 0x000080D5 }, /* GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE */
- { 27609, 0x000080D4 }, /* GL_PROXY_POST_CONVOLUTION_COLOR_TABLE */
- { 27647, 0x00008063 }, /* GL_PROXY_TEXTURE_1D */
- { 27667, 0x00008C19 }, /* GL_PROXY_TEXTURE_1D_ARRAY_EXT */
- { 27697, 0x00008063 }, /* GL_PROXY_TEXTURE_1D_EXT */
- { 27721, 0x00008064 }, /* GL_PROXY_TEXTURE_2D */
- { 27741, 0x00008C1B }, /* GL_PROXY_TEXTURE_2D_ARRAY_EXT */
- { 27771, 0x00008064 }, /* GL_PROXY_TEXTURE_2D_EXT */
- { 27795, 0x00008070 }, /* GL_PROXY_TEXTURE_3D */
- { 27815, 0x000080BD }, /* GL_PROXY_TEXTURE_COLOR_TABLE_SGI */
- { 27848, 0x0000851B }, /* GL_PROXY_TEXTURE_CUBE_MAP */
- { 27874, 0x0000851B }, /* GL_PROXY_TEXTURE_CUBE_MAP_ARB */
- { 27904, 0x000084F7 }, /* GL_PROXY_TEXTURE_RECTANGLE_ARB */
- { 27935, 0x000084F7 }, /* GL_PROXY_TEXTURE_RECTANGLE_NV */
- { 27965, 0x00002003 }, /* GL_Q */
- { 27970, 0x00001209 }, /* GL_QUADRATIC_ATTENUATION */
- { 27995, 0x00000007 }, /* GL_QUADS */
- { 28004, 0x00008E4C }, /* GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT */
- { 28052, 0x00008614 }, /* GL_QUAD_MESH_SUN */
- { 28069, 0x00000008 }, /* GL_QUAD_STRIP */
- { 28083, 0x00008864 }, /* GL_QUERY_COUNTER_BITS */
- { 28105, 0x00008864 }, /* GL_QUERY_COUNTER_BITS_ARB */
- { 28131, 0x00008866 }, /* GL_QUERY_RESULT */
- { 28147, 0x00008866 }, /* GL_QUERY_RESULT_ARB */
- { 28167, 0x00008867 }, /* GL_QUERY_RESULT_AVAILABLE */
- { 28193, 0x00008867 }, /* GL_QUERY_RESULT_AVAILABLE_ARB */
- { 28223, 0x00002002 }, /* GL_R */
- { 28228, 0x00002A10 }, /* GL_R3_G3_B2 */
- { 28240, 0x00019262 }, /* GL_RASTER_POSITION_UNCLIPPED_IBM */
- { 28273, 0x00000C02 }, /* GL_READ_BUFFER */
- { 28288, 0x00008CA8 }, /* GL_READ_FRAMEBUFFER */
- { 28308, 0x00008CAA }, /* GL_READ_FRAMEBUFFER_BINDING_EXT */
- { 28340, 0x00008CA8 }, /* GL_READ_FRAMEBUFFER_EXT */
- { 28364, 0x000088B8 }, /* GL_READ_ONLY */
- { 28377, 0x000088B8 }, /* GL_READ_ONLY_ARB */
- { 28394, 0x000088BA }, /* GL_READ_WRITE */
- { 28408, 0x000088BA }, /* GL_READ_WRITE_ARB */
- { 28426, 0x00001903 }, /* GL_RED */
- { 28433, 0x00008016 }, /* GL_REDUCE */
- { 28443, 0x00008016 }, /* GL_REDUCE_EXT */
- { 28457, 0x00000D15 }, /* GL_RED_BIAS */
- { 28469, 0x00000D52 }, /* GL_RED_BITS */
- { 28481, 0x00000D14 }, /* GL_RED_SCALE */
- { 28494, 0x00008512 }, /* GL_REFLECTION_MAP */
- { 28512, 0x00008512 }, /* GL_REFLECTION_MAP_ARB */
- { 28534, 0x00008512 }, /* GL_REFLECTION_MAP_NV */
- { 28555, 0x00001C00 }, /* GL_RENDER */
- { 28565, 0x00008D41 }, /* GL_RENDERBUFFER */
- { 28581, 0x00008D53 }, /* GL_RENDERBUFFER_ALPHA_SIZE */
- { 28608, 0x00008CA7 }, /* GL_RENDERBUFFER_BINDING_EXT */
- { 28636, 0x00008D52 }, /* GL_RENDERBUFFER_BLUE_SIZE */
- { 28662, 0x00008D54 }, /* GL_RENDERBUFFER_DEPTH_SIZE */
- { 28689, 0x00008D41 }, /* GL_RENDERBUFFER_EXT */
- { 28709, 0x00008D51 }, /* GL_RENDERBUFFER_GREEN_SIZE */
- { 28736, 0x00008D43 }, /* GL_RENDERBUFFER_HEIGHT */
- { 28759, 0x00008D43 }, /* GL_RENDERBUFFER_HEIGHT_EXT */
- { 28786, 0x00008D44 }, /* GL_RENDERBUFFER_INTERNAL_FORMAT */
- { 28818, 0x00008D44 }, /* GL_RENDERBUFFER_INTERNAL_FORMAT_EXT */
- { 28854, 0x00008D50 }, /* GL_RENDERBUFFER_RED_SIZE */
- { 28879, 0x00008CAB }, /* GL_RENDERBUFFER_SAMPLES */
- { 28903, 0x00008D55 }, /* GL_RENDERBUFFER_STENCIL_SIZE */
- { 28932, 0x00008D42 }, /* GL_RENDERBUFFER_WIDTH */
- { 28954, 0x00008D42 }, /* GL_RENDERBUFFER_WIDTH_EXT */
- { 28980, 0x00001F01 }, /* GL_RENDERER */
- { 28992, 0x00000C40 }, /* GL_RENDER_MODE */
- { 29007, 0x00002901 }, /* GL_REPEAT */
- { 29017, 0x00001E01 }, /* GL_REPLACE */
- { 29028, 0x00008062 }, /* GL_REPLACE_EXT */
- { 29043, 0x00008153 }, /* GL_REPLICATE_BORDER_HP */
- { 29066, 0x0000803A }, /* GL_RESCALE_NORMAL */
- { 29084, 0x0000803A }, /* GL_RESCALE_NORMAL_EXT */
- { 29106, 0x00000102 }, /* GL_RETURN */
- { 29116, 0x00001907 }, /* GL_RGB */
- { 29123, 0x00008052 }, /* GL_RGB10 */
- { 29132, 0x00008059 }, /* GL_RGB10_A2 */
- { 29144, 0x00008059 }, /* GL_RGB10_A2_EXT */
- { 29160, 0x00008052 }, /* GL_RGB10_EXT */
- { 29173, 0x00008053 }, /* GL_RGB12 */
- { 29182, 0x00008053 }, /* GL_RGB12_EXT */
- { 29195, 0x00008054 }, /* GL_RGB16 */
- { 29204, 0x00008054 }, /* GL_RGB16_EXT */
- { 29217, 0x0000804E }, /* GL_RGB2_EXT */
- { 29229, 0x0000804F }, /* GL_RGB4 */
- { 29237, 0x0000804F }, /* GL_RGB4_EXT */
- { 29249, 0x000083A1 }, /* GL_RGB4_S3TC */
- { 29262, 0x00008050 }, /* GL_RGB5 */
- { 29270, 0x00008057 }, /* GL_RGB5_A1 */
- { 29281, 0x00008057 }, /* GL_RGB5_A1_EXT */
- { 29296, 0x00008050 }, /* GL_RGB5_EXT */
- { 29308, 0x00008051 }, /* GL_RGB8 */
- { 29316, 0x00008051 }, /* GL_RGB8_EXT */
- { 29328, 0x00001908 }, /* GL_RGBA */
- { 29336, 0x0000805A }, /* GL_RGBA12 */
- { 29346, 0x0000805A }, /* GL_RGBA12_EXT */
- { 29360, 0x0000805B }, /* GL_RGBA16 */
- { 29370, 0x0000805B }, /* GL_RGBA16_EXT */
- { 29384, 0x00008055 }, /* GL_RGBA2 */
- { 29393, 0x00008055 }, /* GL_RGBA2_EXT */
- { 29406, 0x00008056 }, /* GL_RGBA4 */
- { 29415, 0x000083A5 }, /* GL_RGBA4_DXT5_S3TC */
- { 29434, 0x00008056 }, /* GL_RGBA4_EXT */
- { 29447, 0x000083A3 }, /* GL_RGBA4_S3TC */
- { 29461, 0x00008058 }, /* GL_RGBA8 */
- { 29470, 0x00008058 }, /* GL_RGBA8_EXT */
- { 29483, 0x00008F97 }, /* GL_RGBA8_SNORM */
- { 29498, 0x000083A4 }, /* GL_RGBA_DXT5_S3TC */
- { 29516, 0x00000C31 }, /* GL_RGBA_MODE */
- { 29529, 0x000083A2 }, /* GL_RGBA_S3TC */
- { 29542, 0x00008F93 }, /* GL_RGBA_SNORM */
- { 29556, 0x000083A0 }, /* GL_RGB_S3TC */
- { 29568, 0x00008573 }, /* GL_RGB_SCALE */
- { 29581, 0x00008573 }, /* GL_RGB_SCALE_ARB */
- { 29598, 0x00008573 }, /* GL_RGB_SCALE_EXT */
- { 29615, 0x00000407 }, /* GL_RIGHT */
- { 29624, 0x00002000 }, /* GL_S */
- { 29629, 0x00008B5D }, /* GL_SAMPLER_1D */
- { 29643, 0x00008B61 }, /* GL_SAMPLER_1D_SHADOW */
- { 29664, 0x00008B5E }, /* GL_SAMPLER_2D */
- { 29678, 0x00008B62 }, /* GL_SAMPLER_2D_SHADOW */
- { 29699, 0x00008B5F }, /* GL_SAMPLER_3D */
- { 29713, 0x00008B60 }, /* GL_SAMPLER_CUBE */
- { 29729, 0x000080A9 }, /* GL_SAMPLES */
- { 29740, 0x000086B4 }, /* GL_SAMPLES_3DFX */
- { 29756, 0x000080A9 }, /* GL_SAMPLES_ARB */
- { 29771, 0x00008914 }, /* GL_SAMPLES_PASSED */
- { 29789, 0x00008914 }, /* GL_SAMPLES_PASSED_ARB */
- { 29811, 0x0000809E }, /* GL_SAMPLE_ALPHA_TO_COVERAGE */
- { 29839, 0x0000809E }, /* GL_SAMPLE_ALPHA_TO_COVERAGE_ARB */
- { 29871, 0x0000809F }, /* GL_SAMPLE_ALPHA_TO_ONE */
- { 29894, 0x0000809F }, /* GL_SAMPLE_ALPHA_TO_ONE_ARB */
- { 29921, 0x000080A8 }, /* GL_SAMPLE_BUFFERS */
- { 29939, 0x000086B3 }, /* GL_SAMPLE_BUFFERS_3DFX */
- { 29962, 0x000080A8 }, /* GL_SAMPLE_BUFFERS_ARB */
- { 29984, 0x000080A0 }, /* GL_SAMPLE_COVERAGE */
- { 30003, 0x000080A0 }, /* GL_SAMPLE_COVERAGE_ARB */
- { 30026, 0x000080AB }, /* GL_SAMPLE_COVERAGE_INVERT */
- { 30052, 0x000080AB }, /* GL_SAMPLE_COVERAGE_INVERT_ARB */
- { 30082, 0x000080AA }, /* GL_SAMPLE_COVERAGE_VALUE */
- { 30107, 0x000080AA }, /* GL_SAMPLE_COVERAGE_VALUE_ARB */
- { 30136, 0x00080000 }, /* GL_SCISSOR_BIT */
- { 30151, 0x00000C10 }, /* GL_SCISSOR_BOX */
- { 30166, 0x00000C11 }, /* GL_SCISSOR_TEST */
- { 30182, 0x0000845E }, /* GL_SECONDARY_COLOR_ARRAY */
- { 30207, 0x0000889C }, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING */
- { 30247, 0x0000889C }, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB */
- { 30291, 0x0000845D }, /* GL_SECONDARY_COLOR_ARRAY_POINTER */
- { 30324, 0x0000845A }, /* GL_SECONDARY_COLOR_ARRAY_SIZE */
- { 30354, 0x0000845C }, /* GL_SECONDARY_COLOR_ARRAY_STRIDE */
- { 30386, 0x0000845B }, /* GL_SECONDARY_COLOR_ARRAY_TYPE */
- { 30416, 0x00001C02 }, /* GL_SELECT */
- { 30426, 0x00000DF3 }, /* GL_SELECTION_BUFFER_POINTER */
- { 30454, 0x00000DF4 }, /* GL_SELECTION_BUFFER_SIZE */
- { 30479, 0x00008012 }, /* GL_SEPARABLE_2D */
- { 30495, 0x000081FA }, /* GL_SEPARATE_SPECULAR_COLOR */
- { 30522, 0x000081FA }, /* GL_SEPARATE_SPECULAR_COLOR_EXT */
- { 30553, 0x0000150F }, /* GL_SET */
- { 30560, 0x00008B48 }, /* GL_SHADER_OBJECT_ARB */
- { 30581, 0x00008B88 }, /* GL_SHADER_SOURCE_LENGTH */
- { 30605, 0x00008B4F }, /* GL_SHADER_TYPE */
- { 30620, 0x00000B54 }, /* GL_SHADE_MODEL */
- { 30635, 0x00008B8C }, /* GL_SHADING_LANGUAGE_VERSION */
- { 30663, 0x000080BF }, /* GL_SHADOW_AMBIENT_SGIX */
- { 30686, 0x000081FB }, /* GL_SHARED_TEXTURE_PALETTE_EXT */
- { 30716, 0x00001601 }, /* GL_SHININESS */
- { 30729, 0x00001402 }, /* GL_SHORT */
- { 30738, 0x00009119 }, /* GL_SIGNALED */
- { 30750, 0x00008F9C }, /* GL_SIGNED_NORMALIZED */
- { 30771, 0x000081F9 }, /* GL_SINGLE_COLOR */
- { 30787, 0x000081F9 }, /* GL_SINGLE_COLOR_EXT */
- { 30807, 0x000085CC }, /* GL_SLICE_ACCUM_SUN */
- { 30826, 0x00008C46 }, /* GL_SLUMINANCE */
- { 30840, 0x00008C47 }, /* GL_SLUMINANCE8 */
- { 30855, 0x00008C45 }, /* GL_SLUMINANCE8_ALPHA8 */
- { 30877, 0x00008C44 }, /* GL_SLUMINANCE_ALPHA */
- { 30897, 0x00001D01 }, /* GL_SMOOTH */
- { 30907, 0x00000B23 }, /* GL_SMOOTH_LINE_WIDTH_GRANULARITY */
- { 30940, 0x00000B22 }, /* GL_SMOOTH_LINE_WIDTH_RANGE */
- { 30967, 0x00000B13 }, /* GL_SMOOTH_POINT_SIZE_GRANULARITY */
- { 31000, 0x00000B12 }, /* GL_SMOOTH_POINT_SIZE_RANGE */
- { 31027, 0x00008588 }, /* GL_SOURCE0_ALPHA */
- { 31044, 0x00008588 }, /* GL_SOURCE0_ALPHA_ARB */
- { 31065, 0x00008588 }, /* GL_SOURCE0_ALPHA_EXT */
- { 31086, 0x00008580 }, /* GL_SOURCE0_RGB */
- { 31101, 0x00008580 }, /* GL_SOURCE0_RGB_ARB */
- { 31120, 0x00008580 }, /* GL_SOURCE0_RGB_EXT */
- { 31139, 0x00008589 }, /* GL_SOURCE1_ALPHA */
- { 31156, 0x00008589 }, /* GL_SOURCE1_ALPHA_ARB */
- { 31177, 0x00008589 }, /* GL_SOURCE1_ALPHA_EXT */
- { 31198, 0x00008581 }, /* GL_SOURCE1_RGB */
- { 31213, 0x00008581 }, /* GL_SOURCE1_RGB_ARB */
- { 31232, 0x00008581 }, /* GL_SOURCE1_RGB_EXT */
- { 31251, 0x0000858A }, /* GL_SOURCE2_ALPHA */
- { 31268, 0x0000858A }, /* GL_SOURCE2_ALPHA_ARB */
- { 31289, 0x0000858A }, /* GL_SOURCE2_ALPHA_EXT */
- { 31310, 0x00008582 }, /* GL_SOURCE2_RGB */
- { 31325, 0x00008582 }, /* GL_SOURCE2_RGB_ARB */
- { 31344, 0x00008582 }, /* GL_SOURCE2_RGB_EXT */
- { 31363, 0x0000858B }, /* GL_SOURCE3_ALPHA_NV */
- { 31383, 0x00008583 }, /* GL_SOURCE3_RGB_NV */
- { 31401, 0x00001202 }, /* GL_SPECULAR */
- { 31413, 0x00002402 }, /* GL_SPHERE_MAP */
- { 31427, 0x00001206 }, /* GL_SPOT_CUTOFF */
- { 31442, 0x00001204 }, /* GL_SPOT_DIRECTION */
- { 31460, 0x00001205 }, /* GL_SPOT_EXPONENT */
- { 31477, 0x00008588 }, /* GL_SRC0_ALPHA */
- { 31491, 0x00008580 }, /* GL_SRC0_RGB */
- { 31503, 0x00008589 }, /* GL_SRC1_ALPHA */
- { 31517, 0x00008581 }, /* GL_SRC1_RGB */
- { 31529, 0x0000858A }, /* GL_SRC2_ALPHA */
- { 31543, 0x00008582 }, /* GL_SRC2_RGB */
- { 31555, 0x00000302 }, /* GL_SRC_ALPHA */
- { 31568, 0x00000308 }, /* GL_SRC_ALPHA_SATURATE */
- { 31590, 0x00000300 }, /* GL_SRC_COLOR */
- { 31603, 0x00008C40 }, /* GL_SRGB */
- { 31611, 0x00008C41 }, /* GL_SRGB8 */
- { 31620, 0x00008C43 }, /* GL_SRGB8_ALPHA8 */
- { 31636, 0x00008C42 }, /* GL_SRGB_ALPHA */
- { 31650, 0x00000503 }, /* GL_STACK_OVERFLOW */
- { 31668, 0x00000504 }, /* GL_STACK_UNDERFLOW */
- { 31687, 0x000088E6 }, /* GL_STATIC_COPY */
- { 31702, 0x000088E6 }, /* GL_STATIC_COPY_ARB */
- { 31721, 0x000088E4 }, /* GL_STATIC_DRAW */
- { 31736, 0x000088E4 }, /* GL_STATIC_DRAW_ARB */
- { 31755, 0x000088E5 }, /* GL_STATIC_READ */
- { 31770, 0x000088E5 }, /* GL_STATIC_READ_ARB */
- { 31789, 0x00001802 }, /* GL_STENCIL */
- { 31800, 0x00008D20 }, /* GL_STENCIL_ATTACHMENT */
- { 31822, 0x00008D20 }, /* GL_STENCIL_ATTACHMENT_EXT */
- { 31848, 0x00008801 }, /* GL_STENCIL_BACK_FAIL */
- { 31869, 0x00008801 }, /* GL_STENCIL_BACK_FAIL_ATI */
- { 31894, 0x00008800 }, /* GL_STENCIL_BACK_FUNC */
- { 31915, 0x00008800 }, /* GL_STENCIL_BACK_FUNC_ATI */
- { 31940, 0x00008802 }, /* GL_STENCIL_BACK_PASS_DEPTH_FAIL */
- { 31972, 0x00008802 }, /* GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI */
- { 32008, 0x00008803 }, /* GL_STENCIL_BACK_PASS_DEPTH_PASS */
- { 32040, 0x00008803 }, /* GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI */
- { 32076, 0x00008CA3 }, /* GL_STENCIL_BACK_REF */
- { 32096, 0x00008CA4 }, /* GL_STENCIL_BACK_VALUE_MASK */
- { 32123, 0x00008CA5 }, /* GL_STENCIL_BACK_WRITEMASK */
- { 32149, 0x00000D57 }, /* GL_STENCIL_BITS */
- { 32165, 0x00000400 }, /* GL_STENCIL_BUFFER_BIT */
- { 32187, 0x00000B91 }, /* GL_STENCIL_CLEAR_VALUE */
- { 32210, 0x00000B94 }, /* GL_STENCIL_FAIL */
- { 32226, 0x00000B92 }, /* GL_STENCIL_FUNC */
- { 32242, 0x00001901 }, /* GL_STENCIL_INDEX */
- { 32259, 0x00008D49 }, /* GL_STENCIL_INDEX16_EXT */
- { 32282, 0x00008D46 }, /* GL_STENCIL_INDEX1_EXT */
- { 32304, 0x00008D47 }, /* GL_STENCIL_INDEX4_EXT */
- { 32326, 0x00008D48 }, /* GL_STENCIL_INDEX8_EXT */
- { 32348, 0x00008D45 }, /* GL_STENCIL_INDEX_EXT */
- { 32369, 0x00000B95 }, /* GL_STENCIL_PASS_DEPTH_FAIL */
- { 32396, 0x00000B96 }, /* GL_STENCIL_PASS_DEPTH_PASS */
- { 32423, 0x00000B97 }, /* GL_STENCIL_REF */
- { 32438, 0x00000B90 }, /* GL_STENCIL_TEST */
- { 32454, 0x00008910 }, /* GL_STENCIL_TEST_TWO_SIDE_EXT */
- { 32483, 0x00000B93 }, /* GL_STENCIL_VALUE_MASK */
- { 32505, 0x00000B98 }, /* GL_STENCIL_WRITEMASK */
- { 32526, 0x00000C33 }, /* GL_STEREO */
- { 32536, 0x000085BE }, /* GL_STORAGE_CACHED_APPLE */
- { 32560, 0x000085BD }, /* GL_STORAGE_PRIVATE_APPLE */
- { 32585, 0x000085BF }, /* GL_STORAGE_SHARED_APPLE */
- { 32609, 0x000088E2 }, /* GL_STREAM_COPY */
- { 32624, 0x000088E2 }, /* GL_STREAM_COPY_ARB */
- { 32643, 0x000088E0 }, /* GL_STREAM_DRAW */
- { 32658, 0x000088E0 }, /* GL_STREAM_DRAW_ARB */
- { 32677, 0x000088E1 }, /* GL_STREAM_READ */
- { 32692, 0x000088E1 }, /* GL_STREAM_READ_ARB */
- { 32711, 0x00000D50 }, /* GL_SUBPIXEL_BITS */
- { 32728, 0x000084E7 }, /* GL_SUBTRACT */
- { 32740, 0x000084E7 }, /* GL_SUBTRACT_ARB */
- { 32756, 0x00009113 }, /* GL_SYNC_CONDITION */
- { 32774, 0x00009116 }, /* GL_SYNC_FENCE */
- { 32788, 0x00009115 }, /* GL_SYNC_FLAGS */
- { 32802, 0x00000001 }, /* GL_SYNC_FLUSH_COMMANDS_BIT */
- { 32829, 0x00009117 }, /* GL_SYNC_GPU_COMMANDS_COMPLETE */
- { 32859, 0x00009114 }, /* GL_SYNC_STATUS */
- { 32874, 0x00002001 }, /* GL_T */
- { 32879, 0x00002A2A }, /* GL_T2F_C3F_V3F */
- { 32894, 0x00002A2C }, /* GL_T2F_C4F_N3F_V3F */
- { 32913, 0x00002A29 }, /* GL_T2F_C4UB_V3F */
- { 32929, 0x00002A2B }, /* GL_T2F_N3F_V3F */
- { 32944, 0x00002A27 }, /* GL_T2F_V3F */
- { 32955, 0x00002A2D }, /* GL_T4F_C4F_N3F_V4F */
- { 32974, 0x00002A28 }, /* GL_T4F_V4F */
- { 32985, 0x00008031 }, /* GL_TABLE_TOO_LARGE_EXT */
- { 33008, 0x00001702 }, /* GL_TEXTURE */
- { 33019, 0x000084C0 }, /* GL_TEXTURE0 */
- { 33031, 0x000084C0 }, /* GL_TEXTURE0_ARB */
- { 33047, 0x000084C1 }, /* GL_TEXTURE1 */
- { 33059, 0x000084CA }, /* GL_TEXTURE10 */
- { 33072, 0x000084CA }, /* GL_TEXTURE10_ARB */
- { 33089, 0x000084CB }, /* GL_TEXTURE11 */
- { 33102, 0x000084CB }, /* GL_TEXTURE11_ARB */
- { 33119, 0x000084CC }, /* GL_TEXTURE12 */
- { 33132, 0x000084CC }, /* GL_TEXTURE12_ARB */
- { 33149, 0x000084CD }, /* GL_TEXTURE13 */
- { 33162, 0x000084CD }, /* GL_TEXTURE13_ARB */
- { 33179, 0x000084CE }, /* GL_TEXTURE14 */
- { 33192, 0x000084CE }, /* GL_TEXTURE14_ARB */
- { 33209, 0x000084CF }, /* GL_TEXTURE15 */
- { 33222, 0x000084CF }, /* GL_TEXTURE15_ARB */
- { 33239, 0x000084D0 }, /* GL_TEXTURE16 */
- { 33252, 0x000084D0 }, /* GL_TEXTURE16_ARB */
- { 33269, 0x000084D1 }, /* GL_TEXTURE17 */
- { 33282, 0x000084D1 }, /* GL_TEXTURE17_ARB */
- { 33299, 0x000084D2 }, /* GL_TEXTURE18 */
- { 33312, 0x000084D2 }, /* GL_TEXTURE18_ARB */
- { 33329, 0x000084D3 }, /* GL_TEXTURE19 */
- { 33342, 0x000084D3 }, /* GL_TEXTURE19_ARB */
- { 33359, 0x000084C1 }, /* GL_TEXTURE1_ARB */
- { 33375, 0x000084C2 }, /* GL_TEXTURE2 */
- { 33387, 0x000084D4 }, /* GL_TEXTURE20 */
- { 33400, 0x000084D4 }, /* GL_TEXTURE20_ARB */
- { 33417, 0x000084D5 }, /* GL_TEXTURE21 */
- { 33430, 0x000084D5 }, /* GL_TEXTURE21_ARB */
- { 33447, 0x000084D6 }, /* GL_TEXTURE22 */
- { 33460, 0x000084D6 }, /* GL_TEXTURE22_ARB */
- { 33477, 0x000084D7 }, /* GL_TEXTURE23 */
- { 33490, 0x000084D7 }, /* GL_TEXTURE23_ARB */
- { 33507, 0x000084D8 }, /* GL_TEXTURE24 */
- { 33520, 0x000084D8 }, /* GL_TEXTURE24_ARB */
- { 33537, 0x000084D9 }, /* GL_TEXTURE25 */
- { 33550, 0x000084D9 }, /* GL_TEXTURE25_ARB */
- { 33567, 0x000084DA }, /* GL_TEXTURE26 */
- { 33580, 0x000084DA }, /* GL_TEXTURE26_ARB */
- { 33597, 0x000084DB }, /* GL_TEXTURE27 */
- { 33610, 0x000084DB }, /* GL_TEXTURE27_ARB */
- { 33627, 0x000084DC }, /* GL_TEXTURE28 */
- { 33640, 0x000084DC }, /* GL_TEXTURE28_ARB */
- { 33657, 0x000084DD }, /* GL_TEXTURE29 */
- { 33670, 0x000084DD }, /* GL_TEXTURE29_ARB */
- { 33687, 0x000084C2 }, /* GL_TEXTURE2_ARB */
- { 33703, 0x000084C3 }, /* GL_TEXTURE3 */
- { 33715, 0x000084DE }, /* GL_TEXTURE30 */
- { 33728, 0x000084DE }, /* GL_TEXTURE30_ARB */
- { 33745, 0x000084DF }, /* GL_TEXTURE31 */
- { 33758, 0x000084DF }, /* GL_TEXTURE31_ARB */
- { 33775, 0x000084C3 }, /* GL_TEXTURE3_ARB */
- { 33791, 0x000084C4 }, /* GL_TEXTURE4 */
- { 33803, 0x000084C4 }, /* GL_TEXTURE4_ARB */
- { 33819, 0x000084C5 }, /* GL_TEXTURE5 */
- { 33831, 0x000084C5 }, /* GL_TEXTURE5_ARB */
- { 33847, 0x000084C6 }, /* GL_TEXTURE6 */
- { 33859, 0x000084C6 }, /* GL_TEXTURE6_ARB */
- { 33875, 0x000084C7 }, /* GL_TEXTURE7 */
- { 33887, 0x000084C7 }, /* GL_TEXTURE7_ARB */
- { 33903, 0x000084C8 }, /* GL_TEXTURE8 */
- { 33915, 0x000084C8 }, /* GL_TEXTURE8_ARB */
- { 33931, 0x000084C9 }, /* GL_TEXTURE9 */
- { 33943, 0x000084C9 }, /* GL_TEXTURE9_ARB */
- { 33959, 0x00000DE0 }, /* GL_TEXTURE_1D */
- { 33973, 0x00008C18 }, /* GL_TEXTURE_1D_ARRAY_EXT */
- { 33997, 0x00000DE1 }, /* GL_TEXTURE_2D */
- { 34011, 0x00008C1A }, /* GL_TEXTURE_2D_ARRAY_EXT */
- { 34035, 0x0000806F }, /* GL_TEXTURE_3D */
- { 34049, 0x0000805F }, /* GL_TEXTURE_ALPHA_SIZE */
- { 34071, 0x0000805F }, /* GL_TEXTURE_ALPHA_SIZE_EXT */
- { 34097, 0x0000813C }, /* GL_TEXTURE_BASE_LEVEL */
- { 34119, 0x00008068 }, /* GL_TEXTURE_BINDING_1D */
- { 34141, 0x00008C1C }, /* GL_TEXTURE_BINDING_1D_ARRAY_EXT */
- { 34173, 0x00008069 }, /* GL_TEXTURE_BINDING_2D */
- { 34195, 0x00008C1D }, /* GL_TEXTURE_BINDING_2D_ARRAY_EXT */
- { 34227, 0x0000806A }, /* GL_TEXTURE_BINDING_3D */
- { 34249, 0x00008514 }, /* GL_TEXTURE_BINDING_CUBE_MAP */
- { 34277, 0x00008514 }, /* GL_TEXTURE_BINDING_CUBE_MAP_ARB */
- { 34309, 0x000084F6 }, /* GL_TEXTURE_BINDING_RECTANGLE_ARB */
- { 34342, 0x000084F6 }, /* GL_TEXTURE_BINDING_RECTANGLE_NV */
- { 34374, 0x00040000 }, /* GL_TEXTURE_BIT */
- { 34389, 0x0000805E }, /* GL_TEXTURE_BLUE_SIZE */
- { 34410, 0x0000805E }, /* GL_TEXTURE_BLUE_SIZE_EXT */
- { 34435, 0x00001005 }, /* GL_TEXTURE_BORDER */
- { 34453, 0x00001004 }, /* GL_TEXTURE_BORDER_COLOR */
- { 34477, 0x00008171 }, /* GL_TEXTURE_CLIPMAP_CENTER_SGIX */
- { 34508, 0x00008176 }, /* GL_TEXTURE_CLIPMAP_DEPTH_SGIX */
- { 34538, 0x00008172 }, /* GL_TEXTURE_CLIPMAP_FRAME_SGIX */
- { 34568, 0x00008175 }, /* GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX */
- { 34603, 0x00008173 }, /* GL_TEXTURE_CLIPMAP_OFFSET_SGIX */
- { 34634, 0x00008174 }, /* GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX */
- { 34672, 0x000080BC }, /* GL_TEXTURE_COLOR_TABLE_SGI */
- { 34699, 0x000081EF }, /* GL_TEXTURE_COLOR_WRITEMASK_SGIS */
- { 34731, 0x000080BF }, /* GL_TEXTURE_COMPARE_FAIL_VALUE_ARB */
- { 34765, 0x0000884D }, /* GL_TEXTURE_COMPARE_FUNC */
- { 34789, 0x0000884D }, /* GL_TEXTURE_COMPARE_FUNC_ARB */
- { 34817, 0x0000884C }, /* GL_TEXTURE_COMPARE_MODE */
- { 34841, 0x0000884C }, /* GL_TEXTURE_COMPARE_MODE_ARB */
- { 34869, 0x0000819B }, /* GL_TEXTURE_COMPARE_OPERATOR_SGIX */
- { 34902, 0x0000819A }, /* GL_TEXTURE_COMPARE_SGIX */
- { 34926, 0x00001003 }, /* GL_TEXTURE_COMPONENTS */
- { 34948, 0x000086A1 }, /* GL_TEXTURE_COMPRESSED */
- { 34970, 0x000086A1 }, /* GL_TEXTURE_COMPRESSED_ARB */
- { 34996, 0x000086A3 }, /* GL_TEXTURE_COMPRESSED_FORMATS_ARB */
- { 35030, 0x000086A0 }, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE */
- { 35063, 0x000086A0 }, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB */
- { 35100, 0x000084EF }, /* GL_TEXTURE_COMPRESSION_HINT */
- { 35128, 0x000084EF }, /* GL_TEXTURE_COMPRESSION_HINT_ARB */
- { 35160, 0x00008078 }, /* GL_TEXTURE_COORD_ARRAY */
- { 35183, 0x0000889A }, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING */
- { 35221, 0x0000889A }, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB */
- { 35263, 0x00008092 }, /* GL_TEXTURE_COORD_ARRAY_POINTER */
- { 35294, 0x00008088 }, /* GL_TEXTURE_COORD_ARRAY_SIZE */
- { 35322, 0x0000808A }, /* GL_TEXTURE_COORD_ARRAY_STRIDE */
- { 35352, 0x00008089 }, /* GL_TEXTURE_COORD_ARRAY_TYPE */
- { 35380, 0x00008513 }, /* GL_TEXTURE_CUBE_MAP */
- { 35400, 0x00008513 }, /* GL_TEXTURE_CUBE_MAP_ARB */
- { 35424, 0x00008516 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X */
- { 35455, 0x00008516 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB */
- { 35490, 0x00008518 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y */
- { 35521, 0x00008518 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB */
- { 35556, 0x0000851A }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z */
- { 35587, 0x0000851A }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB */
- { 35622, 0x00008515 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X */
- { 35653, 0x00008515 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB */
- { 35688, 0x00008517 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y */
- { 35719, 0x00008517 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB */
- { 35754, 0x00008519 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z */
- { 35785, 0x00008519 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB */
- { 35820, 0x000088F4 }, /* GL_TEXTURE_CUBE_MAP_SEAMLESS */
- { 35849, 0x00008071 }, /* GL_TEXTURE_DEPTH */
- { 35866, 0x0000884A }, /* GL_TEXTURE_DEPTH_SIZE */
- { 35888, 0x0000884A }, /* GL_TEXTURE_DEPTH_SIZE_ARB */
- { 35914, 0x00002300 }, /* GL_TEXTURE_ENV */
- { 35929, 0x00002201 }, /* GL_TEXTURE_ENV_COLOR */
- { 35950, 0x00002200 }, /* GL_TEXTURE_ENV_MODE */
- { 35970, 0x00008500 }, /* GL_TEXTURE_FILTER_CONTROL */
- { 35996, 0x00002500 }, /* GL_TEXTURE_GEN_MODE */
- { 36016, 0x00000C63 }, /* GL_TEXTURE_GEN_Q */
- { 36033, 0x00000C62 }, /* GL_TEXTURE_GEN_R */
- { 36050, 0x00000C60 }, /* GL_TEXTURE_GEN_S */
- { 36067, 0x00000C61 }, /* GL_TEXTURE_GEN_T */
- { 36084, 0x0000819D }, /* GL_TEXTURE_GEQUAL_R_SGIX */
- { 36109, 0x0000805D }, /* GL_TEXTURE_GREEN_SIZE */
- { 36131, 0x0000805D }, /* GL_TEXTURE_GREEN_SIZE_EXT */
- { 36157, 0x00001001 }, /* GL_TEXTURE_HEIGHT */
- { 36175, 0x000080ED }, /* GL_TEXTURE_INDEX_SIZE_EXT */
- { 36201, 0x00008061 }, /* GL_TEXTURE_INTENSITY_SIZE */
- { 36227, 0x00008061 }, /* GL_TEXTURE_INTENSITY_SIZE_EXT */
- { 36257, 0x00001003 }, /* GL_TEXTURE_INTERNAL_FORMAT */
- { 36284, 0x0000819C }, /* GL_TEXTURE_LEQUAL_R_SGIX */
- { 36309, 0x00008501 }, /* GL_TEXTURE_LOD_BIAS */
- { 36329, 0x00008501 }, /* GL_TEXTURE_LOD_BIAS_EXT */
- { 36353, 0x00008190 }, /* GL_TEXTURE_LOD_BIAS_R_SGIX */
- { 36380, 0x0000818E }, /* GL_TEXTURE_LOD_BIAS_S_SGIX */
- { 36407, 0x0000818F }, /* GL_TEXTURE_LOD_BIAS_T_SGIX */
- { 36434, 0x00008060 }, /* GL_TEXTURE_LUMINANCE_SIZE */
- { 36460, 0x00008060 }, /* GL_TEXTURE_LUMINANCE_SIZE_EXT */
- { 36490, 0x00002800 }, /* GL_TEXTURE_MAG_FILTER */
- { 36512, 0x00000BA8 }, /* GL_TEXTURE_MATRIX */
- { 36530, 0x000084FE }, /* GL_TEXTURE_MAX_ANISOTROPY_EXT */
- { 36560, 0x0000836B }, /* GL_TEXTURE_MAX_CLAMP_R_SGIX */
- { 36588, 0x00008369 }, /* GL_TEXTURE_MAX_CLAMP_S_SGIX */
- { 36616, 0x0000836A }, /* GL_TEXTURE_MAX_CLAMP_T_SGIX */
- { 36644, 0x0000813D }, /* GL_TEXTURE_MAX_LEVEL */
- { 36665, 0x0000813B }, /* GL_TEXTURE_MAX_LOD */
- { 36684, 0x00002801 }, /* GL_TEXTURE_MIN_FILTER */
- { 36706, 0x0000813A }, /* GL_TEXTURE_MIN_LOD */
- { 36725, 0x00008066 }, /* GL_TEXTURE_PRIORITY */
- { 36745, 0x000085B7 }, /* GL_TEXTURE_RANGE_LENGTH_APPLE */
- { 36775, 0x000085B8 }, /* GL_TEXTURE_RANGE_POINTER_APPLE */
- { 36806, 0x000084F5 }, /* GL_TEXTURE_RECTANGLE_ARB */
- { 36831, 0x000084F5 }, /* GL_TEXTURE_RECTANGLE_NV */
- { 36855, 0x0000805C }, /* GL_TEXTURE_RED_SIZE */
- { 36875, 0x0000805C }, /* GL_TEXTURE_RED_SIZE_EXT */
- { 36899, 0x00008067 }, /* GL_TEXTURE_RESIDENT */
- { 36919, 0x00000BA5 }, /* GL_TEXTURE_STACK_DEPTH */
- { 36942, 0x000088F1 }, /* GL_TEXTURE_STENCIL_SIZE */
- { 36966, 0x000085BC }, /* GL_TEXTURE_STORAGE_HINT_APPLE */
- { 36996, 0x00008065 }, /* GL_TEXTURE_TOO_LARGE_EXT */
- { 37021, 0x0000888F }, /* GL_TEXTURE_UNSIGNED_REMAP_MODE_NV */
- { 37055, 0x00001000 }, /* GL_TEXTURE_WIDTH */
- { 37072, 0x00008072 }, /* GL_TEXTURE_WRAP_R */
- { 37090, 0x00002802 }, /* GL_TEXTURE_WRAP_S */
- { 37108, 0x00002803 }, /* GL_TEXTURE_WRAP_T */
- { 37126, 0x0000911B }, /* GL_TIMEOUT_EXPIRED */
- { 37145, 0xFFFFFFFFFFFFFFFF }, /* GL_TIMEOUT_IGNORED */
- { 37164, 0x000088BF }, /* GL_TIME_ELAPSED_EXT */
- { 37184, 0x00008648 }, /* GL_TRACK_MATRIX_NV */
- { 37203, 0x00008649 }, /* GL_TRACK_MATRIX_TRANSFORM_NV */
- { 37232, 0x00001000 }, /* GL_TRANSFORM_BIT */
- { 37249, 0x000084E6 }, /* GL_TRANSPOSE_COLOR_MATRIX */
- { 37275, 0x000084E6 }, /* GL_TRANSPOSE_COLOR_MATRIX_ARB */
- { 37305, 0x000088B7 }, /* GL_TRANSPOSE_CURRENT_MATRIX_ARB */
- { 37337, 0x000084E3 }, /* GL_TRANSPOSE_MODELVIEW_MATRIX */
- { 37367, 0x000084E3 }, /* GL_TRANSPOSE_MODELVIEW_MATRIX_ARB */
- { 37401, 0x0000862C }, /* GL_TRANSPOSE_NV */
- { 37417, 0x000084E4 }, /* GL_TRANSPOSE_PROJECTION_MATRIX */
- { 37448, 0x000084E4 }, /* GL_TRANSPOSE_PROJECTION_MATRIX_ARB */
- { 37483, 0x000084E5 }, /* GL_TRANSPOSE_TEXTURE_MATRIX */
- { 37511, 0x000084E5 }, /* GL_TRANSPOSE_TEXTURE_MATRIX_ARB */
- { 37543, 0x00000004 }, /* GL_TRIANGLES */
- { 37556, 0x00000006 }, /* GL_TRIANGLE_FAN */
- { 37572, 0x00008615 }, /* GL_TRIANGLE_MESH_SUN */
- { 37593, 0x00000005 }, /* GL_TRIANGLE_STRIP */
- { 37611, 0x00000001 }, /* GL_TRUE */
- { 37619, 0x00000CF5 }, /* GL_UNPACK_ALIGNMENT */
- { 37639, 0x0000806E }, /* GL_UNPACK_IMAGE_HEIGHT */
- { 37662, 0x00000CF1 }, /* GL_UNPACK_LSB_FIRST */
- { 37682, 0x00000CF2 }, /* GL_UNPACK_ROW_LENGTH */
- { 37703, 0x0000806D }, /* GL_UNPACK_SKIP_IMAGES */
- { 37725, 0x00000CF4 }, /* GL_UNPACK_SKIP_PIXELS */
- { 37747, 0x00000CF3 }, /* GL_UNPACK_SKIP_ROWS */
- { 37767, 0x00000CF0 }, /* GL_UNPACK_SWAP_BYTES */
- { 37788, 0x00009118 }, /* GL_UNSIGNALED */
- { 37802, 0x00001401 }, /* GL_UNSIGNED_BYTE */
- { 37819, 0x00008362 }, /* GL_UNSIGNED_BYTE_2_3_3_REV */
- { 37846, 0x00008032 }, /* GL_UNSIGNED_BYTE_3_3_2 */
- { 37869, 0x00001405 }, /* GL_UNSIGNED_INT */
- { 37885, 0x00008036 }, /* GL_UNSIGNED_INT_10_10_10_2 */
- { 37912, 0x000084FA }, /* GL_UNSIGNED_INT_24_8 */
- { 37933, 0x000084FA }, /* GL_UNSIGNED_INT_24_8_NV */
- { 37957, 0x00008368 }, /* GL_UNSIGNED_INT_2_10_10_10_REV */
- { 37988, 0x00008035 }, /* GL_UNSIGNED_INT_8_8_8_8 */
- { 38012, 0x00008367 }, /* GL_UNSIGNED_INT_8_8_8_8_REV */
- { 38040, 0x00008C17 }, /* GL_UNSIGNED_NORMALIZED */
- { 38063, 0x00001403 }, /* GL_UNSIGNED_SHORT */
- { 38081, 0x00008366 }, /* GL_UNSIGNED_SHORT_1_5_5_5_REV */
- { 38111, 0x00008033 }, /* GL_UNSIGNED_SHORT_4_4_4_4 */
- { 38137, 0x00008365 }, /* GL_UNSIGNED_SHORT_4_4_4_4_REV */
- { 38167, 0x00008034 }, /* GL_UNSIGNED_SHORT_5_5_5_1 */
- { 38193, 0x00008363 }, /* GL_UNSIGNED_SHORT_5_6_5 */
- { 38217, 0x00008364 }, /* GL_UNSIGNED_SHORT_5_6_5_REV */
- { 38245, 0x000085BA }, /* GL_UNSIGNED_SHORT_8_8_APPLE */
- { 38273, 0x000085BA }, /* GL_UNSIGNED_SHORT_8_8_MESA */
- { 38300, 0x000085BB }, /* GL_UNSIGNED_SHORT_8_8_REV_APPLE */
- { 38332, 0x000085BB }, /* GL_UNSIGNED_SHORT_8_8_REV_MESA */
- { 38363, 0x00008CA2 }, /* GL_UPPER_LEFT */
- { 38377, 0x00002A20 }, /* GL_V2F */
- { 38384, 0x00002A21 }, /* GL_V3F */
- { 38391, 0x00008B83 }, /* GL_VALIDATE_STATUS */
- { 38410, 0x00001F00 }, /* GL_VENDOR */
- { 38420, 0x00001F02 }, /* GL_VERSION */
- { 38431, 0x00008074 }, /* GL_VERTEX_ARRAY */
- { 38447, 0x000085B5 }, /* GL_VERTEX_ARRAY_BINDING */
- { 38471, 0x000085B5 }, /* GL_VERTEX_ARRAY_BINDING_APPLE */
- { 38501, 0x00008896 }, /* GL_VERTEX_ARRAY_BUFFER_BINDING */
- { 38532, 0x00008896 }, /* GL_VERTEX_ARRAY_BUFFER_BINDING_ARB */
- { 38567, 0x0000808E }, /* GL_VERTEX_ARRAY_POINTER */
- { 38591, 0x0000807A }, /* GL_VERTEX_ARRAY_SIZE */
- { 38612, 0x0000807C }, /* GL_VERTEX_ARRAY_STRIDE */
- { 38635, 0x0000807B }, /* GL_VERTEX_ARRAY_TYPE */
- { 38656, 0x00008650 }, /* GL_VERTEX_ATTRIB_ARRAY0_NV */
- { 38683, 0x0000865A }, /* GL_VERTEX_ATTRIB_ARRAY10_NV */
- { 38711, 0x0000865B }, /* GL_VERTEX_ATTRIB_ARRAY11_NV */
- { 38739, 0x0000865C }, /* GL_VERTEX_ATTRIB_ARRAY12_NV */
- { 38767, 0x0000865D }, /* GL_VERTEX_ATTRIB_ARRAY13_NV */
- { 38795, 0x0000865E }, /* GL_VERTEX_ATTRIB_ARRAY14_NV */
- { 38823, 0x0000865F }, /* GL_VERTEX_ATTRIB_ARRAY15_NV */
- { 38851, 0x00008651 }, /* GL_VERTEX_ATTRIB_ARRAY1_NV */
- { 38878, 0x00008652 }, /* GL_VERTEX_ATTRIB_ARRAY2_NV */
- { 38905, 0x00008653 }, /* GL_VERTEX_ATTRIB_ARRAY3_NV */
- { 38932, 0x00008654 }, /* GL_VERTEX_ATTRIB_ARRAY4_NV */
- { 38959, 0x00008655 }, /* GL_VERTEX_ATTRIB_ARRAY5_NV */
- { 38986, 0x00008656 }, /* GL_VERTEX_ATTRIB_ARRAY6_NV */
- { 39013, 0x00008657 }, /* GL_VERTEX_ATTRIB_ARRAY7_NV */
- { 39040, 0x00008658 }, /* GL_VERTEX_ATTRIB_ARRAY8_NV */
- { 39067, 0x00008659 }, /* GL_VERTEX_ATTRIB_ARRAY9_NV */
- { 39094, 0x0000889F }, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING */
- { 39132, 0x0000889F }, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB */
- { 39174, 0x00008622 }, /* GL_VERTEX_ATTRIB_ARRAY_ENABLED */
- { 39205, 0x00008622 }, /* GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB */
- { 39240, 0x0000886A }, /* GL_VERTEX_ATTRIB_ARRAY_NORMALIZED */
- { 39274, 0x0000886A }, /* GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB */
- { 39312, 0x00008645 }, /* GL_VERTEX_ATTRIB_ARRAY_POINTER */
- { 39343, 0x00008645 }, /* GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB */
- { 39378, 0x00008623 }, /* GL_VERTEX_ATTRIB_ARRAY_SIZE */
- { 39406, 0x00008623 }, /* GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB */
- { 39438, 0x00008624 }, /* GL_VERTEX_ATTRIB_ARRAY_STRIDE */
- { 39468, 0x00008624 }, /* GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB */
- { 39502, 0x00008625 }, /* GL_VERTEX_ATTRIB_ARRAY_TYPE */
- { 39530, 0x00008625 }, /* GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB */
- { 39562, 0x000086A7 }, /* GL_VERTEX_BLEND_ARB */
- { 39582, 0x00008620 }, /* GL_VERTEX_PROGRAM_ARB */
- { 39604, 0x0000864A }, /* GL_VERTEX_PROGRAM_BINDING_NV */
- { 39633, 0x00008620 }, /* GL_VERTEX_PROGRAM_NV */
- { 39654, 0x00008642 }, /* GL_VERTEX_PROGRAM_POINT_SIZE */
- { 39683, 0x00008642 }, /* GL_VERTEX_PROGRAM_POINT_SIZE_ARB */
- { 39716, 0x00008642 }, /* GL_VERTEX_PROGRAM_POINT_SIZE_NV */
- { 39748, 0x00008643 }, /* GL_VERTEX_PROGRAM_TWO_SIDE */
- { 39775, 0x00008643 }, /* GL_VERTEX_PROGRAM_TWO_SIDE_ARB */
- { 39806, 0x00008643 }, /* GL_VERTEX_PROGRAM_TWO_SIDE_NV */
- { 39836, 0x00008B31 }, /* GL_VERTEX_SHADER */
- { 39853, 0x00008B31 }, /* GL_VERTEX_SHADER_ARB */
- { 39874, 0x00008621 }, /* GL_VERTEX_STATE_PROGRAM_NV */
- { 39901, 0x00000BA2 }, /* GL_VIEWPORT */
- { 39913, 0x00000800 }, /* GL_VIEWPORT_BIT */
- { 39929, 0x0000911D }, /* GL_WAIT_FAILED */
- { 39944, 0x000086AD }, /* GL_WEIGHT_ARRAY_ARB */
- { 39964, 0x0000889E }, /* GL_WEIGHT_ARRAY_BUFFER_BINDING */
- { 39995, 0x0000889E }, /* GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB */
- { 40030, 0x000086AC }, /* GL_WEIGHT_ARRAY_POINTER_ARB */
- { 40058, 0x000086AB }, /* GL_WEIGHT_ARRAY_SIZE_ARB */
- { 40083, 0x000086AA }, /* GL_WEIGHT_ARRAY_STRIDE_ARB */
- { 40110, 0x000086A9 }, /* GL_WEIGHT_ARRAY_TYPE_ARB */
- { 40135, 0x000086A6 }, /* GL_WEIGHT_SUM_UNITY_ARB */
- { 40159, 0x000081D4 }, /* GL_WRAP_BORDER_SUN */
- { 40178, 0x000088B9 }, /* GL_WRITE_ONLY */
- { 40192, 0x000088B9 }, /* GL_WRITE_ONLY_ARB */
- { 40210, 0x00001506 }, /* GL_XOR */
- { 40217, 0x000085B9 }, /* GL_YCBCR_422_APPLE */
- { 40236, 0x00008757 }, /* GL_YCBCR_MESA */
- { 40250, 0x00000000 }, /* GL_ZERO */
- { 40258, 0x00000D16 }, /* GL_ZOOM_X */
- { 40268, 0x00000D17 }, /* GL_ZOOM_Y */
+ { 7327, 0x0000864F }, /* GL_DEPTH_CLAMP */
+ { 7342, 0x0000864F }, /* GL_DEPTH_CLAMP_NV */
+ { 7360, 0x00000B73 }, /* GL_DEPTH_CLEAR_VALUE */
+ { 7381, 0x00001902 }, /* GL_DEPTH_COMPONENT */
+ { 7400, 0x000081A5 }, /* GL_DEPTH_COMPONENT16 */
+ { 7421, 0x000081A5 }, /* GL_DEPTH_COMPONENT16_ARB */
+ { 7446, 0x000081A5 }, /* GL_DEPTH_COMPONENT16_SGIX */
+ { 7472, 0x000081A6 }, /* GL_DEPTH_COMPONENT24 */
+ { 7493, 0x000081A6 }, /* GL_DEPTH_COMPONENT24_ARB */
+ { 7518, 0x000081A6 }, /* GL_DEPTH_COMPONENT24_SGIX */
+ { 7544, 0x000081A7 }, /* GL_DEPTH_COMPONENT32 */
+ { 7565, 0x000081A7 }, /* GL_DEPTH_COMPONENT32_ARB */
+ { 7590, 0x000081A7 }, /* GL_DEPTH_COMPONENT32_SGIX */
+ { 7616, 0x00000B74 }, /* GL_DEPTH_FUNC */
+ { 7630, 0x00000B70 }, /* GL_DEPTH_RANGE */
+ { 7645, 0x00000D1E }, /* GL_DEPTH_SCALE */
+ { 7660, 0x000084F9 }, /* GL_DEPTH_STENCIL */
+ { 7677, 0x0000821A }, /* GL_DEPTH_STENCIL_ATTACHMENT */
+ { 7705, 0x000084F9 }, /* GL_DEPTH_STENCIL_NV */
+ { 7725, 0x0000886F }, /* GL_DEPTH_STENCIL_TO_BGRA_NV */
+ { 7753, 0x0000886E }, /* GL_DEPTH_STENCIL_TO_RGBA_NV */
+ { 7781, 0x00000B71 }, /* GL_DEPTH_TEST */
+ { 7795, 0x0000884B }, /* GL_DEPTH_TEXTURE_MODE */
+ { 7817, 0x0000884B }, /* GL_DEPTH_TEXTURE_MODE_ARB */
+ { 7843, 0x00000B72 }, /* GL_DEPTH_WRITEMASK */
+ { 7862, 0x00001201 }, /* GL_DIFFUSE */
+ { 7873, 0x00000BD0 }, /* GL_DITHER */
+ { 7883, 0x00000A02 }, /* GL_DOMAIN */
+ { 7893, 0x00001100 }, /* GL_DONT_CARE */
+ { 7906, 0x000086AE }, /* GL_DOT3_RGB */
+ { 7918, 0x000086AF }, /* GL_DOT3_RGBA */
+ { 7931, 0x000086AF }, /* GL_DOT3_RGBA_ARB */
+ { 7948, 0x00008741 }, /* GL_DOT3_RGBA_EXT */
+ { 7965, 0x000086AE }, /* GL_DOT3_RGB_ARB */
+ { 7981, 0x00008740 }, /* GL_DOT3_RGB_EXT */
+ { 7997, 0x0000140A }, /* GL_DOUBLE */
+ { 8007, 0x00000C32 }, /* GL_DOUBLEBUFFER */
+ { 8023, 0x00000C01 }, /* GL_DRAW_BUFFER */
+ { 8038, 0x00008825 }, /* GL_DRAW_BUFFER0 */
+ { 8054, 0x00008825 }, /* GL_DRAW_BUFFER0_ARB */
+ { 8074, 0x00008825 }, /* GL_DRAW_BUFFER0_ATI */
+ { 8094, 0x00008826 }, /* GL_DRAW_BUFFER1 */
+ { 8110, 0x0000882F }, /* GL_DRAW_BUFFER10 */
+ { 8127, 0x0000882F }, /* GL_DRAW_BUFFER10_ARB */
+ { 8148, 0x0000882F }, /* GL_DRAW_BUFFER10_ATI */
+ { 8169, 0x00008830 }, /* GL_DRAW_BUFFER11 */
+ { 8186, 0x00008830 }, /* GL_DRAW_BUFFER11_ARB */
+ { 8207, 0x00008830 }, /* GL_DRAW_BUFFER11_ATI */
+ { 8228, 0x00008831 }, /* GL_DRAW_BUFFER12 */
+ { 8245, 0x00008831 }, /* GL_DRAW_BUFFER12_ARB */
+ { 8266, 0x00008831 }, /* GL_DRAW_BUFFER12_ATI */
+ { 8287, 0x00008832 }, /* GL_DRAW_BUFFER13 */
+ { 8304, 0x00008832 }, /* GL_DRAW_BUFFER13_ARB */
+ { 8325, 0x00008832 }, /* GL_DRAW_BUFFER13_ATI */
+ { 8346, 0x00008833 }, /* GL_DRAW_BUFFER14 */
+ { 8363, 0x00008833 }, /* GL_DRAW_BUFFER14_ARB */
+ { 8384, 0x00008833 }, /* GL_DRAW_BUFFER14_ATI */
+ { 8405, 0x00008834 }, /* GL_DRAW_BUFFER15 */
+ { 8422, 0x00008834 }, /* GL_DRAW_BUFFER15_ARB */
+ { 8443, 0x00008834 }, /* GL_DRAW_BUFFER15_ATI */
+ { 8464, 0x00008826 }, /* GL_DRAW_BUFFER1_ARB */
+ { 8484, 0x00008826 }, /* GL_DRAW_BUFFER1_ATI */
+ { 8504, 0x00008827 }, /* GL_DRAW_BUFFER2 */
+ { 8520, 0x00008827 }, /* GL_DRAW_BUFFER2_ARB */
+ { 8540, 0x00008827 }, /* GL_DRAW_BUFFER2_ATI */
+ { 8560, 0x00008828 }, /* GL_DRAW_BUFFER3 */
+ { 8576, 0x00008828 }, /* GL_DRAW_BUFFER3_ARB */
+ { 8596, 0x00008828 }, /* GL_DRAW_BUFFER3_ATI */
+ { 8616, 0x00008829 }, /* GL_DRAW_BUFFER4 */
+ { 8632, 0x00008829 }, /* GL_DRAW_BUFFER4_ARB */
+ { 8652, 0x00008829 }, /* GL_DRAW_BUFFER4_ATI */
+ { 8672, 0x0000882A }, /* GL_DRAW_BUFFER5 */
+ { 8688, 0x0000882A }, /* GL_DRAW_BUFFER5_ARB */
+ { 8708, 0x0000882A }, /* GL_DRAW_BUFFER5_ATI */
+ { 8728, 0x0000882B }, /* GL_DRAW_BUFFER6 */
+ { 8744, 0x0000882B }, /* GL_DRAW_BUFFER6_ARB */
+ { 8764, 0x0000882B }, /* GL_DRAW_BUFFER6_ATI */
+ { 8784, 0x0000882C }, /* GL_DRAW_BUFFER7 */
+ { 8800, 0x0000882C }, /* GL_DRAW_BUFFER7_ARB */
+ { 8820, 0x0000882C }, /* GL_DRAW_BUFFER7_ATI */
+ { 8840, 0x0000882D }, /* GL_DRAW_BUFFER8 */
+ { 8856, 0x0000882D }, /* GL_DRAW_BUFFER8_ARB */
+ { 8876, 0x0000882D }, /* GL_DRAW_BUFFER8_ATI */
+ { 8896, 0x0000882E }, /* GL_DRAW_BUFFER9 */
+ { 8912, 0x0000882E }, /* GL_DRAW_BUFFER9_ARB */
+ { 8932, 0x0000882E }, /* GL_DRAW_BUFFER9_ATI */
+ { 8952, 0x00008CA9 }, /* GL_DRAW_FRAMEBUFFER */
+ { 8972, 0x00008CA6 }, /* GL_DRAW_FRAMEBUFFER_BINDING_EXT */
+ { 9004, 0x00008CA9 }, /* GL_DRAW_FRAMEBUFFER_EXT */
+ { 9028, 0x00000705 }, /* GL_DRAW_PIXEL_TOKEN */
+ { 9048, 0x00000304 }, /* GL_DST_ALPHA */
+ { 9061, 0x00000306 }, /* GL_DST_COLOR */
+ { 9074, 0x0000877A }, /* GL_DU8DV8_ATI */
+ { 9088, 0x00008779 }, /* GL_DUDV_ATI */
+ { 9100, 0x000088EA }, /* GL_DYNAMIC_COPY */
+ { 9116, 0x000088EA }, /* GL_DYNAMIC_COPY_ARB */
+ { 9136, 0x000088E8 }, /* GL_DYNAMIC_DRAW */
+ { 9152, 0x000088E8 }, /* GL_DYNAMIC_DRAW_ARB */
+ { 9172, 0x000088E9 }, /* GL_DYNAMIC_READ */
+ { 9188, 0x000088E9 }, /* GL_DYNAMIC_READ_ARB */
+ { 9208, 0x00000B43 }, /* GL_EDGE_FLAG */
+ { 9221, 0x00008079 }, /* GL_EDGE_FLAG_ARRAY */
+ { 9240, 0x0000889B }, /* GL_EDGE_FLAG_ARRAY_BUFFER_BINDING */
+ { 9274, 0x0000889B }, /* GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB */
+ { 9312, 0x00008093 }, /* GL_EDGE_FLAG_ARRAY_POINTER */
+ { 9339, 0x0000808C }, /* GL_EDGE_FLAG_ARRAY_STRIDE */
+ { 9365, 0x00008893 }, /* GL_ELEMENT_ARRAY_BUFFER */
+ { 9389, 0x00008895 }, /* GL_ELEMENT_ARRAY_BUFFER_BINDING */
+ { 9421, 0x00008895 }, /* GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB */
+ { 9457, 0x00001600 }, /* GL_EMISSION */
+ { 9469, 0x00002000 }, /* GL_ENABLE_BIT */
+ { 9483, 0x00000202 }, /* GL_EQUAL */
+ { 9492, 0x00001509 }, /* GL_EQUIV */
+ { 9501, 0x00010000 }, /* GL_EVAL_BIT */
+ { 9513, 0x00000800 }, /* GL_EXP */
+ { 9520, 0x00000801 }, /* GL_EXP2 */
+ { 9528, 0x00001F03 }, /* GL_EXTENSIONS */
+ { 9542, 0x00002400 }, /* GL_EYE_LINEAR */
+ { 9556, 0x00002502 }, /* GL_EYE_PLANE */
+ { 9569, 0x0000855C }, /* GL_EYE_PLANE_ABSOLUTE_NV */
+ { 9594, 0x0000855B }, /* GL_EYE_RADIAL_NV */
+ { 9611, 0x00000000 }, /* GL_FALSE */
+ { 9620, 0x00001101 }, /* GL_FASTEST */
+ { 9631, 0x00001C01 }, /* GL_FEEDBACK */
+ { 9643, 0x00000DF0 }, /* GL_FEEDBACK_BUFFER_POINTER */
+ { 9670, 0x00000DF1 }, /* GL_FEEDBACK_BUFFER_SIZE */
+ { 9694, 0x00000DF2 }, /* GL_FEEDBACK_BUFFER_TYPE */
+ { 9718, 0x00001B02 }, /* GL_FILL */
+ { 9726, 0x00008E4D }, /* GL_FIRST_VERTEX_CONVENTION_EXT */
+ { 9757, 0x00001D00 }, /* GL_FLAT */
+ { 9765, 0x00001406 }, /* GL_FLOAT */
+ { 9774, 0x00008B5A }, /* GL_FLOAT_MAT2 */
+ { 9788, 0x00008B5A }, /* GL_FLOAT_MAT2_ARB */
+ { 9806, 0x00008B65 }, /* GL_FLOAT_MAT2x3 */
+ { 9822, 0x00008B66 }, /* GL_FLOAT_MAT2x4 */
+ { 9838, 0x00008B5B }, /* GL_FLOAT_MAT3 */
+ { 9852, 0x00008B5B }, /* GL_FLOAT_MAT3_ARB */
+ { 9870, 0x00008B67 }, /* GL_FLOAT_MAT3x2 */
+ { 9886, 0x00008B68 }, /* GL_FLOAT_MAT3x4 */
+ { 9902, 0x00008B5C }, /* GL_FLOAT_MAT4 */
+ { 9916, 0x00008B5C }, /* GL_FLOAT_MAT4_ARB */
+ { 9934, 0x00008B69 }, /* GL_FLOAT_MAT4x2 */
+ { 9950, 0x00008B6A }, /* GL_FLOAT_MAT4x3 */
+ { 9966, 0x00008B50 }, /* GL_FLOAT_VEC2 */
+ { 9980, 0x00008B50 }, /* GL_FLOAT_VEC2_ARB */
+ { 9998, 0x00008B51 }, /* GL_FLOAT_VEC3 */
+ { 10012, 0x00008B51 }, /* GL_FLOAT_VEC3_ARB */
+ { 10030, 0x00008B52 }, /* GL_FLOAT_VEC4 */
+ { 10044, 0x00008B52 }, /* GL_FLOAT_VEC4_ARB */
+ { 10062, 0x00000B60 }, /* GL_FOG */
+ { 10069, 0x00000080 }, /* GL_FOG_BIT */
+ { 10080, 0x00000B66 }, /* GL_FOG_COLOR */
+ { 10093, 0x00008451 }, /* GL_FOG_COORD */
+ { 10106, 0x00008451 }, /* GL_FOG_COORDINATE */
+ { 10124, 0x00008457 }, /* GL_FOG_COORDINATE_ARRAY */
+ { 10148, 0x0000889D }, /* GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING */
+ { 10187, 0x0000889D }, /* GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB */
+ { 10230, 0x00008456 }, /* GL_FOG_COORDINATE_ARRAY_POINTER */
+ { 10262, 0x00008455 }, /* GL_FOG_COORDINATE_ARRAY_STRIDE */
+ { 10293, 0x00008454 }, /* GL_FOG_COORDINATE_ARRAY_TYPE */
+ { 10322, 0x00008450 }, /* GL_FOG_COORDINATE_SOURCE */
+ { 10347, 0x00008457 }, /* GL_FOG_COORD_ARRAY */
+ { 10366, 0x0000889D }, /* GL_FOG_COORD_ARRAY_BUFFER_BINDING */
+ { 10400, 0x00008456 }, /* GL_FOG_COORD_ARRAY_POINTER */
+ { 10427, 0x00008455 }, /* GL_FOG_COORD_ARRAY_STRIDE */
+ { 10453, 0x00008454 }, /* GL_FOG_COORD_ARRAY_TYPE */
+ { 10477, 0x00008450 }, /* GL_FOG_COORD_SRC */
+ { 10494, 0x00000B62 }, /* GL_FOG_DENSITY */
+ { 10509, 0x0000855A }, /* GL_FOG_DISTANCE_MODE_NV */
+ { 10533, 0x00000B64 }, /* GL_FOG_END */
+ { 10544, 0x00000C54 }, /* GL_FOG_HINT */
+ { 10556, 0x00000B61 }, /* GL_FOG_INDEX */
+ { 10569, 0x00000B65 }, /* GL_FOG_MODE */
+ { 10581, 0x00008198 }, /* GL_FOG_OFFSET_SGIX */
+ { 10600, 0x00008199 }, /* GL_FOG_OFFSET_VALUE_SGIX */
+ { 10625, 0x00000B63 }, /* GL_FOG_START */
+ { 10638, 0x00008452 }, /* GL_FRAGMENT_DEPTH */
+ { 10656, 0x00008804 }, /* GL_FRAGMENT_PROGRAM_ARB */
+ { 10680, 0x00008B30 }, /* GL_FRAGMENT_SHADER */
+ { 10699, 0x00008B30 }, /* GL_FRAGMENT_SHADER_ARB */
+ { 10722, 0x00008B8B }, /* GL_FRAGMENT_SHADER_DERIVATIVE_HINT */
+ { 10757, 0x00008D40 }, /* GL_FRAMEBUFFER */
+ { 10772, 0x00008215 }, /* GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE */
+ { 10809, 0x00008214 }, /* GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE */
+ { 10845, 0x00008210 }, /* GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING */
+ { 10886, 0x00008211 }, /* GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE */
+ { 10927, 0x00008216 }, /* GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE */
+ { 10964, 0x00008213 }, /* GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE */
+ { 11001, 0x00008CD1 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME */
+ { 11039, 0x00008CD1 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT */
+ { 11081, 0x00008CD0 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE */
+ { 11119, 0x00008CD0 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT */
+ { 11161, 0x00008212 }, /* GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE */
+ { 11196, 0x00008217 }, /* GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE */
+ { 11235, 0x00008CD4 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT */
+ { 11284, 0x00008CD3 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE */
+ { 11332, 0x00008CD3 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT */
+ { 11384, 0x00008CD4 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER */
+ { 11424, 0x00008CD4 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT */
+ { 11468, 0x00008CD2 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL */
+ { 11508, 0x00008CD2 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT */
+ { 11552, 0x00008CA6 }, /* GL_FRAMEBUFFER_BINDING_EXT */
+ { 11579, 0x00008CD5 }, /* GL_FRAMEBUFFER_COMPLETE */
+ { 11603, 0x00008CD5 }, /* GL_FRAMEBUFFER_COMPLETE_EXT */
+ { 11631, 0x00008218 }, /* GL_FRAMEBUFFER_DEFAULT */
+ { 11654, 0x00008D40 }, /* GL_FRAMEBUFFER_EXT */
+ { 11673, 0x00008CD6 }, /* GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT */
+ { 11710, 0x00008CD6 }, /* GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT */
+ { 11751, 0x00008CD9 }, /* GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT */
+ { 11792, 0x00008CDB }, /* GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT */
+ { 11834, 0x00008CD8 }, /* GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT */
+ { 11885, 0x00008CDA }, /* GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT */
+ { 11923, 0x00008CD7 }, /* GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT */
+ { 11968, 0x00008CD7 }, /* GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT */
+ { 12017, 0x00008D56 }, /* GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE */
+ { 12055, 0x00008CDC }, /* GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT */
+ { 12097, 0x00008CDE }, /* GL_FRAMEBUFFER_STATUS_ERROR_EXT */
+ { 12129, 0x00008219 }, /* GL_FRAMEBUFFER_UNDEFINED */
+ { 12154, 0x00008CDD }, /* GL_FRAMEBUFFER_UNSUPPORTED */
+ { 12181, 0x00008CDD }, /* GL_FRAMEBUFFER_UNSUPPORTED_EXT */
+ { 12212, 0x00000404 }, /* GL_FRONT */
+ { 12221, 0x00000408 }, /* GL_FRONT_AND_BACK */
+ { 12239, 0x00000B46 }, /* GL_FRONT_FACE */
+ { 12253, 0x00000400 }, /* GL_FRONT_LEFT */
+ { 12267, 0x00000401 }, /* GL_FRONT_RIGHT */
+ { 12282, 0x00008006 }, /* GL_FUNC_ADD */
+ { 12294, 0x00008006 }, /* GL_FUNC_ADD_EXT */
+ { 12310, 0x0000800B }, /* GL_FUNC_REVERSE_SUBTRACT */
+ { 12335, 0x0000800B }, /* GL_FUNC_REVERSE_SUBTRACT_EXT */
+ { 12364, 0x0000800A }, /* GL_FUNC_SUBTRACT */
+ { 12381, 0x0000800A }, /* GL_FUNC_SUBTRACT_EXT */
+ { 12402, 0x00008191 }, /* GL_GENERATE_MIPMAP */
+ { 12421, 0x00008192 }, /* GL_GENERATE_MIPMAP_HINT */
+ { 12445, 0x00008192 }, /* GL_GENERATE_MIPMAP_HINT_SGIS */
+ { 12474, 0x00008191 }, /* GL_GENERATE_MIPMAP_SGIS */
+ { 12498, 0x00000206 }, /* GL_GEQUAL */
+ { 12508, 0x00000204 }, /* GL_GREATER */
+ { 12519, 0x00001904 }, /* GL_GREEN */
+ { 12528, 0x00000D19 }, /* GL_GREEN_BIAS */
+ { 12542, 0x00000D53 }, /* GL_GREEN_BITS */
+ { 12556, 0x00000D18 }, /* GL_GREEN_SCALE */
+ { 12571, 0x00008000 }, /* GL_HINT_BIT */
+ { 12583, 0x00008024 }, /* GL_HISTOGRAM */
+ { 12596, 0x0000802B }, /* GL_HISTOGRAM_ALPHA_SIZE */
+ { 12620, 0x0000802B }, /* GL_HISTOGRAM_ALPHA_SIZE_EXT */
+ { 12648, 0x0000802A }, /* GL_HISTOGRAM_BLUE_SIZE */
+ { 12671, 0x0000802A }, /* GL_HISTOGRAM_BLUE_SIZE_EXT */
+ { 12698, 0x00008024 }, /* GL_HISTOGRAM_EXT */
+ { 12715, 0x00008027 }, /* GL_HISTOGRAM_FORMAT */
+ { 12735, 0x00008027 }, /* GL_HISTOGRAM_FORMAT_EXT */
+ { 12759, 0x00008029 }, /* GL_HISTOGRAM_GREEN_SIZE */
+ { 12783, 0x00008029 }, /* GL_HISTOGRAM_GREEN_SIZE_EXT */
+ { 12811, 0x0000802C }, /* GL_HISTOGRAM_LUMINANCE_SIZE */
+ { 12839, 0x0000802C }, /* GL_HISTOGRAM_LUMINANCE_SIZE_EXT */
+ { 12871, 0x00008028 }, /* GL_HISTOGRAM_RED_SIZE */
+ { 12893, 0x00008028 }, /* GL_HISTOGRAM_RED_SIZE_EXT */
+ { 12919, 0x0000802D }, /* GL_HISTOGRAM_SINK */
+ { 12937, 0x0000802D }, /* GL_HISTOGRAM_SINK_EXT */
+ { 12959, 0x00008026 }, /* GL_HISTOGRAM_WIDTH */
+ { 12978, 0x00008026 }, /* GL_HISTOGRAM_WIDTH_EXT */
+ { 13001, 0x0000862A }, /* GL_IDENTITY_NV */
+ { 13016, 0x00008150 }, /* GL_IGNORE_BORDER_HP */
+ { 13036, 0x00008B9B }, /* GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES */
+ { 13076, 0x00008B9A }, /* GL_IMPLEMENTATION_COLOR_READ_TYPE_OES */
+ { 13114, 0x00001E02 }, /* GL_INCR */
+ { 13122, 0x00008507 }, /* GL_INCR_WRAP */
+ { 13135, 0x00008507 }, /* GL_INCR_WRAP_EXT */
+ { 13152, 0x00008222 }, /* GL_INDEX */
+ { 13161, 0x00008077 }, /* GL_INDEX_ARRAY */
+ { 13176, 0x00008899 }, /* GL_INDEX_ARRAY_BUFFER_BINDING */
+ { 13206, 0x00008899 }, /* GL_INDEX_ARRAY_BUFFER_BINDING_ARB */
+ { 13240, 0x00008091 }, /* GL_INDEX_ARRAY_POINTER */
+ { 13263, 0x00008086 }, /* GL_INDEX_ARRAY_STRIDE */
+ { 13285, 0x00008085 }, /* GL_INDEX_ARRAY_TYPE */
+ { 13305, 0x00000D51 }, /* GL_INDEX_BITS */
+ { 13319, 0x00000C20 }, /* GL_INDEX_CLEAR_VALUE */
+ { 13340, 0x00000BF1 }, /* GL_INDEX_LOGIC_OP */
+ { 13358, 0x00000C30 }, /* GL_INDEX_MODE */
+ { 13372, 0x00000D13 }, /* GL_INDEX_OFFSET */
+ { 13388, 0x00000D12 }, /* GL_INDEX_SHIFT */
+ { 13403, 0x00000C21 }, /* GL_INDEX_WRITEMASK */
+ { 13422, 0x00008B84 }, /* GL_INFO_LOG_LENGTH */
+ { 13441, 0x00001404 }, /* GL_INT */
+ { 13448, 0x00008049 }, /* GL_INTENSITY */
+ { 13461, 0x0000804C }, /* GL_INTENSITY12 */
+ { 13476, 0x0000804C }, /* GL_INTENSITY12_EXT */
+ { 13495, 0x0000804D }, /* GL_INTENSITY16 */
+ { 13510, 0x0000804D }, /* GL_INTENSITY16_EXT */
+ { 13529, 0x0000804A }, /* GL_INTENSITY4 */
+ { 13543, 0x0000804A }, /* GL_INTENSITY4_EXT */
+ { 13561, 0x0000804B }, /* GL_INTENSITY8 */
+ { 13575, 0x0000804B }, /* GL_INTENSITY8_EXT */
+ { 13593, 0x00008049 }, /* GL_INTENSITY_EXT */
+ { 13610, 0x00008575 }, /* GL_INTERPOLATE */
+ { 13625, 0x00008575 }, /* GL_INTERPOLATE_ARB */
+ { 13644, 0x00008575 }, /* GL_INTERPOLATE_EXT */
+ { 13663, 0x00008B53 }, /* GL_INT_VEC2 */
+ { 13675, 0x00008B53 }, /* GL_INT_VEC2_ARB */
+ { 13691, 0x00008B54 }, /* GL_INT_VEC3 */
+ { 13703, 0x00008B54 }, /* GL_INT_VEC3_ARB */
+ { 13719, 0x00008B55 }, /* GL_INT_VEC4 */
+ { 13731, 0x00008B55 }, /* GL_INT_VEC4_ARB */
+ { 13747, 0x00000500 }, /* GL_INVALID_ENUM */
+ { 13763, 0x00000506 }, /* GL_INVALID_FRAMEBUFFER_OPERATION */
+ { 13796, 0x00000506 }, /* GL_INVALID_FRAMEBUFFER_OPERATION_EXT */
+ { 13833, 0x00000502 }, /* GL_INVALID_OPERATION */
+ { 13854, 0x00000501 }, /* GL_INVALID_VALUE */
+ { 13871, 0x0000862B }, /* GL_INVERSE_NV */
+ { 13885, 0x0000862D }, /* GL_INVERSE_TRANSPOSE_NV */
+ { 13909, 0x0000150A }, /* GL_INVERT */
+ { 13919, 0x00001E00 }, /* GL_KEEP */
+ { 13927, 0x00008E4E }, /* GL_LAST_VERTEX_CONVENTION_EXT */
+ { 13957, 0x00000406 }, /* GL_LEFT */
+ { 13965, 0x00000203 }, /* GL_LEQUAL */
+ { 13975, 0x00000201 }, /* GL_LESS */
+ { 13983, 0x00004000 }, /* GL_LIGHT0 */
+ { 13993, 0x00004001 }, /* GL_LIGHT1 */
+ { 14003, 0x00004002 }, /* GL_LIGHT2 */
+ { 14013, 0x00004003 }, /* GL_LIGHT3 */
+ { 14023, 0x00004004 }, /* GL_LIGHT4 */
+ { 14033, 0x00004005 }, /* GL_LIGHT5 */
+ { 14043, 0x00004006 }, /* GL_LIGHT6 */
+ { 14053, 0x00004007 }, /* GL_LIGHT7 */
+ { 14063, 0x00000B50 }, /* GL_LIGHTING */
+ { 14075, 0x00000040 }, /* GL_LIGHTING_BIT */
+ { 14091, 0x00000B53 }, /* GL_LIGHT_MODEL_AMBIENT */
+ { 14114, 0x000081F8 }, /* GL_LIGHT_MODEL_COLOR_CONTROL */
+ { 14143, 0x000081F8 }, /* GL_LIGHT_MODEL_COLOR_CONTROL_EXT */
+ { 14176, 0x00000B51 }, /* GL_LIGHT_MODEL_LOCAL_VIEWER */
+ { 14204, 0x00000B52 }, /* GL_LIGHT_MODEL_TWO_SIDE */
+ { 14228, 0x00001B01 }, /* GL_LINE */
+ { 14236, 0x00002601 }, /* GL_LINEAR */
+ { 14246, 0x00001208 }, /* GL_LINEAR_ATTENUATION */
+ { 14268, 0x00008170 }, /* GL_LINEAR_CLIPMAP_LINEAR_SGIX */
+ { 14298, 0x0000844F }, /* GL_LINEAR_CLIPMAP_NEAREST_SGIX */
+ { 14329, 0x00002703 }, /* GL_LINEAR_MIPMAP_LINEAR */
+ { 14353, 0x00002701 }, /* GL_LINEAR_MIPMAP_NEAREST */
+ { 14378, 0x00000001 }, /* GL_LINES */
+ { 14387, 0x00000004 }, /* GL_LINE_BIT */
+ { 14399, 0x00000002 }, /* GL_LINE_LOOP */
+ { 14412, 0x00000707 }, /* GL_LINE_RESET_TOKEN */
+ { 14432, 0x00000B20 }, /* GL_LINE_SMOOTH */
+ { 14447, 0x00000C52 }, /* GL_LINE_SMOOTH_HINT */
+ { 14467, 0x00000B24 }, /* GL_LINE_STIPPLE */
+ { 14483, 0x00000B25 }, /* GL_LINE_STIPPLE_PATTERN */
+ { 14507, 0x00000B26 }, /* GL_LINE_STIPPLE_REPEAT */
+ { 14530, 0x00000003 }, /* GL_LINE_STRIP */
+ { 14544, 0x00000702 }, /* GL_LINE_TOKEN */
+ { 14558, 0x00000B21 }, /* GL_LINE_WIDTH */
+ { 14572, 0x00000B23 }, /* GL_LINE_WIDTH_GRANULARITY */
+ { 14598, 0x00000B22 }, /* GL_LINE_WIDTH_RANGE */
+ { 14618, 0x00008B82 }, /* GL_LINK_STATUS */
+ { 14633, 0x00000B32 }, /* GL_LIST_BASE */
+ { 14646, 0x00020000 }, /* GL_LIST_BIT */
+ { 14658, 0x00000B33 }, /* GL_LIST_INDEX */
+ { 14672, 0x00000B30 }, /* GL_LIST_MODE */
+ { 14685, 0x00000101 }, /* GL_LOAD */
+ { 14693, 0x00000BF1 }, /* GL_LOGIC_OP */
+ { 14705, 0x00000BF0 }, /* GL_LOGIC_OP_MODE */
+ { 14722, 0x00008CA1 }, /* GL_LOWER_LEFT */
+ { 14736, 0x00001909 }, /* GL_LUMINANCE */
+ { 14749, 0x00008041 }, /* GL_LUMINANCE12 */
+ { 14764, 0x00008047 }, /* GL_LUMINANCE12_ALPHA12 */
+ { 14787, 0x00008047 }, /* GL_LUMINANCE12_ALPHA12_EXT */
+ { 14814, 0x00008046 }, /* GL_LUMINANCE12_ALPHA4 */
+ { 14836, 0x00008046 }, /* GL_LUMINANCE12_ALPHA4_EXT */
+ { 14862, 0x00008041 }, /* GL_LUMINANCE12_EXT */
+ { 14881, 0x00008042 }, /* GL_LUMINANCE16 */
+ { 14896, 0x00008048 }, /* GL_LUMINANCE16_ALPHA16 */
+ { 14919, 0x00008048 }, /* GL_LUMINANCE16_ALPHA16_EXT */
+ { 14946, 0x00008042 }, /* GL_LUMINANCE16_EXT */
+ { 14965, 0x0000803F }, /* GL_LUMINANCE4 */
+ { 14979, 0x00008043 }, /* GL_LUMINANCE4_ALPHA4 */
+ { 15000, 0x00008043 }, /* GL_LUMINANCE4_ALPHA4_EXT */
+ { 15025, 0x0000803F }, /* GL_LUMINANCE4_EXT */
+ { 15043, 0x00008044 }, /* GL_LUMINANCE6_ALPHA2 */
+ { 15064, 0x00008044 }, /* GL_LUMINANCE6_ALPHA2_EXT */
+ { 15089, 0x00008040 }, /* GL_LUMINANCE8 */
+ { 15103, 0x00008045 }, /* GL_LUMINANCE8_ALPHA8 */
+ { 15124, 0x00008045 }, /* GL_LUMINANCE8_ALPHA8_EXT */
+ { 15149, 0x00008040 }, /* GL_LUMINANCE8_EXT */
+ { 15167, 0x0000190A }, /* GL_LUMINANCE_ALPHA */
+ { 15186, 0x00000D90 }, /* GL_MAP1_COLOR_4 */
+ { 15202, 0x00000DD0 }, /* GL_MAP1_GRID_DOMAIN */
+ { 15222, 0x00000DD1 }, /* GL_MAP1_GRID_SEGMENTS */
+ { 15244, 0x00000D91 }, /* GL_MAP1_INDEX */
+ { 15258, 0x00000D92 }, /* GL_MAP1_NORMAL */
+ { 15273, 0x00000D93 }, /* GL_MAP1_TEXTURE_COORD_1 */
+ { 15297, 0x00000D94 }, /* GL_MAP1_TEXTURE_COORD_2 */
+ { 15321, 0x00000D95 }, /* GL_MAP1_TEXTURE_COORD_3 */
+ { 15345, 0x00000D96 }, /* GL_MAP1_TEXTURE_COORD_4 */
+ { 15369, 0x00000D97 }, /* GL_MAP1_VERTEX_3 */
+ { 15386, 0x00000D98 }, /* GL_MAP1_VERTEX_4 */
+ { 15403, 0x00008660 }, /* GL_MAP1_VERTEX_ATTRIB0_4_NV */
+ { 15431, 0x0000866A }, /* GL_MAP1_VERTEX_ATTRIB10_4_NV */
+ { 15460, 0x0000866B }, /* GL_MAP1_VERTEX_ATTRIB11_4_NV */
+ { 15489, 0x0000866C }, /* GL_MAP1_VERTEX_ATTRIB12_4_NV */
+ { 15518, 0x0000866D }, /* GL_MAP1_VERTEX_ATTRIB13_4_NV */
+ { 15547, 0x0000866E }, /* GL_MAP1_VERTEX_ATTRIB14_4_NV */
+ { 15576, 0x0000866F }, /* GL_MAP1_VERTEX_ATTRIB15_4_NV */
+ { 15605, 0x00008661 }, /* GL_MAP1_VERTEX_ATTRIB1_4_NV */
+ { 15633, 0x00008662 }, /* GL_MAP1_VERTEX_ATTRIB2_4_NV */
+ { 15661, 0x00008663 }, /* GL_MAP1_VERTEX_ATTRIB3_4_NV */
+ { 15689, 0x00008664 }, /* GL_MAP1_VERTEX_ATTRIB4_4_NV */
+ { 15717, 0x00008665 }, /* GL_MAP1_VERTEX_ATTRIB5_4_NV */
+ { 15745, 0x00008666 }, /* GL_MAP1_VERTEX_ATTRIB6_4_NV */
+ { 15773, 0x00008667 }, /* GL_MAP1_VERTEX_ATTRIB7_4_NV */
+ { 15801, 0x00008668 }, /* GL_MAP1_VERTEX_ATTRIB8_4_NV */
+ { 15829, 0x00008669 }, /* GL_MAP1_VERTEX_ATTRIB9_4_NV */
+ { 15857, 0x00000DB0 }, /* GL_MAP2_COLOR_4 */
+ { 15873, 0x00000DD2 }, /* GL_MAP2_GRID_DOMAIN */
+ { 15893, 0x00000DD3 }, /* GL_MAP2_GRID_SEGMENTS */
+ { 15915, 0x00000DB1 }, /* GL_MAP2_INDEX */
+ { 15929, 0x00000DB2 }, /* GL_MAP2_NORMAL */
+ { 15944, 0x00000DB3 }, /* GL_MAP2_TEXTURE_COORD_1 */
+ { 15968, 0x00000DB4 }, /* GL_MAP2_TEXTURE_COORD_2 */
+ { 15992, 0x00000DB5 }, /* GL_MAP2_TEXTURE_COORD_3 */
+ { 16016, 0x00000DB6 }, /* GL_MAP2_TEXTURE_COORD_4 */
+ { 16040, 0x00000DB7 }, /* GL_MAP2_VERTEX_3 */
+ { 16057, 0x00000DB8 }, /* GL_MAP2_VERTEX_4 */
+ { 16074, 0x00008670 }, /* GL_MAP2_VERTEX_ATTRIB0_4_NV */
+ { 16102, 0x0000867A }, /* GL_MAP2_VERTEX_ATTRIB10_4_NV */
+ { 16131, 0x0000867B }, /* GL_MAP2_VERTEX_ATTRIB11_4_NV */
+ { 16160, 0x0000867C }, /* GL_MAP2_VERTEX_ATTRIB12_4_NV */
+ { 16189, 0x0000867D }, /* GL_MAP2_VERTEX_ATTRIB13_4_NV */
+ { 16218, 0x0000867E }, /* GL_MAP2_VERTEX_ATTRIB14_4_NV */
+ { 16247, 0x0000867F }, /* GL_MAP2_VERTEX_ATTRIB15_4_NV */
+ { 16276, 0x00008671 }, /* GL_MAP2_VERTEX_ATTRIB1_4_NV */
+ { 16304, 0x00008672 }, /* GL_MAP2_VERTEX_ATTRIB2_4_NV */
+ { 16332, 0x00008673 }, /* GL_MAP2_VERTEX_ATTRIB3_4_NV */
+ { 16360, 0x00008674 }, /* GL_MAP2_VERTEX_ATTRIB4_4_NV */
+ { 16388, 0x00008675 }, /* GL_MAP2_VERTEX_ATTRIB5_4_NV */
+ { 16416, 0x00008676 }, /* GL_MAP2_VERTEX_ATTRIB6_4_NV */
+ { 16444, 0x00008677 }, /* GL_MAP2_VERTEX_ATTRIB7_4_NV */
+ { 16472, 0x00008678 }, /* GL_MAP2_VERTEX_ATTRIB8_4_NV */
+ { 16500, 0x00008679 }, /* GL_MAP2_VERTEX_ATTRIB9_4_NV */
+ { 16528, 0x00000D10 }, /* GL_MAP_COLOR */
+ { 16541, 0x00000010 }, /* GL_MAP_FLUSH_EXPLICIT_BIT */
+ { 16567, 0x00000008 }, /* GL_MAP_INVALIDATE_BUFFER_BIT */
+ { 16596, 0x00000004 }, /* GL_MAP_INVALIDATE_RANGE_BIT */
+ { 16624, 0x00000001 }, /* GL_MAP_READ_BIT */
+ { 16640, 0x00000D11 }, /* GL_MAP_STENCIL */
+ { 16655, 0x00000020 }, /* GL_MAP_UNSYNCHRONIZED_BIT */
+ { 16681, 0x00000002 }, /* GL_MAP_WRITE_BIT */
+ { 16698, 0x000088C0 }, /* GL_MATRIX0_ARB */
+ { 16713, 0x00008630 }, /* GL_MATRIX0_NV */
+ { 16727, 0x000088CA }, /* GL_MATRIX10_ARB */
+ { 16743, 0x000088CB }, /* GL_MATRIX11_ARB */
+ { 16759, 0x000088CC }, /* GL_MATRIX12_ARB */
+ { 16775, 0x000088CD }, /* GL_MATRIX13_ARB */
+ { 16791, 0x000088CE }, /* GL_MATRIX14_ARB */
+ { 16807, 0x000088CF }, /* GL_MATRIX15_ARB */
+ { 16823, 0x000088D0 }, /* GL_MATRIX16_ARB */
+ { 16839, 0x000088D1 }, /* GL_MATRIX17_ARB */
+ { 16855, 0x000088D2 }, /* GL_MATRIX18_ARB */
+ { 16871, 0x000088D3 }, /* GL_MATRIX19_ARB */
+ { 16887, 0x000088C1 }, /* GL_MATRIX1_ARB */
+ { 16902, 0x00008631 }, /* GL_MATRIX1_NV */
+ { 16916, 0x000088D4 }, /* GL_MATRIX20_ARB */
+ { 16932, 0x000088D5 }, /* GL_MATRIX21_ARB */
+ { 16948, 0x000088D6 }, /* GL_MATRIX22_ARB */
+ { 16964, 0x000088D7 }, /* GL_MATRIX23_ARB */
+ { 16980, 0x000088D8 }, /* GL_MATRIX24_ARB */
+ { 16996, 0x000088D9 }, /* GL_MATRIX25_ARB */
+ { 17012, 0x000088DA }, /* GL_MATRIX26_ARB */
+ { 17028, 0x000088DB }, /* GL_MATRIX27_ARB */
+ { 17044, 0x000088DC }, /* GL_MATRIX28_ARB */
+ { 17060, 0x000088DD }, /* GL_MATRIX29_ARB */
+ { 17076, 0x000088C2 }, /* GL_MATRIX2_ARB */
+ { 17091, 0x00008632 }, /* GL_MATRIX2_NV */
+ { 17105, 0x000088DE }, /* GL_MATRIX30_ARB */
+ { 17121, 0x000088DF }, /* GL_MATRIX31_ARB */
+ { 17137, 0x000088C3 }, /* GL_MATRIX3_ARB */
+ { 17152, 0x00008633 }, /* GL_MATRIX3_NV */
+ { 17166, 0x000088C4 }, /* GL_MATRIX4_ARB */
+ { 17181, 0x00008634 }, /* GL_MATRIX4_NV */
+ { 17195, 0x000088C5 }, /* GL_MATRIX5_ARB */
+ { 17210, 0x00008635 }, /* GL_MATRIX5_NV */
+ { 17224, 0x000088C6 }, /* GL_MATRIX6_ARB */
+ { 17239, 0x00008636 }, /* GL_MATRIX6_NV */
+ { 17253, 0x000088C7 }, /* GL_MATRIX7_ARB */
+ { 17268, 0x00008637 }, /* GL_MATRIX7_NV */
+ { 17282, 0x000088C8 }, /* GL_MATRIX8_ARB */
+ { 17297, 0x000088C9 }, /* GL_MATRIX9_ARB */
+ { 17312, 0x00008844 }, /* GL_MATRIX_INDEX_ARRAY_ARB */
+ { 17338, 0x00008849 }, /* GL_MATRIX_INDEX_ARRAY_POINTER_ARB */
+ { 17372, 0x00008846 }, /* GL_MATRIX_INDEX_ARRAY_SIZE_ARB */
+ { 17403, 0x00008848 }, /* GL_MATRIX_INDEX_ARRAY_STRIDE_ARB */
+ { 17436, 0x00008847 }, /* GL_MATRIX_INDEX_ARRAY_TYPE_ARB */
+ { 17467, 0x00000BA0 }, /* GL_MATRIX_MODE */
+ { 17482, 0x00008840 }, /* GL_MATRIX_PALETTE_ARB */
+ { 17504, 0x00008008 }, /* GL_MAX */
+ { 17511, 0x00008073 }, /* GL_MAX_3D_TEXTURE_SIZE */
+ { 17534, 0x000088FF }, /* GL_MAX_ARRAY_TEXTURE_LAYERS_EXT */
+ { 17566, 0x00000D35 }, /* GL_MAX_ATTRIB_STACK_DEPTH */
+ { 17592, 0x00000D3B }, /* GL_MAX_CLIENT_ATTRIB_STACK_DEPTH */
+ { 17625, 0x00008177 }, /* GL_MAX_CLIPMAP_DEPTH_SGIX */
+ { 17651, 0x00008178 }, /* GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX */
+ { 17685, 0x00000D32 }, /* GL_MAX_CLIP_PLANES */
+ { 17704, 0x00008CDF }, /* GL_MAX_COLOR_ATTACHMENTS_EXT */
+ { 17733, 0x000080B3 }, /* GL_MAX_COLOR_MATRIX_STACK_DEPTH */
+ { 17765, 0x000080B3 }, /* GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI */
+ { 17801, 0x00008B4D }, /* GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS */
+ { 17837, 0x00008B4D }, /* GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB */
+ { 17877, 0x0000801B }, /* GL_MAX_CONVOLUTION_HEIGHT */
+ { 17903, 0x0000801B }, /* GL_MAX_CONVOLUTION_HEIGHT_EXT */
+ { 17933, 0x0000801A }, /* GL_MAX_CONVOLUTION_WIDTH */
+ { 17958, 0x0000801A }, /* GL_MAX_CONVOLUTION_WIDTH_EXT */
+ { 17987, 0x0000851C }, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE */
+ { 18016, 0x0000851C }, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB */
+ { 18049, 0x00008824 }, /* GL_MAX_DRAW_BUFFERS */
+ { 18069, 0x00008824 }, /* GL_MAX_DRAW_BUFFERS_ARB */
+ { 18093, 0x00008824 }, /* GL_MAX_DRAW_BUFFERS_ATI */
+ { 18117, 0x000080E9 }, /* GL_MAX_ELEMENTS_INDICES */
+ { 18141, 0x000080E8 }, /* GL_MAX_ELEMENTS_VERTICES */
+ { 18166, 0x00000D30 }, /* GL_MAX_EVAL_ORDER */
+ { 18184, 0x00008008 }, /* GL_MAX_EXT */
+ { 18195, 0x00008B49 }, /* GL_MAX_FRAGMENT_UNIFORM_COMPONENTS */
+ { 18230, 0x00008B49 }, /* GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB */
+ { 18269, 0x00000D31 }, /* GL_MAX_LIGHTS */
+ { 18283, 0x00000B31 }, /* GL_MAX_LIST_NESTING */
+ { 18303, 0x00008841 }, /* GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB */
+ { 18341, 0x00000D36 }, /* GL_MAX_MODELVIEW_STACK_DEPTH */
+ { 18370, 0x00000D37 }, /* GL_MAX_NAME_STACK_DEPTH */
+ { 18394, 0x00008842 }, /* GL_MAX_PALETTE_MATRICES_ARB */
+ { 18422, 0x00000D34 }, /* GL_MAX_PIXEL_MAP_TABLE */
+ { 18445, 0x000088B1 }, /* GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB */
+ { 18482, 0x0000880B }, /* GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB */
+ { 18518, 0x000088AD }, /* GL_MAX_PROGRAM_ATTRIBS_ARB */
+ { 18545, 0x000088F5 }, /* GL_MAX_PROGRAM_CALL_DEPTH_NV */
+ { 18574, 0x000088B5 }, /* GL_MAX_PROGRAM_ENV_PARAMETERS_ARB */
+ { 18608, 0x000088F4 }, /* GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV */
+ { 18644, 0x000088F6 }, /* GL_MAX_PROGRAM_IF_DEPTH_NV */
+ { 18671, 0x000088A1 }, /* GL_MAX_PROGRAM_INSTRUCTIONS_ARB */
+ { 18703, 0x000088B4 }, /* GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB */
+ { 18739, 0x000088F8 }, /* GL_MAX_PROGRAM_LOOP_COUNT_NV */
+ { 18768, 0x000088F7 }, /* GL_MAX_PROGRAM_LOOP_DEPTH_NV */
+ { 18797, 0x0000862F }, /* GL_MAX_PROGRAM_MATRICES_ARB */
+ { 18825, 0x0000862E }, /* GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB */
+ { 18863, 0x000088B3 }, /* GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */
+ { 18907, 0x0000880E }, /* GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */
+ { 18950, 0x000088AF }, /* GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB */
+ { 18984, 0x000088A3 }, /* GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB */
+ { 19023, 0x000088AB }, /* GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB */
+ { 19060, 0x000088A7 }, /* GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB */
+ { 19098, 0x00008810 }, /* GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */
+ { 19141, 0x0000880F }, /* GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */
+ { 19184, 0x000088A9 }, /* GL_MAX_PROGRAM_PARAMETERS_ARB */
+ { 19214, 0x000088A5 }, /* GL_MAX_PROGRAM_TEMPORARIES_ARB */
+ { 19245, 0x0000880D }, /* GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB */
+ { 19281, 0x0000880C }, /* GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB */
+ { 19317, 0x00000D38 }, /* GL_MAX_PROJECTION_STACK_DEPTH */
+ { 19347, 0x000084F8 }, /* GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB */
+ { 19381, 0x000084F8 }, /* GL_MAX_RECTANGLE_TEXTURE_SIZE_NV */
+ { 19414, 0x000084E8 }, /* GL_MAX_RENDERBUFFER_SIZE_EXT */
+ { 19443, 0x00008D57 }, /* GL_MAX_SAMPLES */
+ { 19458, 0x00009111 }, /* GL_MAX_SERVER_WAIT_TIMEOUT */
+ { 19485, 0x00008504 }, /* GL_MAX_SHININESS_NV */
+ { 19505, 0x00008505 }, /* GL_MAX_SPOT_EXPONENT_NV */
+ { 19529, 0x00008871 }, /* GL_MAX_TEXTURE_COORDS */
+ { 19551, 0x00008871 }, /* GL_MAX_TEXTURE_COORDS_ARB */
+ { 19577, 0x00008872 }, /* GL_MAX_TEXTURE_IMAGE_UNITS */
+ { 19604, 0x00008872 }, /* GL_MAX_TEXTURE_IMAGE_UNITS_ARB */
+ { 19635, 0x000084FD }, /* GL_MAX_TEXTURE_LOD_BIAS */
+ { 19659, 0x000084FF }, /* GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT */
+ { 19693, 0x00000D33 }, /* GL_MAX_TEXTURE_SIZE */
+ { 19713, 0x00000D39 }, /* GL_MAX_TEXTURE_STACK_DEPTH */
+ { 19740, 0x000084E2 }, /* GL_MAX_TEXTURE_UNITS */
+ { 19761, 0x000084E2 }, /* GL_MAX_TEXTURE_UNITS_ARB */
+ { 19786, 0x0000862F }, /* GL_MAX_TRACK_MATRICES_NV */
+ { 19811, 0x0000862E }, /* GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV */
+ { 19846, 0x00008B4B }, /* GL_MAX_VARYING_FLOATS */
+ { 19868, 0x00008B4B }, /* GL_MAX_VARYING_FLOATS_ARB */
+ { 19894, 0x00008869 }, /* GL_MAX_VERTEX_ATTRIBS */
+ { 19916, 0x00008869 }, /* GL_MAX_VERTEX_ATTRIBS_ARB */
+ { 19942, 0x00008B4C }, /* GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS */
+ { 19976, 0x00008B4C }, /* GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB */
+ { 20014, 0x00008B4A }, /* GL_MAX_VERTEX_UNIFORM_COMPONENTS */
+ { 20047, 0x00008B4A }, /* GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB */
+ { 20084, 0x000086A4 }, /* GL_MAX_VERTEX_UNITS_ARB */
+ { 20108, 0x00000D3A }, /* GL_MAX_VIEWPORT_DIMS */
+ { 20129, 0x00008007 }, /* GL_MIN */
+ { 20136, 0x0000802E }, /* GL_MINMAX */
+ { 20146, 0x0000802E }, /* GL_MINMAX_EXT */
+ { 20160, 0x0000802F }, /* GL_MINMAX_FORMAT */
+ { 20177, 0x0000802F }, /* GL_MINMAX_FORMAT_EXT */
+ { 20198, 0x00008030 }, /* GL_MINMAX_SINK */
+ { 20213, 0x00008030 }, /* GL_MINMAX_SINK_EXT */
+ { 20232, 0x00008007 }, /* GL_MIN_EXT */
+ { 20243, 0x00008370 }, /* GL_MIRRORED_REPEAT */
+ { 20262, 0x00008370 }, /* GL_MIRRORED_REPEAT_ARB */
+ { 20285, 0x00008370 }, /* GL_MIRRORED_REPEAT_IBM */
+ { 20308, 0x00008742 }, /* GL_MIRROR_CLAMP_ATI */
+ { 20328, 0x00008742 }, /* GL_MIRROR_CLAMP_EXT */
+ { 20348, 0x00008912 }, /* GL_MIRROR_CLAMP_TO_BORDER_EXT */
+ { 20378, 0x00008743 }, /* GL_MIRROR_CLAMP_TO_EDGE_ATI */
+ { 20406, 0x00008743 }, /* GL_MIRROR_CLAMP_TO_EDGE_EXT */
+ { 20434, 0x00001700 }, /* GL_MODELVIEW */
+ { 20447, 0x00001700 }, /* GL_MODELVIEW0_ARB */
+ { 20465, 0x0000872A }, /* GL_MODELVIEW10_ARB */
+ { 20484, 0x0000872B }, /* GL_MODELVIEW11_ARB */
+ { 20503, 0x0000872C }, /* GL_MODELVIEW12_ARB */
+ { 20522, 0x0000872D }, /* GL_MODELVIEW13_ARB */
+ { 20541, 0x0000872E }, /* GL_MODELVIEW14_ARB */
+ { 20560, 0x0000872F }, /* GL_MODELVIEW15_ARB */
+ { 20579, 0x00008730 }, /* GL_MODELVIEW16_ARB */
+ { 20598, 0x00008731 }, /* GL_MODELVIEW17_ARB */
+ { 20617, 0x00008732 }, /* GL_MODELVIEW18_ARB */
+ { 20636, 0x00008733 }, /* GL_MODELVIEW19_ARB */
+ { 20655, 0x0000850A }, /* GL_MODELVIEW1_ARB */
+ { 20673, 0x00008734 }, /* GL_MODELVIEW20_ARB */
+ { 20692, 0x00008735 }, /* GL_MODELVIEW21_ARB */
+ { 20711, 0x00008736 }, /* GL_MODELVIEW22_ARB */
+ { 20730, 0x00008737 }, /* GL_MODELVIEW23_ARB */
+ { 20749, 0x00008738 }, /* GL_MODELVIEW24_ARB */
+ { 20768, 0x00008739 }, /* GL_MODELVIEW25_ARB */
+ { 20787, 0x0000873A }, /* GL_MODELVIEW26_ARB */
+ { 20806, 0x0000873B }, /* GL_MODELVIEW27_ARB */
+ { 20825, 0x0000873C }, /* GL_MODELVIEW28_ARB */
+ { 20844, 0x0000873D }, /* GL_MODELVIEW29_ARB */
+ { 20863, 0x00008722 }, /* GL_MODELVIEW2_ARB */
+ { 20881, 0x0000873E }, /* GL_MODELVIEW30_ARB */
+ { 20900, 0x0000873F }, /* GL_MODELVIEW31_ARB */
+ { 20919, 0x00008723 }, /* GL_MODELVIEW3_ARB */
+ { 20937, 0x00008724 }, /* GL_MODELVIEW4_ARB */
+ { 20955, 0x00008725 }, /* GL_MODELVIEW5_ARB */
+ { 20973, 0x00008726 }, /* GL_MODELVIEW6_ARB */
+ { 20991, 0x00008727 }, /* GL_MODELVIEW7_ARB */
+ { 21009, 0x00008728 }, /* GL_MODELVIEW8_ARB */
+ { 21027, 0x00008729 }, /* GL_MODELVIEW9_ARB */
+ { 21045, 0x00000BA6 }, /* GL_MODELVIEW_MATRIX */
+ { 21065, 0x00008629 }, /* GL_MODELVIEW_PROJECTION_NV */
+ { 21092, 0x00000BA3 }, /* GL_MODELVIEW_STACK_DEPTH */
+ { 21117, 0x00002100 }, /* GL_MODULATE */
+ { 21129, 0x00008744 }, /* GL_MODULATE_ADD_ATI */
+ { 21149, 0x00008745 }, /* GL_MODULATE_SIGNED_ADD_ATI */
+ { 21176, 0x00008746 }, /* GL_MODULATE_SUBTRACT_ATI */
+ { 21201, 0x00000103 }, /* GL_MULT */
+ { 21209, 0x0000809D }, /* GL_MULTISAMPLE */
+ { 21224, 0x000086B2 }, /* GL_MULTISAMPLE_3DFX */
+ { 21244, 0x0000809D }, /* GL_MULTISAMPLE_ARB */
+ { 21263, 0x20000000 }, /* GL_MULTISAMPLE_BIT */
+ { 21282, 0x20000000 }, /* GL_MULTISAMPLE_BIT_3DFX */
+ { 21306, 0x20000000 }, /* GL_MULTISAMPLE_BIT_ARB */
+ { 21329, 0x00008534 }, /* GL_MULTISAMPLE_FILTER_HINT_NV */
+ { 21359, 0x00002A25 }, /* GL_N3F_V3F */
+ { 21370, 0x00000D70 }, /* GL_NAME_STACK_DEPTH */
+ { 21390, 0x0000150E }, /* GL_NAND */
+ { 21398, 0x00002600 }, /* GL_NEAREST */
+ { 21409, 0x0000844E }, /* GL_NEAREST_CLIPMAP_LINEAR_SGIX */
+ { 21440, 0x0000844D }, /* GL_NEAREST_CLIPMAP_NEAREST_SGIX */
+ { 21472, 0x00002702 }, /* GL_NEAREST_MIPMAP_LINEAR */
+ { 21497, 0x00002700 }, /* GL_NEAREST_MIPMAP_NEAREST */
+ { 21523, 0x00000200 }, /* GL_NEVER */
+ { 21532, 0x00001102 }, /* GL_NICEST */
+ { 21542, 0x00000000 }, /* GL_NONE */
+ { 21550, 0x00001505 }, /* GL_NOOP */
+ { 21558, 0x00001508 }, /* GL_NOR */
+ { 21565, 0x00000BA1 }, /* GL_NORMALIZE */
+ { 21578, 0x00008075 }, /* GL_NORMAL_ARRAY */
+ { 21594, 0x00008897 }, /* GL_NORMAL_ARRAY_BUFFER_BINDING */
+ { 21625, 0x00008897 }, /* GL_NORMAL_ARRAY_BUFFER_BINDING_ARB */
+ { 21660, 0x0000808F }, /* GL_NORMAL_ARRAY_POINTER */
+ { 21684, 0x0000807F }, /* GL_NORMAL_ARRAY_STRIDE */
+ { 21707, 0x0000807E }, /* GL_NORMAL_ARRAY_TYPE */
+ { 21728, 0x00008511 }, /* GL_NORMAL_MAP */
+ { 21742, 0x00008511 }, /* GL_NORMAL_MAP_ARB */
+ { 21760, 0x00008511 }, /* GL_NORMAL_MAP_NV */
+ { 21777, 0x00000205 }, /* GL_NOTEQUAL */
+ { 21789, 0x00000000 }, /* GL_NO_ERROR */
+ { 21801, 0x000086A2 }, /* GL_NUM_COMPRESSED_TEXTURE_FORMATS */
+ { 21835, 0x000086A2 }, /* GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB */
+ { 21873, 0x00008B89 }, /* GL_OBJECT_ACTIVE_ATTRIBUTES_ARB */
+ { 21905, 0x00008B8A }, /* GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB */
+ { 21947, 0x00008B86 }, /* GL_OBJECT_ACTIVE_UNIFORMS_ARB */
+ { 21977, 0x00008B87 }, /* GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB */
+ { 22017, 0x00008B85 }, /* GL_OBJECT_ATTACHED_OBJECTS_ARB */
+ { 22048, 0x00008B81 }, /* GL_OBJECT_COMPILE_STATUS_ARB */
+ { 22077, 0x00008B80 }, /* GL_OBJECT_DELETE_STATUS_ARB */
+ { 22105, 0x00008B84 }, /* GL_OBJECT_INFO_LOG_LENGTH_ARB */
+ { 22135, 0x00002401 }, /* GL_OBJECT_LINEAR */
+ { 22152, 0x00008B82 }, /* GL_OBJECT_LINK_STATUS_ARB */
+ { 22178, 0x00002501 }, /* GL_OBJECT_PLANE */
+ { 22194, 0x00008B88 }, /* GL_OBJECT_SHADER_SOURCE_LENGTH_ARB */
+ { 22229, 0x00008B4F }, /* GL_OBJECT_SUBTYPE_ARB */
+ { 22251, 0x00009112 }, /* GL_OBJECT_TYPE */
+ { 22266, 0x00008B4E }, /* GL_OBJECT_TYPE_ARB */
+ { 22285, 0x00008B83 }, /* GL_OBJECT_VALIDATE_STATUS_ARB */
+ { 22315, 0x00008165 }, /* GL_OCCLUSION_TEST_HP */
+ { 22336, 0x00008166 }, /* GL_OCCLUSION_TEST_RESULT_HP */
+ { 22364, 0x00000001 }, /* GL_ONE */
+ { 22371, 0x00008004 }, /* GL_ONE_MINUS_CONSTANT_ALPHA */
+ { 22399, 0x00008004 }, /* GL_ONE_MINUS_CONSTANT_ALPHA_EXT */
+ { 22431, 0x00008002 }, /* GL_ONE_MINUS_CONSTANT_COLOR */
+ { 22459, 0x00008002 }, /* GL_ONE_MINUS_CONSTANT_COLOR_EXT */
+ { 22491, 0x00000305 }, /* GL_ONE_MINUS_DST_ALPHA */
+ { 22514, 0x00000307 }, /* GL_ONE_MINUS_DST_COLOR */
+ { 22537, 0x00000303 }, /* GL_ONE_MINUS_SRC_ALPHA */
+ { 22560, 0x00000301 }, /* GL_ONE_MINUS_SRC_COLOR */
+ { 22583, 0x00008598 }, /* GL_OPERAND0_ALPHA */
+ { 22601, 0x00008598 }, /* GL_OPERAND0_ALPHA_ARB */
+ { 22623, 0x00008598 }, /* GL_OPERAND0_ALPHA_EXT */
+ { 22645, 0x00008590 }, /* GL_OPERAND0_RGB */
+ { 22661, 0x00008590 }, /* GL_OPERAND0_RGB_ARB */
+ { 22681, 0x00008590 }, /* GL_OPERAND0_RGB_EXT */
+ { 22701, 0x00008599 }, /* GL_OPERAND1_ALPHA */
+ { 22719, 0x00008599 }, /* GL_OPERAND1_ALPHA_ARB */
+ { 22741, 0x00008599 }, /* GL_OPERAND1_ALPHA_EXT */
+ { 22763, 0x00008591 }, /* GL_OPERAND1_RGB */
+ { 22779, 0x00008591 }, /* GL_OPERAND1_RGB_ARB */
+ { 22799, 0x00008591 }, /* GL_OPERAND1_RGB_EXT */
+ { 22819, 0x0000859A }, /* GL_OPERAND2_ALPHA */
+ { 22837, 0x0000859A }, /* GL_OPERAND2_ALPHA_ARB */
+ { 22859, 0x0000859A }, /* GL_OPERAND2_ALPHA_EXT */
+ { 22881, 0x00008592 }, /* GL_OPERAND2_RGB */
+ { 22897, 0x00008592 }, /* GL_OPERAND2_RGB_ARB */
+ { 22917, 0x00008592 }, /* GL_OPERAND2_RGB_EXT */
+ { 22937, 0x0000859B }, /* GL_OPERAND3_ALPHA_NV */
+ { 22958, 0x00008593 }, /* GL_OPERAND3_RGB_NV */
+ { 22977, 0x00001507 }, /* GL_OR */
+ { 22983, 0x00000A01 }, /* GL_ORDER */
+ { 22992, 0x0000150D }, /* GL_OR_INVERTED */
+ { 23007, 0x0000150B }, /* GL_OR_REVERSE */
+ { 23021, 0x00000505 }, /* GL_OUT_OF_MEMORY */
+ { 23038, 0x00000D05 }, /* GL_PACK_ALIGNMENT */
+ { 23056, 0x0000806C }, /* GL_PACK_IMAGE_HEIGHT */
+ { 23077, 0x00008758 }, /* GL_PACK_INVERT_MESA */
+ { 23097, 0x00000D01 }, /* GL_PACK_LSB_FIRST */
+ { 23115, 0x00000D02 }, /* GL_PACK_ROW_LENGTH */
+ { 23134, 0x0000806B }, /* GL_PACK_SKIP_IMAGES */
+ { 23154, 0x00000D04 }, /* GL_PACK_SKIP_PIXELS */
+ { 23174, 0x00000D03 }, /* GL_PACK_SKIP_ROWS */
+ { 23192, 0x00000D00 }, /* GL_PACK_SWAP_BYTES */
+ { 23211, 0x00008B92 }, /* GL_PALETTE4_R5_G6_B5_OES */
+ { 23236, 0x00008B94 }, /* GL_PALETTE4_RGB5_A1_OES */
+ { 23260, 0x00008B90 }, /* GL_PALETTE4_RGB8_OES */
+ { 23281, 0x00008B93 }, /* GL_PALETTE4_RGBA4_OES */
+ { 23303, 0x00008B91 }, /* GL_PALETTE4_RGBA8_OES */
+ { 23325, 0x00008B97 }, /* GL_PALETTE8_R5_G6_B5_OES */
+ { 23350, 0x00008B99 }, /* GL_PALETTE8_RGB5_A1_OES */
+ { 23374, 0x00008B95 }, /* GL_PALETTE8_RGB8_OES */
+ { 23395, 0x00008B98 }, /* GL_PALETTE8_RGBA4_OES */
+ { 23417, 0x00008B96 }, /* GL_PALETTE8_RGBA8_OES */
+ { 23439, 0x00000700 }, /* GL_PASS_THROUGH_TOKEN */
+ { 23461, 0x00000C50 }, /* GL_PERSPECTIVE_CORRECTION_HINT */
+ { 23492, 0x00000C79 }, /* GL_PIXEL_MAP_A_TO_A */
+ { 23512, 0x00000CB9 }, /* GL_PIXEL_MAP_A_TO_A_SIZE */
+ { 23537, 0x00000C78 }, /* GL_PIXEL_MAP_B_TO_B */
+ { 23557, 0x00000CB8 }, /* GL_PIXEL_MAP_B_TO_B_SIZE */
+ { 23582, 0x00000C77 }, /* GL_PIXEL_MAP_G_TO_G */
+ { 23602, 0x00000CB7 }, /* GL_PIXEL_MAP_G_TO_G_SIZE */
+ { 23627, 0x00000C75 }, /* GL_PIXEL_MAP_I_TO_A */
+ { 23647, 0x00000CB5 }, /* GL_PIXEL_MAP_I_TO_A_SIZE */
+ { 23672, 0x00000C74 }, /* GL_PIXEL_MAP_I_TO_B */
+ { 23692, 0x00000CB4 }, /* GL_PIXEL_MAP_I_TO_B_SIZE */
+ { 23717, 0x00000C73 }, /* GL_PIXEL_MAP_I_TO_G */
+ { 23737, 0x00000CB3 }, /* GL_PIXEL_MAP_I_TO_G_SIZE */
+ { 23762, 0x00000C70 }, /* GL_PIXEL_MAP_I_TO_I */
+ { 23782, 0x00000CB0 }, /* GL_PIXEL_MAP_I_TO_I_SIZE */
+ { 23807, 0x00000C72 }, /* GL_PIXEL_MAP_I_TO_R */
+ { 23827, 0x00000CB2 }, /* GL_PIXEL_MAP_I_TO_R_SIZE */
+ { 23852, 0x00000C76 }, /* GL_PIXEL_MAP_R_TO_R */
+ { 23872, 0x00000CB6 }, /* GL_PIXEL_MAP_R_TO_R_SIZE */
+ { 23897, 0x00000C71 }, /* GL_PIXEL_MAP_S_TO_S */
+ { 23917, 0x00000CB1 }, /* GL_PIXEL_MAP_S_TO_S_SIZE */
+ { 23942, 0x00000020 }, /* GL_PIXEL_MODE_BIT */
+ { 23960, 0x000088EB }, /* GL_PIXEL_PACK_BUFFER */
+ { 23981, 0x000088ED }, /* GL_PIXEL_PACK_BUFFER_BINDING */
+ { 24010, 0x000088ED }, /* GL_PIXEL_PACK_BUFFER_BINDING_EXT */
+ { 24043, 0x000088EB }, /* GL_PIXEL_PACK_BUFFER_EXT */
+ { 24068, 0x000088EC }, /* GL_PIXEL_UNPACK_BUFFER */
+ { 24091, 0x000088EF }, /* GL_PIXEL_UNPACK_BUFFER_BINDING */
+ { 24122, 0x000088EF }, /* GL_PIXEL_UNPACK_BUFFER_BINDING_EXT */
+ { 24157, 0x000088EC }, /* GL_PIXEL_UNPACK_BUFFER_EXT */
+ { 24184, 0x00001B00 }, /* GL_POINT */
+ { 24193, 0x00000000 }, /* GL_POINTS */
+ { 24203, 0x00000002 }, /* GL_POINT_BIT */
+ { 24216, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION */
+ { 24246, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_ARB */
+ { 24280, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_EXT */
+ { 24314, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_SGIS */
+ { 24349, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE */
+ { 24378, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_ARB */
+ { 24411, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_EXT */
+ { 24444, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_SGIS */
+ { 24478, 0x00000B11 }, /* GL_POINT_SIZE */
+ { 24492, 0x00000B13 }, /* GL_POINT_SIZE_GRANULARITY */
+ { 24518, 0x00008127 }, /* GL_POINT_SIZE_MAX */
+ { 24536, 0x00008127 }, /* GL_POINT_SIZE_MAX_ARB */
+ { 24558, 0x00008127 }, /* GL_POINT_SIZE_MAX_EXT */
+ { 24580, 0x00008127 }, /* GL_POINT_SIZE_MAX_SGIS */
+ { 24603, 0x00008126 }, /* GL_POINT_SIZE_MIN */
+ { 24621, 0x00008126 }, /* GL_POINT_SIZE_MIN_ARB */
+ { 24643, 0x00008126 }, /* GL_POINT_SIZE_MIN_EXT */
+ { 24665, 0x00008126 }, /* GL_POINT_SIZE_MIN_SGIS */
+ { 24688, 0x00000B12 }, /* GL_POINT_SIZE_RANGE */
+ { 24708, 0x00000B10 }, /* GL_POINT_SMOOTH */
+ { 24724, 0x00000C51 }, /* GL_POINT_SMOOTH_HINT */
+ { 24745, 0x00008861 }, /* GL_POINT_SPRITE */
+ { 24761, 0x00008861 }, /* GL_POINT_SPRITE_ARB */
+ { 24781, 0x00008CA0 }, /* GL_POINT_SPRITE_COORD_ORIGIN */
+ { 24810, 0x00008861 }, /* GL_POINT_SPRITE_NV */
+ { 24829, 0x00008863 }, /* GL_POINT_SPRITE_R_MODE_NV */
+ { 24855, 0x00000701 }, /* GL_POINT_TOKEN */
+ { 24870, 0x00000009 }, /* GL_POLYGON */
+ { 24881, 0x00000008 }, /* GL_POLYGON_BIT */
+ { 24896, 0x00000B40 }, /* GL_POLYGON_MODE */
+ { 24912, 0x00008039 }, /* GL_POLYGON_OFFSET_BIAS */
+ { 24935, 0x00008038 }, /* GL_POLYGON_OFFSET_FACTOR */
+ { 24960, 0x00008037 }, /* GL_POLYGON_OFFSET_FILL */
+ { 24983, 0x00002A02 }, /* GL_POLYGON_OFFSET_LINE */
+ { 25006, 0x00002A01 }, /* GL_POLYGON_OFFSET_POINT */
+ { 25030, 0x00002A00 }, /* GL_POLYGON_OFFSET_UNITS */
+ { 25054, 0x00000B41 }, /* GL_POLYGON_SMOOTH */
+ { 25072, 0x00000C53 }, /* GL_POLYGON_SMOOTH_HINT */
+ { 25095, 0x00000B42 }, /* GL_POLYGON_STIPPLE */
+ { 25114, 0x00000010 }, /* GL_POLYGON_STIPPLE_BIT */
+ { 25137, 0x00000703 }, /* GL_POLYGON_TOKEN */
+ { 25154, 0x00001203 }, /* GL_POSITION */
+ { 25166, 0x000080BB }, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS */
+ { 25198, 0x000080BB }, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI */
+ { 25234, 0x000080B7 }, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE */
+ { 25267, 0x000080B7 }, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI */
+ { 25304, 0x000080BA }, /* GL_POST_COLOR_MATRIX_BLUE_BIAS */
+ { 25335, 0x000080BA }, /* GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI */
+ { 25370, 0x000080B6 }, /* GL_POST_COLOR_MATRIX_BLUE_SCALE */
+ { 25402, 0x000080B6 }, /* GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI */
+ { 25438, 0x000080D2 }, /* GL_POST_COLOR_MATRIX_COLOR_TABLE */
+ { 25471, 0x000080B9 }, /* GL_POST_COLOR_MATRIX_GREEN_BIAS */
+ { 25503, 0x000080B9 }, /* GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI */
+ { 25539, 0x000080B5 }, /* GL_POST_COLOR_MATRIX_GREEN_SCALE */
+ { 25572, 0x000080B5 }, /* GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI */
+ { 25609, 0x000080B8 }, /* GL_POST_COLOR_MATRIX_RED_BIAS */
+ { 25639, 0x000080B8 }, /* GL_POST_COLOR_MATRIX_RED_BIAS_SGI */
+ { 25673, 0x000080B4 }, /* GL_POST_COLOR_MATRIX_RED_SCALE */
+ { 25704, 0x000080B4 }, /* GL_POST_COLOR_MATRIX_RED_SCALE_SGI */
+ { 25739, 0x00008023 }, /* GL_POST_CONVOLUTION_ALPHA_BIAS */
+ { 25770, 0x00008023 }, /* GL_POST_CONVOLUTION_ALPHA_BIAS_EXT */
+ { 25805, 0x0000801F }, /* GL_POST_CONVOLUTION_ALPHA_SCALE */
+ { 25837, 0x0000801F }, /* GL_POST_CONVOLUTION_ALPHA_SCALE_EXT */
+ { 25873, 0x00008022 }, /* GL_POST_CONVOLUTION_BLUE_BIAS */
+ { 25903, 0x00008022 }, /* GL_POST_CONVOLUTION_BLUE_BIAS_EXT */
+ { 25937, 0x0000801E }, /* GL_POST_CONVOLUTION_BLUE_SCALE */
+ { 25968, 0x0000801E }, /* GL_POST_CONVOLUTION_BLUE_SCALE_EXT */
+ { 26003, 0x000080D1 }, /* GL_POST_CONVOLUTION_COLOR_TABLE */
+ { 26035, 0x00008021 }, /* GL_POST_CONVOLUTION_GREEN_BIAS */
+ { 26066, 0x00008021 }, /* GL_POST_CONVOLUTION_GREEN_BIAS_EXT */
+ { 26101, 0x0000801D }, /* GL_POST_CONVOLUTION_GREEN_SCALE */
+ { 26133, 0x0000801D }, /* GL_POST_CONVOLUTION_GREEN_SCALE_EXT */
+ { 26169, 0x00008020 }, /* GL_POST_CONVOLUTION_RED_BIAS */
+ { 26198, 0x00008020 }, /* GL_POST_CONVOLUTION_RED_BIAS_EXT */
+ { 26231, 0x0000801C }, /* GL_POST_CONVOLUTION_RED_SCALE */
+ { 26261, 0x0000801C }, /* GL_POST_CONVOLUTION_RED_SCALE_EXT */
+ { 26295, 0x0000817B }, /* GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX */
+ { 26334, 0x00008179 }, /* GL_POST_TEXTURE_FILTER_BIAS_SGIX */
+ { 26367, 0x0000817C }, /* GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX */
+ { 26407, 0x0000817A }, /* GL_POST_TEXTURE_FILTER_SCALE_SGIX */
+ { 26441, 0x00008578 }, /* GL_PREVIOUS */
+ { 26453, 0x00008578 }, /* GL_PREVIOUS_ARB */
+ { 26469, 0x00008578 }, /* GL_PREVIOUS_EXT */
+ { 26485, 0x00008577 }, /* GL_PRIMARY_COLOR */
+ { 26502, 0x00008577 }, /* GL_PRIMARY_COLOR_ARB */
+ { 26523, 0x00008577 }, /* GL_PRIMARY_COLOR_EXT */
+ { 26544, 0x000088B0 }, /* GL_PROGRAM_ADDRESS_REGISTERS_ARB */
+ { 26577, 0x00008805 }, /* GL_PROGRAM_ALU_INSTRUCTIONS_ARB */
+ { 26609, 0x000088AC }, /* GL_PROGRAM_ATTRIBS_ARB */
+ { 26632, 0x00008677 }, /* GL_PROGRAM_BINDING_ARB */
+ { 26655, 0x0000864B }, /* GL_PROGRAM_ERROR_POSITION_ARB */
+ { 26685, 0x0000864B }, /* GL_PROGRAM_ERROR_POSITION_NV */
+ { 26714, 0x00008874 }, /* GL_PROGRAM_ERROR_STRING_ARB */
+ { 26742, 0x00008876 }, /* GL_PROGRAM_FORMAT_ARB */
+ { 26764, 0x00008875 }, /* GL_PROGRAM_FORMAT_ASCII_ARB */
+ { 26792, 0x000088A0 }, /* GL_PROGRAM_INSTRUCTIONS_ARB */
+ { 26820, 0x00008627 }, /* GL_PROGRAM_LENGTH_ARB */
+ { 26842, 0x00008627 }, /* GL_PROGRAM_LENGTH_NV */
+ { 26863, 0x000088B2 }, /* GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */
+ { 26903, 0x00008808 }, /* GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */
+ { 26942, 0x000088AE }, /* GL_PROGRAM_NATIVE_ATTRIBS_ARB */
+ { 26972, 0x000088A2 }, /* GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB */
+ { 27007, 0x000088AA }, /* GL_PROGRAM_NATIVE_PARAMETERS_ARB */
+ { 27040, 0x000088A6 }, /* GL_PROGRAM_NATIVE_TEMPORARIES_ARB */
+ { 27074, 0x0000880A }, /* GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */
+ { 27113, 0x00008809 }, /* GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */
+ { 27152, 0x00008B40 }, /* GL_PROGRAM_OBJECT_ARB */
+ { 27174, 0x000088A8 }, /* GL_PROGRAM_PARAMETERS_ARB */
+ { 27200, 0x00008644 }, /* GL_PROGRAM_PARAMETER_NV */
+ { 27224, 0x00008647 }, /* GL_PROGRAM_RESIDENT_NV */
+ { 27247, 0x00008628 }, /* GL_PROGRAM_STRING_ARB */
+ { 27269, 0x00008628 }, /* GL_PROGRAM_STRING_NV */
+ { 27290, 0x00008646 }, /* GL_PROGRAM_TARGET_NV */
+ { 27311, 0x000088A4 }, /* GL_PROGRAM_TEMPORARIES_ARB */
+ { 27338, 0x00008807 }, /* GL_PROGRAM_TEX_INDIRECTIONS_ARB */
+ { 27370, 0x00008806 }, /* GL_PROGRAM_TEX_INSTRUCTIONS_ARB */
+ { 27402, 0x000088B6 }, /* GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB */
+ { 27437, 0x00001701 }, /* GL_PROJECTION */
+ { 27451, 0x00000BA7 }, /* GL_PROJECTION_MATRIX */
+ { 27472, 0x00000BA4 }, /* GL_PROJECTION_STACK_DEPTH */
+ { 27498, 0x00008E4F }, /* GL_PROVOKING_VERTEX_EXT */
+ { 27522, 0x000080D3 }, /* GL_PROXY_COLOR_TABLE */
+ { 27543, 0x00008025 }, /* GL_PROXY_HISTOGRAM */
+ { 27562, 0x00008025 }, /* GL_PROXY_HISTOGRAM_EXT */
+ { 27585, 0x000080D5 }, /* GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE */
+ { 27624, 0x000080D4 }, /* GL_PROXY_POST_CONVOLUTION_COLOR_TABLE */
+ { 27662, 0x00008063 }, /* GL_PROXY_TEXTURE_1D */
+ { 27682, 0x00008C19 }, /* GL_PROXY_TEXTURE_1D_ARRAY_EXT */
+ { 27712, 0x00008063 }, /* GL_PROXY_TEXTURE_1D_EXT */
+ { 27736, 0x00008064 }, /* GL_PROXY_TEXTURE_2D */
+ { 27756, 0x00008C1B }, /* GL_PROXY_TEXTURE_2D_ARRAY_EXT */
+ { 27786, 0x00008064 }, /* GL_PROXY_TEXTURE_2D_EXT */
+ { 27810, 0x00008070 }, /* GL_PROXY_TEXTURE_3D */
+ { 27830, 0x000080BD }, /* GL_PROXY_TEXTURE_COLOR_TABLE_SGI */
+ { 27863, 0x0000851B }, /* GL_PROXY_TEXTURE_CUBE_MAP */
+ { 27889, 0x0000851B }, /* GL_PROXY_TEXTURE_CUBE_MAP_ARB */
+ { 27919, 0x000084F7 }, /* GL_PROXY_TEXTURE_RECTANGLE_ARB */
+ { 27950, 0x000084F7 }, /* GL_PROXY_TEXTURE_RECTANGLE_NV */
+ { 27980, 0x00002003 }, /* GL_Q */
+ { 27985, 0x00001209 }, /* GL_QUADRATIC_ATTENUATION */
+ { 28010, 0x00000007 }, /* GL_QUADS */
+ { 28019, 0x00008E4C }, /* GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT */
+ { 28067, 0x00008614 }, /* GL_QUAD_MESH_SUN */
+ { 28084, 0x00000008 }, /* GL_QUAD_STRIP */
+ { 28098, 0x00008864 }, /* GL_QUERY_COUNTER_BITS */
+ { 28120, 0x00008864 }, /* GL_QUERY_COUNTER_BITS_ARB */
+ { 28146, 0x00008866 }, /* GL_QUERY_RESULT */
+ { 28162, 0x00008866 }, /* GL_QUERY_RESULT_ARB */
+ { 28182, 0x00008867 }, /* GL_QUERY_RESULT_AVAILABLE */
+ { 28208, 0x00008867 }, /* GL_QUERY_RESULT_AVAILABLE_ARB */
+ { 28238, 0x00002002 }, /* GL_R */
+ { 28243, 0x00002A10 }, /* GL_R3_G3_B2 */
+ { 28255, 0x00019262 }, /* GL_RASTER_POSITION_UNCLIPPED_IBM */
+ { 28288, 0x00000C02 }, /* GL_READ_BUFFER */
+ { 28303, 0x00008CA8 }, /* GL_READ_FRAMEBUFFER */
+ { 28323, 0x00008CAA }, /* GL_READ_FRAMEBUFFER_BINDING_EXT */
+ { 28355, 0x00008CA8 }, /* GL_READ_FRAMEBUFFER_EXT */
+ { 28379, 0x000088B8 }, /* GL_READ_ONLY */
+ { 28392, 0x000088B8 }, /* GL_READ_ONLY_ARB */
+ { 28409, 0x000088BA }, /* GL_READ_WRITE */
+ { 28423, 0x000088BA }, /* GL_READ_WRITE_ARB */
+ { 28441, 0x00001903 }, /* GL_RED */
+ { 28448, 0x00008016 }, /* GL_REDUCE */
+ { 28458, 0x00008016 }, /* GL_REDUCE_EXT */
+ { 28472, 0x00000D15 }, /* GL_RED_BIAS */
+ { 28484, 0x00000D52 }, /* GL_RED_BITS */
+ { 28496, 0x00000D14 }, /* GL_RED_SCALE */
+ { 28509, 0x00008512 }, /* GL_REFLECTION_MAP */
+ { 28527, 0x00008512 }, /* GL_REFLECTION_MAP_ARB */
+ { 28549, 0x00008512 }, /* GL_REFLECTION_MAP_NV */
+ { 28570, 0x00001C00 }, /* GL_RENDER */
+ { 28580, 0x00008D41 }, /* GL_RENDERBUFFER */
+ { 28596, 0x00008D53 }, /* GL_RENDERBUFFER_ALPHA_SIZE */
+ { 28623, 0x00008CA7 }, /* GL_RENDERBUFFER_BINDING_EXT */
+ { 28651, 0x00008D52 }, /* GL_RENDERBUFFER_BLUE_SIZE */
+ { 28677, 0x00008D54 }, /* GL_RENDERBUFFER_DEPTH_SIZE */
+ { 28704, 0x00008D41 }, /* GL_RENDERBUFFER_EXT */
+ { 28724, 0x00008D51 }, /* GL_RENDERBUFFER_GREEN_SIZE */
+ { 28751, 0x00008D43 }, /* GL_RENDERBUFFER_HEIGHT */
+ { 28774, 0x00008D43 }, /* GL_RENDERBUFFER_HEIGHT_EXT */
+ { 28801, 0x00008D44 }, /* GL_RENDERBUFFER_INTERNAL_FORMAT */
+ { 28833, 0x00008D44 }, /* GL_RENDERBUFFER_INTERNAL_FORMAT_EXT */
+ { 28869, 0x00008D50 }, /* GL_RENDERBUFFER_RED_SIZE */
+ { 28894, 0x00008CAB }, /* GL_RENDERBUFFER_SAMPLES */
+ { 28918, 0x00008D55 }, /* GL_RENDERBUFFER_STENCIL_SIZE */
+ { 28947, 0x00008D42 }, /* GL_RENDERBUFFER_WIDTH */
+ { 28969, 0x00008D42 }, /* GL_RENDERBUFFER_WIDTH_EXT */
+ { 28995, 0x00001F01 }, /* GL_RENDERER */
+ { 29007, 0x00000C40 }, /* GL_RENDER_MODE */
+ { 29022, 0x00002901 }, /* GL_REPEAT */
+ { 29032, 0x00001E01 }, /* GL_REPLACE */
+ { 29043, 0x00008062 }, /* GL_REPLACE_EXT */
+ { 29058, 0x00008153 }, /* GL_REPLICATE_BORDER_HP */
+ { 29081, 0x0000803A }, /* GL_RESCALE_NORMAL */
+ { 29099, 0x0000803A }, /* GL_RESCALE_NORMAL_EXT */
+ { 29121, 0x00000102 }, /* GL_RETURN */
+ { 29131, 0x00001907 }, /* GL_RGB */
+ { 29138, 0x00008052 }, /* GL_RGB10 */
+ { 29147, 0x00008059 }, /* GL_RGB10_A2 */
+ { 29159, 0x00008059 }, /* GL_RGB10_A2_EXT */
+ { 29175, 0x00008052 }, /* GL_RGB10_EXT */
+ { 29188, 0x00008053 }, /* GL_RGB12 */
+ { 29197, 0x00008053 }, /* GL_RGB12_EXT */
+ { 29210, 0x00008054 }, /* GL_RGB16 */
+ { 29219, 0x00008054 }, /* GL_RGB16_EXT */
+ { 29232, 0x0000804E }, /* GL_RGB2_EXT */
+ { 29244, 0x0000804F }, /* GL_RGB4 */
+ { 29252, 0x0000804F }, /* GL_RGB4_EXT */
+ { 29264, 0x000083A1 }, /* GL_RGB4_S3TC */
+ { 29277, 0x00008050 }, /* GL_RGB5 */
+ { 29285, 0x00008057 }, /* GL_RGB5_A1 */
+ { 29296, 0x00008057 }, /* GL_RGB5_A1_EXT */
+ { 29311, 0x00008050 }, /* GL_RGB5_EXT */
+ { 29323, 0x00008051 }, /* GL_RGB8 */
+ { 29331, 0x00008051 }, /* GL_RGB8_EXT */
+ { 29343, 0x00001908 }, /* GL_RGBA */
+ { 29351, 0x0000805A }, /* GL_RGBA12 */
+ { 29361, 0x0000805A }, /* GL_RGBA12_EXT */
+ { 29375, 0x0000805B }, /* GL_RGBA16 */
+ { 29385, 0x0000805B }, /* GL_RGBA16_EXT */
+ { 29399, 0x00008055 }, /* GL_RGBA2 */
+ { 29408, 0x00008055 }, /* GL_RGBA2_EXT */
+ { 29421, 0x00008056 }, /* GL_RGBA4 */
+ { 29430, 0x000083A5 }, /* GL_RGBA4_DXT5_S3TC */
+ { 29449, 0x00008056 }, /* GL_RGBA4_EXT */
+ { 29462, 0x000083A3 }, /* GL_RGBA4_S3TC */
+ { 29476, 0x00008058 }, /* GL_RGBA8 */
+ { 29485, 0x00008058 }, /* GL_RGBA8_EXT */
+ { 29498, 0x00008F97 }, /* GL_RGBA8_SNORM */
+ { 29513, 0x000083A4 }, /* GL_RGBA_DXT5_S3TC */
+ { 29531, 0x00000C31 }, /* GL_RGBA_MODE */
+ { 29544, 0x000083A2 }, /* GL_RGBA_S3TC */
+ { 29557, 0x00008F93 }, /* GL_RGBA_SNORM */
+ { 29571, 0x000083A0 }, /* GL_RGB_S3TC */
+ { 29583, 0x00008573 }, /* GL_RGB_SCALE */
+ { 29596, 0x00008573 }, /* GL_RGB_SCALE_ARB */
+ { 29613, 0x00008573 }, /* GL_RGB_SCALE_EXT */
+ { 29630, 0x00000407 }, /* GL_RIGHT */
+ { 29639, 0x00002000 }, /* GL_S */
+ { 29644, 0x00008B5D }, /* GL_SAMPLER_1D */
+ { 29658, 0x00008B61 }, /* GL_SAMPLER_1D_SHADOW */
+ { 29679, 0x00008B5E }, /* GL_SAMPLER_2D */
+ { 29693, 0x00008B62 }, /* GL_SAMPLER_2D_SHADOW */
+ { 29714, 0x00008B5F }, /* GL_SAMPLER_3D */
+ { 29728, 0x00008B60 }, /* GL_SAMPLER_CUBE */
+ { 29744, 0x000080A9 }, /* GL_SAMPLES */
+ { 29755, 0x000086B4 }, /* GL_SAMPLES_3DFX */
+ { 29771, 0x000080A9 }, /* GL_SAMPLES_ARB */
+ { 29786, 0x00008914 }, /* GL_SAMPLES_PASSED */
+ { 29804, 0x00008914 }, /* GL_SAMPLES_PASSED_ARB */
+ { 29826, 0x0000809E }, /* GL_SAMPLE_ALPHA_TO_COVERAGE */
+ { 29854, 0x0000809E }, /* GL_SAMPLE_ALPHA_TO_COVERAGE_ARB */
+ { 29886, 0x0000809F }, /* GL_SAMPLE_ALPHA_TO_ONE */
+ { 29909, 0x0000809F }, /* GL_SAMPLE_ALPHA_TO_ONE_ARB */
+ { 29936, 0x000080A8 }, /* GL_SAMPLE_BUFFERS */
+ { 29954, 0x000086B3 }, /* GL_SAMPLE_BUFFERS_3DFX */
+ { 29977, 0x000080A8 }, /* GL_SAMPLE_BUFFERS_ARB */
+ { 29999, 0x000080A0 }, /* GL_SAMPLE_COVERAGE */
+ { 30018, 0x000080A0 }, /* GL_SAMPLE_COVERAGE_ARB */
+ { 30041, 0x000080AB }, /* GL_SAMPLE_COVERAGE_INVERT */
+ { 30067, 0x000080AB }, /* GL_SAMPLE_COVERAGE_INVERT_ARB */
+ { 30097, 0x000080AA }, /* GL_SAMPLE_COVERAGE_VALUE */
+ { 30122, 0x000080AA }, /* GL_SAMPLE_COVERAGE_VALUE_ARB */
+ { 30151, 0x00080000 }, /* GL_SCISSOR_BIT */
+ { 30166, 0x00000C10 }, /* GL_SCISSOR_BOX */
+ { 30181, 0x00000C11 }, /* GL_SCISSOR_TEST */
+ { 30197, 0x0000845E }, /* GL_SECONDARY_COLOR_ARRAY */
+ { 30222, 0x0000889C }, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING */
+ { 30262, 0x0000889C }, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB */
+ { 30306, 0x0000845D }, /* GL_SECONDARY_COLOR_ARRAY_POINTER */
+ { 30339, 0x0000845A }, /* GL_SECONDARY_COLOR_ARRAY_SIZE */
+ { 30369, 0x0000845C }, /* GL_SECONDARY_COLOR_ARRAY_STRIDE */
+ { 30401, 0x0000845B }, /* GL_SECONDARY_COLOR_ARRAY_TYPE */
+ { 30431, 0x00001C02 }, /* GL_SELECT */
+ { 30441, 0x00000DF3 }, /* GL_SELECTION_BUFFER_POINTER */
+ { 30469, 0x00000DF4 }, /* GL_SELECTION_BUFFER_SIZE */
+ { 30494, 0x00008012 }, /* GL_SEPARABLE_2D */
+ { 30510, 0x000081FA }, /* GL_SEPARATE_SPECULAR_COLOR */
+ { 30537, 0x000081FA }, /* GL_SEPARATE_SPECULAR_COLOR_EXT */
+ { 30568, 0x0000150F }, /* GL_SET */
+ { 30575, 0x00008B48 }, /* GL_SHADER_OBJECT_ARB */
+ { 30596, 0x00008B88 }, /* GL_SHADER_SOURCE_LENGTH */
+ { 30620, 0x00008B4F }, /* GL_SHADER_TYPE */
+ { 30635, 0x00000B54 }, /* GL_SHADE_MODEL */
+ { 30650, 0x00008B8C }, /* GL_SHADING_LANGUAGE_VERSION */
+ { 30678, 0x000080BF }, /* GL_SHADOW_AMBIENT_SGIX */
+ { 30701, 0x000081FB }, /* GL_SHARED_TEXTURE_PALETTE_EXT */
+ { 30731, 0x00001601 }, /* GL_SHININESS */
+ { 30744, 0x00001402 }, /* GL_SHORT */
+ { 30753, 0x00009119 }, /* GL_SIGNALED */
+ { 30765, 0x00008F9C }, /* GL_SIGNED_NORMALIZED */
+ { 30786, 0x000081F9 }, /* GL_SINGLE_COLOR */
+ { 30802, 0x000081F9 }, /* GL_SINGLE_COLOR_EXT */
+ { 30822, 0x000085CC }, /* GL_SLICE_ACCUM_SUN */
+ { 30841, 0x00008C46 }, /* GL_SLUMINANCE */
+ { 30855, 0x00008C47 }, /* GL_SLUMINANCE8 */
+ { 30870, 0x00008C45 }, /* GL_SLUMINANCE8_ALPHA8 */
+ { 30892, 0x00008C44 }, /* GL_SLUMINANCE_ALPHA */
+ { 30912, 0x00001D01 }, /* GL_SMOOTH */
+ { 30922, 0x00000B23 }, /* GL_SMOOTH_LINE_WIDTH_GRANULARITY */
+ { 30955, 0x00000B22 }, /* GL_SMOOTH_LINE_WIDTH_RANGE */
+ { 30982, 0x00000B13 }, /* GL_SMOOTH_POINT_SIZE_GRANULARITY */
+ { 31015, 0x00000B12 }, /* GL_SMOOTH_POINT_SIZE_RANGE */
+ { 31042, 0x00008588 }, /* GL_SOURCE0_ALPHA */
+ { 31059, 0x00008588 }, /* GL_SOURCE0_ALPHA_ARB */
+ { 31080, 0x00008588 }, /* GL_SOURCE0_ALPHA_EXT */
+ { 31101, 0x00008580 }, /* GL_SOURCE0_RGB */
+ { 31116, 0x00008580 }, /* GL_SOURCE0_RGB_ARB */
+ { 31135, 0x00008580 }, /* GL_SOURCE0_RGB_EXT */
+ { 31154, 0x00008589 }, /* GL_SOURCE1_ALPHA */
+ { 31171, 0x00008589 }, /* GL_SOURCE1_ALPHA_ARB */
+ { 31192, 0x00008589 }, /* GL_SOURCE1_ALPHA_EXT */
+ { 31213, 0x00008581 }, /* GL_SOURCE1_RGB */
+ { 31228, 0x00008581 }, /* GL_SOURCE1_RGB_ARB */
+ { 31247, 0x00008581 }, /* GL_SOURCE1_RGB_EXT */
+ { 31266, 0x0000858A }, /* GL_SOURCE2_ALPHA */
+ { 31283, 0x0000858A }, /* GL_SOURCE2_ALPHA_ARB */
+ { 31304, 0x0000858A }, /* GL_SOURCE2_ALPHA_EXT */
+ { 31325, 0x00008582 }, /* GL_SOURCE2_RGB */
+ { 31340, 0x00008582 }, /* GL_SOURCE2_RGB_ARB */
+ { 31359, 0x00008582 }, /* GL_SOURCE2_RGB_EXT */
+ { 31378, 0x0000858B }, /* GL_SOURCE3_ALPHA_NV */
+ { 31398, 0x00008583 }, /* GL_SOURCE3_RGB_NV */
+ { 31416, 0x00001202 }, /* GL_SPECULAR */
+ { 31428, 0x00002402 }, /* GL_SPHERE_MAP */
+ { 31442, 0x00001206 }, /* GL_SPOT_CUTOFF */
+ { 31457, 0x00001204 }, /* GL_SPOT_DIRECTION */
+ { 31475, 0x00001205 }, /* GL_SPOT_EXPONENT */
+ { 31492, 0x00008588 }, /* GL_SRC0_ALPHA */
+ { 31506, 0x00008580 }, /* GL_SRC0_RGB */
+ { 31518, 0x00008589 }, /* GL_SRC1_ALPHA */
+ { 31532, 0x00008581 }, /* GL_SRC1_RGB */
+ { 31544, 0x0000858A }, /* GL_SRC2_ALPHA */
+ { 31558, 0x00008582 }, /* GL_SRC2_RGB */
+ { 31570, 0x00000302 }, /* GL_SRC_ALPHA */
+ { 31583, 0x00000308 }, /* GL_SRC_ALPHA_SATURATE */
+ { 31605, 0x00000300 }, /* GL_SRC_COLOR */
+ { 31618, 0x00008C40 }, /* GL_SRGB */
+ { 31626, 0x00008C41 }, /* GL_SRGB8 */
+ { 31635, 0x00008C43 }, /* GL_SRGB8_ALPHA8 */
+ { 31651, 0x00008C42 }, /* GL_SRGB_ALPHA */
+ { 31665, 0x00000503 }, /* GL_STACK_OVERFLOW */
+ { 31683, 0x00000504 }, /* GL_STACK_UNDERFLOW */
+ { 31702, 0x000088E6 }, /* GL_STATIC_COPY */
+ { 31717, 0x000088E6 }, /* GL_STATIC_COPY_ARB */
+ { 31736, 0x000088E4 }, /* GL_STATIC_DRAW */
+ { 31751, 0x000088E4 }, /* GL_STATIC_DRAW_ARB */
+ { 31770, 0x000088E5 }, /* GL_STATIC_READ */
+ { 31785, 0x000088E5 }, /* GL_STATIC_READ_ARB */
+ { 31804, 0x00001802 }, /* GL_STENCIL */
+ { 31815, 0x00008D20 }, /* GL_STENCIL_ATTACHMENT */
+ { 31837, 0x00008D20 }, /* GL_STENCIL_ATTACHMENT_EXT */
+ { 31863, 0x00008801 }, /* GL_STENCIL_BACK_FAIL */
+ { 31884, 0x00008801 }, /* GL_STENCIL_BACK_FAIL_ATI */
+ { 31909, 0x00008800 }, /* GL_STENCIL_BACK_FUNC */
+ { 31930, 0x00008800 }, /* GL_STENCIL_BACK_FUNC_ATI */
+ { 31955, 0x00008802 }, /* GL_STENCIL_BACK_PASS_DEPTH_FAIL */
+ { 31987, 0x00008802 }, /* GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI */
+ { 32023, 0x00008803 }, /* GL_STENCIL_BACK_PASS_DEPTH_PASS */
+ { 32055, 0x00008803 }, /* GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI */
+ { 32091, 0x00008CA3 }, /* GL_STENCIL_BACK_REF */
+ { 32111, 0x00008CA4 }, /* GL_STENCIL_BACK_VALUE_MASK */
+ { 32138, 0x00008CA5 }, /* GL_STENCIL_BACK_WRITEMASK */
+ { 32164, 0x00000D57 }, /* GL_STENCIL_BITS */
+ { 32180, 0x00000400 }, /* GL_STENCIL_BUFFER_BIT */
+ { 32202, 0x00000B91 }, /* GL_STENCIL_CLEAR_VALUE */
+ { 32225, 0x00000B94 }, /* GL_STENCIL_FAIL */
+ { 32241, 0x00000B92 }, /* GL_STENCIL_FUNC */
+ { 32257, 0x00001901 }, /* GL_STENCIL_INDEX */
+ { 32274, 0x00008D49 }, /* GL_STENCIL_INDEX16_EXT */
+ { 32297, 0x00008D46 }, /* GL_STENCIL_INDEX1_EXT */
+ { 32319, 0x00008D47 }, /* GL_STENCIL_INDEX4_EXT */
+ { 32341, 0x00008D48 }, /* GL_STENCIL_INDEX8_EXT */
+ { 32363, 0x00008D45 }, /* GL_STENCIL_INDEX_EXT */
+ { 32384, 0x00000B95 }, /* GL_STENCIL_PASS_DEPTH_FAIL */
+ { 32411, 0x00000B96 }, /* GL_STENCIL_PASS_DEPTH_PASS */
+ { 32438, 0x00000B97 }, /* GL_STENCIL_REF */
+ { 32453, 0x00000B90 }, /* GL_STENCIL_TEST */
+ { 32469, 0x00008910 }, /* GL_STENCIL_TEST_TWO_SIDE_EXT */
+ { 32498, 0x00000B93 }, /* GL_STENCIL_VALUE_MASK */
+ { 32520, 0x00000B98 }, /* GL_STENCIL_WRITEMASK */
+ { 32541, 0x00000C33 }, /* GL_STEREO */
+ { 32551, 0x000085BE }, /* GL_STORAGE_CACHED_APPLE */
+ { 32575, 0x000085BD }, /* GL_STORAGE_PRIVATE_APPLE */
+ { 32600, 0x000085BF }, /* GL_STORAGE_SHARED_APPLE */
+ { 32624, 0x000088E2 }, /* GL_STREAM_COPY */
+ { 32639, 0x000088E2 }, /* GL_STREAM_COPY_ARB */
+ { 32658, 0x000088E0 }, /* GL_STREAM_DRAW */
+ { 32673, 0x000088E0 }, /* GL_STREAM_DRAW_ARB */
+ { 32692, 0x000088E1 }, /* GL_STREAM_READ */
+ { 32707, 0x000088E1 }, /* GL_STREAM_READ_ARB */
+ { 32726, 0x00000D50 }, /* GL_SUBPIXEL_BITS */
+ { 32743, 0x000084E7 }, /* GL_SUBTRACT */
+ { 32755, 0x000084E7 }, /* GL_SUBTRACT_ARB */
+ { 32771, 0x00009113 }, /* GL_SYNC_CONDITION */
+ { 32789, 0x00009116 }, /* GL_SYNC_FENCE */
+ { 32803, 0x00009115 }, /* GL_SYNC_FLAGS */
+ { 32817, 0x00000001 }, /* GL_SYNC_FLUSH_COMMANDS_BIT */
+ { 32844, 0x00009117 }, /* GL_SYNC_GPU_COMMANDS_COMPLETE */
+ { 32874, 0x00009114 }, /* GL_SYNC_STATUS */
+ { 32889, 0x00002001 }, /* GL_T */
+ { 32894, 0x00002A2A }, /* GL_T2F_C3F_V3F */
+ { 32909, 0x00002A2C }, /* GL_T2F_C4F_N3F_V3F */
+ { 32928, 0x00002A29 }, /* GL_T2F_C4UB_V3F */
+ { 32944, 0x00002A2B }, /* GL_T2F_N3F_V3F */
+ { 32959, 0x00002A27 }, /* GL_T2F_V3F */
+ { 32970, 0x00002A2D }, /* GL_T4F_C4F_N3F_V4F */
+ { 32989, 0x00002A28 }, /* GL_T4F_V4F */
+ { 33000, 0x00008031 }, /* GL_TABLE_TOO_LARGE_EXT */
+ { 33023, 0x00001702 }, /* GL_TEXTURE */
+ { 33034, 0x000084C0 }, /* GL_TEXTURE0 */
+ { 33046, 0x000084C0 }, /* GL_TEXTURE0_ARB */
+ { 33062, 0x000084C1 }, /* GL_TEXTURE1 */
+ { 33074, 0x000084CA }, /* GL_TEXTURE10 */
+ { 33087, 0x000084CA }, /* GL_TEXTURE10_ARB */
+ { 33104, 0x000084CB }, /* GL_TEXTURE11 */
+ { 33117, 0x000084CB }, /* GL_TEXTURE11_ARB */
+ { 33134, 0x000084CC }, /* GL_TEXTURE12 */
+ { 33147, 0x000084CC }, /* GL_TEXTURE12_ARB */
+ { 33164, 0x000084CD }, /* GL_TEXTURE13 */
+ { 33177, 0x000084CD }, /* GL_TEXTURE13_ARB */
+ { 33194, 0x000084CE }, /* GL_TEXTURE14 */
+ { 33207, 0x000084CE }, /* GL_TEXTURE14_ARB */
+ { 33224, 0x000084CF }, /* GL_TEXTURE15 */
+ { 33237, 0x000084CF }, /* GL_TEXTURE15_ARB */
+ { 33254, 0x000084D0 }, /* GL_TEXTURE16 */
+ { 33267, 0x000084D0 }, /* GL_TEXTURE16_ARB */
+ { 33284, 0x000084D1 }, /* GL_TEXTURE17 */
+ { 33297, 0x000084D1 }, /* GL_TEXTURE17_ARB */
+ { 33314, 0x000084D2 }, /* GL_TEXTURE18 */
+ { 33327, 0x000084D2 }, /* GL_TEXTURE18_ARB */
+ { 33344, 0x000084D3 }, /* GL_TEXTURE19 */
+ { 33357, 0x000084D3 }, /* GL_TEXTURE19_ARB */
+ { 33374, 0x000084C1 }, /* GL_TEXTURE1_ARB */
+ { 33390, 0x000084C2 }, /* GL_TEXTURE2 */
+ { 33402, 0x000084D4 }, /* GL_TEXTURE20 */
+ { 33415, 0x000084D4 }, /* GL_TEXTURE20_ARB */
+ { 33432, 0x000084D5 }, /* GL_TEXTURE21 */
+ { 33445, 0x000084D5 }, /* GL_TEXTURE21_ARB */
+ { 33462, 0x000084D6 }, /* GL_TEXTURE22 */
+ { 33475, 0x000084D6 }, /* GL_TEXTURE22_ARB */
+ { 33492, 0x000084D7 }, /* GL_TEXTURE23 */
+ { 33505, 0x000084D7 }, /* GL_TEXTURE23_ARB */
+ { 33522, 0x000084D8 }, /* GL_TEXTURE24 */
+ { 33535, 0x000084D8 }, /* GL_TEXTURE24_ARB */
+ { 33552, 0x000084D9 }, /* GL_TEXTURE25 */
+ { 33565, 0x000084D9 }, /* GL_TEXTURE25_ARB */
+ { 33582, 0x000084DA }, /* GL_TEXTURE26 */
+ { 33595, 0x000084DA }, /* GL_TEXTURE26_ARB */
+ { 33612, 0x000084DB }, /* GL_TEXTURE27 */
+ { 33625, 0x000084DB }, /* GL_TEXTURE27_ARB */
+ { 33642, 0x000084DC }, /* GL_TEXTURE28 */
+ { 33655, 0x000084DC }, /* GL_TEXTURE28_ARB */
+ { 33672, 0x000084DD }, /* GL_TEXTURE29 */
+ { 33685, 0x000084DD }, /* GL_TEXTURE29_ARB */
+ { 33702, 0x000084C2 }, /* GL_TEXTURE2_ARB */
+ { 33718, 0x000084C3 }, /* GL_TEXTURE3 */
+ { 33730, 0x000084DE }, /* GL_TEXTURE30 */
+ { 33743, 0x000084DE }, /* GL_TEXTURE30_ARB */
+ { 33760, 0x000084DF }, /* GL_TEXTURE31 */
+ { 33773, 0x000084DF }, /* GL_TEXTURE31_ARB */
+ { 33790, 0x000084C3 }, /* GL_TEXTURE3_ARB */
+ { 33806, 0x000084C4 }, /* GL_TEXTURE4 */
+ { 33818, 0x000084C4 }, /* GL_TEXTURE4_ARB */
+ { 33834, 0x000084C5 }, /* GL_TEXTURE5 */
+ { 33846, 0x000084C5 }, /* GL_TEXTURE5_ARB */
+ { 33862, 0x000084C6 }, /* GL_TEXTURE6 */
+ { 33874, 0x000084C6 }, /* GL_TEXTURE6_ARB */
+ { 33890, 0x000084C7 }, /* GL_TEXTURE7 */
+ { 33902, 0x000084C7 }, /* GL_TEXTURE7_ARB */
+ { 33918, 0x000084C8 }, /* GL_TEXTURE8 */
+ { 33930, 0x000084C8 }, /* GL_TEXTURE8_ARB */
+ { 33946, 0x000084C9 }, /* GL_TEXTURE9 */
+ { 33958, 0x000084C9 }, /* GL_TEXTURE9_ARB */
+ { 33974, 0x00000DE0 }, /* GL_TEXTURE_1D */
+ { 33988, 0x00008C18 }, /* GL_TEXTURE_1D_ARRAY_EXT */
+ { 34012, 0x00000DE1 }, /* GL_TEXTURE_2D */
+ { 34026, 0x00008C1A }, /* GL_TEXTURE_2D_ARRAY_EXT */
+ { 34050, 0x0000806F }, /* GL_TEXTURE_3D */
+ { 34064, 0x0000805F }, /* GL_TEXTURE_ALPHA_SIZE */
+ { 34086, 0x0000805F }, /* GL_TEXTURE_ALPHA_SIZE_EXT */
+ { 34112, 0x0000813C }, /* GL_TEXTURE_BASE_LEVEL */
+ { 34134, 0x00008068 }, /* GL_TEXTURE_BINDING_1D */
+ { 34156, 0x00008C1C }, /* GL_TEXTURE_BINDING_1D_ARRAY_EXT */
+ { 34188, 0x00008069 }, /* GL_TEXTURE_BINDING_2D */
+ { 34210, 0x00008C1D }, /* GL_TEXTURE_BINDING_2D_ARRAY_EXT */
+ { 34242, 0x0000806A }, /* GL_TEXTURE_BINDING_3D */
+ { 34264, 0x00008514 }, /* GL_TEXTURE_BINDING_CUBE_MAP */
+ { 34292, 0x00008514 }, /* GL_TEXTURE_BINDING_CUBE_MAP_ARB */
+ { 34324, 0x000084F6 }, /* GL_TEXTURE_BINDING_RECTANGLE_ARB */
+ { 34357, 0x000084F6 }, /* GL_TEXTURE_BINDING_RECTANGLE_NV */
+ { 34389, 0x00040000 }, /* GL_TEXTURE_BIT */
+ { 34404, 0x0000805E }, /* GL_TEXTURE_BLUE_SIZE */
+ { 34425, 0x0000805E }, /* GL_TEXTURE_BLUE_SIZE_EXT */
+ { 34450, 0x00001005 }, /* GL_TEXTURE_BORDER */
+ { 34468, 0x00001004 }, /* GL_TEXTURE_BORDER_COLOR */
+ { 34492, 0x00008171 }, /* GL_TEXTURE_CLIPMAP_CENTER_SGIX */
+ { 34523, 0x00008176 }, /* GL_TEXTURE_CLIPMAP_DEPTH_SGIX */
+ { 34553, 0x00008172 }, /* GL_TEXTURE_CLIPMAP_FRAME_SGIX */
+ { 34583, 0x00008175 }, /* GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX */
+ { 34618, 0x00008173 }, /* GL_TEXTURE_CLIPMAP_OFFSET_SGIX */
+ { 34649, 0x00008174 }, /* GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX */
+ { 34687, 0x000080BC }, /* GL_TEXTURE_COLOR_TABLE_SGI */
+ { 34714, 0x000081EF }, /* GL_TEXTURE_COLOR_WRITEMASK_SGIS */
+ { 34746, 0x000080BF }, /* GL_TEXTURE_COMPARE_FAIL_VALUE_ARB */
+ { 34780, 0x0000884D }, /* GL_TEXTURE_COMPARE_FUNC */
+ { 34804, 0x0000884D }, /* GL_TEXTURE_COMPARE_FUNC_ARB */
+ { 34832, 0x0000884C }, /* GL_TEXTURE_COMPARE_MODE */
+ { 34856, 0x0000884C }, /* GL_TEXTURE_COMPARE_MODE_ARB */
+ { 34884, 0x0000819B }, /* GL_TEXTURE_COMPARE_OPERATOR_SGIX */
+ { 34917, 0x0000819A }, /* GL_TEXTURE_COMPARE_SGIX */
+ { 34941, 0x00001003 }, /* GL_TEXTURE_COMPONENTS */
+ { 34963, 0x000086A1 }, /* GL_TEXTURE_COMPRESSED */
+ { 34985, 0x000086A1 }, /* GL_TEXTURE_COMPRESSED_ARB */
+ { 35011, 0x000086A3 }, /* GL_TEXTURE_COMPRESSED_FORMATS_ARB */
+ { 35045, 0x000086A0 }, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE */
+ { 35078, 0x000086A0 }, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB */
+ { 35115, 0x000084EF }, /* GL_TEXTURE_COMPRESSION_HINT */
+ { 35143, 0x000084EF }, /* GL_TEXTURE_COMPRESSION_HINT_ARB */
+ { 35175, 0x00008078 }, /* GL_TEXTURE_COORD_ARRAY */
+ { 35198, 0x0000889A }, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING */
+ { 35236, 0x0000889A }, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB */
+ { 35278, 0x00008092 }, /* GL_TEXTURE_COORD_ARRAY_POINTER */
+ { 35309, 0x00008088 }, /* GL_TEXTURE_COORD_ARRAY_SIZE */
+ { 35337, 0x0000808A }, /* GL_TEXTURE_COORD_ARRAY_STRIDE */
+ { 35367, 0x00008089 }, /* GL_TEXTURE_COORD_ARRAY_TYPE */
+ { 35395, 0x00008513 }, /* GL_TEXTURE_CUBE_MAP */
+ { 35415, 0x00008513 }, /* GL_TEXTURE_CUBE_MAP_ARB */
+ { 35439, 0x00008516 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X */
+ { 35470, 0x00008516 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB */
+ { 35505, 0x00008518 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y */
+ { 35536, 0x00008518 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB */
+ { 35571, 0x0000851A }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z */
+ { 35602, 0x0000851A }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB */
+ { 35637, 0x00008515 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X */
+ { 35668, 0x00008515 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB */
+ { 35703, 0x00008517 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y */
+ { 35734, 0x00008517 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB */
+ { 35769, 0x00008519 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z */
+ { 35800, 0x00008519 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB */
+ { 35835, 0x000088F4 }, /* GL_TEXTURE_CUBE_MAP_SEAMLESS */
+ { 35864, 0x00008071 }, /* GL_TEXTURE_DEPTH */
+ { 35881, 0x0000884A }, /* GL_TEXTURE_DEPTH_SIZE */
+ { 35903, 0x0000884A }, /* GL_TEXTURE_DEPTH_SIZE_ARB */
+ { 35929, 0x00002300 }, /* GL_TEXTURE_ENV */
+ { 35944, 0x00002201 }, /* GL_TEXTURE_ENV_COLOR */
+ { 35965, 0x00002200 }, /* GL_TEXTURE_ENV_MODE */
+ { 35985, 0x00008500 }, /* GL_TEXTURE_FILTER_CONTROL */
+ { 36011, 0x00002500 }, /* GL_TEXTURE_GEN_MODE */
+ { 36031, 0x00000C63 }, /* GL_TEXTURE_GEN_Q */
+ { 36048, 0x00000C62 }, /* GL_TEXTURE_GEN_R */
+ { 36065, 0x00000C60 }, /* GL_TEXTURE_GEN_S */
+ { 36082, 0x00000C61 }, /* GL_TEXTURE_GEN_T */
+ { 36099, 0x0000819D }, /* GL_TEXTURE_GEQUAL_R_SGIX */
+ { 36124, 0x0000805D }, /* GL_TEXTURE_GREEN_SIZE */
+ { 36146, 0x0000805D }, /* GL_TEXTURE_GREEN_SIZE_EXT */
+ { 36172, 0x00001001 }, /* GL_TEXTURE_HEIGHT */
+ { 36190, 0x000080ED }, /* GL_TEXTURE_INDEX_SIZE_EXT */
+ { 36216, 0x00008061 }, /* GL_TEXTURE_INTENSITY_SIZE */
+ { 36242, 0x00008061 }, /* GL_TEXTURE_INTENSITY_SIZE_EXT */
+ { 36272, 0x00001003 }, /* GL_TEXTURE_INTERNAL_FORMAT */
+ { 36299, 0x0000819C }, /* GL_TEXTURE_LEQUAL_R_SGIX */
+ { 36324, 0x00008501 }, /* GL_TEXTURE_LOD_BIAS */
+ { 36344, 0x00008501 }, /* GL_TEXTURE_LOD_BIAS_EXT */
+ { 36368, 0x00008190 }, /* GL_TEXTURE_LOD_BIAS_R_SGIX */
+ { 36395, 0x0000818E }, /* GL_TEXTURE_LOD_BIAS_S_SGIX */
+ { 36422, 0x0000818F }, /* GL_TEXTURE_LOD_BIAS_T_SGIX */
+ { 36449, 0x00008060 }, /* GL_TEXTURE_LUMINANCE_SIZE */
+ { 36475, 0x00008060 }, /* GL_TEXTURE_LUMINANCE_SIZE_EXT */
+ { 36505, 0x00002800 }, /* GL_TEXTURE_MAG_FILTER */
+ { 36527, 0x00000BA8 }, /* GL_TEXTURE_MATRIX */
+ { 36545, 0x000084FE }, /* GL_TEXTURE_MAX_ANISOTROPY_EXT */
+ { 36575, 0x0000836B }, /* GL_TEXTURE_MAX_CLAMP_R_SGIX */
+ { 36603, 0x00008369 }, /* GL_TEXTURE_MAX_CLAMP_S_SGIX */
+ { 36631, 0x0000836A }, /* GL_TEXTURE_MAX_CLAMP_T_SGIX */
+ { 36659, 0x0000813D }, /* GL_TEXTURE_MAX_LEVEL */
+ { 36680, 0x0000813B }, /* GL_TEXTURE_MAX_LOD */
+ { 36699, 0x00002801 }, /* GL_TEXTURE_MIN_FILTER */
+ { 36721, 0x0000813A }, /* GL_TEXTURE_MIN_LOD */
+ { 36740, 0x00008066 }, /* GL_TEXTURE_PRIORITY */
+ { 36760, 0x000085B7 }, /* GL_TEXTURE_RANGE_LENGTH_APPLE */
+ { 36790, 0x000085B8 }, /* GL_TEXTURE_RANGE_POINTER_APPLE */
+ { 36821, 0x000084F5 }, /* GL_TEXTURE_RECTANGLE_ARB */
+ { 36846, 0x000084F5 }, /* GL_TEXTURE_RECTANGLE_NV */
+ { 36870, 0x0000805C }, /* GL_TEXTURE_RED_SIZE */
+ { 36890, 0x0000805C }, /* GL_TEXTURE_RED_SIZE_EXT */
+ { 36914, 0x00008067 }, /* GL_TEXTURE_RESIDENT */
+ { 36934, 0x00000BA5 }, /* GL_TEXTURE_STACK_DEPTH */
+ { 36957, 0x000088F1 }, /* GL_TEXTURE_STENCIL_SIZE */
+ { 36981, 0x000085BC }, /* GL_TEXTURE_STORAGE_HINT_APPLE */
+ { 37011, 0x00008065 }, /* GL_TEXTURE_TOO_LARGE_EXT */
+ { 37036, 0x0000888F }, /* GL_TEXTURE_UNSIGNED_REMAP_MODE_NV */
+ { 37070, 0x00001000 }, /* GL_TEXTURE_WIDTH */
+ { 37087, 0x00008072 }, /* GL_TEXTURE_WRAP_R */
+ { 37105, 0x00002802 }, /* GL_TEXTURE_WRAP_S */
+ { 37123, 0x00002803 }, /* GL_TEXTURE_WRAP_T */
+ { 37141, 0x0000911B }, /* GL_TIMEOUT_EXPIRED */
+ { 37160, 0xFFFFFFFFFFFFFFFF }, /* GL_TIMEOUT_IGNORED */
+ { 37179, 0x000088BF }, /* GL_TIME_ELAPSED_EXT */
+ { 37199, 0x00008648 }, /* GL_TRACK_MATRIX_NV */
+ { 37218, 0x00008649 }, /* GL_TRACK_MATRIX_TRANSFORM_NV */
+ { 37247, 0x00001000 }, /* GL_TRANSFORM_BIT */
+ { 37264, 0x000084E6 }, /* GL_TRANSPOSE_COLOR_MATRIX */
+ { 37290, 0x000084E6 }, /* GL_TRANSPOSE_COLOR_MATRIX_ARB */
+ { 37320, 0x000088B7 }, /* GL_TRANSPOSE_CURRENT_MATRIX_ARB */
+ { 37352, 0x000084E3 }, /* GL_TRANSPOSE_MODELVIEW_MATRIX */
+ { 37382, 0x000084E3 }, /* GL_TRANSPOSE_MODELVIEW_MATRIX_ARB */
+ { 37416, 0x0000862C }, /* GL_TRANSPOSE_NV */
+ { 37432, 0x000084E4 }, /* GL_TRANSPOSE_PROJECTION_MATRIX */
+ { 37463, 0x000084E4 }, /* GL_TRANSPOSE_PROJECTION_MATRIX_ARB */
+ { 37498, 0x000084E5 }, /* GL_TRANSPOSE_TEXTURE_MATRIX */
+ { 37526, 0x000084E5 }, /* GL_TRANSPOSE_TEXTURE_MATRIX_ARB */
+ { 37558, 0x00000004 }, /* GL_TRIANGLES */
+ { 37571, 0x00000006 }, /* GL_TRIANGLE_FAN */
+ { 37587, 0x00008615 }, /* GL_TRIANGLE_MESH_SUN */
+ { 37608, 0x00000005 }, /* GL_TRIANGLE_STRIP */
+ { 37626, 0x00000001 }, /* GL_TRUE */
+ { 37634, 0x00000CF5 }, /* GL_UNPACK_ALIGNMENT */
+ { 37654, 0x0000806E }, /* GL_UNPACK_IMAGE_HEIGHT */
+ { 37677, 0x00000CF1 }, /* GL_UNPACK_LSB_FIRST */
+ { 37697, 0x00000CF2 }, /* GL_UNPACK_ROW_LENGTH */
+ { 37718, 0x0000806D }, /* GL_UNPACK_SKIP_IMAGES */
+ { 37740, 0x00000CF4 }, /* GL_UNPACK_SKIP_PIXELS */
+ { 37762, 0x00000CF3 }, /* GL_UNPACK_SKIP_ROWS */
+ { 37782, 0x00000CF0 }, /* GL_UNPACK_SWAP_BYTES */
+ { 37803, 0x00009118 }, /* GL_UNSIGNALED */
+ { 37817, 0x00001401 }, /* GL_UNSIGNED_BYTE */
+ { 37834, 0x00008362 }, /* GL_UNSIGNED_BYTE_2_3_3_REV */
+ { 37861, 0x00008032 }, /* GL_UNSIGNED_BYTE_3_3_2 */
+ { 37884, 0x00001405 }, /* GL_UNSIGNED_INT */
+ { 37900, 0x00008036 }, /* GL_UNSIGNED_INT_10_10_10_2 */
+ { 37927, 0x000084FA }, /* GL_UNSIGNED_INT_24_8 */
+ { 37948, 0x000084FA }, /* GL_UNSIGNED_INT_24_8_NV */
+ { 37972, 0x00008368 }, /* GL_UNSIGNED_INT_2_10_10_10_REV */
+ { 38003, 0x00008035 }, /* GL_UNSIGNED_INT_8_8_8_8 */
+ { 38027, 0x00008367 }, /* GL_UNSIGNED_INT_8_8_8_8_REV */
+ { 38055, 0x00008C17 }, /* GL_UNSIGNED_NORMALIZED */
+ { 38078, 0x00001403 }, /* GL_UNSIGNED_SHORT */
+ { 38096, 0x00008366 }, /* GL_UNSIGNED_SHORT_1_5_5_5_REV */
+ { 38126, 0x00008033 }, /* GL_UNSIGNED_SHORT_4_4_4_4 */
+ { 38152, 0x00008365 }, /* GL_UNSIGNED_SHORT_4_4_4_4_REV */
+ { 38182, 0x00008034 }, /* GL_UNSIGNED_SHORT_5_5_5_1 */
+ { 38208, 0x00008363 }, /* GL_UNSIGNED_SHORT_5_6_5 */
+ { 38232, 0x00008364 }, /* GL_UNSIGNED_SHORT_5_6_5_REV */
+ { 38260, 0x000085BA }, /* GL_UNSIGNED_SHORT_8_8_APPLE */
+ { 38288, 0x000085BA }, /* GL_UNSIGNED_SHORT_8_8_MESA */
+ { 38315, 0x000085BB }, /* GL_UNSIGNED_SHORT_8_8_REV_APPLE */
+ { 38347, 0x000085BB }, /* GL_UNSIGNED_SHORT_8_8_REV_MESA */
+ { 38378, 0x00008CA2 }, /* GL_UPPER_LEFT */
+ { 38392, 0x00002A20 }, /* GL_V2F */
+ { 38399, 0x00002A21 }, /* GL_V3F */
+ { 38406, 0x00008B83 }, /* GL_VALIDATE_STATUS */
+ { 38425, 0x00001F00 }, /* GL_VENDOR */
+ { 38435, 0x00001F02 }, /* GL_VERSION */
+ { 38446, 0x00008074 }, /* GL_VERTEX_ARRAY */
+ { 38462, 0x000085B5 }, /* GL_VERTEX_ARRAY_BINDING */
+ { 38486, 0x000085B5 }, /* GL_VERTEX_ARRAY_BINDING_APPLE */
+ { 38516, 0x00008896 }, /* GL_VERTEX_ARRAY_BUFFER_BINDING */
+ { 38547, 0x00008896 }, /* GL_VERTEX_ARRAY_BUFFER_BINDING_ARB */
+ { 38582, 0x0000808E }, /* GL_VERTEX_ARRAY_POINTER */
+ { 38606, 0x0000807A }, /* GL_VERTEX_ARRAY_SIZE */
+ { 38627, 0x0000807C }, /* GL_VERTEX_ARRAY_STRIDE */
+ { 38650, 0x0000807B }, /* GL_VERTEX_ARRAY_TYPE */
+ { 38671, 0x00008650 }, /* GL_VERTEX_ATTRIB_ARRAY0_NV */
+ { 38698, 0x0000865A }, /* GL_VERTEX_ATTRIB_ARRAY10_NV */
+ { 38726, 0x0000865B }, /* GL_VERTEX_ATTRIB_ARRAY11_NV */
+ { 38754, 0x0000865C }, /* GL_VERTEX_ATTRIB_ARRAY12_NV */
+ { 38782, 0x0000865D }, /* GL_VERTEX_ATTRIB_ARRAY13_NV */
+ { 38810, 0x0000865E }, /* GL_VERTEX_ATTRIB_ARRAY14_NV */
+ { 38838, 0x0000865F }, /* GL_VERTEX_ATTRIB_ARRAY15_NV */
+ { 38866, 0x00008651 }, /* GL_VERTEX_ATTRIB_ARRAY1_NV */
+ { 38893, 0x00008652 }, /* GL_VERTEX_ATTRIB_ARRAY2_NV */
+ { 38920, 0x00008653 }, /* GL_VERTEX_ATTRIB_ARRAY3_NV */
+ { 38947, 0x00008654 }, /* GL_VERTEX_ATTRIB_ARRAY4_NV */
+ { 38974, 0x00008655 }, /* GL_VERTEX_ATTRIB_ARRAY5_NV */
+ { 39001, 0x00008656 }, /* GL_VERTEX_ATTRIB_ARRAY6_NV */
+ { 39028, 0x00008657 }, /* GL_VERTEX_ATTRIB_ARRAY7_NV */
+ { 39055, 0x00008658 }, /* GL_VERTEX_ATTRIB_ARRAY8_NV */
+ { 39082, 0x00008659 }, /* GL_VERTEX_ATTRIB_ARRAY9_NV */
+ { 39109, 0x0000889F }, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING */
+ { 39147, 0x0000889F }, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB */
+ { 39189, 0x00008622 }, /* GL_VERTEX_ATTRIB_ARRAY_ENABLED */
+ { 39220, 0x00008622 }, /* GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB */
+ { 39255, 0x0000886A }, /* GL_VERTEX_ATTRIB_ARRAY_NORMALIZED */
+ { 39289, 0x0000886A }, /* GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB */
+ { 39327, 0x00008645 }, /* GL_VERTEX_ATTRIB_ARRAY_POINTER */
+ { 39358, 0x00008645 }, /* GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB */
+ { 39393, 0x00008623 }, /* GL_VERTEX_ATTRIB_ARRAY_SIZE */
+ { 39421, 0x00008623 }, /* GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB */
+ { 39453, 0x00008624 }, /* GL_VERTEX_ATTRIB_ARRAY_STRIDE */
+ { 39483, 0x00008624 }, /* GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB */
+ { 39517, 0x00008625 }, /* GL_VERTEX_ATTRIB_ARRAY_TYPE */
+ { 39545, 0x00008625 }, /* GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB */
+ { 39577, 0x000086A7 }, /* GL_VERTEX_BLEND_ARB */
+ { 39597, 0x00008620 }, /* GL_VERTEX_PROGRAM_ARB */
+ { 39619, 0x0000864A }, /* GL_VERTEX_PROGRAM_BINDING_NV */
+ { 39648, 0x00008620 }, /* GL_VERTEX_PROGRAM_NV */
+ { 39669, 0x00008642 }, /* GL_VERTEX_PROGRAM_POINT_SIZE */
+ { 39698, 0x00008642 }, /* GL_VERTEX_PROGRAM_POINT_SIZE_ARB */
+ { 39731, 0x00008642 }, /* GL_VERTEX_PROGRAM_POINT_SIZE_NV */
+ { 39763, 0x00008643 }, /* GL_VERTEX_PROGRAM_TWO_SIDE */
+ { 39790, 0x00008643 }, /* GL_VERTEX_PROGRAM_TWO_SIDE_ARB */
+ { 39821, 0x00008643 }, /* GL_VERTEX_PROGRAM_TWO_SIDE_NV */
+ { 39851, 0x00008B31 }, /* GL_VERTEX_SHADER */
+ { 39868, 0x00008B31 }, /* GL_VERTEX_SHADER_ARB */
+ { 39889, 0x00008621 }, /* GL_VERTEX_STATE_PROGRAM_NV */
+ { 39916, 0x00000BA2 }, /* GL_VIEWPORT */
+ { 39928, 0x00000800 }, /* GL_VIEWPORT_BIT */
+ { 39944, 0x0000911D }, /* GL_WAIT_FAILED */
+ { 39959, 0x000086AD }, /* GL_WEIGHT_ARRAY_ARB */
+ { 39979, 0x0000889E }, /* GL_WEIGHT_ARRAY_BUFFER_BINDING */
+ { 40010, 0x0000889E }, /* GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB */
+ { 40045, 0x000086AC }, /* GL_WEIGHT_ARRAY_POINTER_ARB */
+ { 40073, 0x000086AB }, /* GL_WEIGHT_ARRAY_SIZE_ARB */
+ { 40098, 0x000086AA }, /* GL_WEIGHT_ARRAY_STRIDE_ARB */
+ { 40125, 0x000086A9 }, /* GL_WEIGHT_ARRAY_TYPE_ARB */
+ { 40150, 0x000086A6 }, /* GL_WEIGHT_SUM_UNITY_ARB */
+ { 40174, 0x000081D4 }, /* GL_WRAP_BORDER_SUN */
+ { 40193, 0x000088B9 }, /* GL_WRITE_ONLY */
+ { 40207, 0x000088B9 }, /* GL_WRITE_ONLY_ARB */
+ { 40225, 0x00001506 }, /* GL_XOR */
+ { 40232, 0x000085B9 }, /* GL_YCBCR_422_APPLE */
+ { 40251, 0x00008757 }, /* GL_YCBCR_MESA */
+ { 40265, 0x00000000 }, /* GL_ZERO */
+ { 40273, 0x00000D16 }, /* GL_ZOOM_X */
+ { 40283, 0x00000D17 }, /* GL_ZOOM_Y */
};
static const unsigned reduced_enums[1347] =
{
- 475, /* GL_FALSE */
- 691, /* GL_LINES */
- 693, /* GL_LINE_LOOP */
- 700, /* GL_LINE_STRIP */
- 1743, /* GL_TRIANGLES */
- 1746, /* GL_TRIANGLE_STRIP */
- 1744, /* GL_TRIANGLE_FAN */
- 1271, /* GL_QUADS */
- 1274, /* GL_QUAD_STRIP */
- 1158, /* GL_POLYGON */
- 1170, /* GL_POLYGON_STIPPLE_BIT */
- 1119, /* GL_PIXEL_MODE_BIT */
- 678, /* GL_LIGHTING_BIT */
- 504, /* GL_FOG_BIT */
+ 476, /* GL_FALSE */
+ 692, /* GL_LINES */
+ 694, /* GL_LINE_LOOP */
+ 701, /* GL_LINE_STRIP */
+ 1744, /* GL_TRIANGLES */
+ 1747, /* GL_TRIANGLE_STRIP */
+ 1745, /* GL_TRIANGLE_FAN */
+ 1272, /* GL_QUADS */
+ 1275, /* GL_QUAD_STRIP */
+ 1159, /* GL_POLYGON */
+ 1171, /* GL_POLYGON_STIPPLE_BIT */
+ 1120, /* GL_PIXEL_MODE_BIT */
+ 679, /* GL_LIGHTING_BIT */
+ 505, /* GL_FOG_BIT */
8, /* GL_ACCUM */
- 710, /* GL_LOAD */
- 1326, /* GL_RETURN */
- 991, /* GL_MULT */
+ 711, /* GL_LOAD */
+ 1327, /* GL_RETURN */
+ 992, /* GL_MULT */
23, /* GL_ADD */
- 1007, /* GL_NEVER */
- 668, /* GL_LESS */
- 465, /* GL_EQUAL */
- 667, /* GL_LEQUAL */
- 590, /* GL_GREATER */
- 1022, /* GL_NOTEQUAL */
- 589, /* GL_GEQUAL */
+ 1008, /* GL_NEVER */
+ 669, /* GL_LESS */
+ 466, /* GL_EQUAL */
+ 668, /* GL_LEQUAL */
+ 591, /* GL_GREATER */
+ 1023, /* GL_NOTEQUAL */
+ 590, /* GL_GEQUAL */
47, /* GL_ALWAYS */
- 1467, /* GL_SRC_COLOR */
- 1052, /* GL_ONE_MINUS_SRC_COLOR */
- 1465, /* GL_SRC_ALPHA */
- 1051, /* GL_ONE_MINUS_SRC_ALPHA */
- 444, /* GL_DST_ALPHA */
- 1049, /* GL_ONE_MINUS_DST_ALPHA */
- 445, /* GL_DST_COLOR */
- 1050, /* GL_ONE_MINUS_DST_COLOR */
- 1466, /* GL_SRC_ALPHA_SATURATE */
- 577, /* GL_FRONT_LEFT */
- 578, /* GL_FRONT_RIGHT */
+ 1468, /* GL_SRC_COLOR */
+ 1053, /* GL_ONE_MINUS_SRC_COLOR */
+ 1466, /* GL_SRC_ALPHA */
+ 1052, /* GL_ONE_MINUS_SRC_ALPHA */
+ 445, /* GL_DST_ALPHA */
+ 1050, /* GL_ONE_MINUS_DST_ALPHA */
+ 446, /* GL_DST_COLOR */
+ 1051, /* GL_ONE_MINUS_DST_COLOR */
+ 1467, /* GL_SRC_ALPHA_SATURATE */
+ 578, /* GL_FRONT_LEFT */
+ 579, /* GL_FRONT_RIGHT */
69, /* GL_BACK_LEFT */
70, /* GL_BACK_RIGHT */
- 574, /* GL_FRONT */
+ 575, /* GL_FRONT */
68, /* GL_BACK */
- 666, /* GL_LEFT */
- 1368, /* GL_RIGHT */
- 575, /* GL_FRONT_AND_BACK */
+ 667, /* GL_LEFT */
+ 1369, /* GL_RIGHT */
+ 576, /* GL_FRONT_AND_BACK */
63, /* GL_AUX0 */
64, /* GL_AUX1 */
65, /* GL_AUX2 */
66, /* GL_AUX3 */
- 656, /* GL_INVALID_ENUM */
- 660, /* GL_INVALID_VALUE */
- 659, /* GL_INVALID_OPERATION */
- 1472, /* GL_STACK_OVERFLOW */
- 1473, /* GL_STACK_UNDERFLOW */
- 1077, /* GL_OUT_OF_MEMORY */
- 657, /* GL_INVALID_FRAMEBUFFER_OPERATION */
+ 657, /* GL_INVALID_ENUM */
+ 661, /* GL_INVALID_VALUE */
+ 660, /* GL_INVALID_OPERATION */
+ 1473, /* GL_STACK_OVERFLOW */
+ 1474, /* GL_STACK_UNDERFLOW */
+ 1078, /* GL_OUT_OF_MEMORY */
+ 658, /* GL_INVALID_FRAMEBUFFER_OPERATION */
0, /* GL_2D */
2, /* GL_3D */
3, /* GL_3D_COLOR */
4, /* GL_3D_COLOR_TEXTURE */
6, /* GL_4D_COLOR_TEXTURE */
- 1097, /* GL_PASS_THROUGH_TOKEN */
- 1157, /* GL_POINT_TOKEN */
- 701, /* GL_LINE_TOKEN */
- 1171, /* GL_POLYGON_TOKEN */
+ 1098, /* GL_PASS_THROUGH_TOKEN */
+ 1158, /* GL_POINT_TOKEN */
+ 702, /* GL_LINE_TOKEN */
+ 1172, /* GL_POLYGON_TOKEN */
74, /* GL_BITMAP_TOKEN */
- 443, /* GL_DRAW_PIXEL_TOKEN */
+ 444, /* GL_DRAW_PIXEL_TOKEN */
301, /* GL_COPY_PIXEL_TOKEN */
- 694, /* GL_LINE_RESET_TOKEN */
- 468, /* GL_EXP */
- 469, /* GL_EXP2 */
+ 695, /* GL_LINE_RESET_TOKEN */
+ 469, /* GL_EXP */
+ 470, /* GL_EXP2 */
337, /* GL_CW */
125, /* GL_CCW */
146, /* GL_COEFF */
- 1074, /* GL_ORDER */
- 381, /* GL_DOMAIN */
+ 1075, /* GL_ORDER */
+ 382, /* GL_DOMAIN */
311, /* GL_CURRENT_COLOR */
314, /* GL_CURRENT_INDEX */
320, /* GL_CURRENT_NORMAL */
328, /* GL_CURRENT_RASTER_POSITION */
329, /* GL_CURRENT_RASTER_POSITION_VALID */
326, /* GL_CURRENT_RASTER_DISTANCE */
- 1150, /* GL_POINT_SMOOTH */
- 1139, /* GL_POINT_SIZE */
- 1149, /* GL_POINT_SIZE_RANGE */
- 1140, /* GL_POINT_SIZE_GRANULARITY */
- 695, /* GL_LINE_SMOOTH */
- 702, /* GL_LINE_WIDTH */
- 704, /* GL_LINE_WIDTH_RANGE */
- 703, /* GL_LINE_WIDTH_GRANULARITY */
- 697, /* GL_LINE_STIPPLE */
- 698, /* GL_LINE_STIPPLE_PATTERN */
- 699, /* GL_LINE_STIPPLE_REPEAT */
- 709, /* GL_LIST_MODE */
- 874, /* GL_MAX_LIST_NESTING */
- 706, /* GL_LIST_BASE */
- 708, /* GL_LIST_INDEX */
- 1160, /* GL_POLYGON_MODE */
- 1167, /* GL_POLYGON_SMOOTH */
- 1169, /* GL_POLYGON_STIPPLE */
- 454, /* GL_EDGE_FLAG */
+ 1151, /* GL_POINT_SMOOTH */
+ 1140, /* GL_POINT_SIZE */
+ 1150, /* GL_POINT_SIZE_RANGE */
+ 1141, /* GL_POINT_SIZE_GRANULARITY */
+ 696, /* GL_LINE_SMOOTH */
+ 703, /* GL_LINE_WIDTH */
+ 705, /* GL_LINE_WIDTH_RANGE */
+ 704, /* GL_LINE_WIDTH_GRANULARITY */
+ 698, /* GL_LINE_STIPPLE */
+ 699, /* GL_LINE_STIPPLE_PATTERN */
+ 700, /* GL_LINE_STIPPLE_REPEAT */
+ 710, /* GL_LIST_MODE */
+ 875, /* GL_MAX_LIST_NESTING */
+ 707, /* GL_LIST_BASE */
+ 709, /* GL_LIST_INDEX */
+ 1161, /* GL_POLYGON_MODE */
+ 1168, /* GL_POLYGON_SMOOTH */
+ 1170, /* GL_POLYGON_STIPPLE */
+ 455, /* GL_EDGE_FLAG */
304, /* GL_CULL_FACE */
305, /* GL_CULL_FACE_MODE */
- 576, /* GL_FRONT_FACE */
- 677, /* GL_LIGHTING */
- 682, /* GL_LIGHT_MODEL_LOCAL_VIEWER */
- 683, /* GL_LIGHT_MODEL_TWO_SIDE */
- 679, /* GL_LIGHT_MODEL_AMBIENT */
- 1414, /* GL_SHADE_MODEL */
+ 577, /* GL_FRONT_FACE */
+ 678, /* GL_LIGHTING */
+ 683, /* GL_LIGHT_MODEL_LOCAL_VIEWER */
+ 684, /* GL_LIGHT_MODEL_TWO_SIDE */
+ 680, /* GL_LIGHT_MODEL_AMBIENT */
+ 1415, /* GL_SHADE_MODEL */
193, /* GL_COLOR_MATERIAL_FACE */
194, /* GL_COLOR_MATERIAL_PARAMETER */
192, /* GL_COLOR_MATERIAL */
- 503, /* GL_FOG */
- 525, /* GL_FOG_INDEX */
- 521, /* GL_FOG_DENSITY */
- 529, /* GL_FOG_START */
- 523, /* GL_FOG_END */
- 526, /* GL_FOG_MODE */
- 505, /* GL_FOG_COLOR */
- 368, /* GL_DEPTH_RANGE */
- 375, /* GL_DEPTH_TEST */
- 378, /* GL_DEPTH_WRITEMASK */
- 356, /* GL_DEPTH_CLEAR_VALUE */
- 367, /* GL_DEPTH_FUNC */
+ 504, /* GL_FOG */
+ 526, /* GL_FOG_INDEX */
+ 522, /* GL_FOG_DENSITY */
+ 530, /* GL_FOG_START */
+ 524, /* GL_FOG_END */
+ 527, /* GL_FOG_MODE */
+ 506, /* GL_FOG_COLOR */
+ 369, /* GL_DEPTH_RANGE */
+ 376, /* GL_DEPTH_TEST */
+ 379, /* GL_DEPTH_WRITEMASK */
+ 357, /* GL_DEPTH_CLEAR_VALUE */
+ 368, /* GL_DEPTH_FUNC */
12, /* GL_ACCUM_CLEAR_VALUE */
- 1508, /* GL_STENCIL_TEST */
- 1496, /* GL_STENCIL_CLEAR_VALUE */
- 1498, /* GL_STENCIL_FUNC */
- 1510, /* GL_STENCIL_VALUE_MASK */
- 1497, /* GL_STENCIL_FAIL */
- 1505, /* GL_STENCIL_PASS_DEPTH_FAIL */
- 1506, /* GL_STENCIL_PASS_DEPTH_PASS */
- 1507, /* GL_STENCIL_REF */
- 1511, /* GL_STENCIL_WRITEMASK */
- 843, /* GL_MATRIX_MODE */
- 1012, /* GL_NORMALIZE */
- 1837, /* GL_VIEWPORT */
- 986, /* GL_MODELVIEW_STACK_DEPTH */
- 1250, /* GL_PROJECTION_STACK_DEPTH */
- 1718, /* GL_TEXTURE_STACK_DEPTH */
- 984, /* GL_MODELVIEW_MATRIX */
- 1249, /* GL_PROJECTION_MATRIX */
- 1701, /* GL_TEXTURE_MATRIX */
+ 1509, /* GL_STENCIL_TEST */
+ 1497, /* GL_STENCIL_CLEAR_VALUE */
+ 1499, /* GL_STENCIL_FUNC */
+ 1511, /* GL_STENCIL_VALUE_MASK */
+ 1498, /* GL_STENCIL_FAIL */
+ 1506, /* GL_STENCIL_PASS_DEPTH_FAIL */
+ 1507, /* GL_STENCIL_PASS_DEPTH_PASS */
+ 1508, /* GL_STENCIL_REF */
+ 1512, /* GL_STENCIL_WRITEMASK */
+ 844, /* GL_MATRIX_MODE */
+ 1013, /* GL_NORMALIZE */
+ 1838, /* GL_VIEWPORT */
+ 987, /* GL_MODELVIEW_STACK_DEPTH */
+ 1251, /* GL_PROJECTION_STACK_DEPTH */
+ 1719, /* GL_TEXTURE_STACK_DEPTH */
+ 985, /* GL_MODELVIEW_MATRIX */
+ 1250, /* GL_PROJECTION_MATRIX */
+ 1702, /* GL_TEXTURE_MATRIX */
61, /* GL_ATTRIB_STACK_DEPTH */
136, /* GL_CLIENT_ATTRIB_STACK_DEPTH */
43, /* GL_ALPHA_TEST */
44, /* GL_ALPHA_TEST_FUNC */
45, /* GL_ALPHA_TEST_REF */
- 380, /* GL_DITHER */
+ 381, /* GL_DITHER */
78, /* GL_BLEND_DST */
87, /* GL_BLEND_SRC */
75, /* GL_BLEND */
- 712, /* GL_LOGIC_OP_MODE */
- 630, /* GL_INDEX_LOGIC_OP */
+ 713, /* GL_LOGIC_OP_MODE */
+ 631, /* GL_INDEX_LOGIC_OP */
191, /* GL_COLOR_LOGIC_OP */
67, /* GL_AUX_BUFFERS */
- 391, /* GL_DRAW_BUFFER */
- 1284, /* GL_READ_BUFFER */
- 1395, /* GL_SCISSOR_BOX */
- 1396, /* GL_SCISSOR_TEST */
- 629, /* GL_INDEX_CLEAR_VALUE */
- 634, /* GL_INDEX_WRITEMASK */
+ 392, /* GL_DRAW_BUFFER */
+ 1285, /* GL_READ_BUFFER */
+ 1396, /* GL_SCISSOR_BOX */
+ 1397, /* GL_SCISSOR_TEST */
+ 630, /* GL_INDEX_CLEAR_VALUE */
+ 635, /* GL_INDEX_WRITEMASK */
188, /* GL_COLOR_CLEAR_VALUE */
230, /* GL_COLOR_WRITEMASK */
- 631, /* GL_INDEX_MODE */
- 1361, /* GL_RGBA_MODE */
- 390, /* GL_DOUBLEBUFFER */
- 1512, /* GL_STEREO */
- 1319, /* GL_RENDER_MODE */
- 1098, /* GL_PERSPECTIVE_CORRECTION_HINT */
- 1151, /* GL_POINT_SMOOTH_HINT */
- 696, /* GL_LINE_SMOOTH_HINT */
- 1168, /* GL_POLYGON_SMOOTH_HINT */
- 524, /* GL_FOG_HINT */
- 1682, /* GL_TEXTURE_GEN_S */
- 1683, /* GL_TEXTURE_GEN_T */
- 1681, /* GL_TEXTURE_GEN_R */
- 1680, /* GL_TEXTURE_GEN_Q */
- 1111, /* GL_PIXEL_MAP_I_TO_I */
- 1117, /* GL_PIXEL_MAP_S_TO_S */
- 1113, /* GL_PIXEL_MAP_I_TO_R */
- 1109, /* GL_PIXEL_MAP_I_TO_G */
- 1107, /* GL_PIXEL_MAP_I_TO_B */
- 1105, /* GL_PIXEL_MAP_I_TO_A */
- 1115, /* GL_PIXEL_MAP_R_TO_R */
- 1103, /* GL_PIXEL_MAP_G_TO_G */
- 1101, /* GL_PIXEL_MAP_B_TO_B */
- 1099, /* GL_PIXEL_MAP_A_TO_A */
- 1112, /* GL_PIXEL_MAP_I_TO_I_SIZE */
- 1118, /* GL_PIXEL_MAP_S_TO_S_SIZE */
- 1114, /* GL_PIXEL_MAP_I_TO_R_SIZE */
- 1110, /* GL_PIXEL_MAP_I_TO_G_SIZE */
- 1108, /* GL_PIXEL_MAP_I_TO_B_SIZE */
- 1106, /* GL_PIXEL_MAP_I_TO_A_SIZE */
- 1116, /* GL_PIXEL_MAP_R_TO_R_SIZE */
- 1104, /* GL_PIXEL_MAP_G_TO_G_SIZE */
- 1102, /* GL_PIXEL_MAP_B_TO_B_SIZE */
- 1100, /* GL_PIXEL_MAP_A_TO_A_SIZE */
- 1755, /* GL_UNPACK_SWAP_BYTES */
- 1750, /* GL_UNPACK_LSB_FIRST */
- 1751, /* GL_UNPACK_ROW_LENGTH */
- 1754, /* GL_UNPACK_SKIP_ROWS */
- 1753, /* GL_UNPACK_SKIP_PIXELS */
- 1748, /* GL_UNPACK_ALIGNMENT */
- 1086, /* GL_PACK_SWAP_BYTES */
- 1081, /* GL_PACK_LSB_FIRST */
- 1082, /* GL_PACK_ROW_LENGTH */
- 1085, /* GL_PACK_SKIP_ROWS */
- 1084, /* GL_PACK_SKIP_PIXELS */
- 1078, /* GL_PACK_ALIGNMENT */
- 790, /* GL_MAP_COLOR */
- 795, /* GL_MAP_STENCIL */
- 633, /* GL_INDEX_SHIFT */
- 632, /* GL_INDEX_OFFSET */
- 1297, /* GL_RED_SCALE */
- 1295, /* GL_RED_BIAS */
- 1855, /* GL_ZOOM_X */
- 1856, /* GL_ZOOM_Y */
- 594, /* GL_GREEN_SCALE */
- 592, /* GL_GREEN_BIAS */
+ 632, /* GL_INDEX_MODE */
+ 1362, /* GL_RGBA_MODE */
+ 391, /* GL_DOUBLEBUFFER */
+ 1513, /* GL_STEREO */
+ 1320, /* GL_RENDER_MODE */
+ 1099, /* GL_PERSPECTIVE_CORRECTION_HINT */
+ 1152, /* GL_POINT_SMOOTH_HINT */
+ 697, /* GL_LINE_SMOOTH_HINT */
+ 1169, /* GL_POLYGON_SMOOTH_HINT */
+ 525, /* GL_FOG_HINT */
+ 1683, /* GL_TEXTURE_GEN_S */
+ 1684, /* GL_TEXTURE_GEN_T */
+ 1682, /* GL_TEXTURE_GEN_R */
+ 1681, /* GL_TEXTURE_GEN_Q */
+ 1112, /* GL_PIXEL_MAP_I_TO_I */
+ 1118, /* GL_PIXEL_MAP_S_TO_S */
+ 1114, /* GL_PIXEL_MAP_I_TO_R */
+ 1110, /* GL_PIXEL_MAP_I_TO_G */
+ 1108, /* GL_PIXEL_MAP_I_TO_B */
+ 1106, /* GL_PIXEL_MAP_I_TO_A */
+ 1116, /* GL_PIXEL_MAP_R_TO_R */
+ 1104, /* GL_PIXEL_MAP_G_TO_G */
+ 1102, /* GL_PIXEL_MAP_B_TO_B */
+ 1100, /* GL_PIXEL_MAP_A_TO_A */
+ 1113, /* GL_PIXEL_MAP_I_TO_I_SIZE */
+ 1119, /* GL_PIXEL_MAP_S_TO_S_SIZE */
+ 1115, /* GL_PIXEL_MAP_I_TO_R_SIZE */
+ 1111, /* GL_PIXEL_MAP_I_TO_G_SIZE */
+ 1109, /* GL_PIXEL_MAP_I_TO_B_SIZE */
+ 1107, /* GL_PIXEL_MAP_I_TO_A_SIZE */
+ 1117, /* GL_PIXEL_MAP_R_TO_R_SIZE */
+ 1105, /* GL_PIXEL_MAP_G_TO_G_SIZE */
+ 1103, /* GL_PIXEL_MAP_B_TO_B_SIZE */
+ 1101, /* GL_PIXEL_MAP_A_TO_A_SIZE */
+ 1756, /* GL_UNPACK_SWAP_BYTES */
+ 1751, /* GL_UNPACK_LSB_FIRST */
+ 1752, /* GL_UNPACK_ROW_LENGTH */
+ 1755, /* GL_UNPACK_SKIP_ROWS */
+ 1754, /* GL_UNPACK_SKIP_PIXELS */
+ 1749, /* GL_UNPACK_ALIGNMENT */
+ 1087, /* GL_PACK_SWAP_BYTES */
+ 1082, /* GL_PACK_LSB_FIRST */
+ 1083, /* GL_PACK_ROW_LENGTH */
+ 1086, /* GL_PACK_SKIP_ROWS */
+ 1085, /* GL_PACK_SKIP_PIXELS */
+ 1079, /* GL_PACK_ALIGNMENT */
+ 791, /* GL_MAP_COLOR */
+ 796, /* GL_MAP_STENCIL */
+ 634, /* GL_INDEX_SHIFT */
+ 633, /* GL_INDEX_OFFSET */
+ 1298, /* GL_RED_SCALE */
+ 1296, /* GL_RED_BIAS */
+ 1856, /* GL_ZOOM_X */
+ 1857, /* GL_ZOOM_Y */
+ 595, /* GL_GREEN_SCALE */
+ 593, /* GL_GREEN_BIAS */
93, /* GL_BLUE_SCALE */
91, /* GL_BLUE_BIAS */
42, /* GL_ALPHA_SCALE */
40, /* GL_ALPHA_BIAS */
- 369, /* GL_DEPTH_SCALE */
+ 370, /* GL_DEPTH_SCALE */
350, /* GL_DEPTH_BIAS */
- 869, /* GL_MAX_EVAL_ORDER */
- 873, /* GL_MAX_LIGHTS */
- 852, /* GL_MAX_CLIP_PLANES */
- 919, /* GL_MAX_TEXTURE_SIZE */
- 879, /* GL_MAX_PIXEL_MAP_TABLE */
- 848, /* GL_MAX_ATTRIB_STACK_DEPTH */
- 876, /* GL_MAX_MODELVIEW_STACK_DEPTH */
- 877, /* GL_MAX_NAME_STACK_DEPTH */
- 905, /* GL_MAX_PROJECTION_STACK_DEPTH */
- 920, /* GL_MAX_TEXTURE_STACK_DEPTH */
- 934, /* GL_MAX_VIEWPORT_DIMS */
- 849, /* GL_MAX_CLIENT_ATTRIB_STACK_DEPTH */
- 1522, /* GL_SUBPIXEL_BITS */
- 628, /* GL_INDEX_BITS */
- 1296, /* GL_RED_BITS */
- 593, /* GL_GREEN_BITS */
+ 870, /* GL_MAX_EVAL_ORDER */
+ 874, /* GL_MAX_LIGHTS */
+ 853, /* GL_MAX_CLIP_PLANES */
+ 920, /* GL_MAX_TEXTURE_SIZE */
+ 880, /* GL_MAX_PIXEL_MAP_TABLE */
+ 849, /* GL_MAX_ATTRIB_STACK_DEPTH */
+ 877, /* GL_MAX_MODELVIEW_STACK_DEPTH */
+ 878, /* GL_MAX_NAME_STACK_DEPTH */
+ 906, /* GL_MAX_PROJECTION_STACK_DEPTH */
+ 921, /* GL_MAX_TEXTURE_STACK_DEPTH */
+ 935, /* GL_MAX_VIEWPORT_DIMS */
+ 850, /* GL_MAX_CLIENT_ATTRIB_STACK_DEPTH */
+ 1523, /* GL_SUBPIXEL_BITS */
+ 629, /* GL_INDEX_BITS */
+ 1297, /* GL_RED_BITS */
+ 594, /* GL_GREEN_BITS */
92, /* GL_BLUE_BITS */
41, /* GL_ALPHA_BITS */
351, /* GL_DEPTH_BITS */
- 1494, /* GL_STENCIL_BITS */
+ 1495, /* GL_STENCIL_BITS */
14, /* GL_ACCUM_RED_BITS */
13, /* GL_ACCUM_GREEN_BITS */
10, /* GL_ACCUM_BLUE_BITS */
9, /* GL_ACCUM_ALPHA_BITS */
- 1000, /* GL_NAME_STACK_DEPTH */
+ 1001, /* GL_NAME_STACK_DEPTH */
62, /* GL_AUTO_NORMAL */
- 736, /* GL_MAP1_COLOR_4 */
- 739, /* GL_MAP1_INDEX */
- 740, /* GL_MAP1_NORMAL */
- 741, /* GL_MAP1_TEXTURE_COORD_1 */
- 742, /* GL_MAP1_TEXTURE_COORD_2 */
- 743, /* GL_MAP1_TEXTURE_COORD_3 */
- 744, /* GL_MAP1_TEXTURE_COORD_4 */
- 745, /* GL_MAP1_VERTEX_3 */
- 746, /* GL_MAP1_VERTEX_4 */
- 763, /* GL_MAP2_COLOR_4 */
- 766, /* GL_MAP2_INDEX */
- 767, /* GL_MAP2_NORMAL */
- 768, /* GL_MAP2_TEXTURE_COORD_1 */
- 769, /* GL_MAP2_TEXTURE_COORD_2 */
- 770, /* GL_MAP2_TEXTURE_COORD_3 */
- 771, /* GL_MAP2_TEXTURE_COORD_4 */
- 772, /* GL_MAP2_VERTEX_3 */
- 773, /* GL_MAP2_VERTEX_4 */
- 737, /* GL_MAP1_GRID_DOMAIN */
- 738, /* GL_MAP1_GRID_SEGMENTS */
- 764, /* GL_MAP2_GRID_DOMAIN */
- 765, /* GL_MAP2_GRID_SEGMENTS */
- 1605, /* GL_TEXTURE_1D */
- 1607, /* GL_TEXTURE_2D */
- 478, /* GL_FEEDBACK_BUFFER_POINTER */
- 479, /* GL_FEEDBACK_BUFFER_SIZE */
- 480, /* GL_FEEDBACK_BUFFER_TYPE */
- 1405, /* GL_SELECTION_BUFFER_POINTER */
- 1406, /* GL_SELECTION_BUFFER_SIZE */
- 1723, /* GL_TEXTURE_WIDTH */
- 1687, /* GL_TEXTURE_HEIGHT */
- 1642, /* GL_TEXTURE_COMPONENTS */
- 1626, /* GL_TEXTURE_BORDER_COLOR */
- 1625, /* GL_TEXTURE_BORDER */
- 382, /* GL_DONT_CARE */
- 476, /* GL_FASTEST */
- 1008, /* GL_NICEST */
+ 737, /* GL_MAP1_COLOR_4 */
+ 740, /* GL_MAP1_INDEX */
+ 741, /* GL_MAP1_NORMAL */
+ 742, /* GL_MAP1_TEXTURE_COORD_1 */
+ 743, /* GL_MAP1_TEXTURE_COORD_2 */
+ 744, /* GL_MAP1_TEXTURE_COORD_3 */
+ 745, /* GL_MAP1_TEXTURE_COORD_4 */
+ 746, /* GL_MAP1_VERTEX_3 */
+ 747, /* GL_MAP1_VERTEX_4 */
+ 764, /* GL_MAP2_COLOR_4 */
+ 767, /* GL_MAP2_INDEX */
+ 768, /* GL_MAP2_NORMAL */
+ 769, /* GL_MAP2_TEXTURE_COORD_1 */
+ 770, /* GL_MAP2_TEXTURE_COORD_2 */
+ 771, /* GL_MAP2_TEXTURE_COORD_3 */
+ 772, /* GL_MAP2_TEXTURE_COORD_4 */
+ 773, /* GL_MAP2_VERTEX_3 */
+ 774, /* GL_MAP2_VERTEX_4 */
+ 738, /* GL_MAP1_GRID_DOMAIN */
+ 739, /* GL_MAP1_GRID_SEGMENTS */
+ 765, /* GL_MAP2_GRID_DOMAIN */
+ 766, /* GL_MAP2_GRID_SEGMENTS */
+ 1606, /* GL_TEXTURE_1D */
+ 1608, /* GL_TEXTURE_2D */
+ 479, /* GL_FEEDBACK_BUFFER_POINTER */
+ 480, /* GL_FEEDBACK_BUFFER_SIZE */
+ 481, /* GL_FEEDBACK_BUFFER_TYPE */
+ 1406, /* GL_SELECTION_BUFFER_POINTER */
+ 1407, /* GL_SELECTION_BUFFER_SIZE */
+ 1724, /* GL_TEXTURE_WIDTH */
+ 1688, /* GL_TEXTURE_HEIGHT */
+ 1643, /* GL_TEXTURE_COMPONENTS */
+ 1627, /* GL_TEXTURE_BORDER_COLOR */
+ 1626, /* GL_TEXTURE_BORDER */
+ 383, /* GL_DONT_CARE */
+ 477, /* GL_FASTEST */
+ 1009, /* GL_NICEST */
48, /* GL_AMBIENT */
- 379, /* GL_DIFFUSE */
- 1454, /* GL_SPECULAR */
- 1172, /* GL_POSITION */
- 1457, /* GL_SPOT_DIRECTION */
- 1458, /* GL_SPOT_EXPONENT */
- 1456, /* GL_SPOT_CUTOFF */
+ 380, /* GL_DIFFUSE */
+ 1455, /* GL_SPECULAR */
+ 1173, /* GL_POSITION */
+ 1458, /* GL_SPOT_DIRECTION */
+ 1459, /* GL_SPOT_EXPONENT */
+ 1457, /* GL_SPOT_CUTOFF */
275, /* GL_CONSTANT_ATTENUATION */
- 686, /* GL_LINEAR_ATTENUATION */
- 1270, /* GL_QUADRATIC_ATTENUATION */
+ 687, /* GL_LINEAR_ATTENUATION */
+ 1271, /* GL_QUADRATIC_ATTENUATION */
244, /* GL_COMPILE */
245, /* GL_COMPILE_AND_EXECUTE */
120, /* GL_BYTE */
- 1757, /* GL_UNSIGNED_BYTE */
- 1419, /* GL_SHORT */
- 1768, /* GL_UNSIGNED_SHORT */
- 636, /* GL_INT */
- 1760, /* GL_UNSIGNED_INT */
- 484, /* GL_FLOAT */
+ 1758, /* GL_UNSIGNED_BYTE */
+ 1420, /* GL_SHORT */
+ 1769, /* GL_UNSIGNED_SHORT */
+ 637, /* GL_INT */
+ 1761, /* GL_UNSIGNED_INT */
+ 485, /* GL_FLOAT */
1, /* GL_2_BYTES */
5, /* GL_3_BYTES */
7, /* GL_4_BYTES */
- 389, /* GL_DOUBLE */
+ 390, /* GL_DOUBLE */
132, /* GL_CLEAR */
50, /* GL_AND */
52, /* GL_AND_REVERSE */
299, /* GL_COPY */
51, /* GL_AND_INVERTED */
- 1010, /* GL_NOOP */
- 1851, /* GL_XOR */
- 1073, /* GL_OR */
- 1011, /* GL_NOR */
- 466, /* GL_EQUIV */
- 663, /* GL_INVERT */
- 1076, /* GL_OR_REVERSE */
+ 1011, /* GL_NOOP */
+ 1852, /* GL_XOR */
+ 1074, /* GL_OR */
+ 1012, /* GL_NOR */
+ 467, /* GL_EQUIV */
+ 664, /* GL_INVERT */
+ 1077, /* GL_OR_REVERSE */
300, /* GL_COPY_INVERTED */
- 1075, /* GL_OR_INVERTED */
- 1001, /* GL_NAND */
- 1410, /* GL_SET */
- 463, /* GL_EMISSION */
- 1418, /* GL_SHININESS */
+ 1076, /* GL_OR_INVERTED */
+ 1002, /* GL_NAND */
+ 1411, /* GL_SET */
+ 464, /* GL_EMISSION */
+ 1419, /* GL_SHININESS */
49, /* GL_AMBIENT_AND_DIFFUSE */
190, /* GL_COLOR_INDEXES */
- 951, /* GL_MODELVIEW */
- 1248, /* GL_PROJECTION */
- 1540, /* GL_TEXTURE */
+ 952, /* GL_MODELVIEW */
+ 1249, /* GL_PROJECTION */
+ 1541, /* GL_TEXTURE */
147, /* GL_COLOR */
346, /* GL_DEPTH */
- 1480, /* GL_STENCIL */
+ 1481, /* GL_STENCIL */
189, /* GL_COLOR_INDEX */
- 1499, /* GL_STENCIL_INDEX */
- 357, /* GL_DEPTH_COMPONENT */
- 1292, /* GL_RED */
- 591, /* GL_GREEN */
+ 1500, /* GL_STENCIL_INDEX */
+ 358, /* GL_DEPTH_COMPONENT */
+ 1293, /* GL_RED */
+ 592, /* GL_GREEN */
90, /* GL_BLUE */
31, /* GL_ALPHA */
- 1327, /* GL_RGB */
- 1346, /* GL_RGBA */
- 714, /* GL_LUMINANCE */
- 735, /* GL_LUMINANCE_ALPHA */
+ 1328, /* GL_RGB */
+ 1347, /* GL_RGBA */
+ 715, /* GL_LUMINANCE */
+ 736, /* GL_LUMINANCE_ALPHA */
73, /* GL_BITMAP */
- 1128, /* GL_POINT */
- 684, /* GL_LINE */
- 481, /* GL_FILL */
- 1301, /* GL_RENDER */
- 477, /* GL_FEEDBACK */
- 1404, /* GL_SELECT */
- 483, /* GL_FLAT */
- 1429, /* GL_SMOOTH */
- 664, /* GL_KEEP */
- 1321, /* GL_REPLACE */
- 618, /* GL_INCR */
+ 1129, /* GL_POINT */
+ 685, /* GL_LINE */
+ 482, /* GL_FILL */
+ 1302, /* GL_RENDER */
+ 478, /* GL_FEEDBACK */
+ 1405, /* GL_SELECT */
+ 484, /* GL_FLAT */
+ 1430, /* GL_SMOOTH */
+ 665, /* GL_KEEP */
+ 1322, /* GL_REPLACE */
+ 619, /* GL_INCR */
342, /* GL_DECR */
- 1783, /* GL_VENDOR */
- 1318, /* GL_RENDERER */
- 1784, /* GL_VERSION */
- 470, /* GL_EXTENSIONS */
- 1369, /* GL_S */
- 1531, /* GL_T */
- 1281, /* GL_R */
- 1269, /* GL_Q */
- 987, /* GL_MODULATE */
+ 1784, /* GL_VENDOR */
+ 1319, /* GL_RENDERER */
+ 1785, /* GL_VERSION */
+ 471, /* GL_EXTENSIONS */
+ 1370, /* GL_S */
+ 1532, /* GL_T */
+ 1282, /* GL_R */
+ 1270, /* GL_Q */
+ 988, /* GL_MODULATE */
341, /* GL_DECAL */
- 1677, /* GL_TEXTURE_ENV_MODE */
- 1676, /* GL_TEXTURE_ENV_COLOR */
- 1675, /* GL_TEXTURE_ENV */
- 471, /* GL_EYE_LINEAR */
- 1034, /* GL_OBJECT_LINEAR */
- 1455, /* GL_SPHERE_MAP */
- 1679, /* GL_TEXTURE_GEN_MODE */
- 1036, /* GL_OBJECT_PLANE */
- 472, /* GL_EYE_PLANE */
- 1002, /* GL_NEAREST */
- 685, /* GL_LINEAR */
- 1006, /* GL_NEAREST_MIPMAP_NEAREST */
- 690, /* GL_LINEAR_MIPMAP_NEAREST */
- 1005, /* GL_NEAREST_MIPMAP_LINEAR */
- 689, /* GL_LINEAR_MIPMAP_LINEAR */
- 1700, /* GL_TEXTURE_MAG_FILTER */
- 1708, /* GL_TEXTURE_MIN_FILTER */
- 1725, /* GL_TEXTURE_WRAP_S */
- 1726, /* GL_TEXTURE_WRAP_T */
+ 1678, /* GL_TEXTURE_ENV_MODE */
+ 1677, /* GL_TEXTURE_ENV_COLOR */
+ 1676, /* GL_TEXTURE_ENV */
+ 472, /* GL_EYE_LINEAR */
+ 1035, /* GL_OBJECT_LINEAR */
+ 1456, /* GL_SPHERE_MAP */
+ 1680, /* GL_TEXTURE_GEN_MODE */
+ 1037, /* GL_OBJECT_PLANE */
+ 473, /* GL_EYE_PLANE */
+ 1003, /* GL_NEAREST */
+ 686, /* GL_LINEAR */
+ 1007, /* GL_NEAREST_MIPMAP_NEAREST */
+ 691, /* GL_LINEAR_MIPMAP_NEAREST */
+ 1006, /* GL_NEAREST_MIPMAP_LINEAR */
+ 690, /* GL_LINEAR_MIPMAP_LINEAR */
+ 1701, /* GL_TEXTURE_MAG_FILTER */
+ 1709, /* GL_TEXTURE_MIN_FILTER */
+ 1726, /* GL_TEXTURE_WRAP_S */
+ 1727, /* GL_TEXTURE_WRAP_T */
126, /* GL_CLAMP */
- 1320, /* GL_REPEAT */
- 1166, /* GL_POLYGON_OFFSET_UNITS */
- 1165, /* GL_POLYGON_OFFSET_POINT */
- 1164, /* GL_POLYGON_OFFSET_LINE */
- 1282, /* GL_R3_G3_B2 */
- 1780, /* GL_V2F */
- 1781, /* GL_V3F */
+ 1321, /* GL_REPEAT */
+ 1167, /* GL_POLYGON_OFFSET_UNITS */
+ 1166, /* GL_POLYGON_OFFSET_POINT */
+ 1165, /* GL_POLYGON_OFFSET_LINE */
+ 1283, /* GL_R3_G3_B2 */
+ 1781, /* GL_V2F */
+ 1782, /* GL_V3F */
123, /* GL_C4UB_V2F */
124, /* GL_C4UB_V3F */
121, /* GL_C3F_V3F */
- 999, /* GL_N3F_V3F */
+ 1000, /* GL_N3F_V3F */
122, /* GL_C4F_N3F_V3F */
- 1536, /* GL_T2F_V3F */
- 1538, /* GL_T4F_V4F */
- 1534, /* GL_T2F_C4UB_V3F */
- 1532, /* GL_T2F_C3F_V3F */
- 1535, /* GL_T2F_N3F_V3F */
- 1533, /* GL_T2F_C4F_N3F_V3F */
- 1537, /* GL_T4F_C4F_N3F_V4F */
+ 1537, /* GL_T2F_V3F */
+ 1539, /* GL_T4F_V4F */
+ 1535, /* GL_T2F_C4UB_V3F */
+ 1533, /* GL_T2F_C3F_V3F */
+ 1536, /* GL_T2F_N3F_V3F */
+ 1534, /* GL_T2F_C4F_N3F_V3F */
+ 1538, /* GL_T4F_C4F_N3F_V4F */
139, /* GL_CLIP_PLANE0 */
140, /* GL_CLIP_PLANE1 */
141, /* GL_CLIP_PLANE2 */
142, /* GL_CLIP_PLANE3 */
143, /* GL_CLIP_PLANE4 */
144, /* GL_CLIP_PLANE5 */
- 669, /* GL_LIGHT0 */
- 670, /* GL_LIGHT1 */
- 671, /* GL_LIGHT2 */
- 672, /* GL_LIGHT3 */
- 673, /* GL_LIGHT4 */
- 674, /* GL_LIGHT5 */
- 675, /* GL_LIGHT6 */
- 676, /* GL_LIGHT7 */
- 595, /* GL_HINT_BIT */
+ 670, /* GL_LIGHT0 */
+ 671, /* GL_LIGHT1 */
+ 672, /* GL_LIGHT2 */
+ 673, /* GL_LIGHT3 */
+ 674, /* GL_LIGHT4 */
+ 675, /* GL_LIGHT5 */
+ 676, /* GL_LIGHT6 */
+ 677, /* GL_LIGHT7 */
+ 596, /* GL_HINT_BIT */
277, /* GL_CONSTANT_COLOR */
- 1047, /* GL_ONE_MINUS_CONSTANT_COLOR */
+ 1048, /* GL_ONE_MINUS_CONSTANT_COLOR */
272, /* GL_CONSTANT_ALPHA */
- 1045, /* GL_ONE_MINUS_CONSTANT_ALPHA */
+ 1046, /* GL_ONE_MINUS_CONSTANT_ALPHA */
76, /* GL_BLEND_COLOR */
- 579, /* GL_FUNC_ADD */
- 935, /* GL_MIN */
- 845, /* GL_MAX */
+ 580, /* GL_FUNC_ADD */
+ 936, /* GL_MIN */
+ 846, /* GL_MAX */
81, /* GL_BLEND_EQUATION */
- 583, /* GL_FUNC_SUBTRACT */
- 581, /* GL_FUNC_REVERSE_SUBTRACT */
+ 584, /* GL_FUNC_SUBTRACT */
+ 582, /* GL_FUNC_REVERSE_SUBTRACT */
280, /* GL_CONVOLUTION_1D */
281, /* GL_CONVOLUTION_2D */
- 1407, /* GL_SEPARABLE_2D */
+ 1408, /* GL_SEPARABLE_2D */
284, /* GL_CONVOLUTION_BORDER_MODE */
288, /* GL_CONVOLUTION_FILTER_SCALE */
286, /* GL_CONVOLUTION_FILTER_BIAS */
- 1293, /* GL_REDUCE */
+ 1294, /* GL_REDUCE */
290, /* GL_CONVOLUTION_FORMAT */
294, /* GL_CONVOLUTION_WIDTH */
292, /* GL_CONVOLUTION_HEIGHT */
- 860, /* GL_MAX_CONVOLUTION_WIDTH */
- 858, /* GL_MAX_CONVOLUTION_HEIGHT */
- 1205, /* GL_POST_CONVOLUTION_RED_SCALE */
- 1201, /* GL_POST_CONVOLUTION_GREEN_SCALE */
- 1196, /* GL_POST_CONVOLUTION_BLUE_SCALE */
- 1192, /* GL_POST_CONVOLUTION_ALPHA_SCALE */
- 1203, /* GL_POST_CONVOLUTION_RED_BIAS */
- 1199, /* GL_POST_CONVOLUTION_GREEN_BIAS */
- 1194, /* GL_POST_CONVOLUTION_BLUE_BIAS */
- 1190, /* GL_POST_CONVOLUTION_ALPHA_BIAS */
- 596, /* GL_HISTOGRAM */
- 1253, /* GL_PROXY_HISTOGRAM */
- 612, /* GL_HISTOGRAM_WIDTH */
- 602, /* GL_HISTOGRAM_FORMAT */
- 608, /* GL_HISTOGRAM_RED_SIZE */
- 604, /* GL_HISTOGRAM_GREEN_SIZE */
- 599, /* GL_HISTOGRAM_BLUE_SIZE */
- 597, /* GL_HISTOGRAM_ALPHA_SIZE */
- 606, /* GL_HISTOGRAM_LUMINANCE_SIZE */
- 610, /* GL_HISTOGRAM_SINK */
- 936, /* GL_MINMAX */
- 938, /* GL_MINMAX_FORMAT */
- 940, /* GL_MINMAX_SINK */
- 1539, /* GL_TABLE_TOO_LARGE_EXT */
- 1759, /* GL_UNSIGNED_BYTE_3_3_2 */
- 1770, /* GL_UNSIGNED_SHORT_4_4_4_4 */
- 1772, /* GL_UNSIGNED_SHORT_5_5_5_1 */
- 1765, /* GL_UNSIGNED_INT_8_8_8_8 */
- 1761, /* GL_UNSIGNED_INT_10_10_10_2 */
- 1163, /* GL_POLYGON_OFFSET_FILL */
- 1162, /* GL_POLYGON_OFFSET_FACTOR */
- 1161, /* GL_POLYGON_OFFSET_BIAS */
- 1324, /* GL_RESCALE_NORMAL */
+ 861, /* GL_MAX_CONVOLUTION_WIDTH */
+ 859, /* GL_MAX_CONVOLUTION_HEIGHT */
+ 1206, /* GL_POST_CONVOLUTION_RED_SCALE */
+ 1202, /* GL_POST_CONVOLUTION_GREEN_SCALE */
+ 1197, /* GL_POST_CONVOLUTION_BLUE_SCALE */
+ 1193, /* GL_POST_CONVOLUTION_ALPHA_SCALE */
+ 1204, /* GL_POST_CONVOLUTION_RED_BIAS */
+ 1200, /* GL_POST_CONVOLUTION_GREEN_BIAS */
+ 1195, /* GL_POST_CONVOLUTION_BLUE_BIAS */
+ 1191, /* GL_POST_CONVOLUTION_ALPHA_BIAS */
+ 597, /* GL_HISTOGRAM */
+ 1254, /* GL_PROXY_HISTOGRAM */
+ 613, /* GL_HISTOGRAM_WIDTH */
+ 603, /* GL_HISTOGRAM_FORMAT */
+ 609, /* GL_HISTOGRAM_RED_SIZE */
+ 605, /* GL_HISTOGRAM_GREEN_SIZE */
+ 600, /* GL_HISTOGRAM_BLUE_SIZE */
+ 598, /* GL_HISTOGRAM_ALPHA_SIZE */
+ 607, /* GL_HISTOGRAM_LUMINANCE_SIZE */
+ 611, /* GL_HISTOGRAM_SINK */
+ 937, /* GL_MINMAX */
+ 939, /* GL_MINMAX_FORMAT */
+ 941, /* GL_MINMAX_SINK */
+ 1540, /* GL_TABLE_TOO_LARGE_EXT */
+ 1760, /* GL_UNSIGNED_BYTE_3_3_2 */
+ 1771, /* GL_UNSIGNED_SHORT_4_4_4_4 */
+ 1773, /* GL_UNSIGNED_SHORT_5_5_5_1 */
+ 1766, /* GL_UNSIGNED_INT_8_8_8_8 */
+ 1762, /* GL_UNSIGNED_INT_10_10_10_2 */
+ 1164, /* GL_POLYGON_OFFSET_FILL */
+ 1163, /* GL_POLYGON_OFFSET_FACTOR */
+ 1162, /* GL_POLYGON_OFFSET_BIAS */
+ 1325, /* GL_RESCALE_NORMAL */
36, /* GL_ALPHA4 */
38, /* GL_ALPHA8 */
32, /* GL_ALPHA12 */
34, /* GL_ALPHA16 */
- 725, /* GL_LUMINANCE4 */
- 731, /* GL_LUMINANCE8 */
- 715, /* GL_LUMINANCE12 */
- 721, /* GL_LUMINANCE16 */
- 726, /* GL_LUMINANCE4_ALPHA4 */
- 729, /* GL_LUMINANCE6_ALPHA2 */
- 732, /* GL_LUMINANCE8_ALPHA8 */
- 718, /* GL_LUMINANCE12_ALPHA4 */
- 716, /* GL_LUMINANCE12_ALPHA12 */
- 722, /* GL_LUMINANCE16_ALPHA16 */
- 637, /* GL_INTENSITY */
- 642, /* GL_INTENSITY4 */
- 644, /* GL_INTENSITY8 */
- 638, /* GL_INTENSITY12 */
- 640, /* GL_INTENSITY16 */
- 1336, /* GL_RGB2_EXT */
- 1337, /* GL_RGB4 */
- 1340, /* GL_RGB5 */
- 1344, /* GL_RGB8 */
- 1328, /* GL_RGB10 */
- 1332, /* GL_RGB12 */
- 1334, /* GL_RGB16 */
- 1351, /* GL_RGBA2 */
- 1353, /* GL_RGBA4 */
- 1341, /* GL_RGB5_A1 */
- 1357, /* GL_RGBA8 */
- 1329, /* GL_RGB10_A2 */
- 1347, /* GL_RGBA12 */
- 1349, /* GL_RGBA16 */
- 1715, /* GL_TEXTURE_RED_SIZE */
- 1685, /* GL_TEXTURE_GREEN_SIZE */
- 1623, /* GL_TEXTURE_BLUE_SIZE */
- 1610, /* GL_TEXTURE_ALPHA_SIZE */
- 1698, /* GL_TEXTURE_LUMINANCE_SIZE */
- 1689, /* GL_TEXTURE_INTENSITY_SIZE */
- 1322, /* GL_REPLACE_EXT */
- 1257, /* GL_PROXY_TEXTURE_1D */
- 1260, /* GL_PROXY_TEXTURE_2D */
- 1721, /* GL_TEXTURE_TOO_LARGE_EXT */
- 1710, /* GL_TEXTURE_PRIORITY */
- 1717, /* GL_TEXTURE_RESIDENT */
- 1613, /* GL_TEXTURE_BINDING_1D */
- 1615, /* GL_TEXTURE_BINDING_2D */
- 1617, /* GL_TEXTURE_BINDING_3D */
- 1083, /* GL_PACK_SKIP_IMAGES */
- 1079, /* GL_PACK_IMAGE_HEIGHT */
- 1752, /* GL_UNPACK_SKIP_IMAGES */
- 1749, /* GL_UNPACK_IMAGE_HEIGHT */
- 1609, /* GL_TEXTURE_3D */
- 1263, /* GL_PROXY_TEXTURE_3D */
- 1672, /* GL_TEXTURE_DEPTH */
- 1724, /* GL_TEXTURE_WRAP_R */
- 846, /* GL_MAX_3D_TEXTURE_SIZE */
- 1785, /* GL_VERTEX_ARRAY */
- 1013, /* GL_NORMAL_ARRAY */
+ 726, /* GL_LUMINANCE4 */
+ 732, /* GL_LUMINANCE8 */
+ 716, /* GL_LUMINANCE12 */
+ 722, /* GL_LUMINANCE16 */
+ 727, /* GL_LUMINANCE4_ALPHA4 */
+ 730, /* GL_LUMINANCE6_ALPHA2 */
+ 733, /* GL_LUMINANCE8_ALPHA8 */
+ 719, /* GL_LUMINANCE12_ALPHA4 */
+ 717, /* GL_LUMINANCE12_ALPHA12 */
+ 723, /* GL_LUMINANCE16_ALPHA16 */
+ 638, /* GL_INTENSITY */
+ 643, /* GL_INTENSITY4 */
+ 645, /* GL_INTENSITY8 */
+ 639, /* GL_INTENSITY12 */
+ 641, /* GL_INTENSITY16 */
+ 1337, /* GL_RGB2_EXT */
+ 1338, /* GL_RGB4 */
+ 1341, /* GL_RGB5 */
+ 1345, /* GL_RGB8 */
+ 1329, /* GL_RGB10 */
+ 1333, /* GL_RGB12 */
+ 1335, /* GL_RGB16 */
+ 1352, /* GL_RGBA2 */
+ 1354, /* GL_RGBA4 */
+ 1342, /* GL_RGB5_A1 */
+ 1358, /* GL_RGBA8 */
+ 1330, /* GL_RGB10_A2 */
+ 1348, /* GL_RGBA12 */
+ 1350, /* GL_RGBA16 */
+ 1716, /* GL_TEXTURE_RED_SIZE */
+ 1686, /* GL_TEXTURE_GREEN_SIZE */
+ 1624, /* GL_TEXTURE_BLUE_SIZE */
+ 1611, /* GL_TEXTURE_ALPHA_SIZE */
+ 1699, /* GL_TEXTURE_LUMINANCE_SIZE */
+ 1690, /* GL_TEXTURE_INTENSITY_SIZE */
+ 1323, /* GL_REPLACE_EXT */
+ 1258, /* GL_PROXY_TEXTURE_1D */
+ 1261, /* GL_PROXY_TEXTURE_2D */
+ 1722, /* GL_TEXTURE_TOO_LARGE_EXT */
+ 1711, /* GL_TEXTURE_PRIORITY */
+ 1718, /* GL_TEXTURE_RESIDENT */
+ 1614, /* GL_TEXTURE_BINDING_1D */
+ 1616, /* GL_TEXTURE_BINDING_2D */
+ 1618, /* GL_TEXTURE_BINDING_3D */
+ 1084, /* GL_PACK_SKIP_IMAGES */
+ 1080, /* GL_PACK_IMAGE_HEIGHT */
+ 1753, /* GL_UNPACK_SKIP_IMAGES */
+ 1750, /* GL_UNPACK_IMAGE_HEIGHT */
+ 1610, /* GL_TEXTURE_3D */
+ 1264, /* GL_PROXY_TEXTURE_3D */
+ 1673, /* GL_TEXTURE_DEPTH */
+ 1725, /* GL_TEXTURE_WRAP_R */
+ 847, /* GL_MAX_3D_TEXTURE_SIZE */
+ 1786, /* GL_VERTEX_ARRAY */
+ 1014, /* GL_NORMAL_ARRAY */
148, /* GL_COLOR_ARRAY */
- 622, /* GL_INDEX_ARRAY */
- 1650, /* GL_TEXTURE_COORD_ARRAY */
- 455, /* GL_EDGE_FLAG_ARRAY */
- 1791, /* GL_VERTEX_ARRAY_SIZE */
- 1793, /* GL_VERTEX_ARRAY_TYPE */
- 1792, /* GL_VERTEX_ARRAY_STRIDE */
- 1018, /* GL_NORMAL_ARRAY_TYPE */
- 1017, /* GL_NORMAL_ARRAY_STRIDE */
+ 623, /* GL_INDEX_ARRAY */
+ 1651, /* GL_TEXTURE_COORD_ARRAY */
+ 456, /* GL_EDGE_FLAG_ARRAY */
+ 1792, /* GL_VERTEX_ARRAY_SIZE */
+ 1794, /* GL_VERTEX_ARRAY_TYPE */
+ 1793, /* GL_VERTEX_ARRAY_STRIDE */
+ 1019, /* GL_NORMAL_ARRAY_TYPE */
+ 1018, /* GL_NORMAL_ARRAY_STRIDE */
152, /* GL_COLOR_ARRAY_SIZE */
154, /* GL_COLOR_ARRAY_TYPE */
153, /* GL_COLOR_ARRAY_STRIDE */
- 627, /* GL_INDEX_ARRAY_TYPE */
- 626, /* GL_INDEX_ARRAY_STRIDE */
- 1654, /* GL_TEXTURE_COORD_ARRAY_SIZE */
- 1656, /* GL_TEXTURE_COORD_ARRAY_TYPE */
- 1655, /* GL_TEXTURE_COORD_ARRAY_STRIDE */
- 459, /* GL_EDGE_FLAG_ARRAY_STRIDE */
- 1790, /* GL_VERTEX_ARRAY_POINTER */
- 1016, /* GL_NORMAL_ARRAY_POINTER */
+ 628, /* GL_INDEX_ARRAY_TYPE */
+ 627, /* GL_INDEX_ARRAY_STRIDE */
+ 1655, /* GL_TEXTURE_COORD_ARRAY_SIZE */
+ 1657, /* GL_TEXTURE_COORD_ARRAY_TYPE */
+ 1656, /* GL_TEXTURE_COORD_ARRAY_STRIDE */
+ 460, /* GL_EDGE_FLAG_ARRAY_STRIDE */
+ 1791, /* GL_VERTEX_ARRAY_POINTER */
+ 1017, /* GL_NORMAL_ARRAY_POINTER */
151, /* GL_COLOR_ARRAY_POINTER */
- 625, /* GL_INDEX_ARRAY_POINTER */
- 1653, /* GL_TEXTURE_COORD_ARRAY_POINTER */
- 458, /* GL_EDGE_FLAG_ARRAY_POINTER */
- 992, /* GL_MULTISAMPLE */
- 1381, /* GL_SAMPLE_ALPHA_TO_COVERAGE */
- 1383, /* GL_SAMPLE_ALPHA_TO_ONE */
- 1388, /* GL_SAMPLE_COVERAGE */
- 1385, /* GL_SAMPLE_BUFFERS */
- 1376, /* GL_SAMPLES */
- 1392, /* GL_SAMPLE_COVERAGE_VALUE */
- 1390, /* GL_SAMPLE_COVERAGE_INVERT */
+ 626, /* GL_INDEX_ARRAY_POINTER */
+ 1654, /* GL_TEXTURE_COORD_ARRAY_POINTER */
+ 459, /* GL_EDGE_FLAG_ARRAY_POINTER */
+ 993, /* GL_MULTISAMPLE */
+ 1382, /* GL_SAMPLE_ALPHA_TO_COVERAGE */
+ 1384, /* GL_SAMPLE_ALPHA_TO_ONE */
+ 1389, /* GL_SAMPLE_COVERAGE */
+ 1386, /* GL_SAMPLE_BUFFERS */
+ 1377, /* GL_SAMPLES */
+ 1393, /* GL_SAMPLE_COVERAGE_VALUE */
+ 1391, /* GL_SAMPLE_COVERAGE_INVERT */
195, /* GL_COLOR_MATRIX */
197, /* GL_COLOR_MATRIX_STACK_DEPTH */
- 854, /* GL_MAX_COLOR_MATRIX_STACK_DEPTH */
- 1188, /* GL_POST_COLOR_MATRIX_RED_SCALE */
- 1184, /* GL_POST_COLOR_MATRIX_GREEN_SCALE */
- 1179, /* GL_POST_COLOR_MATRIX_BLUE_SCALE */
- 1175, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE */
- 1186, /* GL_POST_COLOR_MATRIX_RED_BIAS */
- 1182, /* GL_POST_COLOR_MATRIX_GREEN_BIAS */
- 1177, /* GL_POST_COLOR_MATRIX_BLUE_BIAS */
- 1173, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS */
- 1633, /* GL_TEXTURE_COLOR_TABLE_SGI */
- 1264, /* GL_PROXY_TEXTURE_COLOR_TABLE_SGI */
- 1635, /* GL_TEXTURE_COMPARE_FAIL_VALUE_ARB */
+ 855, /* GL_MAX_COLOR_MATRIX_STACK_DEPTH */
+ 1189, /* GL_POST_COLOR_MATRIX_RED_SCALE */
+ 1185, /* GL_POST_COLOR_MATRIX_GREEN_SCALE */
+ 1180, /* GL_POST_COLOR_MATRIX_BLUE_SCALE */
+ 1176, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE */
+ 1187, /* GL_POST_COLOR_MATRIX_RED_BIAS */
+ 1183, /* GL_POST_COLOR_MATRIX_GREEN_BIAS */
+ 1178, /* GL_POST_COLOR_MATRIX_BLUE_BIAS */
+ 1174, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS */
+ 1634, /* GL_TEXTURE_COLOR_TABLE_SGI */
+ 1265, /* GL_PROXY_TEXTURE_COLOR_TABLE_SGI */
+ 1636, /* GL_TEXTURE_COMPARE_FAIL_VALUE_ARB */
80, /* GL_BLEND_DST_RGB */
89, /* GL_BLEND_SRC_RGB */
79, /* GL_BLEND_DST_ALPHA */
88, /* GL_BLEND_SRC_ALPHA */
201, /* GL_COLOR_TABLE */
- 1198, /* GL_POST_CONVOLUTION_COLOR_TABLE */
- 1181, /* GL_POST_COLOR_MATRIX_COLOR_TABLE */
- 1252, /* GL_PROXY_COLOR_TABLE */
- 1256, /* GL_PROXY_POST_CONVOLUTION_COLOR_TABLE */
- 1255, /* GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE */
+ 1199, /* GL_POST_CONVOLUTION_COLOR_TABLE */
+ 1182, /* GL_POST_COLOR_MATRIX_COLOR_TABLE */
+ 1253, /* GL_PROXY_COLOR_TABLE */
+ 1257, /* GL_PROXY_POST_CONVOLUTION_COLOR_TABLE */
+ 1256, /* GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE */
225, /* GL_COLOR_TABLE_SCALE */
205, /* GL_COLOR_TABLE_BIAS */
210, /* GL_COLOR_TABLE_FORMAT */
216, /* GL_COLOR_TABLE_INTENSITY_SIZE */
71, /* GL_BGR */
72, /* GL_BGRA */
- 868, /* GL_MAX_ELEMENTS_VERTICES */
- 867, /* GL_MAX_ELEMENTS_INDICES */
- 1688, /* GL_TEXTURE_INDEX_SIZE_EXT */
+ 869, /* GL_MAX_ELEMENTS_VERTICES */
+ 868, /* GL_MAX_ELEMENTS_INDICES */
+ 1689, /* GL_TEXTURE_INDEX_SIZE_EXT */
145, /* GL_CLIP_VOLUME_CLIPPING_HINT_EXT */
- 1145, /* GL_POINT_SIZE_MIN */
- 1141, /* GL_POINT_SIZE_MAX */
- 1135, /* GL_POINT_FADE_THRESHOLD_SIZE */
- 1131, /* GL_POINT_DISTANCE_ATTENUATION */
+ 1146, /* GL_POINT_SIZE_MIN */
+ 1142, /* GL_POINT_SIZE_MAX */
+ 1136, /* GL_POINT_FADE_THRESHOLD_SIZE */
+ 1132, /* GL_POINT_DISTANCE_ATTENUATION */
127, /* GL_CLAMP_TO_BORDER */
130, /* GL_CLAMP_TO_EDGE */
- 1709, /* GL_TEXTURE_MIN_LOD */
- 1707, /* GL_TEXTURE_MAX_LOD */
- 1612, /* GL_TEXTURE_BASE_LEVEL */
- 1706, /* GL_TEXTURE_MAX_LEVEL */
- 615, /* GL_IGNORE_BORDER_HP */
+ 1710, /* GL_TEXTURE_MIN_LOD */
+ 1708, /* GL_TEXTURE_MAX_LOD */
+ 1613, /* GL_TEXTURE_BASE_LEVEL */
+ 1707, /* GL_TEXTURE_MAX_LEVEL */
+ 616, /* GL_IGNORE_BORDER_HP */
276, /* GL_CONSTANT_BORDER_HP */
- 1323, /* GL_REPLICATE_BORDER_HP */
+ 1324, /* GL_REPLICATE_BORDER_HP */
282, /* GL_CONVOLUTION_BORDER_COLOR */
- 1042, /* GL_OCCLUSION_TEST_HP */
- 1043, /* GL_OCCLUSION_TEST_RESULT_HP */
- 687, /* GL_LINEAR_CLIPMAP_LINEAR_SGIX */
- 1627, /* GL_TEXTURE_CLIPMAP_CENTER_SGIX */
- 1629, /* GL_TEXTURE_CLIPMAP_FRAME_SGIX */
- 1631, /* GL_TEXTURE_CLIPMAP_OFFSET_SGIX */
- 1632, /* GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX */
- 1630, /* GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX */
- 1628, /* GL_TEXTURE_CLIPMAP_DEPTH_SGIX */
- 850, /* GL_MAX_CLIPMAP_DEPTH_SGIX */
- 851, /* GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX */
- 1208, /* GL_POST_TEXTURE_FILTER_BIAS_SGIX */
- 1210, /* GL_POST_TEXTURE_FILTER_SCALE_SGIX */
- 1207, /* GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX */
- 1209, /* GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX */
- 1696, /* GL_TEXTURE_LOD_BIAS_S_SGIX */
- 1697, /* GL_TEXTURE_LOD_BIAS_T_SGIX */
- 1695, /* GL_TEXTURE_LOD_BIAS_R_SGIX */
- 585, /* GL_GENERATE_MIPMAP */
- 586, /* GL_GENERATE_MIPMAP_HINT */
- 527, /* GL_FOG_OFFSET_SGIX */
- 528, /* GL_FOG_OFFSET_VALUE_SGIX */
- 1641, /* GL_TEXTURE_COMPARE_SGIX */
- 1640, /* GL_TEXTURE_COMPARE_OPERATOR_SGIX */
- 1692, /* GL_TEXTURE_LEQUAL_R_SGIX */
- 1684, /* GL_TEXTURE_GEQUAL_R_SGIX */
- 358, /* GL_DEPTH_COMPONENT16 */
- 361, /* GL_DEPTH_COMPONENT24 */
- 364, /* GL_DEPTH_COMPONENT32 */
+ 1043, /* GL_OCCLUSION_TEST_HP */
+ 1044, /* GL_OCCLUSION_TEST_RESULT_HP */
+ 688, /* GL_LINEAR_CLIPMAP_LINEAR_SGIX */
+ 1628, /* GL_TEXTURE_CLIPMAP_CENTER_SGIX */
+ 1630, /* GL_TEXTURE_CLIPMAP_FRAME_SGIX */
+ 1632, /* GL_TEXTURE_CLIPMAP_OFFSET_SGIX */
+ 1633, /* GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX */
+ 1631, /* GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX */
+ 1629, /* GL_TEXTURE_CLIPMAP_DEPTH_SGIX */
+ 851, /* GL_MAX_CLIPMAP_DEPTH_SGIX */
+ 852, /* GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX */
+ 1209, /* GL_POST_TEXTURE_FILTER_BIAS_SGIX */
+ 1211, /* GL_POST_TEXTURE_FILTER_SCALE_SGIX */
+ 1208, /* GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX */
+ 1210, /* GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX */
+ 1697, /* GL_TEXTURE_LOD_BIAS_S_SGIX */
+ 1698, /* GL_TEXTURE_LOD_BIAS_T_SGIX */
+ 1696, /* GL_TEXTURE_LOD_BIAS_R_SGIX */
+ 586, /* GL_GENERATE_MIPMAP */
+ 587, /* GL_GENERATE_MIPMAP_HINT */
+ 528, /* GL_FOG_OFFSET_SGIX */
+ 529, /* GL_FOG_OFFSET_VALUE_SGIX */
+ 1642, /* GL_TEXTURE_COMPARE_SGIX */
+ 1641, /* GL_TEXTURE_COMPARE_OPERATOR_SGIX */
+ 1693, /* GL_TEXTURE_LEQUAL_R_SGIX */
+ 1685, /* GL_TEXTURE_GEQUAL_R_SGIX */
+ 359, /* GL_DEPTH_COMPONENT16 */
+ 362, /* GL_DEPTH_COMPONENT24 */
+ 365, /* GL_DEPTH_COMPONENT32 */
306, /* GL_CULL_VERTEX_EXT */
308, /* GL_CULL_VERTEX_OBJECT_POSITION_EXT */
307, /* GL_CULL_VERTEX_EYE_POSITION_EXT */
- 1848, /* GL_WRAP_BORDER_SUN */
- 1634, /* GL_TEXTURE_COLOR_WRITEMASK_SGIS */
- 680, /* GL_LIGHT_MODEL_COLOR_CONTROL */
- 1422, /* GL_SINGLE_COLOR */
- 1408, /* GL_SEPARATE_SPECULAR_COLOR */
- 1417, /* GL_SHARED_TEXTURE_PALETTE_EXT */
- 538, /* GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING */
- 539, /* GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE */
- 546, /* GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE */
- 541, /* GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE */
- 537, /* GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE */
- 536, /* GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE */
- 540, /* GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE */
- 547, /* GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE */
- 558, /* GL_FRAMEBUFFER_DEFAULT */
- 571, /* GL_FRAMEBUFFER_UNDEFINED */
- 371, /* GL_DEPTH_STENCIL_ATTACHMENT */
- 621, /* GL_INDEX */
- 1758, /* GL_UNSIGNED_BYTE_2_3_3_REV */
- 1773, /* GL_UNSIGNED_SHORT_5_6_5 */
- 1774, /* GL_UNSIGNED_SHORT_5_6_5_REV */
- 1771, /* GL_UNSIGNED_SHORT_4_4_4_4_REV */
- 1769, /* GL_UNSIGNED_SHORT_1_5_5_5_REV */
- 1766, /* GL_UNSIGNED_INT_8_8_8_8_REV */
- 1764, /* GL_UNSIGNED_INT_2_10_10_10_REV */
- 1704, /* GL_TEXTURE_MAX_CLAMP_S_SGIX */
- 1705, /* GL_TEXTURE_MAX_CLAMP_T_SGIX */
- 1703, /* GL_TEXTURE_MAX_CLAMP_R_SGIX */
- 943, /* GL_MIRRORED_REPEAT */
- 1364, /* GL_RGB_S3TC */
- 1339, /* GL_RGB4_S3TC */
- 1362, /* GL_RGBA_S3TC */
- 1356, /* GL_RGBA4_S3TC */
- 1360, /* GL_RGBA_DXT5_S3TC */
- 1354, /* GL_RGBA4_DXT5_S3TC */
+ 1849, /* GL_WRAP_BORDER_SUN */
+ 1635, /* GL_TEXTURE_COLOR_WRITEMASK_SGIS */
+ 681, /* GL_LIGHT_MODEL_COLOR_CONTROL */
+ 1423, /* GL_SINGLE_COLOR */
+ 1409, /* GL_SEPARATE_SPECULAR_COLOR */
+ 1418, /* GL_SHARED_TEXTURE_PALETTE_EXT */
+ 539, /* GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING */
+ 540, /* GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE */
+ 547, /* GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE */
+ 542, /* GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE */
+ 538, /* GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE */
+ 537, /* GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE */
+ 541, /* GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE */
+ 548, /* GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE */
+ 559, /* GL_FRAMEBUFFER_DEFAULT */
+ 572, /* GL_FRAMEBUFFER_UNDEFINED */
+ 372, /* GL_DEPTH_STENCIL_ATTACHMENT */
+ 622, /* GL_INDEX */
+ 1759, /* GL_UNSIGNED_BYTE_2_3_3_REV */
+ 1774, /* GL_UNSIGNED_SHORT_5_6_5 */
+ 1775, /* GL_UNSIGNED_SHORT_5_6_5_REV */
+ 1772, /* GL_UNSIGNED_SHORT_4_4_4_4_REV */
+ 1770, /* GL_UNSIGNED_SHORT_1_5_5_5_REV */
+ 1767, /* GL_UNSIGNED_INT_8_8_8_8_REV */
+ 1765, /* GL_UNSIGNED_INT_2_10_10_10_REV */
+ 1705, /* GL_TEXTURE_MAX_CLAMP_S_SGIX */
+ 1706, /* GL_TEXTURE_MAX_CLAMP_T_SGIX */
+ 1704, /* GL_TEXTURE_MAX_CLAMP_R_SGIX */
+ 944, /* GL_MIRRORED_REPEAT */
+ 1365, /* GL_RGB_S3TC */
+ 1340, /* GL_RGB4_S3TC */
+ 1363, /* GL_RGBA_S3TC */
+ 1357, /* GL_RGBA4_S3TC */
+ 1361, /* GL_RGBA_DXT5_S3TC */
+ 1355, /* GL_RGBA4_DXT5_S3TC */
264, /* GL_COMPRESSED_RGB_S3TC_DXT1_EXT */
259, /* GL_COMPRESSED_RGBA_S3TC_DXT1_EXT */
260, /* GL_COMPRESSED_RGBA_S3TC_DXT3_EXT */
261, /* GL_COMPRESSED_RGBA_S3TC_DXT5_EXT */
- 1004, /* GL_NEAREST_CLIPMAP_NEAREST_SGIX */
- 1003, /* GL_NEAREST_CLIPMAP_LINEAR_SGIX */
- 688, /* GL_LINEAR_CLIPMAP_NEAREST_SGIX */
- 514, /* GL_FOG_COORDINATE_SOURCE */
- 506, /* GL_FOG_COORD */
- 530, /* GL_FRAGMENT_DEPTH */
+ 1005, /* GL_NEAREST_CLIPMAP_NEAREST_SGIX */
+ 1004, /* GL_NEAREST_CLIPMAP_LINEAR_SGIX */
+ 689, /* GL_LINEAR_CLIPMAP_NEAREST_SGIX */
+ 515, /* GL_FOG_COORDINATE_SOURCE */
+ 507, /* GL_FOG_COORD */
+ 531, /* GL_FRAGMENT_DEPTH */
312, /* GL_CURRENT_FOG_COORD */
- 513, /* GL_FOG_COORDINATE_ARRAY_TYPE */
- 512, /* GL_FOG_COORDINATE_ARRAY_STRIDE */
- 511, /* GL_FOG_COORDINATE_ARRAY_POINTER */
- 508, /* GL_FOG_COORDINATE_ARRAY */
+ 514, /* GL_FOG_COORDINATE_ARRAY_TYPE */
+ 513, /* GL_FOG_COORDINATE_ARRAY_STRIDE */
+ 512, /* GL_FOG_COORDINATE_ARRAY_POINTER */
+ 509, /* GL_FOG_COORDINATE_ARRAY */
199, /* GL_COLOR_SUM */
332, /* GL_CURRENT_SECONDARY_COLOR */
- 1401, /* GL_SECONDARY_COLOR_ARRAY_SIZE */
- 1403, /* GL_SECONDARY_COLOR_ARRAY_TYPE */
- 1402, /* GL_SECONDARY_COLOR_ARRAY_STRIDE */
- 1400, /* GL_SECONDARY_COLOR_ARRAY_POINTER */
- 1397, /* GL_SECONDARY_COLOR_ARRAY */
+ 1402, /* GL_SECONDARY_COLOR_ARRAY_SIZE */
+ 1404, /* GL_SECONDARY_COLOR_ARRAY_TYPE */
+ 1403, /* GL_SECONDARY_COLOR_ARRAY_STRIDE */
+ 1401, /* GL_SECONDARY_COLOR_ARRAY_POINTER */
+ 1398, /* GL_SECONDARY_COLOR_ARRAY */
330, /* GL_CURRENT_RASTER_SECONDARY_COLOR */
28, /* GL_ALIASED_POINT_SIZE_RANGE */
27, /* GL_ALIASED_LINE_WIDTH_RANGE */
- 1541, /* GL_TEXTURE0 */
- 1543, /* GL_TEXTURE1 */
- 1565, /* GL_TEXTURE2 */
- 1587, /* GL_TEXTURE3 */
- 1593, /* GL_TEXTURE4 */
- 1595, /* GL_TEXTURE5 */
- 1597, /* GL_TEXTURE6 */
- 1599, /* GL_TEXTURE7 */
- 1601, /* GL_TEXTURE8 */
- 1603, /* GL_TEXTURE9 */
- 1544, /* GL_TEXTURE10 */
- 1546, /* GL_TEXTURE11 */
- 1548, /* GL_TEXTURE12 */
- 1550, /* GL_TEXTURE13 */
- 1552, /* GL_TEXTURE14 */
- 1554, /* GL_TEXTURE15 */
- 1556, /* GL_TEXTURE16 */
- 1558, /* GL_TEXTURE17 */
- 1560, /* GL_TEXTURE18 */
- 1562, /* GL_TEXTURE19 */
- 1566, /* GL_TEXTURE20 */
- 1568, /* GL_TEXTURE21 */
- 1570, /* GL_TEXTURE22 */
- 1572, /* GL_TEXTURE23 */
- 1574, /* GL_TEXTURE24 */
- 1576, /* GL_TEXTURE25 */
- 1578, /* GL_TEXTURE26 */
- 1580, /* GL_TEXTURE27 */
- 1582, /* GL_TEXTURE28 */
- 1584, /* GL_TEXTURE29 */
- 1588, /* GL_TEXTURE30 */
- 1590, /* GL_TEXTURE31 */
+ 1542, /* GL_TEXTURE0 */
+ 1544, /* GL_TEXTURE1 */
+ 1566, /* GL_TEXTURE2 */
+ 1588, /* GL_TEXTURE3 */
+ 1594, /* GL_TEXTURE4 */
+ 1596, /* GL_TEXTURE5 */
+ 1598, /* GL_TEXTURE6 */
+ 1600, /* GL_TEXTURE7 */
+ 1602, /* GL_TEXTURE8 */
+ 1604, /* GL_TEXTURE9 */
+ 1545, /* GL_TEXTURE10 */
+ 1547, /* GL_TEXTURE11 */
+ 1549, /* GL_TEXTURE12 */
+ 1551, /* GL_TEXTURE13 */
+ 1553, /* GL_TEXTURE14 */
+ 1555, /* GL_TEXTURE15 */
+ 1557, /* GL_TEXTURE16 */
+ 1559, /* GL_TEXTURE17 */
+ 1561, /* GL_TEXTURE18 */
+ 1563, /* GL_TEXTURE19 */
+ 1567, /* GL_TEXTURE20 */
+ 1569, /* GL_TEXTURE21 */
+ 1571, /* GL_TEXTURE22 */
+ 1573, /* GL_TEXTURE23 */
+ 1575, /* GL_TEXTURE24 */
+ 1577, /* GL_TEXTURE25 */
+ 1579, /* GL_TEXTURE26 */
+ 1581, /* GL_TEXTURE27 */
+ 1583, /* GL_TEXTURE28 */
+ 1585, /* GL_TEXTURE29 */
+ 1589, /* GL_TEXTURE30 */
+ 1591, /* GL_TEXTURE31 */
18, /* GL_ACTIVE_TEXTURE */
133, /* GL_CLIENT_ACTIVE_TEXTURE */
- 921, /* GL_MAX_TEXTURE_UNITS */
- 1736, /* GL_TRANSPOSE_MODELVIEW_MATRIX */
- 1739, /* GL_TRANSPOSE_PROJECTION_MATRIX */
- 1741, /* GL_TRANSPOSE_TEXTURE_MATRIX */
- 1733, /* GL_TRANSPOSE_COLOR_MATRIX */
- 1523, /* GL_SUBTRACT */
- 908, /* GL_MAX_RENDERBUFFER_SIZE_EXT */
+ 922, /* GL_MAX_TEXTURE_UNITS */
+ 1737, /* GL_TRANSPOSE_MODELVIEW_MATRIX */
+ 1740, /* GL_TRANSPOSE_PROJECTION_MATRIX */
+ 1742, /* GL_TRANSPOSE_TEXTURE_MATRIX */
+ 1734, /* GL_TRANSPOSE_COLOR_MATRIX */
+ 1524, /* GL_SUBTRACT */
+ 909, /* GL_MAX_RENDERBUFFER_SIZE_EXT */
247, /* GL_COMPRESSED_ALPHA */
251, /* GL_COMPRESSED_LUMINANCE */
252, /* GL_COMPRESSED_LUMINANCE_ALPHA */
249, /* GL_COMPRESSED_INTENSITY */
255, /* GL_COMPRESSED_RGB */
256, /* GL_COMPRESSED_RGBA */
- 1648, /* GL_TEXTURE_COMPRESSION_HINT */
- 1713, /* GL_TEXTURE_RECTANGLE_ARB */
- 1620, /* GL_TEXTURE_BINDING_RECTANGLE_ARB */
- 1267, /* GL_PROXY_TEXTURE_RECTANGLE_ARB */
- 906, /* GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB */
- 370, /* GL_DEPTH_STENCIL */
- 1762, /* GL_UNSIGNED_INT_24_8 */
- 917, /* GL_MAX_TEXTURE_LOD_BIAS */
- 1702, /* GL_TEXTURE_MAX_ANISOTROPY_EXT */
- 918, /* GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT */
- 1678, /* GL_TEXTURE_FILTER_CONTROL */
- 1693, /* GL_TEXTURE_LOD_BIAS */
+ 1649, /* GL_TEXTURE_COMPRESSION_HINT */
+ 1714, /* GL_TEXTURE_RECTANGLE_ARB */
+ 1621, /* GL_TEXTURE_BINDING_RECTANGLE_ARB */
+ 1268, /* GL_PROXY_TEXTURE_RECTANGLE_ARB */
+ 907, /* GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB */
+ 371, /* GL_DEPTH_STENCIL */
+ 1763, /* GL_UNSIGNED_INT_24_8 */
+ 918, /* GL_MAX_TEXTURE_LOD_BIAS */
+ 1703, /* GL_TEXTURE_MAX_ANISOTROPY_EXT */
+ 919, /* GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT */
+ 1679, /* GL_TEXTURE_FILTER_CONTROL */
+ 1694, /* GL_TEXTURE_LOD_BIAS */
232, /* GL_COMBINE4 */
- 911, /* GL_MAX_SHININESS_NV */
- 912, /* GL_MAX_SPOT_EXPONENT_NV */
- 619, /* GL_INCR_WRAP */
+ 912, /* GL_MAX_SHININESS_NV */
+ 913, /* GL_MAX_SPOT_EXPONENT_NV */
+ 620, /* GL_INCR_WRAP */
343, /* GL_DECR_WRAP */
- 963, /* GL_MODELVIEW1_ARB */
- 1019, /* GL_NORMAL_MAP */
- 1298, /* GL_REFLECTION_MAP */
- 1657, /* GL_TEXTURE_CUBE_MAP */
- 1618, /* GL_TEXTURE_BINDING_CUBE_MAP */
- 1665, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X */
- 1659, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X */
- 1667, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y */
- 1661, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y */
- 1669, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z */
- 1663, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z */
- 1265, /* GL_PROXY_TEXTURE_CUBE_MAP */
- 862, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE */
- 998, /* GL_MULTISAMPLE_FILTER_HINT_NV */
- 522, /* GL_FOG_DISTANCE_MODE_NV */
- 474, /* GL_EYE_RADIAL_NV */
- 473, /* GL_EYE_PLANE_ABSOLUTE_NV */
+ 964, /* GL_MODELVIEW1_ARB */
+ 1020, /* GL_NORMAL_MAP */
+ 1299, /* GL_REFLECTION_MAP */
+ 1658, /* GL_TEXTURE_CUBE_MAP */
+ 1619, /* GL_TEXTURE_BINDING_CUBE_MAP */
+ 1666, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X */
+ 1660, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X */
+ 1668, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y */
+ 1662, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y */
+ 1670, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z */
+ 1664, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z */
+ 1266, /* GL_PROXY_TEXTURE_CUBE_MAP */
+ 863, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE */
+ 999, /* GL_MULTISAMPLE_FILTER_HINT_NV */
+ 523, /* GL_FOG_DISTANCE_MODE_NV */
+ 475, /* GL_EYE_RADIAL_NV */
+ 474, /* GL_EYE_PLANE_ABSOLUTE_NV */
231, /* GL_COMBINE */
238, /* GL_COMBINE_RGB */
233, /* GL_COMBINE_ALPHA */
- 1365, /* GL_RGB_SCALE */
+ 1366, /* GL_RGB_SCALE */
24, /* GL_ADD_SIGNED */
- 647, /* GL_INTERPOLATE */
+ 648, /* GL_INTERPOLATE */
271, /* GL_CONSTANT */
- 1214, /* GL_PRIMARY_COLOR */
- 1211, /* GL_PREVIOUS */
- 1437, /* GL_SOURCE0_RGB */
- 1443, /* GL_SOURCE1_RGB */
- 1449, /* GL_SOURCE2_RGB */
- 1453, /* GL_SOURCE3_RGB_NV */
- 1434, /* GL_SOURCE0_ALPHA */
- 1440, /* GL_SOURCE1_ALPHA */
- 1446, /* GL_SOURCE2_ALPHA */
- 1452, /* GL_SOURCE3_ALPHA_NV */
- 1056, /* GL_OPERAND0_RGB */
- 1062, /* GL_OPERAND1_RGB */
- 1068, /* GL_OPERAND2_RGB */
- 1072, /* GL_OPERAND3_RGB_NV */
- 1053, /* GL_OPERAND0_ALPHA */
- 1059, /* GL_OPERAND1_ALPHA */
- 1065, /* GL_OPERAND2_ALPHA */
- 1071, /* GL_OPERAND3_ALPHA_NV */
- 1786, /* GL_VERTEX_ARRAY_BINDING */
- 1711, /* GL_TEXTURE_RANGE_LENGTH_APPLE */
- 1712, /* GL_TEXTURE_RANGE_POINTER_APPLE */
- 1852, /* GL_YCBCR_422_APPLE */
- 1775, /* GL_UNSIGNED_SHORT_8_8_APPLE */
- 1777, /* GL_UNSIGNED_SHORT_8_8_REV_APPLE */
- 1720, /* GL_TEXTURE_STORAGE_HINT_APPLE */
- 1514, /* GL_STORAGE_PRIVATE_APPLE */
- 1513, /* GL_STORAGE_CACHED_APPLE */
- 1515, /* GL_STORAGE_SHARED_APPLE */
- 1424, /* GL_SLICE_ACCUM_SUN */
- 1273, /* GL_QUAD_MESH_SUN */
- 1745, /* GL_TRIANGLE_MESH_SUN */
- 1825, /* GL_VERTEX_PROGRAM_ARB */
- 1836, /* GL_VERTEX_STATE_PROGRAM_NV */
- 1812, /* GL_VERTEX_ATTRIB_ARRAY_ENABLED */
- 1818, /* GL_VERTEX_ATTRIB_ARRAY_SIZE */
- 1820, /* GL_VERTEX_ATTRIB_ARRAY_STRIDE */
- 1822, /* GL_VERTEX_ATTRIB_ARRAY_TYPE */
+ 1215, /* GL_PRIMARY_COLOR */
+ 1212, /* GL_PREVIOUS */
+ 1438, /* GL_SOURCE0_RGB */
+ 1444, /* GL_SOURCE1_RGB */
+ 1450, /* GL_SOURCE2_RGB */
+ 1454, /* GL_SOURCE3_RGB_NV */
+ 1435, /* GL_SOURCE0_ALPHA */
+ 1441, /* GL_SOURCE1_ALPHA */
+ 1447, /* GL_SOURCE2_ALPHA */
+ 1453, /* GL_SOURCE3_ALPHA_NV */
+ 1057, /* GL_OPERAND0_RGB */
+ 1063, /* GL_OPERAND1_RGB */
+ 1069, /* GL_OPERAND2_RGB */
+ 1073, /* GL_OPERAND3_RGB_NV */
+ 1054, /* GL_OPERAND0_ALPHA */
+ 1060, /* GL_OPERAND1_ALPHA */
+ 1066, /* GL_OPERAND2_ALPHA */
+ 1072, /* GL_OPERAND3_ALPHA_NV */
+ 1787, /* GL_VERTEX_ARRAY_BINDING */
+ 1712, /* GL_TEXTURE_RANGE_LENGTH_APPLE */
+ 1713, /* GL_TEXTURE_RANGE_POINTER_APPLE */
+ 1853, /* GL_YCBCR_422_APPLE */
+ 1776, /* GL_UNSIGNED_SHORT_8_8_APPLE */
+ 1778, /* GL_UNSIGNED_SHORT_8_8_REV_APPLE */
+ 1721, /* GL_TEXTURE_STORAGE_HINT_APPLE */
+ 1515, /* GL_STORAGE_PRIVATE_APPLE */
+ 1514, /* GL_STORAGE_CACHED_APPLE */
+ 1516, /* GL_STORAGE_SHARED_APPLE */
+ 1425, /* GL_SLICE_ACCUM_SUN */
+ 1274, /* GL_QUAD_MESH_SUN */
+ 1746, /* GL_TRIANGLE_MESH_SUN */
+ 1826, /* GL_VERTEX_PROGRAM_ARB */
+ 1837, /* GL_VERTEX_STATE_PROGRAM_NV */
+ 1813, /* GL_VERTEX_ATTRIB_ARRAY_ENABLED */
+ 1819, /* GL_VERTEX_ATTRIB_ARRAY_SIZE */
+ 1821, /* GL_VERTEX_ATTRIB_ARRAY_STRIDE */
+ 1823, /* GL_VERTEX_ATTRIB_ARRAY_TYPE */
334, /* GL_CURRENT_VERTEX_ATTRIB */
- 1227, /* GL_PROGRAM_LENGTH_ARB */
- 1241, /* GL_PROGRAM_STRING_ARB */
- 985, /* GL_MODELVIEW_PROJECTION_NV */
- 614, /* GL_IDENTITY_NV */
- 661, /* GL_INVERSE_NV */
- 1738, /* GL_TRANSPOSE_NV */
- 662, /* GL_INVERSE_TRANSPOSE_NV */
- 892, /* GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB */
- 891, /* GL_MAX_PROGRAM_MATRICES_ARB */
- 799, /* GL_MATRIX0_NV */
- 811, /* GL_MATRIX1_NV */
- 823, /* GL_MATRIX2_NV */
- 827, /* GL_MATRIX3_NV */
- 829, /* GL_MATRIX4_NV */
- 831, /* GL_MATRIX5_NV */
- 833, /* GL_MATRIX6_NV */
- 835, /* GL_MATRIX7_NV */
+ 1228, /* GL_PROGRAM_LENGTH_ARB */
+ 1242, /* GL_PROGRAM_STRING_ARB */
+ 986, /* GL_MODELVIEW_PROJECTION_NV */
+ 615, /* GL_IDENTITY_NV */
+ 662, /* GL_INVERSE_NV */
+ 1739, /* GL_TRANSPOSE_NV */
+ 663, /* GL_INVERSE_TRANSPOSE_NV */
+ 893, /* GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB */
+ 892, /* GL_MAX_PROGRAM_MATRICES_ARB */
+ 800, /* GL_MATRIX0_NV */
+ 812, /* GL_MATRIX1_NV */
+ 824, /* GL_MATRIX2_NV */
+ 828, /* GL_MATRIX3_NV */
+ 830, /* GL_MATRIX4_NV */
+ 832, /* GL_MATRIX5_NV */
+ 834, /* GL_MATRIX6_NV */
+ 836, /* GL_MATRIX7_NV */
318, /* GL_CURRENT_MATRIX_STACK_DEPTH_ARB */
315, /* GL_CURRENT_MATRIX_ARB */
- 1828, /* GL_VERTEX_PROGRAM_POINT_SIZE */
- 1831, /* GL_VERTEX_PROGRAM_TWO_SIDE */
- 1239, /* GL_PROGRAM_PARAMETER_NV */
- 1816, /* GL_VERTEX_ATTRIB_ARRAY_POINTER */
- 1243, /* GL_PROGRAM_TARGET_NV */
- 1240, /* GL_PROGRAM_RESIDENT_NV */
- 1730, /* GL_TRACK_MATRIX_NV */
- 1731, /* GL_TRACK_MATRIX_TRANSFORM_NV */
- 1826, /* GL_VERTEX_PROGRAM_BINDING_NV */
- 1221, /* GL_PROGRAM_ERROR_POSITION_ARB */
- 355, /* GL_DEPTH_CLAMP_NV */
- 1794, /* GL_VERTEX_ATTRIB_ARRAY0_NV */
- 1801, /* GL_VERTEX_ATTRIB_ARRAY1_NV */
- 1802, /* GL_VERTEX_ATTRIB_ARRAY2_NV */
- 1803, /* GL_VERTEX_ATTRIB_ARRAY3_NV */
- 1804, /* GL_VERTEX_ATTRIB_ARRAY4_NV */
- 1805, /* GL_VERTEX_ATTRIB_ARRAY5_NV */
- 1806, /* GL_VERTEX_ATTRIB_ARRAY6_NV */
- 1807, /* GL_VERTEX_ATTRIB_ARRAY7_NV */
- 1808, /* GL_VERTEX_ATTRIB_ARRAY8_NV */
- 1809, /* GL_VERTEX_ATTRIB_ARRAY9_NV */
- 1795, /* GL_VERTEX_ATTRIB_ARRAY10_NV */
- 1796, /* GL_VERTEX_ATTRIB_ARRAY11_NV */
- 1797, /* GL_VERTEX_ATTRIB_ARRAY12_NV */
- 1798, /* GL_VERTEX_ATTRIB_ARRAY13_NV */
- 1799, /* GL_VERTEX_ATTRIB_ARRAY14_NV */
- 1800, /* GL_VERTEX_ATTRIB_ARRAY15_NV */
- 747, /* GL_MAP1_VERTEX_ATTRIB0_4_NV */
- 754, /* GL_MAP1_VERTEX_ATTRIB1_4_NV */
- 755, /* GL_MAP1_VERTEX_ATTRIB2_4_NV */
- 756, /* GL_MAP1_VERTEX_ATTRIB3_4_NV */
- 757, /* GL_MAP1_VERTEX_ATTRIB4_4_NV */
- 758, /* GL_MAP1_VERTEX_ATTRIB5_4_NV */
- 759, /* GL_MAP1_VERTEX_ATTRIB6_4_NV */
- 760, /* GL_MAP1_VERTEX_ATTRIB7_4_NV */
- 761, /* GL_MAP1_VERTEX_ATTRIB8_4_NV */
- 762, /* GL_MAP1_VERTEX_ATTRIB9_4_NV */
- 748, /* GL_MAP1_VERTEX_ATTRIB10_4_NV */
- 749, /* GL_MAP1_VERTEX_ATTRIB11_4_NV */
- 750, /* GL_MAP1_VERTEX_ATTRIB12_4_NV */
- 751, /* GL_MAP1_VERTEX_ATTRIB13_4_NV */
- 752, /* GL_MAP1_VERTEX_ATTRIB14_4_NV */
- 753, /* GL_MAP1_VERTEX_ATTRIB15_4_NV */
- 774, /* GL_MAP2_VERTEX_ATTRIB0_4_NV */
- 781, /* GL_MAP2_VERTEX_ATTRIB1_4_NV */
- 782, /* GL_MAP2_VERTEX_ATTRIB2_4_NV */
- 783, /* GL_MAP2_VERTEX_ATTRIB3_4_NV */
- 784, /* GL_MAP2_VERTEX_ATTRIB4_4_NV */
- 785, /* GL_MAP2_VERTEX_ATTRIB5_4_NV */
- 786, /* GL_MAP2_VERTEX_ATTRIB6_4_NV */
- 1220, /* GL_PROGRAM_BINDING_ARB */
- 788, /* GL_MAP2_VERTEX_ATTRIB8_4_NV */
- 789, /* GL_MAP2_VERTEX_ATTRIB9_4_NV */
- 775, /* GL_MAP2_VERTEX_ATTRIB10_4_NV */
- 776, /* GL_MAP2_VERTEX_ATTRIB11_4_NV */
- 777, /* GL_MAP2_VERTEX_ATTRIB12_4_NV */
- 778, /* GL_MAP2_VERTEX_ATTRIB13_4_NV */
- 779, /* GL_MAP2_VERTEX_ATTRIB14_4_NV */
- 780, /* GL_MAP2_VERTEX_ATTRIB15_4_NV */
- 1646, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE */
- 1643, /* GL_TEXTURE_COMPRESSED */
- 1024, /* GL_NUM_COMPRESSED_TEXTURE_FORMATS */
+ 1829, /* GL_VERTEX_PROGRAM_POINT_SIZE */
+ 1832, /* GL_VERTEX_PROGRAM_TWO_SIDE */
+ 1240, /* GL_PROGRAM_PARAMETER_NV */
+ 1817, /* GL_VERTEX_ATTRIB_ARRAY_POINTER */
+ 1244, /* GL_PROGRAM_TARGET_NV */
+ 1241, /* GL_PROGRAM_RESIDENT_NV */
+ 1731, /* GL_TRACK_MATRIX_NV */
+ 1732, /* GL_TRACK_MATRIX_TRANSFORM_NV */
+ 1827, /* GL_VERTEX_PROGRAM_BINDING_NV */
+ 1222, /* GL_PROGRAM_ERROR_POSITION_ARB */
+ 355, /* GL_DEPTH_CLAMP */
+ 1795, /* GL_VERTEX_ATTRIB_ARRAY0_NV */
+ 1802, /* GL_VERTEX_ATTRIB_ARRAY1_NV */
+ 1803, /* GL_VERTEX_ATTRIB_ARRAY2_NV */
+ 1804, /* GL_VERTEX_ATTRIB_ARRAY3_NV */
+ 1805, /* GL_VERTEX_ATTRIB_ARRAY4_NV */
+ 1806, /* GL_VERTEX_ATTRIB_ARRAY5_NV */
+ 1807, /* GL_VERTEX_ATTRIB_ARRAY6_NV */
+ 1808, /* GL_VERTEX_ATTRIB_ARRAY7_NV */
+ 1809, /* GL_VERTEX_ATTRIB_ARRAY8_NV */
+ 1810, /* GL_VERTEX_ATTRIB_ARRAY9_NV */
+ 1796, /* GL_VERTEX_ATTRIB_ARRAY10_NV */
+ 1797, /* GL_VERTEX_ATTRIB_ARRAY11_NV */
+ 1798, /* GL_VERTEX_ATTRIB_ARRAY12_NV */
+ 1799, /* GL_VERTEX_ATTRIB_ARRAY13_NV */
+ 1800, /* GL_VERTEX_ATTRIB_ARRAY14_NV */
+ 1801, /* GL_VERTEX_ATTRIB_ARRAY15_NV */
+ 748, /* GL_MAP1_VERTEX_ATTRIB0_4_NV */
+ 755, /* GL_MAP1_VERTEX_ATTRIB1_4_NV */
+ 756, /* GL_MAP1_VERTEX_ATTRIB2_4_NV */
+ 757, /* GL_MAP1_VERTEX_ATTRIB3_4_NV */
+ 758, /* GL_MAP1_VERTEX_ATTRIB4_4_NV */
+ 759, /* GL_MAP1_VERTEX_ATTRIB5_4_NV */
+ 760, /* GL_MAP1_VERTEX_ATTRIB6_4_NV */
+ 761, /* GL_MAP1_VERTEX_ATTRIB7_4_NV */
+ 762, /* GL_MAP1_VERTEX_ATTRIB8_4_NV */
+ 763, /* GL_MAP1_VERTEX_ATTRIB9_4_NV */
+ 749, /* GL_MAP1_VERTEX_ATTRIB10_4_NV */
+ 750, /* GL_MAP1_VERTEX_ATTRIB11_4_NV */
+ 751, /* GL_MAP1_VERTEX_ATTRIB12_4_NV */
+ 752, /* GL_MAP1_VERTEX_ATTRIB13_4_NV */
+ 753, /* GL_MAP1_VERTEX_ATTRIB14_4_NV */
+ 754, /* GL_MAP1_VERTEX_ATTRIB15_4_NV */
+ 775, /* GL_MAP2_VERTEX_ATTRIB0_4_NV */
+ 782, /* GL_MAP2_VERTEX_ATTRIB1_4_NV */
+ 783, /* GL_MAP2_VERTEX_ATTRIB2_4_NV */
+ 784, /* GL_MAP2_VERTEX_ATTRIB3_4_NV */
+ 785, /* GL_MAP2_VERTEX_ATTRIB4_4_NV */
+ 786, /* GL_MAP2_VERTEX_ATTRIB5_4_NV */
+ 787, /* GL_MAP2_VERTEX_ATTRIB6_4_NV */
+ 1221, /* GL_PROGRAM_BINDING_ARB */
+ 789, /* GL_MAP2_VERTEX_ATTRIB8_4_NV */
+ 790, /* GL_MAP2_VERTEX_ATTRIB9_4_NV */
+ 776, /* GL_MAP2_VERTEX_ATTRIB10_4_NV */
+ 777, /* GL_MAP2_VERTEX_ATTRIB11_4_NV */
+ 778, /* GL_MAP2_VERTEX_ATTRIB12_4_NV */
+ 779, /* GL_MAP2_VERTEX_ATTRIB13_4_NV */
+ 780, /* GL_MAP2_VERTEX_ATTRIB14_4_NV */
+ 781, /* GL_MAP2_VERTEX_ATTRIB15_4_NV */
+ 1647, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE */
+ 1644, /* GL_TEXTURE_COMPRESSED */
+ 1025, /* GL_NUM_COMPRESSED_TEXTURE_FORMATS */
269, /* GL_COMPRESSED_TEXTURE_FORMATS */
- 933, /* GL_MAX_VERTEX_UNITS_ARB */
+ 934, /* GL_MAX_VERTEX_UNITS_ARB */
22, /* GL_ACTIVE_VERTEX_UNITS_ARB */
- 1847, /* GL_WEIGHT_SUM_UNITY_ARB */
- 1824, /* GL_VERTEX_BLEND_ARB */
+ 1848, /* GL_WEIGHT_SUM_UNITY_ARB */
+ 1825, /* GL_VERTEX_BLEND_ARB */
336, /* GL_CURRENT_WEIGHT_ARB */
- 1846, /* GL_WEIGHT_ARRAY_TYPE_ARB */
- 1845, /* GL_WEIGHT_ARRAY_STRIDE_ARB */
- 1844, /* GL_WEIGHT_ARRAY_SIZE_ARB */
- 1843, /* GL_WEIGHT_ARRAY_POINTER_ARB */
- 1840, /* GL_WEIGHT_ARRAY_ARB */
- 383, /* GL_DOT3_RGB */
- 384, /* GL_DOT3_RGBA */
+ 1847, /* GL_WEIGHT_ARRAY_TYPE_ARB */
+ 1846, /* GL_WEIGHT_ARRAY_STRIDE_ARB */
+ 1845, /* GL_WEIGHT_ARRAY_SIZE_ARB */
+ 1844, /* GL_WEIGHT_ARRAY_POINTER_ARB */
+ 1841, /* GL_WEIGHT_ARRAY_ARB */
+ 384, /* GL_DOT3_RGB */
+ 385, /* GL_DOT3_RGBA */
263, /* GL_COMPRESSED_RGB_FXT1_3DFX */
258, /* GL_COMPRESSED_RGBA_FXT1_3DFX */
- 993, /* GL_MULTISAMPLE_3DFX */
- 1386, /* GL_SAMPLE_BUFFERS_3DFX */
- 1377, /* GL_SAMPLES_3DFX */
- 974, /* GL_MODELVIEW2_ARB */
- 977, /* GL_MODELVIEW3_ARB */
- 978, /* GL_MODELVIEW4_ARB */
- 979, /* GL_MODELVIEW5_ARB */
- 980, /* GL_MODELVIEW6_ARB */
- 981, /* GL_MODELVIEW7_ARB */
- 982, /* GL_MODELVIEW8_ARB */
- 983, /* GL_MODELVIEW9_ARB */
- 953, /* GL_MODELVIEW10_ARB */
- 954, /* GL_MODELVIEW11_ARB */
- 955, /* GL_MODELVIEW12_ARB */
- 956, /* GL_MODELVIEW13_ARB */
- 957, /* GL_MODELVIEW14_ARB */
- 958, /* GL_MODELVIEW15_ARB */
- 959, /* GL_MODELVIEW16_ARB */
- 960, /* GL_MODELVIEW17_ARB */
- 961, /* GL_MODELVIEW18_ARB */
- 962, /* GL_MODELVIEW19_ARB */
- 964, /* GL_MODELVIEW20_ARB */
- 965, /* GL_MODELVIEW21_ARB */
- 966, /* GL_MODELVIEW22_ARB */
- 967, /* GL_MODELVIEW23_ARB */
- 968, /* GL_MODELVIEW24_ARB */
- 969, /* GL_MODELVIEW25_ARB */
- 970, /* GL_MODELVIEW26_ARB */
- 971, /* GL_MODELVIEW27_ARB */
- 972, /* GL_MODELVIEW28_ARB */
- 973, /* GL_MODELVIEW29_ARB */
- 975, /* GL_MODELVIEW30_ARB */
- 976, /* GL_MODELVIEW31_ARB */
- 388, /* GL_DOT3_RGB_EXT */
- 386, /* GL_DOT3_RGBA_EXT */
- 947, /* GL_MIRROR_CLAMP_EXT */
- 950, /* GL_MIRROR_CLAMP_TO_EDGE_EXT */
- 988, /* GL_MODULATE_ADD_ATI */
- 989, /* GL_MODULATE_SIGNED_ADD_ATI */
- 990, /* GL_MODULATE_SUBTRACT_ATI */
- 1853, /* GL_YCBCR_MESA */
- 1080, /* GL_PACK_INVERT_MESA */
+ 994, /* GL_MULTISAMPLE_3DFX */
+ 1387, /* GL_SAMPLE_BUFFERS_3DFX */
+ 1378, /* GL_SAMPLES_3DFX */
+ 975, /* GL_MODELVIEW2_ARB */
+ 978, /* GL_MODELVIEW3_ARB */
+ 979, /* GL_MODELVIEW4_ARB */
+ 980, /* GL_MODELVIEW5_ARB */
+ 981, /* GL_MODELVIEW6_ARB */
+ 982, /* GL_MODELVIEW7_ARB */
+ 983, /* GL_MODELVIEW8_ARB */
+ 984, /* GL_MODELVIEW9_ARB */
+ 954, /* GL_MODELVIEW10_ARB */
+ 955, /* GL_MODELVIEW11_ARB */
+ 956, /* GL_MODELVIEW12_ARB */
+ 957, /* GL_MODELVIEW13_ARB */
+ 958, /* GL_MODELVIEW14_ARB */
+ 959, /* GL_MODELVIEW15_ARB */
+ 960, /* GL_MODELVIEW16_ARB */
+ 961, /* GL_MODELVIEW17_ARB */
+ 962, /* GL_MODELVIEW18_ARB */
+ 963, /* GL_MODELVIEW19_ARB */
+ 965, /* GL_MODELVIEW20_ARB */
+ 966, /* GL_MODELVIEW21_ARB */
+ 967, /* GL_MODELVIEW22_ARB */
+ 968, /* GL_MODELVIEW23_ARB */
+ 969, /* GL_MODELVIEW24_ARB */
+ 970, /* GL_MODELVIEW25_ARB */
+ 971, /* GL_MODELVIEW26_ARB */
+ 972, /* GL_MODELVIEW27_ARB */
+ 973, /* GL_MODELVIEW28_ARB */
+ 974, /* GL_MODELVIEW29_ARB */
+ 976, /* GL_MODELVIEW30_ARB */
+ 977, /* GL_MODELVIEW31_ARB */
+ 389, /* GL_DOT3_RGB_EXT */
+ 387, /* GL_DOT3_RGBA_EXT */
+ 948, /* GL_MIRROR_CLAMP_EXT */
+ 951, /* GL_MIRROR_CLAMP_TO_EDGE_EXT */
+ 989, /* GL_MODULATE_ADD_ATI */
+ 990, /* GL_MODULATE_SIGNED_ADD_ATI */
+ 991, /* GL_MODULATE_SUBTRACT_ATI */
+ 1854, /* GL_YCBCR_MESA */
+ 1081, /* GL_PACK_INVERT_MESA */
339, /* GL_DEBUG_OBJECT_MESA */
340, /* GL_DEBUG_PRINT_MESA */
338, /* GL_DEBUG_ASSERT_MESA */
117, /* GL_BUMP_ROT_MATRIX_SIZE_ATI */
115, /* GL_BUMP_NUM_TEX_UNITS_ATI */
119, /* GL_BUMP_TEX_UNITS_ATI */
- 447, /* GL_DUDV_ATI */
- 446, /* GL_DU8DV8_ATI */
+ 448, /* GL_DUDV_ATI */
+ 447, /* GL_DU8DV8_ATI */
114, /* GL_BUMP_ENVMAP_ATI */
118, /* GL_BUMP_TARGET_ATI */
- 1485, /* GL_STENCIL_BACK_FUNC */
- 1483, /* GL_STENCIL_BACK_FAIL */
- 1487, /* GL_STENCIL_BACK_PASS_DEPTH_FAIL */
- 1489, /* GL_STENCIL_BACK_PASS_DEPTH_PASS */
- 531, /* GL_FRAGMENT_PROGRAM_ARB */
- 1218, /* GL_PROGRAM_ALU_INSTRUCTIONS_ARB */
- 1246, /* GL_PROGRAM_TEX_INSTRUCTIONS_ARB */
- 1245, /* GL_PROGRAM_TEX_INDIRECTIONS_ARB */
- 1230, /* GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */
- 1236, /* GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */
- 1235, /* GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */
- 881, /* GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB */
- 904, /* GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB */
- 903, /* GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB */
- 894, /* GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */
- 900, /* GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */
- 899, /* GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */
- 864, /* GL_MAX_DRAW_BUFFERS */
- 392, /* GL_DRAW_BUFFER0 */
- 395, /* GL_DRAW_BUFFER1 */
- 416, /* GL_DRAW_BUFFER2 */
- 419, /* GL_DRAW_BUFFER3 */
- 422, /* GL_DRAW_BUFFER4 */
- 425, /* GL_DRAW_BUFFER5 */
- 428, /* GL_DRAW_BUFFER6 */
- 431, /* GL_DRAW_BUFFER7 */
- 434, /* GL_DRAW_BUFFER8 */
- 437, /* GL_DRAW_BUFFER9 */
- 396, /* GL_DRAW_BUFFER10 */
- 399, /* GL_DRAW_BUFFER11 */
- 402, /* GL_DRAW_BUFFER12 */
- 405, /* GL_DRAW_BUFFER13 */
- 408, /* GL_DRAW_BUFFER14 */
- 411, /* GL_DRAW_BUFFER15 */
+ 1486, /* GL_STENCIL_BACK_FUNC */
+ 1484, /* GL_STENCIL_BACK_FAIL */
+ 1488, /* GL_STENCIL_BACK_PASS_DEPTH_FAIL */
+ 1490, /* GL_STENCIL_BACK_PASS_DEPTH_PASS */
+ 532, /* GL_FRAGMENT_PROGRAM_ARB */
+ 1219, /* GL_PROGRAM_ALU_INSTRUCTIONS_ARB */
+ 1247, /* GL_PROGRAM_TEX_INSTRUCTIONS_ARB */
+ 1246, /* GL_PROGRAM_TEX_INDIRECTIONS_ARB */
+ 1231, /* GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */
+ 1237, /* GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */
+ 1236, /* GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */
+ 882, /* GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB */
+ 905, /* GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB */
+ 904, /* GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB */
+ 895, /* GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */
+ 901, /* GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */
+ 900, /* GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */
+ 865, /* GL_MAX_DRAW_BUFFERS */
+ 393, /* GL_DRAW_BUFFER0 */
+ 396, /* GL_DRAW_BUFFER1 */
+ 417, /* GL_DRAW_BUFFER2 */
+ 420, /* GL_DRAW_BUFFER3 */
+ 423, /* GL_DRAW_BUFFER4 */
+ 426, /* GL_DRAW_BUFFER5 */
+ 429, /* GL_DRAW_BUFFER6 */
+ 432, /* GL_DRAW_BUFFER7 */
+ 435, /* GL_DRAW_BUFFER8 */
+ 438, /* GL_DRAW_BUFFER9 */
+ 397, /* GL_DRAW_BUFFER10 */
+ 400, /* GL_DRAW_BUFFER11 */
+ 403, /* GL_DRAW_BUFFER12 */
+ 406, /* GL_DRAW_BUFFER13 */
+ 409, /* GL_DRAW_BUFFER14 */
+ 412, /* GL_DRAW_BUFFER15 */
82, /* GL_BLEND_EQUATION_ALPHA */
- 844, /* GL_MATRIX_PALETTE_ARB */
- 875, /* GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB */
- 878, /* GL_MAX_PALETTE_MATRICES_ARB */
+ 845, /* GL_MATRIX_PALETTE_ARB */
+ 876, /* GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB */
+ 879, /* GL_MAX_PALETTE_MATRICES_ARB */
321, /* GL_CURRENT_PALETTE_MATRIX_ARB */
- 838, /* GL_MATRIX_INDEX_ARRAY_ARB */
+ 839, /* GL_MATRIX_INDEX_ARRAY_ARB */
316, /* GL_CURRENT_MATRIX_INDEX_ARB */
- 840, /* GL_MATRIX_INDEX_ARRAY_SIZE_ARB */
- 842, /* GL_MATRIX_INDEX_ARRAY_TYPE_ARB */
- 841, /* GL_MATRIX_INDEX_ARRAY_STRIDE_ARB */
- 839, /* GL_MATRIX_INDEX_ARRAY_POINTER_ARB */
- 1673, /* GL_TEXTURE_DEPTH_SIZE */
- 376, /* GL_DEPTH_TEXTURE_MODE */
- 1638, /* GL_TEXTURE_COMPARE_MODE */
- 1636, /* GL_TEXTURE_COMPARE_FUNC */
+ 841, /* GL_MATRIX_INDEX_ARRAY_SIZE_ARB */
+ 843, /* GL_MATRIX_INDEX_ARRAY_TYPE_ARB */
+ 842, /* GL_MATRIX_INDEX_ARRAY_STRIDE_ARB */
+ 840, /* GL_MATRIX_INDEX_ARRAY_POINTER_ARB */
+ 1674, /* GL_TEXTURE_DEPTH_SIZE */
+ 377, /* GL_DEPTH_TEXTURE_MODE */
+ 1639, /* GL_TEXTURE_COMPARE_MODE */
+ 1637, /* GL_TEXTURE_COMPARE_FUNC */
242, /* GL_COMPARE_R_TO_TEXTURE */
- 1152, /* GL_POINT_SPRITE */
+ 1153, /* GL_POINT_SPRITE */
296, /* GL_COORD_REPLACE */
- 1156, /* GL_POINT_SPRITE_R_MODE_NV */
- 1275, /* GL_QUERY_COUNTER_BITS */
+ 1157, /* GL_POINT_SPRITE_R_MODE_NV */
+ 1276, /* GL_QUERY_COUNTER_BITS */
323, /* GL_CURRENT_QUERY */
- 1277, /* GL_QUERY_RESULT */
- 1279, /* GL_QUERY_RESULT_AVAILABLE */
- 927, /* GL_MAX_VERTEX_ATTRIBS */
- 1814, /* GL_VERTEX_ATTRIB_ARRAY_NORMALIZED */
- 374, /* GL_DEPTH_STENCIL_TO_RGBA_NV */
- 373, /* GL_DEPTH_STENCIL_TO_BGRA_NV */
- 913, /* GL_MAX_TEXTURE_COORDS */
- 915, /* GL_MAX_TEXTURE_IMAGE_UNITS */
- 1223, /* GL_PROGRAM_ERROR_STRING_ARB */
- 1225, /* GL_PROGRAM_FORMAT_ASCII_ARB */
- 1224, /* GL_PROGRAM_FORMAT_ARB */
- 1722, /* GL_TEXTURE_UNSIGNED_REMAP_MODE_NV */
+ 1278, /* GL_QUERY_RESULT */
+ 1280, /* GL_QUERY_RESULT_AVAILABLE */
+ 928, /* GL_MAX_VERTEX_ATTRIBS */
+ 1815, /* GL_VERTEX_ATTRIB_ARRAY_NORMALIZED */
+ 375, /* GL_DEPTH_STENCIL_TO_RGBA_NV */
+ 374, /* GL_DEPTH_STENCIL_TO_BGRA_NV */
+ 914, /* GL_MAX_TEXTURE_COORDS */
+ 916, /* GL_MAX_TEXTURE_IMAGE_UNITS */
+ 1224, /* GL_PROGRAM_ERROR_STRING_ARB */
+ 1226, /* GL_PROGRAM_FORMAT_ASCII_ARB */
+ 1225, /* GL_PROGRAM_FORMAT_ARB */
+ 1723, /* GL_TEXTURE_UNSIGNED_REMAP_MODE_NV */
353, /* GL_DEPTH_BOUNDS_TEST_EXT */
352, /* GL_DEPTH_BOUNDS_EXT */
53, /* GL_ARRAY_BUFFER */
- 460, /* GL_ELEMENT_ARRAY_BUFFER */
+ 461, /* GL_ELEMENT_ARRAY_BUFFER */
54, /* GL_ARRAY_BUFFER_BINDING */
- 461, /* GL_ELEMENT_ARRAY_BUFFER_BINDING */
- 1788, /* GL_VERTEX_ARRAY_BUFFER_BINDING */
- 1014, /* GL_NORMAL_ARRAY_BUFFER_BINDING */
+ 462, /* GL_ELEMENT_ARRAY_BUFFER_BINDING */
+ 1789, /* GL_VERTEX_ARRAY_BUFFER_BINDING */
+ 1015, /* GL_NORMAL_ARRAY_BUFFER_BINDING */
149, /* GL_COLOR_ARRAY_BUFFER_BINDING */
- 623, /* GL_INDEX_ARRAY_BUFFER_BINDING */
- 1651, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING */
- 456, /* GL_EDGE_FLAG_ARRAY_BUFFER_BINDING */
- 1398, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING */
- 509, /* GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING */
- 1841, /* GL_WEIGHT_ARRAY_BUFFER_BINDING */
- 1810, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING */
- 1226, /* GL_PROGRAM_INSTRUCTIONS_ARB */
- 887, /* GL_MAX_PROGRAM_INSTRUCTIONS_ARB */
- 1232, /* GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB */
- 896, /* GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB */
- 1244, /* GL_PROGRAM_TEMPORARIES_ARB */
- 902, /* GL_MAX_PROGRAM_TEMPORARIES_ARB */
- 1234, /* GL_PROGRAM_NATIVE_TEMPORARIES_ARB */
- 898, /* GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB */
- 1238, /* GL_PROGRAM_PARAMETERS_ARB */
- 901, /* GL_MAX_PROGRAM_PARAMETERS_ARB */
- 1233, /* GL_PROGRAM_NATIVE_PARAMETERS_ARB */
- 897, /* GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB */
- 1219, /* GL_PROGRAM_ATTRIBS_ARB */
- 882, /* GL_MAX_PROGRAM_ATTRIBS_ARB */
- 1231, /* GL_PROGRAM_NATIVE_ATTRIBS_ARB */
- 895, /* GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB */
- 1217, /* GL_PROGRAM_ADDRESS_REGISTERS_ARB */
- 880, /* GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB */
- 1229, /* GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */
- 893, /* GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */
- 888, /* GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB */
- 884, /* GL_MAX_PROGRAM_ENV_PARAMETERS_ARB */
- 1247, /* GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB */
- 1735, /* GL_TRANSPOSE_CURRENT_MATRIX_ARB */
- 1288, /* GL_READ_ONLY */
- 1849, /* GL_WRITE_ONLY */
- 1290, /* GL_READ_WRITE */
+ 624, /* GL_INDEX_ARRAY_BUFFER_BINDING */
+ 1652, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING */
+ 457, /* GL_EDGE_FLAG_ARRAY_BUFFER_BINDING */
+ 1399, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING */
+ 510, /* GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING */
+ 1842, /* GL_WEIGHT_ARRAY_BUFFER_BINDING */
+ 1811, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING */
+ 1227, /* GL_PROGRAM_INSTRUCTIONS_ARB */
+ 888, /* GL_MAX_PROGRAM_INSTRUCTIONS_ARB */
+ 1233, /* GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB */
+ 897, /* GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB */
+ 1245, /* GL_PROGRAM_TEMPORARIES_ARB */
+ 903, /* GL_MAX_PROGRAM_TEMPORARIES_ARB */
+ 1235, /* GL_PROGRAM_NATIVE_TEMPORARIES_ARB */
+ 899, /* GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB */
+ 1239, /* GL_PROGRAM_PARAMETERS_ARB */
+ 902, /* GL_MAX_PROGRAM_PARAMETERS_ARB */
+ 1234, /* GL_PROGRAM_NATIVE_PARAMETERS_ARB */
+ 898, /* GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB */
+ 1220, /* GL_PROGRAM_ATTRIBS_ARB */
+ 883, /* GL_MAX_PROGRAM_ATTRIBS_ARB */
+ 1232, /* GL_PROGRAM_NATIVE_ATTRIBS_ARB */
+ 896, /* GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB */
+ 1218, /* GL_PROGRAM_ADDRESS_REGISTERS_ARB */
+ 881, /* GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB */
+ 1230, /* GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */
+ 894, /* GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */
+ 889, /* GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB */
+ 885, /* GL_MAX_PROGRAM_ENV_PARAMETERS_ARB */
+ 1248, /* GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB */
+ 1736, /* GL_TRANSPOSE_CURRENT_MATRIX_ARB */
+ 1289, /* GL_READ_ONLY */
+ 1850, /* GL_WRITE_ONLY */
+ 1291, /* GL_READ_WRITE */
102, /* GL_BUFFER_ACCESS */
105, /* GL_BUFFER_MAPPED */
107, /* GL_BUFFER_MAP_POINTER */
- 1729, /* GL_TIME_ELAPSED_EXT */
- 798, /* GL_MATRIX0_ARB */
- 810, /* GL_MATRIX1_ARB */
- 822, /* GL_MATRIX2_ARB */
- 826, /* GL_MATRIX3_ARB */
- 828, /* GL_MATRIX4_ARB */
- 830, /* GL_MATRIX5_ARB */
- 832, /* GL_MATRIX6_ARB */
- 834, /* GL_MATRIX7_ARB */
- 836, /* GL_MATRIX8_ARB */
- 837, /* GL_MATRIX9_ARB */
- 800, /* GL_MATRIX10_ARB */
- 801, /* GL_MATRIX11_ARB */
- 802, /* GL_MATRIX12_ARB */
- 803, /* GL_MATRIX13_ARB */
- 804, /* GL_MATRIX14_ARB */
- 805, /* GL_MATRIX15_ARB */
- 806, /* GL_MATRIX16_ARB */
- 807, /* GL_MATRIX17_ARB */
- 808, /* GL_MATRIX18_ARB */
- 809, /* GL_MATRIX19_ARB */
- 812, /* GL_MATRIX20_ARB */
- 813, /* GL_MATRIX21_ARB */
- 814, /* GL_MATRIX22_ARB */
- 815, /* GL_MATRIX23_ARB */
- 816, /* GL_MATRIX24_ARB */
- 817, /* GL_MATRIX25_ARB */
- 818, /* GL_MATRIX26_ARB */
- 819, /* GL_MATRIX27_ARB */
- 820, /* GL_MATRIX28_ARB */
- 821, /* GL_MATRIX29_ARB */
- 824, /* GL_MATRIX30_ARB */
- 825, /* GL_MATRIX31_ARB */
- 1518, /* GL_STREAM_DRAW */
- 1520, /* GL_STREAM_READ */
- 1516, /* GL_STREAM_COPY */
- 1476, /* GL_STATIC_DRAW */
- 1478, /* GL_STATIC_READ */
- 1474, /* GL_STATIC_COPY */
- 450, /* GL_DYNAMIC_DRAW */
- 452, /* GL_DYNAMIC_READ */
- 448, /* GL_DYNAMIC_COPY */
- 1120, /* GL_PIXEL_PACK_BUFFER */
- 1124, /* GL_PIXEL_UNPACK_BUFFER */
- 1121, /* GL_PIXEL_PACK_BUFFER_BINDING */
- 1125, /* GL_PIXEL_UNPACK_BUFFER_BINDING */
+ 1730, /* GL_TIME_ELAPSED_EXT */
+ 799, /* GL_MATRIX0_ARB */
+ 811, /* GL_MATRIX1_ARB */
+ 823, /* GL_MATRIX2_ARB */
+ 827, /* GL_MATRIX3_ARB */
+ 829, /* GL_MATRIX4_ARB */
+ 831, /* GL_MATRIX5_ARB */
+ 833, /* GL_MATRIX6_ARB */
+ 835, /* GL_MATRIX7_ARB */
+ 837, /* GL_MATRIX8_ARB */
+ 838, /* GL_MATRIX9_ARB */
+ 801, /* GL_MATRIX10_ARB */
+ 802, /* GL_MATRIX11_ARB */
+ 803, /* GL_MATRIX12_ARB */
+ 804, /* GL_MATRIX13_ARB */
+ 805, /* GL_MATRIX14_ARB */
+ 806, /* GL_MATRIX15_ARB */
+ 807, /* GL_MATRIX16_ARB */
+ 808, /* GL_MATRIX17_ARB */
+ 809, /* GL_MATRIX18_ARB */
+ 810, /* GL_MATRIX19_ARB */
+ 813, /* GL_MATRIX20_ARB */
+ 814, /* GL_MATRIX21_ARB */
+ 815, /* GL_MATRIX22_ARB */
+ 816, /* GL_MATRIX23_ARB */
+ 817, /* GL_MATRIX24_ARB */
+ 818, /* GL_MATRIX25_ARB */
+ 819, /* GL_MATRIX26_ARB */
+ 820, /* GL_MATRIX27_ARB */
+ 821, /* GL_MATRIX28_ARB */
+ 822, /* GL_MATRIX29_ARB */
+ 825, /* GL_MATRIX30_ARB */
+ 826, /* GL_MATRIX31_ARB */
+ 1519, /* GL_STREAM_DRAW */
+ 1521, /* GL_STREAM_READ */
+ 1517, /* GL_STREAM_COPY */
+ 1477, /* GL_STATIC_DRAW */
+ 1479, /* GL_STATIC_READ */
+ 1475, /* GL_STATIC_COPY */
+ 451, /* GL_DYNAMIC_DRAW */
+ 453, /* GL_DYNAMIC_READ */
+ 449, /* GL_DYNAMIC_COPY */
+ 1121, /* GL_PIXEL_PACK_BUFFER */
+ 1125, /* GL_PIXEL_UNPACK_BUFFER */
+ 1122, /* GL_PIXEL_PACK_BUFFER_BINDING */
+ 1126, /* GL_PIXEL_UNPACK_BUFFER_BINDING */
347, /* GL_DEPTH24_STENCIL8 */
- 1719, /* GL_TEXTURE_STENCIL_SIZE */
- 1671, /* GL_TEXTURE_CUBE_MAP_SEAMLESS */
- 883, /* GL_MAX_PROGRAM_CALL_DEPTH_NV */
- 886, /* GL_MAX_PROGRAM_IF_DEPTH_NV */
- 890, /* GL_MAX_PROGRAM_LOOP_DEPTH_NV */
- 889, /* GL_MAX_PROGRAM_LOOP_COUNT_NV */
- 847, /* GL_MAX_ARRAY_TEXTURE_LAYERS_EXT */
- 1509, /* GL_STENCIL_TEST_TWO_SIDE_EXT */
+ 1720, /* GL_TEXTURE_STENCIL_SIZE */
+ 1672, /* GL_TEXTURE_CUBE_MAP_SEAMLESS */
+ 884, /* GL_MAX_PROGRAM_CALL_DEPTH_NV */
+ 887, /* GL_MAX_PROGRAM_IF_DEPTH_NV */
+ 891, /* GL_MAX_PROGRAM_LOOP_DEPTH_NV */
+ 890, /* GL_MAX_PROGRAM_LOOP_COUNT_NV */
+ 848, /* GL_MAX_ARRAY_TEXTURE_LAYERS_EXT */
+ 1510, /* GL_STENCIL_TEST_TWO_SIDE_EXT */
17, /* GL_ACTIVE_STENCIL_FACE_EXT */
- 948, /* GL_MIRROR_CLAMP_TO_BORDER_EXT */
- 1379, /* GL_SAMPLES_PASSED */
+ 949, /* GL_MIRROR_CLAMP_TO_BORDER_EXT */
+ 1380, /* GL_SAMPLES_PASSED */
109, /* GL_BUFFER_SERIALIZED_MODIFY_APPLE */
104, /* GL_BUFFER_FLUSHING_UNMAP_APPLE */
- 532, /* GL_FRAGMENT_SHADER */
- 1834, /* GL_VERTEX_SHADER */
- 1237, /* GL_PROGRAM_OBJECT_ARB */
- 1411, /* GL_SHADER_OBJECT_ARB */
- 871, /* GL_MAX_FRAGMENT_UNIFORM_COMPONENTS */
- 931, /* GL_MAX_VERTEX_UNIFORM_COMPONENTS */
- 925, /* GL_MAX_VARYING_FLOATS */
- 929, /* GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS */
- 856, /* GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS */
- 1040, /* GL_OBJECT_TYPE_ARB */
- 1413, /* GL_SHADER_TYPE */
- 497, /* GL_FLOAT_VEC2 */
- 499, /* GL_FLOAT_VEC3 */
- 501, /* GL_FLOAT_VEC4 */
- 650, /* GL_INT_VEC2 */
- 652, /* GL_INT_VEC3 */
- 654, /* GL_INT_VEC4 */
+ 533, /* GL_FRAGMENT_SHADER */
+ 1835, /* GL_VERTEX_SHADER */
+ 1238, /* GL_PROGRAM_OBJECT_ARB */
+ 1412, /* GL_SHADER_OBJECT_ARB */
+ 872, /* GL_MAX_FRAGMENT_UNIFORM_COMPONENTS */
+ 932, /* GL_MAX_VERTEX_UNIFORM_COMPONENTS */
+ 926, /* GL_MAX_VARYING_FLOATS */
+ 930, /* GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS */
+ 857, /* GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS */
+ 1041, /* GL_OBJECT_TYPE_ARB */
+ 1414, /* GL_SHADER_TYPE */
+ 498, /* GL_FLOAT_VEC2 */
+ 500, /* GL_FLOAT_VEC3 */
+ 502, /* GL_FLOAT_VEC4 */
+ 651, /* GL_INT_VEC2 */
+ 653, /* GL_INT_VEC3 */
+ 655, /* GL_INT_VEC4 */
94, /* GL_BOOL */
96, /* GL_BOOL_VEC2 */
98, /* GL_BOOL_VEC3 */
100, /* GL_BOOL_VEC4 */
- 485, /* GL_FLOAT_MAT2 */
- 489, /* GL_FLOAT_MAT3 */
- 493, /* GL_FLOAT_MAT4 */
- 1370, /* GL_SAMPLER_1D */
- 1372, /* GL_SAMPLER_2D */
- 1374, /* GL_SAMPLER_3D */
- 1375, /* GL_SAMPLER_CUBE */
- 1371, /* GL_SAMPLER_1D_SHADOW */
- 1373, /* GL_SAMPLER_2D_SHADOW */
- 487, /* GL_FLOAT_MAT2x3 */
- 488, /* GL_FLOAT_MAT2x4 */
- 491, /* GL_FLOAT_MAT3x2 */
- 492, /* GL_FLOAT_MAT3x4 */
- 495, /* GL_FLOAT_MAT4x2 */
- 496, /* GL_FLOAT_MAT4x3 */
+ 486, /* GL_FLOAT_MAT2 */
+ 490, /* GL_FLOAT_MAT3 */
+ 494, /* GL_FLOAT_MAT4 */
+ 1371, /* GL_SAMPLER_1D */
+ 1373, /* GL_SAMPLER_2D */
+ 1375, /* GL_SAMPLER_3D */
+ 1376, /* GL_SAMPLER_CUBE */
+ 1372, /* GL_SAMPLER_1D_SHADOW */
+ 1374, /* GL_SAMPLER_2D_SHADOW */
+ 488, /* GL_FLOAT_MAT2x3 */
+ 489, /* GL_FLOAT_MAT2x4 */
+ 492, /* GL_FLOAT_MAT3x2 */
+ 493, /* GL_FLOAT_MAT3x4 */
+ 496, /* GL_FLOAT_MAT4x2 */
+ 497, /* GL_FLOAT_MAT4x3 */
345, /* GL_DELETE_STATUS */
246, /* GL_COMPILE_STATUS */
- 705, /* GL_LINK_STATUS */
- 1782, /* GL_VALIDATE_STATUS */
- 635, /* GL_INFO_LOG_LENGTH */
+ 706, /* GL_LINK_STATUS */
+ 1783, /* GL_VALIDATE_STATUS */
+ 636, /* GL_INFO_LOG_LENGTH */
56, /* GL_ATTACHED_SHADERS */
20, /* GL_ACTIVE_UNIFORMS */
21, /* GL_ACTIVE_UNIFORM_MAX_LENGTH */
- 1412, /* GL_SHADER_SOURCE_LENGTH */
+ 1413, /* GL_SHADER_SOURCE_LENGTH */
15, /* GL_ACTIVE_ATTRIBUTES */
16, /* GL_ACTIVE_ATTRIBUTE_MAX_LENGTH */
- 534, /* GL_FRAGMENT_SHADER_DERIVATIVE_HINT */
- 1415, /* GL_SHADING_LANGUAGE_VERSION */
+ 535, /* GL_FRAGMENT_SHADER_DERIVATIVE_HINT */
+ 1416, /* GL_SHADING_LANGUAGE_VERSION */
322, /* GL_CURRENT_PROGRAM */
- 1089, /* GL_PALETTE4_RGB8_OES */
- 1091, /* GL_PALETTE4_RGBA8_OES */
- 1087, /* GL_PALETTE4_R5_G6_B5_OES */
- 1090, /* GL_PALETTE4_RGBA4_OES */
- 1088, /* GL_PALETTE4_RGB5_A1_OES */
- 1094, /* GL_PALETTE8_RGB8_OES */
- 1096, /* GL_PALETTE8_RGBA8_OES */
- 1092, /* GL_PALETTE8_R5_G6_B5_OES */
- 1095, /* GL_PALETTE8_RGBA4_OES */
- 1093, /* GL_PALETTE8_RGB5_A1_OES */
- 617, /* GL_IMPLEMENTATION_COLOR_READ_TYPE_OES */
- 616, /* GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES */
- 1767, /* GL_UNSIGNED_NORMALIZED */
- 1606, /* GL_TEXTURE_1D_ARRAY_EXT */
- 1258, /* GL_PROXY_TEXTURE_1D_ARRAY_EXT */
- 1608, /* GL_TEXTURE_2D_ARRAY_EXT */
- 1261, /* GL_PROXY_TEXTURE_2D_ARRAY_EXT */
- 1614, /* GL_TEXTURE_BINDING_1D_ARRAY_EXT */
- 1616, /* GL_TEXTURE_BINDING_2D_ARRAY_EXT */
- 1468, /* GL_SRGB */
- 1469, /* GL_SRGB8 */
- 1471, /* GL_SRGB_ALPHA */
- 1470, /* GL_SRGB8_ALPHA8 */
- 1428, /* GL_SLUMINANCE_ALPHA */
- 1427, /* GL_SLUMINANCE8_ALPHA8 */
- 1425, /* GL_SLUMINANCE */
- 1426, /* GL_SLUMINANCE8 */
+ 1090, /* GL_PALETTE4_RGB8_OES */
+ 1092, /* GL_PALETTE4_RGBA8_OES */
+ 1088, /* GL_PALETTE4_R5_G6_B5_OES */
+ 1091, /* GL_PALETTE4_RGBA4_OES */
+ 1089, /* GL_PALETTE4_RGB5_A1_OES */
+ 1095, /* GL_PALETTE8_RGB8_OES */
+ 1097, /* GL_PALETTE8_RGBA8_OES */
+ 1093, /* GL_PALETTE8_R5_G6_B5_OES */
+ 1096, /* GL_PALETTE8_RGBA4_OES */
+ 1094, /* GL_PALETTE8_RGB5_A1_OES */
+ 618, /* GL_IMPLEMENTATION_COLOR_READ_TYPE_OES */
+ 617, /* GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES */
+ 1768, /* GL_UNSIGNED_NORMALIZED */
+ 1607, /* GL_TEXTURE_1D_ARRAY_EXT */
+ 1259, /* GL_PROXY_TEXTURE_1D_ARRAY_EXT */
+ 1609, /* GL_TEXTURE_2D_ARRAY_EXT */
+ 1262, /* GL_PROXY_TEXTURE_2D_ARRAY_EXT */
+ 1615, /* GL_TEXTURE_BINDING_1D_ARRAY_EXT */
+ 1617, /* GL_TEXTURE_BINDING_2D_ARRAY_EXT */
+ 1469, /* GL_SRGB */
+ 1470, /* GL_SRGB8 */
+ 1472, /* GL_SRGB_ALPHA */
+ 1471, /* GL_SRGB8_ALPHA8 */
+ 1429, /* GL_SLUMINANCE_ALPHA */
+ 1428, /* GL_SLUMINANCE8_ALPHA8 */
+ 1426, /* GL_SLUMINANCE */
+ 1427, /* GL_SLUMINANCE8 */
267, /* GL_COMPRESSED_SRGB */
268, /* GL_COMPRESSED_SRGB_ALPHA */
265, /* GL_COMPRESSED_SLUMINANCE */
266, /* GL_COMPRESSED_SLUMINANCE_ALPHA */
- 1154, /* GL_POINT_SPRITE_COORD_ORIGIN */
- 713, /* GL_LOWER_LEFT */
- 1779, /* GL_UPPER_LEFT */
- 1491, /* GL_STENCIL_BACK_REF */
- 1492, /* GL_STENCIL_BACK_VALUE_MASK */
- 1493, /* GL_STENCIL_BACK_WRITEMASK */
- 441, /* GL_DRAW_FRAMEBUFFER_BINDING_EXT */
- 1304, /* GL_RENDERBUFFER_BINDING_EXT */
- 1285, /* GL_READ_FRAMEBUFFER */
- 440, /* GL_DRAW_FRAMEBUFFER */
- 1286, /* GL_READ_FRAMEBUFFER_BINDING_EXT */
- 1314, /* GL_RENDERBUFFER_SAMPLES */
- 544, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE */
- 542, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME */
- 553, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL */
- 549, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE */
- 551, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER */
- 556, /* GL_FRAMEBUFFER_COMPLETE */
- 560, /* GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT */
- 566, /* GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT */
- 564, /* GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT */
- 562, /* GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT */
- 565, /* GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT */
- 563, /* GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT */
- 569, /* GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT */
- 572, /* GL_FRAMEBUFFER_UNSUPPORTED */
- 570, /* GL_FRAMEBUFFER_STATUS_ERROR_EXT */
- 853, /* GL_MAX_COLOR_ATTACHMENTS_EXT */
+ 1155, /* GL_POINT_SPRITE_COORD_ORIGIN */
+ 714, /* GL_LOWER_LEFT */
+ 1780, /* GL_UPPER_LEFT */
+ 1492, /* GL_STENCIL_BACK_REF */
+ 1493, /* GL_STENCIL_BACK_VALUE_MASK */
+ 1494, /* GL_STENCIL_BACK_WRITEMASK */
+ 442, /* GL_DRAW_FRAMEBUFFER_BINDING_EXT */
+ 1305, /* GL_RENDERBUFFER_BINDING_EXT */
+ 1286, /* GL_READ_FRAMEBUFFER */
+ 441, /* GL_DRAW_FRAMEBUFFER */
+ 1287, /* GL_READ_FRAMEBUFFER_BINDING_EXT */
+ 1315, /* GL_RENDERBUFFER_SAMPLES */
+ 545, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE */
+ 543, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME */
+ 554, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL */
+ 550, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE */
+ 552, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER */
+ 557, /* GL_FRAMEBUFFER_COMPLETE */
+ 561, /* GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT */
+ 567, /* GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT */
+ 565, /* GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT */
+ 563, /* GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT */
+ 566, /* GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT */
+ 564, /* GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT */
+ 570, /* GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT */
+ 573, /* GL_FRAMEBUFFER_UNSUPPORTED */
+ 571, /* GL_FRAMEBUFFER_STATUS_ERROR_EXT */
+ 854, /* GL_MAX_COLOR_ATTACHMENTS_EXT */
155, /* GL_COLOR_ATTACHMENT0 */
157, /* GL_COLOR_ATTACHMENT1 */
171, /* GL_COLOR_ATTACHMENT2 */
166, /* GL_COLOR_ATTACHMENT14 */
168, /* GL_COLOR_ATTACHMENT15 */
348, /* GL_DEPTH_ATTACHMENT */
- 1481, /* GL_STENCIL_ATTACHMENT */
- 535, /* GL_FRAMEBUFFER */
- 1302, /* GL_RENDERBUFFER */
- 1316, /* GL_RENDERBUFFER_WIDTH */
- 1309, /* GL_RENDERBUFFER_HEIGHT */
- 1311, /* GL_RENDERBUFFER_INTERNAL_FORMAT */
- 1504, /* GL_STENCIL_INDEX_EXT */
- 1501, /* GL_STENCIL_INDEX1_EXT */
- 1502, /* GL_STENCIL_INDEX4_EXT */
- 1503, /* GL_STENCIL_INDEX8_EXT */
- 1500, /* GL_STENCIL_INDEX16_EXT */
- 1313, /* GL_RENDERBUFFER_RED_SIZE */
- 1308, /* GL_RENDERBUFFER_GREEN_SIZE */
- 1305, /* GL_RENDERBUFFER_BLUE_SIZE */
- 1303, /* GL_RENDERBUFFER_ALPHA_SIZE */
- 1306, /* GL_RENDERBUFFER_DEPTH_SIZE */
- 1315, /* GL_RENDERBUFFER_STENCIL_SIZE */
- 568, /* GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE */
- 909, /* GL_MAX_SAMPLES */
- 1272, /* GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT */
- 482, /* GL_FIRST_VERTEX_CONVENTION_EXT */
- 665, /* GL_LAST_VERTEX_CONVENTION_EXT */
- 1251, /* GL_PROVOKING_VERTEX_EXT */
+ 1482, /* GL_STENCIL_ATTACHMENT */
+ 536, /* GL_FRAMEBUFFER */
+ 1303, /* GL_RENDERBUFFER */
+ 1317, /* GL_RENDERBUFFER_WIDTH */
+ 1310, /* GL_RENDERBUFFER_HEIGHT */
+ 1312, /* GL_RENDERBUFFER_INTERNAL_FORMAT */
+ 1505, /* GL_STENCIL_INDEX_EXT */
+ 1502, /* GL_STENCIL_INDEX1_EXT */
+ 1503, /* GL_STENCIL_INDEX4_EXT */
+ 1504, /* GL_STENCIL_INDEX8_EXT */
+ 1501, /* GL_STENCIL_INDEX16_EXT */
+ 1314, /* GL_RENDERBUFFER_RED_SIZE */
+ 1309, /* GL_RENDERBUFFER_GREEN_SIZE */
+ 1306, /* GL_RENDERBUFFER_BLUE_SIZE */
+ 1304, /* GL_RENDERBUFFER_ALPHA_SIZE */
+ 1307, /* GL_RENDERBUFFER_DEPTH_SIZE */
+ 1316, /* GL_RENDERBUFFER_STENCIL_SIZE */
+ 569, /* GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE */
+ 910, /* GL_MAX_SAMPLES */
+ 1273, /* GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT */
+ 483, /* GL_FIRST_VERTEX_CONVENTION_EXT */
+ 666, /* GL_LAST_VERTEX_CONVENTION_EXT */
+ 1252, /* GL_PROVOKING_VERTEX_EXT */
302, /* GL_COPY_READ_BUFFER */
303, /* GL_COPY_WRITE_BUFFER */
- 1363, /* GL_RGBA_SNORM */
- 1359, /* GL_RGBA8_SNORM */
- 1421, /* GL_SIGNED_NORMALIZED */
- 910, /* GL_MAX_SERVER_WAIT_TIMEOUT */
- 1039, /* GL_OBJECT_TYPE */
- 1525, /* GL_SYNC_CONDITION */
- 1530, /* GL_SYNC_STATUS */
- 1527, /* GL_SYNC_FLAGS */
- 1526, /* GL_SYNC_FENCE */
- 1529, /* GL_SYNC_GPU_COMMANDS_COMPLETE */
- 1756, /* GL_UNSIGNALED */
- 1420, /* GL_SIGNALED */
+ 1364, /* GL_RGBA_SNORM */
+ 1360, /* GL_RGBA8_SNORM */
+ 1422, /* GL_SIGNED_NORMALIZED */
+ 911, /* GL_MAX_SERVER_WAIT_TIMEOUT */
+ 1040, /* GL_OBJECT_TYPE */
+ 1526, /* GL_SYNC_CONDITION */
+ 1531, /* GL_SYNC_STATUS */
+ 1528, /* GL_SYNC_FLAGS */
+ 1527, /* GL_SYNC_FENCE */
+ 1530, /* GL_SYNC_GPU_COMMANDS_COMPLETE */
+ 1757, /* GL_UNSIGNALED */
+ 1421, /* GL_SIGNALED */
46, /* GL_ALREADY_SIGNALED */
- 1727, /* GL_TIMEOUT_EXPIRED */
+ 1728, /* GL_TIMEOUT_EXPIRED */
270, /* GL_CONDITION_SATISFIED */
- 1839, /* GL_WAIT_FAILED */
- 467, /* GL_EVAL_BIT */
- 1283, /* GL_RASTER_POSITION_UNCLIPPED_IBM */
- 707, /* GL_LIST_BIT */
- 1622, /* GL_TEXTURE_BIT */
- 1394, /* GL_SCISSOR_BIT */
+ 1840, /* GL_WAIT_FAILED */
+ 468, /* GL_EVAL_BIT */
+ 1284, /* GL_RASTER_POSITION_UNCLIPPED_IBM */
+ 708, /* GL_LIST_BIT */
+ 1623, /* GL_TEXTURE_BIT */
+ 1395, /* GL_SCISSOR_BIT */
29, /* GL_ALL_ATTRIB_BITS */
- 995, /* GL_MULTISAMPLE_BIT */
+ 996, /* GL_MULTISAMPLE_BIT */
30, /* GL_ALL_CLIENT_ATTRIB_BITS */
- 1728, /* GL_TIMEOUT_IGNORED */
+ 1729, /* GL_TIMEOUT_IGNORED */
};
typedef int (*cfunc)(const void *, const void *);
} default_extensions[] = {
{ OFF, "GL_ARB_copy_buffer", F(ARB_copy_buffer) },
{ OFF, "GL_ARB_depth_texture", F(ARB_depth_texture) },
+ { OFF, "GL_ARB_depth_clamp", F(ARB_depth_clamp) },
{ ON, "GL_ARB_draw_buffers", F(ARB_draw_buffers) },
+ { OFF, "GL_ARB_draw_elements_base_vertex", F(ARB_draw_elements_base_vertex) },
{ OFF, "GL_ARB_fragment_program", F(ARB_fragment_program) },
{ OFF, "GL_ARB_fragment_program_shadow", F(ARB_fragment_program_shadow) },
{ OFF, "GL_ARB_fragment_shader", F(ARB_fragment_shader) },
{ OFF, "GL_MESA_ycbcr_texture", F(MESA_ycbcr_texture) },
{ ON, "GL_MESA_window_pos", F(ARB_window_pos) },
{ OFF, "GL_NV_blend_square", F(NV_blend_square) },
+ { OFF, "GL_NV_depth_clamp", F(ARB_depth_clamp) },
{ OFF, "GL_NV_fragment_program", F(NV_fragment_program) },
{ ON, "GL_NV_light_max_exponent", F(NV_light_max_exponent) },
{ OFF, "GL_NV_point_sprite", F(NV_point_sprite) },
_mesa_enable_sw_extensions(GLcontext *ctx)
{
ctx->Extensions.ARB_copy_buffer = GL_TRUE;
+ ctx->Extensions.ARB_depth_clamp = GL_TRUE;
ctx->Extensions.ARB_depth_texture = GL_TRUE;
/*ctx->Extensions.ARB_draw_buffers = GL_TRUE;*/
+ ctx->Extensions.ARB_draw_elements_base_vertex = GL_TRUE;
#if FEATURE_ARB_fragment_program
ctx->Extensions.ARB_fragment_program = GL_TRUE;
ctx->Extensions.ARB_fragment_program_shadow = GL_TRUE;
params[0] = FLOAT_TO_BOOLEAN(ctx->Depth.BoundsMin);
params[1] = FLOAT_TO_BOOLEAN(ctx->Depth.BoundsMax);
break;
+ case GL_DEPTH_CLAMP:
+ CHECK_EXT1(ARB_depth_clamp, "GetBooleanv");
+ params[0] = ctx->Transform.DepthClamp;
+ break;
case GL_MAX_DRAW_BUFFERS_ARB:
params[0] = INT_TO_BOOLEAN(ctx->Const.MaxDrawBuffers);
break;
params[0] = ctx->Depth.BoundsMin;
params[1] = ctx->Depth.BoundsMax;
break;
+ case GL_DEPTH_CLAMP:
+ CHECK_EXT1(ARB_depth_clamp, "GetFloatv");
+ params[0] = BOOLEAN_TO_FLOAT(ctx->Transform.DepthClamp);
+ break;
case GL_MAX_DRAW_BUFFERS_ARB:
params[0] = (GLfloat)(ctx->Const.MaxDrawBuffers);
break;
params[0] = IROUND(ctx->Depth.BoundsMin);
params[1] = IROUND(ctx->Depth.BoundsMax);
break;
+ case GL_DEPTH_CLAMP:
+ CHECK_EXT1(ARB_depth_clamp, "GetIntegerv");
+ params[0] = BOOLEAN_TO_INT(ctx->Transform.DepthClamp);
+ break;
case GL_MAX_DRAW_BUFFERS_ARB:
params[0] = ctx->Const.MaxDrawBuffers;
break;
params[0] = IROUND64(ctx->Depth.BoundsMin);
params[1] = IROUND64(ctx->Depth.BoundsMax);
break;
+ case GL_DEPTH_CLAMP:
+ CHECK_EXT1(ARB_depth_clamp, "GetInteger64v");
+ params[0] = BOOLEAN_TO_INT64(ctx->Transform.DepthClamp);
+ break;
case GL_MAX_DRAW_BUFFERS_ARB:
params[0] = ctx->Const.MaxDrawBuffers;
break;
["ctx->Depth.BoundsMin", "ctx->Depth.BoundsMax"],
"", ["EXT_depth_bounds_test"] ),
+ # GL_ARB_depth_clamp
+ ( "GL_DEPTH_CLAMP", GLboolean, ["ctx->Transform.DepthClamp"], "",
+ ["ARB_depth_clamp"] ),
+
# GL_ARB_draw_buffers
( "GL_MAX_DRAW_BUFFERS_ARB", GLint,
["ctx->Const.MaxDrawBuffers"], "", None ),
GLboolean Normalize; /**< Normalize all normals? */
GLboolean RescaleNormals; /**< GL_EXT_rescale_normal */
GLboolean RasterPositionUnclipped; /**< GL_IBM_rasterpos_clip */
+ GLboolean DepthClamp; /**< GL_ARB_depth_clamp */
GLboolean CullVertexFlag; /**< True if GL_CULL_VERTEX_EXT is enabled */
GLfloat CullEyePos[4];
GLboolean dummy; /* don't remove this! */
GLboolean ARB_copy_buffer;
GLboolean ARB_depth_texture;
+ GLboolean ARB_depth_clamp;
GLboolean ARB_draw_buffers;
+ GLboolean ARB_draw_elements_base_vertex;
GLboolean ARB_fragment_program;
GLboolean ARB_fragment_program_shadow;
GLboolean ARB_fragment_shader;
}
+/**
+ * Do we need to clamp the results of the given texture env/combine mode?
+ * If the inputs to the mode are in [0,1] we don't always have to clamp
+ * the results.
+ */
+static GLboolean
+need_saturate( GLuint mode )
+{
+ switch (mode) {
+ case MODE_REPLACE:
+ case MODE_MODULATE:
+ case MODE_INTERPOLATE:
+ return GL_FALSE;
+ case MODE_ADD:
+ case MODE_ADD_SIGNED:
+ case MODE_SUBTRACT:
+ case MODE_DOT3_RGB:
+ case MODE_DOT3_RGB_EXT:
+ case MODE_DOT3_RGBA:
+ case MODE_DOT3_RGBA_EXT:
+ case MODE_MODULATE_ADD_ATI:
+ case MODE_MODULATE_SIGNED_ADD_ATI:
+ case MODE_MODULATE_SUBTRACT_ATI:
+ case MODE_ADD_PRODUCTS:
+ case MODE_ADD_PRODUCTS_SIGNED:
+ case MODE_BUMP_ENVMAP_ATI:
+ return GL_TRUE;
+ default:
+ assert(0);
+ }
+}
+
+
+
/**
* Translate TEXTURE_x_BIT to TEXTURE_x_INDEX.
*/
emit_texenv(struct texenv_fragment_program *p, GLuint unit)
{
const struct state_key *key = p->state;
- GLboolean saturate;
+ GLboolean rgb_saturate, alpha_saturate;
GLuint rgb_shift, alpha_shift;
struct ureg out, dest;
/* If we'll do rgb/alpha shifting don't saturate in emit_combine().
* We don't want to clamp twice.
*/
- saturate = !(rgb_shift || alpha_shift);
+ if (rgb_shift)
+ rgb_saturate = GL_FALSE; /* saturate after rgb shift */
+ else if (need_saturate(key->unit[unit].ModeRGB))
+ rgb_saturate = GL_TRUE;
+ else
+ rgb_saturate = GL_FALSE;
+
+ if (alpha_shift)
+ alpha_saturate = GL_FALSE; /* saturate after alpha shift */
+ else if (need_saturate(key->unit[unit].ModeA))
+ alpha_saturate = GL_TRUE;
+ else
+ alpha_saturate = GL_FALSE;
/* If this is the very last calculation, emit direct to output reg:
*/
*/
if (key->unit[unit].ModeRGB == key->unit[unit].ModeA &&
args_match(key, unit)) {
- out = emit_combine( p, dest, WRITEMASK_XYZW, saturate,
+ out = emit_combine( p, dest, WRITEMASK_XYZW, rgb_saturate,
unit,
key->unit[unit].NumArgsRGB,
key->unit[unit].ModeRGB,
}
else if (key->unit[unit].ModeRGB == MODE_DOT3_RGBA_EXT ||
key->unit[unit].ModeRGB == MODE_DOT3_RGBA) {
- out = emit_combine( p, dest, WRITEMASK_XYZW, saturate,
+ out = emit_combine( p, dest, WRITEMASK_XYZW, rgb_saturate,
unit,
key->unit[unit].NumArgsRGB,
key->unit[unit].ModeRGB,
/* Need to do something to stop from re-emitting identical
* argument calculations here:
*/
- out = emit_combine( p, dest, WRITEMASK_XYZ, saturate,
+ out = emit_combine( p, dest, WRITEMASK_XYZ, rgb_saturate,
unit,
key->unit[unit].NumArgsRGB,
key->unit[unit].ModeRGB,
key->unit[unit].OptRGB);
- out = emit_combine( p, dest, WRITEMASK_W, saturate,
+ out = emit_combine( p, dest, WRITEMASK_W, alpha_saturate,
unit,
key->unit[unit].NumArgsA,
key->unit[unit].ModeA,
*/
if (alpha_shift || rgb_shift) {
struct ureg shift;
-
- saturate = GL_TRUE; /* always saturate at this point */
+ GLboolean saturate = GL_TRUE; /* always saturate at this point */
if (rgb_shift == alpha_shift) {
shift = register_scalar_const(p, (GLfloat)(1<<rgb_shift));
_mesa_MultiDrawElementsEXT( GLenum mode, const GLsizei *count, GLenum type,
const GLvoid **indices, GLsizei primcount );
+extern void GLAPIENTRY
+_mesa_MultiDrawElementsBaseVertex( GLenum mode,
+ const GLsizei *count, GLenum type,
+ const GLvoid **indices, GLsizei primcount,
+ const GLint *basevertex);
extern void GLAPIENTRY
_mesa_MultiModeDrawArraysIBM( const GLenum * mode, const GLint * first,
_mesa_DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count,
GLenum type, const GLvoid *indices);
+extern void GLAPIENTRY
+_mesa_DrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type,
+ const GLvoid *indices, GLint basevertex);
+
+extern void GLAPIENTRY
+_mesa_DrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end,
+ GLsizei count, GLenum type,
+ const GLvoid *indices,
+ GLint basevertex);
+
extern void
_mesa_copy_client_array(GLcontext *ctx,
/*
* Mesa 3-D graphics library
- * Version: 7.6
+ * Version: 7.7
*
* Copyright (C) 1999-2008 Brian Paul All Rights Reserved.
* Copyright (C) 2009 VMware, Inc. All Rights Reserved.
/* Mesa version */
#define MESA_MAJOR 7
-#define MESA_MINOR 6
+#define MESA_MINOR 7
#define MESA_PATCH 0
-#define MESA_VERSION_STRING "7.6-devel"
+#define MESA_VERSION_STRING "7.7-devel"
/* To make version comparison easy */
#define MESA_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))
SET_DrawElements(tab, vfmt->DrawElements);
SET_DrawRangeElements(tab, vfmt->DrawRangeElements);
SET_MultiDrawElementsEXT(tab, vfmt->MultiDrawElementsEXT);
+ SET_DrawElementsBaseVertex(tab, vfmt->DrawElementsBaseVertex);
+ SET_DrawRangeElementsBaseVertex(tab, vfmt->DrawRangeElementsBaseVertex);
+ SET_MultiDrawElementsBaseVertex(tab, vfmt->MultiDrawElementsBaseVertex);
SET_EvalMesh1(tab, vfmt->EvalMesh1);
SET_EvalMesh2(tab, vfmt->EvalMesh2);
ASSERT(tab->EvalMesh2);
CALL_DrawRangeElements(GET_DISPATCH(), ( mode, start, end, count, type, indices ));
}
+static void GLAPIENTRY TAG(DrawElementsBaseVertex)( GLenum mode,
+ GLsizei count,
+ GLenum type,
+ const GLvoid *indices,
+ GLint basevertex)
+{
+ PRE_LOOPBACK( DrawElementsBaseVertex );
+ CALL_DrawElementsBaseVertex(GET_DISPATCH(), ( mode, count, type,
+ indices, basevertex ));
+}
+
+static void GLAPIENTRY TAG(DrawRangeElementsBaseVertex)( GLenum mode,
+ GLuint start,
+ GLuint end,
+ GLsizei count,
+ GLenum type,
+ const GLvoid *indices,
+ GLint basevertex)
+{
+ PRE_LOOPBACK( DrawRangeElementsBaseVertex );
+ CALL_DrawRangeElementsBaseVertex(GET_DISPATCH(), ( mode, start, end,
+ count, type, indices,
+ basevertex ));
+}
+
+static void GLAPIENTRY TAG(MultiDrawElementsBaseVertex)( GLenum mode,
+ const GLsizei *count,
+ GLenum type,
+ const GLvoid **indices,
+ GLsizei primcount,
+ const GLint *basevertex)
+{
+ PRE_LOOPBACK( MultiDrawElementsBaseVertex );
+ CALL_MultiDrawElementsBaseVertex(GET_DISPATCH(), ( mode, count, type,
+ indices,
+ primcount, basevertex ));
+}
+
static void GLAPIENTRY TAG(EvalMesh1)( GLenum mode, GLint i1, GLint i2 )
{
PRE_LOOPBACK( EvalMesh1 );
TAG(DrawElements),
TAG(DrawRangeElements),
TAG(MultiDrawElementsEXT),
+ TAG(DrawElementsBaseVertex),
+ TAG(DrawRangeElementsBaseVertex),
+ TAG(MultiDrawElementsBaseVertex),
TAG(EvalMesh1),
TAG(EvalMesh2)
};
GLvector4f *proj_vec,
GLubyte clipMask[],
GLubyte *orMask,
- GLubyte *andMask )
+ GLubyte *andMask,
+ GLboolean viewport_z_clip )
{
const GLuint stride = clip_vec->stride;
const GLfloat *from = (GLfloat *)clip_vec->start;
mask |= (((cw < -cx) << CLIP_LEFT_SHIFT));
mask |= (((cw < cy) << CLIP_TOP_SHIFT));
mask |= (((cw < -cy) << CLIP_BOTTOM_SHIFT));
- mask |= (((cw < cz) << CLIP_FAR_SHIFT));
- mask |= (((cw < -cz) << CLIP_NEAR_SHIFT));
+ if (viewport_z_clip) {
+ mask |= (((cw < cz) << CLIP_FAR_SHIFT));
+ mask |= (((cw < -cz) << CLIP_NEAR_SHIFT));
+ }
#else /* !defined(macintosh)) */
GLubyte mask = 0;
if (-cx + cw < 0) mask |= CLIP_RIGHT_BIT;
if ( cx + cw < 0) mask |= CLIP_LEFT_BIT;
if (-cy + cw < 0) mask |= CLIP_TOP_BIT;
if ( cy + cw < 0) mask |= CLIP_BOTTOM_BIT;
- if (-cz + cw < 0) mask |= CLIP_FAR_BIT;
- if ( cz + cw < 0) mask |= CLIP_NEAR_BIT;
+ if (viewport_z_clip) {
+ if (-cz + cw < 0) mask |= CLIP_FAR_BIT;
+ if ( cz + cw < 0) mask |= CLIP_NEAR_BIT;
+ }
#endif /* defined(macintosh) */
clipMask[i] = mask;
GLvector4f *proj_vec,
GLubyte clipMask[],
GLubyte *orMask,
- GLubyte *andMask )
+ GLubyte *andMask,
+ GLboolean viewport_z_clip )
{
const GLuint stride = clip_vec->stride;
const GLuint count = clip_vec->count;
mask |= (((cw < -cx) << CLIP_LEFT_SHIFT));
mask |= (((cw < cy) << CLIP_TOP_SHIFT));
mask |= (((cw < -cy) << CLIP_BOTTOM_SHIFT));
- mask |= (((cw < cz) << CLIP_FAR_SHIFT));
- mask |= (((cw < -cz) << CLIP_NEAR_SHIFT));
+ if (viewport_z_clip) {
+ mask |= (((cw < cz) << CLIP_FAR_SHIFT));
+ mask |= (((cw < -cz) << CLIP_NEAR_SHIFT));
+ }
#else /* !defined(macintosh)) */
GLubyte mask = 0;
if (-cx + cw < 0) mask |= CLIP_RIGHT_BIT;
if ( cx + cw < 0) mask |= CLIP_LEFT_BIT;
if (-cy + cw < 0) mask |= CLIP_TOP_BIT;
if ( cy + cw < 0) mask |= CLIP_BOTTOM_BIT;
- if (-cz + cw < 0) mask |= CLIP_FAR_BIT;
- if ( cz + cw < 0) mask |= CLIP_NEAR_BIT;
+ if (viewport_z_clip) {
+ if (-cz + cw < 0) mask |= CLIP_FAR_BIT;
+ if ( cz + cw < 0) mask |= CLIP_NEAR_BIT;
+ }
#endif /* defined(macintosh) */
clipMask[i] = mask;
GLvector4f *proj_vec,
GLubyte clipMask[],
GLubyte *orMask,
- GLubyte *andMask )
+ GLubyte *andMask,
+ GLboolean viewport_z_clip )
{
const GLuint stride = clip_vec->stride;
const GLuint count = clip_vec->count;
else if (cx < -1.0) mask |= CLIP_LEFT_BIT;
if (cy > 1.0) mask |= CLIP_TOP_BIT;
else if (cy < -1.0) mask |= CLIP_BOTTOM_BIT;
- if (cz > 1.0) mask |= CLIP_FAR_BIT;
- else if (cz < -1.0) mask |= CLIP_NEAR_BIT;
+ if (viewport_z_clip) {
+ if (cz > 1.0) mask |= CLIP_FAR_BIT;
+ else if (cz < -1.0) mask |= CLIP_NEAR_BIT;
+ }
clipMask[i] = mask;
tmpOrMask |= mask;
tmpAndMask &= mask;
GLvector4f *proj_vec,
GLubyte clipMask[],
GLubyte *orMask,
- GLubyte *andMask )
+ GLubyte *andMask,
+ GLboolean viewport_z_clip )
{
const GLuint stride = clip_vec->stride;
const GLuint count = clip_vec->count;
}
-static void TAG(init_c_cliptest)( void )
+void TAG(init_c_cliptest)( void )
{
_mesa_clip_tab[4] = TAG(cliptest_points4);
_mesa_clip_tab[3] = TAG(cliptest_points3);
GLvector4f *proj_vec,
GLubyte clipMask[],
GLubyte *orMask,
- GLubyte *andMask )
+ GLubyte *andMask,
+ GLboolean viewport_z_clip )
{
const GLuint stride = clip_vec->stride;
const GLuint count = clip_vec->count;
if ( cx + cw < 0 ) mask |= CLIP_LEFT_BIT;
if ( -cy + cw < 0 ) mask |= CLIP_TOP_BIT;
if ( cy + cw < 0 ) mask |= CLIP_BOTTOM_BIT;
- if ( -cz + cw < 0 ) mask |= CLIP_FAR_BIT;
- if ( cz + cw < 0 ) mask |= CLIP_NEAR_BIT;
+ if (viewport_z_clip) {
+ if ( -cz + cw < 0 ) mask |= CLIP_FAR_BIT;
+ if ( cz + cw < 0 ) mask |= CLIP_NEAR_BIT;
+ }
clipMask[i] = mask;
if ( mask ) {
c++;
GLvector4f *proj_vec,
GLubyte clipMask[],
GLubyte *orMask,
- GLubyte *andMask )
+ GLubyte *andMask,
+ GLboolean viewport_z_clip )
{
const GLuint stride = clip_vec->stride;
const GLuint count = clip_vec->count;
else if ( cx < -1.0 ) mask |= CLIP_LEFT_BIT;
if ( cy > 1.0 ) mask |= CLIP_TOP_BIT;
else if ( cy < -1.0 ) mask |= CLIP_BOTTOM_BIT;
- if ( cz > 1.0 ) mask |= CLIP_FAR_BIT;
- else if ( cz < -1.0 ) mask |= CLIP_NEAR_BIT;
+ if (viewport_z_clip) {
+ if ( cz > 1.0 ) mask |= CLIP_FAR_BIT;
+ else if ( cz < -1.0 ) mask |= CLIP_NEAR_BIT;
+ }
clipMask[i] = mask;
tmpOrMask |= mask;
tmpAndMask &= mask;
GLvector4f *proj_vec,
GLubyte clipMask[],
GLubyte *orMask,
- GLubyte *andMask )
+ GLubyte *andMask,
+ GLboolean viewport_z_clip )
{
const GLuint stride = clip_vec->stride;
const GLuint count = clip_vec->count;
GLubyte tmpOrMask = *orMask;
GLubyte tmpAndMask = *andMask;
GLuint i;
+
+ (void) viewport_z_clip;
+
for ( i = 0 ; i < count ; i++, STRIDE_F(from, stride) ) {
const GLfloat cx = from[0], cy = from[1];
GLubyte mask = 0;
#ifdef RUN_DEBUG_BENCHMARK
int cycle_i; /* the counter for the benchmarks we run */
#endif
+ GLboolean viewport_z_clip = GL_TRUE;
(void) cycles;
dco = rco = 0;
dca = rca = CLIP_FRUSTUM_BITS;
- ref_cliptest[psize]( source, ref, rm, &rco, &rca );
+ ref_cliptest[psize]( source, ref, rm, &rco, &rca, viewport_z_clip );
if ( mesa_profile ) {
BEGIN_RACE( *cycles );
- func( source, dest, dm, &dco, &dca );
+ func( source, dest, dm, &dco, &dca, viewport_z_clip );
END_RACE( *cycles );
}
else {
- func( source, dest, dm, &dco, &dca );
+ func( source, dest, dm, &dco, &dca, viewport_z_clip );
}
if ( dco != rco ) {
extern void
_math_init_transformation(void);
-
+extern void
+init_c_cliptest(void);
/* KW: Clip functions now do projective divide as well. The projected
* coordinates are very useful to us because they let us cull
GLvector4f *vProj,
GLubyte clipMask[],
GLubyte *orMask,
- GLubyte *andMask );
+ GLubyte *andMask,
+ GLboolean viewport_z_clip );
typedef void (*dotprod_func)( GLfloat *out,
GLuint out_stride,
/*@{*/
#define SATURATE_OFF 0
#define SATURATE_ZERO_ONE 1
-#define SATURATE_PLUS_MINUS_ONE 2
/*@}*/
.byte 31, 29, 31, 30, 27, 25, 27, 26
/* GLvector4f *clip_vec, GLvector4f *proj_vec,
- GLubyte clipMask[], GLubyte *orMask, GLubyte *andMask */
+ GLubyte clipMask[], GLubyte *orMask, GLubyte *andMask,
+ GLboolean viewport_z_enable */
.align 64
__pc_tramp:
GL_STUB(glGetSynciv, _gloffset_GetSynciv)
GL_STUB(glIsSync, _gloffset_IsSync)
GL_STUB(glWaitSync, _gloffset_WaitSync)
+ GL_STUB(glDrawElementsBaseVertex, _gloffset_DrawElementsBaseVertex)
+ GL_STUB(glDrawRangeElementsBaseVertex, _gloffset_DrawRangeElementsBaseVertex)
+ GL_STUB(glMultiDrawElementsBaseVertex, _gloffset_MultiDrawElementsBaseVertex)
GL_STUB(glPolygonOffsetEXT, _gloffset_PolygonOffsetEXT)
- GL_STUB(gl_dispatch_stub_575, _gloffset_GetPixelTexGenParameterfvSGIS)
- HIDDEN(gl_dispatch_stub_575)
- GL_STUB(gl_dispatch_stub_576, _gloffset_GetPixelTexGenParameterivSGIS)
- HIDDEN(gl_dispatch_stub_576)
- GL_STUB(gl_dispatch_stub_577, _gloffset_PixelTexGenParameterfSGIS)
- HIDDEN(gl_dispatch_stub_577)
- GL_STUB(gl_dispatch_stub_578, _gloffset_PixelTexGenParameterfvSGIS)
+ GL_STUB(gl_dispatch_stub_578, _gloffset_GetPixelTexGenParameterfvSGIS)
HIDDEN(gl_dispatch_stub_578)
- GL_STUB(gl_dispatch_stub_579, _gloffset_PixelTexGenParameteriSGIS)
+ GL_STUB(gl_dispatch_stub_579, _gloffset_GetPixelTexGenParameterivSGIS)
HIDDEN(gl_dispatch_stub_579)
- GL_STUB(gl_dispatch_stub_580, _gloffset_PixelTexGenParameterivSGIS)
+ GL_STUB(gl_dispatch_stub_580, _gloffset_PixelTexGenParameterfSGIS)
HIDDEN(gl_dispatch_stub_580)
- GL_STUB(gl_dispatch_stub_581, _gloffset_SampleMaskSGIS)
+ GL_STUB(gl_dispatch_stub_581, _gloffset_PixelTexGenParameterfvSGIS)
HIDDEN(gl_dispatch_stub_581)
- GL_STUB(gl_dispatch_stub_582, _gloffset_SamplePatternSGIS)
+ GL_STUB(gl_dispatch_stub_582, _gloffset_PixelTexGenParameteriSGIS)
HIDDEN(gl_dispatch_stub_582)
+ GL_STUB(gl_dispatch_stub_583, _gloffset_PixelTexGenParameterivSGIS)
+ HIDDEN(gl_dispatch_stub_583)
+ GL_STUB(gl_dispatch_stub_584, _gloffset_SampleMaskSGIS)
+ HIDDEN(gl_dispatch_stub_584)
+ GL_STUB(gl_dispatch_stub_585, _gloffset_SamplePatternSGIS)
+ HIDDEN(gl_dispatch_stub_585)
GL_STUB(glColorPointerEXT, _gloffset_ColorPointerEXT)
GL_STUB(glEdgeFlagPointerEXT, _gloffset_EdgeFlagPointerEXT)
GL_STUB(glIndexPointerEXT, _gloffset_IndexPointerEXT)
GL_STUB(glPointParameterfvEXT, _gloffset_PointParameterfvEXT)
GL_STUB(glLockArraysEXT, _gloffset_LockArraysEXT)
GL_STUB(glUnlockArraysEXT, _gloffset_UnlockArraysEXT)
- GL_STUB(gl_dispatch_stub_593, _gloffset_CullParameterdvEXT)
- HIDDEN(gl_dispatch_stub_593)
- GL_STUB(gl_dispatch_stub_594, _gloffset_CullParameterfvEXT)
- HIDDEN(gl_dispatch_stub_594)
+ GL_STUB(gl_dispatch_stub_596, _gloffset_CullParameterdvEXT)
+ HIDDEN(gl_dispatch_stub_596)
+ GL_STUB(gl_dispatch_stub_597, _gloffset_CullParameterfvEXT)
+ HIDDEN(gl_dispatch_stub_597)
GL_STUB(glSecondaryColor3bEXT, _gloffset_SecondaryColor3bEXT)
GL_STUB(glSecondaryColor3bvEXT, _gloffset_SecondaryColor3bvEXT)
GL_STUB(glSecondaryColor3dEXT, _gloffset_SecondaryColor3dEXT)
GL_STUB(glFogCoorddvEXT, _gloffset_FogCoorddvEXT)
GL_STUB(glFogCoordfEXT, _gloffset_FogCoordfEXT)
GL_STUB(glFogCoordfvEXT, _gloffset_FogCoordfvEXT)
- GL_STUB(gl_dispatch_stub_619, _gloffset_PixelTexGenSGIX)
- HIDDEN(gl_dispatch_stub_619)
+ GL_STUB(gl_dispatch_stub_622, _gloffset_PixelTexGenSGIX)
+ HIDDEN(gl_dispatch_stub_622)
GL_STUB(glBlendFuncSeparateEXT, _gloffset_BlendFuncSeparateEXT)
GL_STUB(glFlushVertexArrayRangeNV, _gloffset_FlushVertexArrayRangeNV)
GL_STUB(glVertexArrayRangeNV, _gloffset_VertexArrayRangeNV)
GL_STUB(glWindowPos4ivMESA, _gloffset_WindowPos4ivMESA)
GL_STUB(glWindowPos4sMESA, _gloffset_WindowPos4sMESA)
GL_STUB(glWindowPos4svMESA, _gloffset_WindowPos4svMESA)
- GL_STUB(gl_dispatch_stub_661, _gloffset_MultiModeDrawArraysIBM)
- HIDDEN(gl_dispatch_stub_661)
- GL_STUB(gl_dispatch_stub_662, _gloffset_MultiModeDrawElementsIBM)
- HIDDEN(gl_dispatch_stub_662)
- GL_STUB(gl_dispatch_stub_663, _gloffset_DeleteFencesNV)
- HIDDEN(gl_dispatch_stub_663)
- GL_STUB(gl_dispatch_stub_664, _gloffset_FinishFenceNV)
+ GL_STUB(gl_dispatch_stub_664, _gloffset_MultiModeDrawArraysIBM)
HIDDEN(gl_dispatch_stub_664)
- GL_STUB(gl_dispatch_stub_665, _gloffset_GenFencesNV)
+ GL_STUB(gl_dispatch_stub_665, _gloffset_MultiModeDrawElementsIBM)
HIDDEN(gl_dispatch_stub_665)
- GL_STUB(gl_dispatch_stub_666, _gloffset_GetFenceivNV)
+ GL_STUB(gl_dispatch_stub_666, _gloffset_DeleteFencesNV)
HIDDEN(gl_dispatch_stub_666)
- GL_STUB(gl_dispatch_stub_667, _gloffset_IsFenceNV)
+ GL_STUB(gl_dispatch_stub_667, _gloffset_FinishFenceNV)
HIDDEN(gl_dispatch_stub_667)
- GL_STUB(gl_dispatch_stub_668, _gloffset_SetFenceNV)
+ GL_STUB(gl_dispatch_stub_668, _gloffset_GenFencesNV)
HIDDEN(gl_dispatch_stub_668)
- GL_STUB(gl_dispatch_stub_669, _gloffset_TestFenceNV)
+ GL_STUB(gl_dispatch_stub_669, _gloffset_GetFenceivNV)
HIDDEN(gl_dispatch_stub_669)
+ GL_STUB(gl_dispatch_stub_670, _gloffset_IsFenceNV)
+ HIDDEN(gl_dispatch_stub_670)
+ GL_STUB(gl_dispatch_stub_671, _gloffset_SetFenceNV)
+ HIDDEN(gl_dispatch_stub_671)
+ GL_STUB(gl_dispatch_stub_672, _gloffset_TestFenceNV)
+ HIDDEN(gl_dispatch_stub_672)
GL_STUB(glAreProgramsResidentNV, _gloffset_AreProgramsResidentNV)
GL_STUB(glBindProgramNV, _gloffset_BindProgramNV)
GL_STUB(glDeleteProgramsNV, _gloffset_DeleteProgramsNV)
GL_STUB(glSetFragmentShaderConstantATI, _gloffset_SetFragmentShaderConstantATI)
GL_STUB(glPointParameteriNV, _gloffset_PointParameteriNV)
GL_STUB(glPointParameterivNV, _gloffset_PointParameterivNV)
- GL_STUB(gl_dispatch_stub_750, _gloffset_ActiveStencilFaceEXT)
- HIDDEN(gl_dispatch_stub_750)
- GL_STUB(gl_dispatch_stub_751, _gloffset_BindVertexArrayAPPLE)
- HIDDEN(gl_dispatch_stub_751)
- GL_STUB(gl_dispatch_stub_752, _gloffset_DeleteVertexArraysAPPLE)
- HIDDEN(gl_dispatch_stub_752)
- GL_STUB(gl_dispatch_stub_753, _gloffset_GenVertexArraysAPPLE)
+ GL_STUB(gl_dispatch_stub_753, _gloffset_ActiveStencilFaceEXT)
HIDDEN(gl_dispatch_stub_753)
- GL_STUB(gl_dispatch_stub_754, _gloffset_IsVertexArrayAPPLE)
+ GL_STUB(gl_dispatch_stub_754, _gloffset_BindVertexArrayAPPLE)
HIDDEN(gl_dispatch_stub_754)
+ GL_STUB(gl_dispatch_stub_755, _gloffset_DeleteVertexArraysAPPLE)
+ HIDDEN(gl_dispatch_stub_755)
+ GL_STUB(gl_dispatch_stub_756, _gloffset_GenVertexArraysAPPLE)
+ HIDDEN(gl_dispatch_stub_756)
+ GL_STUB(gl_dispatch_stub_757, _gloffset_IsVertexArrayAPPLE)
+ HIDDEN(gl_dispatch_stub_757)
GL_STUB(glGetProgramNamedParameterdvNV, _gloffset_GetProgramNamedParameterdvNV)
GL_STUB(glGetProgramNamedParameterfvNV, _gloffset_GetProgramNamedParameterfvNV)
GL_STUB(glProgramNamedParameter4dNV, _gloffset_ProgramNamedParameter4dNV)
GL_STUB(glProgramNamedParameter4dvNV, _gloffset_ProgramNamedParameter4dvNV)
GL_STUB(glProgramNamedParameter4fNV, _gloffset_ProgramNamedParameter4fNV)
GL_STUB(glProgramNamedParameter4fvNV, _gloffset_ProgramNamedParameter4fvNV)
- GL_STUB(gl_dispatch_stub_761, _gloffset_DepthBoundsEXT)
- HIDDEN(gl_dispatch_stub_761)
- GL_STUB(gl_dispatch_stub_762, _gloffset_BlendEquationSeparateEXT)
- HIDDEN(gl_dispatch_stub_762)
+ GL_STUB(gl_dispatch_stub_764, _gloffset_DepthBoundsEXT)
+ HIDDEN(gl_dispatch_stub_764)
+ GL_STUB(gl_dispatch_stub_765, _gloffset_BlendEquationSeparateEXT)
+ HIDDEN(gl_dispatch_stub_765)
GL_STUB(glBindFramebufferEXT, _gloffset_BindFramebufferEXT)
GL_STUB(glBindRenderbufferEXT, _gloffset_BindRenderbufferEXT)
GL_STUB(glCheckFramebufferStatusEXT, _gloffset_CheckFramebufferStatusEXT)
GL_STUB(glIsFramebufferEXT, _gloffset_IsFramebufferEXT)
GL_STUB(glIsRenderbufferEXT, _gloffset_IsRenderbufferEXT)
GL_STUB(glRenderbufferStorageEXT, _gloffset_RenderbufferStorageEXT)
- GL_STUB(gl_dispatch_stub_780, _gloffset_BlitFramebufferEXT)
- HIDDEN(gl_dispatch_stub_780)
- GL_STUB(gl_dispatch_stub_781, _gloffset_BufferParameteriAPPLE)
- HIDDEN(gl_dispatch_stub_781)
- GL_STUB(gl_dispatch_stub_782, _gloffset_FlushMappedBufferRangeAPPLE)
- HIDDEN(gl_dispatch_stub_782)
+ GL_STUB(gl_dispatch_stub_783, _gloffset_BlitFramebufferEXT)
+ HIDDEN(gl_dispatch_stub_783)
+ GL_STUB(gl_dispatch_stub_784, _gloffset_BufferParameteriAPPLE)
+ HIDDEN(gl_dispatch_stub_784)
+ GL_STUB(gl_dispatch_stub_785, _gloffset_FlushMappedBufferRangeAPPLE)
+ HIDDEN(gl_dispatch_stub_785)
GL_STUB(glFramebufferTextureLayerEXT, _gloffset_FramebufferTextureLayerEXT)
GL_STUB(glProvokingVertexEXT, _gloffset_ProvokingVertexEXT)
- GL_STUB(gl_dispatch_stub_785, _gloffset_GetTexParameterPointervAPPLE)
- HIDDEN(gl_dispatch_stub_785)
- GL_STUB(gl_dispatch_stub_786, _gloffset_TextureRangeAPPLE)
- HIDDEN(gl_dispatch_stub_786)
- GL_STUB(gl_dispatch_stub_787, _gloffset_StencilFuncSeparateATI)
- HIDDEN(gl_dispatch_stub_787)
- GL_STUB(gl_dispatch_stub_788, _gloffset_ProgramEnvParameters4fvEXT)
+ GL_STUB(gl_dispatch_stub_788, _gloffset_GetTexParameterPointervAPPLE)
HIDDEN(gl_dispatch_stub_788)
- GL_STUB(gl_dispatch_stub_789, _gloffset_ProgramLocalParameters4fvEXT)
+ GL_STUB(gl_dispatch_stub_789, _gloffset_TextureRangeAPPLE)
HIDDEN(gl_dispatch_stub_789)
- GL_STUB(gl_dispatch_stub_790, _gloffset_GetQueryObjecti64vEXT)
+ GL_STUB(gl_dispatch_stub_790, _gloffset_StencilFuncSeparateATI)
HIDDEN(gl_dispatch_stub_790)
- GL_STUB(gl_dispatch_stub_791, _gloffset_GetQueryObjectui64vEXT)
+ GL_STUB(gl_dispatch_stub_791, _gloffset_ProgramEnvParameters4fvEXT)
HIDDEN(gl_dispatch_stub_791)
+ GL_STUB(gl_dispatch_stub_792, _gloffset_ProgramLocalParameters4fvEXT)
+ HIDDEN(gl_dispatch_stub_792)
+ GL_STUB(gl_dispatch_stub_793, _gloffset_GetQueryObjecti64vEXT)
+ HIDDEN(gl_dispatch_stub_793)
+ GL_STUB(gl_dispatch_stub_794, _gloffset_GetQueryObjectui64vEXT)
+ HIDDEN(gl_dispatch_stub_794)
GL_STUB_ALIAS(glArrayElementEXT, glArrayElement)
GL_STUB_ALIAS(glBindTextureEXT, glBindTexture)
GL_STUB_ALIAS(glDrawArraysEXT, glDrawArrays)
GLvector4f *proj_vec,
GLubyte clipMask[],
GLubyte *orMask,
- GLubyte *andMask);
+ GLubyte *andMask,
+ GLboolean viewport_z_clip);
extern GLvector4f *_mesa_sparc_cliptest_points4_np(GLvector4f *clip_vec,
GLvector4f *proj_vec,
GLubyte clipMask[],
GLubyte *orMask,
- GLubyte *andMask);
+ GLubyte *andMask,
+ GLboolean viewport_z_clip);
#define NORM_ARGS const GLmatrix *mat, \
GLfloat scale, \
static struct st_fragment_program *
combined_drawpix_fragment_program(GLcontext *ctx)
{
- struct st_context *st = ctx->st;
+ struct st_context *st = st_context(ctx);
struct st_fragment_program *stfp;
if (st->pixel_xfer.program->serialNo == st->pixel_xfer.xfer_prog_sn
GLfloat x1, GLfloat y1, const GLfloat *color,
GLboolean invertTex, GLfloat maxXcoord, GLfloat maxYcoord)
{
- struct st_context *st = ctx->st;
- struct pipe_context *pipe = ctx->st->pipe;
+ struct st_context *st = st_context(ctx);
+ struct pipe_context *pipe = st->pipe;
GLfloat verts[4][3][4]; /* four verts, three attribs, XYZW */
/* setup vertex data */
const GLfloat *color,
GLboolean invertTex)
{
- struct st_context *st = ctx->st;
- struct pipe_context *pipe = ctx->st->pipe;
- struct cso_context *cso = ctx->st->cso_context;
+ struct st_context *st = st_context(ctx);
+ struct pipe_context *pipe = st->pipe;
+ struct cso_context *cso = st->cso_context;
GLfloat x0, y0, x1, y1;
GLsizei maxSize;
const struct gl_pixelstore_attrib *unpack,
const GLvoid *pixels)
{
- struct st_context *st = ctx->st;
+ struct st_context *st = st_context(ctx);
struct pipe_context *pipe = st->pipe;
struct pipe_screen *screen = pipe->screen;
struct st_renderbuffer *strb;
{
struct st_fragment_program *stfp;
struct st_vertex_program *stvp;
- struct st_context *st = ctx->st;
+ struct st_context *st = st_context(ctx);
struct pipe_surface *ps;
const GLfloat *color;
if (format == GL_DEPTH_COMPONENT) {
ps = st->state.framebuffer.zsbuf;
- stfp = make_fragment_shader_z(ctx->st);
- stvp = st_make_passthrough_vertex_shader(ctx->st, GL_TRUE);
+ stfp = make_fragment_shader_z(st);
+ stvp = st_make_passthrough_vertex_shader(st, GL_TRUE);
color = ctx->Current.RasterColor;
}
else {
ps = st->state.framebuffer.cbufs[0];
stfp = combined_drawpix_fragment_program(ctx);
- stvp = st_make_passthrough_vertex_shader(ctx->st, GL_FALSE);
+ stvp = st_make_passthrough_vertex_shader(st, GL_FALSE);
color = NULL;
}
/* draw with textured quad */
{
struct pipe_texture *pt
- = make_texture(ctx->st, width, height, format, type, unpack, pixels);
+ = make_texture(st, width, height, format, type, unpack, pixels);
if (pt) {
draw_textured_quad(ctx, x, y, ctx->Current.RasterPos[2],
width, height, ctx->Pixel.ZoomX, ctx->Pixel.ZoomY,
GLsizei width, GLsizei height,
GLint dstx, GLint dsty, GLenum type)
{
- struct st_context *st = ctx->st;
+ struct st_context *st = st_context(ctx);
struct pipe_context *pipe = st->pipe;
struct pipe_screen *screen = pipe->screen;
struct st_renderbuffer *rbRead;
rbRead = st_get_color_read_renderbuffer(ctx);
color = NULL;
stfp = combined_drawpix_fragment_program(ctx);
- stvp = st_make_passthrough_vertex_shader(ctx->st, GL_FALSE);
+ stvp = st_make_passthrough_vertex_shader(st, GL_FALSE);
}
else {
assert(type == GL_DEPTH);
rbRead = st_renderbuffer(ctx->ReadBuffer->_DepthBuffer);
color = ctx->Current.Attrib[VERT_ATTRIB_COLOR0];
- stfp = make_fragment_shader_z(ctx->st);
- stvp = st_make_passthrough_vertex_shader(ctx->st, GL_TRUE);
+ stfp = make_fragment_shader_z(st);
+ stvp = st_make_passthrough_vertex_shader(st, GL_TRUE);
}
srcFormat = rbRead->texture->format;
assert(pth <= maxSize);
}
- pt = st_texture_create(ctx->st, PIPE_TEXTURE_2D, texFormat, 0,
+ pt = st_texture_create(st, PIPE_TEXTURE_2D, texFormat, 0,
ptw, pth, 1,
PIPE_TEXTURE_USAGE_SAMPLER);
if (!pt)
return TGSI_SAT_NONE;
case SATURATE_ZERO_ONE:
return TGSI_SAT_ZERO_ONE;
- case SATURATE_PLUS_MINUS_ONE:
- return TGSI_SAT_MINUS_PLUS_ONE;
default:
assert( 0 );
return TGSI_SAT_NONE;
return passed;
}
+/* Apply ARB_depth_clamp to span of fragments. */
+void
+_swrast_depth_clamp_span( GLcontext *ctx, SWspan *span )
+{
+ struct gl_framebuffer *fb = ctx->DrawBuffer;
+ struct gl_renderbuffer *rb = fb->_DepthBuffer;
+ const GLuint count = span->end;
+ GLuint *zValues = span->array->z;
+ GLuint near, far;
+ int i;
+
+ if (rb->DataType == GL_UNSIGNED_SHORT) {
+ near = FLOAT_TO_UINT(ctx->Viewport.Near);
+ far = FLOAT_TO_UINT(ctx->Viewport.Far);
+ } else {
+ assert(rb->DataType == GL_UNSIGNED_INT);
+ CLAMPED_FLOAT_TO_USHORT(near, ctx->Viewport.Near);
+ CLAMPED_FLOAT_TO_USHORT(far, ctx->Viewport.Far);
+ }
+ for (i = 0; i < count; i++) {
+ if (zValues[i] < near)
+ zValues[i] = near;
+ if (zValues[i] > far)
+ zValues[i] = far;
+ }
+}
+
/*
extern GLuint
_swrast_depth_test_span( GLcontext *ctx, SWspan *span);
+extern void
+_swrast_depth_clamp_span( GLcontext *ctx, SWspan *span );
extern GLboolean
_swrast_depth_bounds_test( GLcontext *ctx, SWspan *span );
stipple_polygon_span(ctx, span);
}
+ if (ctx->Transform.DepthClamp)
+ _swrast_depth_clamp_span(ctx, span);
+
/* Stencil and Z testing */
if (ctx->Stencil._Enabled || ctx->Depth.Test) {
if (!(span->arrayMask & SPAN_Z))
#define MAX_TYPES TYPE_IDX(GL_DOUBLE)+1 /* 0xa + 1 */
+extern void
+tnl_clip_prepare(GLcontext *ctx);
+
+
#endif
ptr = ADD_POINTERS(ib->obj->Pointer, ib->ptr);
- if (ib->type == GL_UNSIGNED_INT) {
+ if (ib->type == GL_UNSIGNED_INT && VB->Primitive[0].basevertex == 0) {
VB->Elts = (GLuint *) ptr;
}
else {
GLuint *elts = (GLuint *)get_space(ctx, ib->count * sizeof(GLuint));
VB->Elts = elts;
- if (ib->type == GL_UNSIGNED_SHORT) {
+ if (ib->type == GL_UNSIGNED_INT) {
+ const GLuint *in = (GLuint *)ptr;
+ for (i = 0; i < ib->count; i++)
+ *elts++ = (GLuint)(*in++) + VB->Primitive[0].basevertex;
+ }
+ else if (ib->type == GL_UNSIGNED_SHORT) {
const GLushort *in = (GLushort *)ptr;
for (i = 0; i < ib->count; i++)
- *elts++ = (GLuint)(*in++);
+ *elts++ = (GLuint)(*in++) + VB->Primitive[0].basevertex;
}
else {
const GLubyte *in = (GLubyte *)ptr;
for (i = 0; i < ib->count; i++)
- *elts++ = (GLuint)(*in++);
+ *elts++ = (GLuint)(*in++) + VB->Primitive[0].basevertex;
}
}
}
TNLcontext *tnl = TNL_CONTEXT(ctx);
const GLuint TEST_SPLIT = 0;
const GLint max = TEST_SPLIT ? 8 : tnl->vb.Size - MAX_CLIPPED_VERTICES;
+ GLuint max_basevertex = prim->basevertex;
+ GLuint i;
+
+ for (i = 1; i < nr_prims; i++)
+ max_basevertex = MAX2(max_basevertex, prim[i].basevertex);
if (0)
{
- GLuint i;
_mesa_printf("%s %d..%d\n", __FUNCTION__, min_index, max_index);
for (i = 0; i < nr_prims; i++)
_mesa_printf("prim %d: %s start %d count %d\n", i,
_tnl_vbo_draw_prims );
return;
}
- else if (max_index > max) {
+ else if (max_index + max_basevertex > max) {
/* The software TNL pipeline has a fixed amount of storage for
* vertices and it is necessary to split incoming drawing commands
* if they exceed that limit.
* recursively call back into this function.
*/
vbo_split_prims( ctx, arrays, prim, nr_prims, ib,
- 0, max_index,
+ 0, max_index + prim->basevertex,
_tnl_vbo_draw_prims,
&limits );
}
struct gl_buffer_object *bo[VERT_ATTRIB_MAX + 1];
GLuint nr_bo = 0;
- /* Binding inputs may imply mapping some vertex buffer objects.
- * They will need to be unmapped below.
- */
- bind_inputs(ctx, arrays, max_index+1, bo, &nr_bo);
- bind_indices(ctx, ib, bo, &nr_bo);
- bind_prims(ctx, prim, nr_prims );
+ for (i = 0; i < nr_prims;) {
+ GLuint this_nr_prims;
+
+ /* Our SW TNL pipeline doesn't handle basevertex yet, so bind_indices
+ * will rebase the elements to the basevertex, and we'll only
+ * emit strings of prims with the same basevertex in one draw call.
+ */
+ for (this_nr_prims = 1; i + this_nr_prims < nr_prims;
+ this_nr_prims++) {
+ if (prim[i].basevertex != prim[i + this_nr_prims].basevertex)
+ break;
+ }
+
+ /* Binding inputs may imply mapping some vertex buffer objects.
+ * They will need to be unmapped below.
+ */
+ bind_prims(ctx, &prim[i], this_nr_prims);
+ bind_inputs(ctx, arrays, max_index + prim[i].basevertex + 1,
+ bo, &nr_bo);
+ bind_indices(ctx, ib, bo, &nr_bo);
- TNL_CONTEXT(ctx)->Driver.RunPipeline(ctx);
+ TNL_CONTEXT(ctx)->Driver.RunPipeline(ctx);
- unmap_vbos(ctx, bo, nr_bo);
- free_space(ctx);
+ unmap_vbos(ctx, bo, nr_bo);
+ free_space(ctx);
+
+ i += this_nr_prims;
+ }
}
}
* \return zero if outside view volume, or one if inside.
*/
static GLuint
-viewclip_point( const GLfloat v[] )
+viewclip_point_xy( const GLfloat v[] )
{
if ( v[0] > v[3] || v[0] < -v[3]
- || v[1] > v[3] || v[1] < -v[3]
- || v[2] > v[3] || v[2] < -v[3] ) {
+ || v[1] > v[3] || v[1] < -v[3] ) {
return 0;
}
else {
/* apply projection matrix: clip = Proj * eye */
TRANSFORM_POINT( clip, ctx->ProjectionMatrixStack.Top->m, eye );
- /* clip to view volume */
- if (ctx->Transform.RasterPositionUnclipped) {
- /* GL_IBM_rasterpos_clip: only clip against Z */
+ /* clip to view volume. */
+ if (!ctx->Transform.DepthClamp) {
if (viewclip_point_z(clip) == 0) {
ctx->Current.RasterPosValid = GL_FALSE;
return;
}
}
- else if (viewclip_point(clip) == 0) {
- /* Normal OpenGL behaviour */
- ctx->Current.RasterPosValid = GL_FALSE;
- return;
+ if (!ctx->Transform.RasterPositionUnclipped) {
+ if (viewclip_point_xy(clip) == 0) {
+ ctx->Current.RasterPosValid = GL_FALSE;
+ return;
+ }
}
/* clip to user clipping planes */
/ ctx->DrawBuffer->_DepthMaxF;
ctx->Current.RasterPos[3] = clip[3];
+ if (ctx->Transform.DepthClamp) {
+ ctx->Current.RasterPos[3] = CLAMP(ctx->Current.RasterPos[3],
+ ctx->Viewport.Near,
+ ctx->Viewport.Far);
+ }
+
/* compute raster distance */
if (ctx->Fog.FogCoordinateSource == GL_FOG_COORDINATE_EXT)
ctx->Current.RasterDistance = ctx->Current.Attrib[VERT_ATTRIB_FOG][0];
store->ormask = 0;
store->andmask = CLIP_FRUSTUM_BITS;
+ tnl_clip_prepare(ctx);
+
if (tnl->NeedNdcCoords) {
VB->NdcPtr =
_mesa_clip_tab[VB->ClipPtr->size]( VB->ClipPtr,
&store->ndcCoords,
store->clipmask,
&store->ormask,
- &store->andmask );
+ &store->andmask,
+ !ctx->Transform.DepthClamp );
}
else {
VB->NdcPtr = NULL;
NULL,
store->clipmask,
&store->ormask,
- &store->andmask );
+ &store->andmask,
+ !ctx->Transform.DepthClamp );
}
if (store->andmask) {
};
+void
+tnl_clip_prepare(GLcontext *ctx)
+{
+ /* Neither the x86 nor sparc asm cliptest functions have been updated
+ * for ARB_depth_clamp, so force the C paths.
+ */
+ if (ctx->Transform.DepthClamp) {
+ static GLboolean c_funcs_installed = GL_FALSE;
+ if (!c_funcs_installed) {
+ init_c_cliptest();
+ c_funcs_installed = GL_TRUE;
+ }
+ }
+}
+
+
static GLboolean run_vertex_stage( GLcontext *ctx,
struct tnl_pipeline_stage *stage )
if (ctx->VertexProgram._Current)
return GL_TRUE;
+ tnl_clip_prepare(ctx);
+
if (ctx->_NeedEyeCoords) {
/* Separate modelview transformation:
* Use combined ModelProject to avoid some depth artifacts
&store->proj,
store->clipmask,
&store->ormask,
- &store->andmask );
+ &store->andmask,
+ !ctx->Transform.DepthClamp );
}
else {
VB->NdcPtr = NULL;
NULL,
store->clipmask,
&store->ormask,
- &store->andmask );
+ &store->andmask,
+ !ctx->Transform.DepthClamp );
}
if (store->andmask)
GLuint start;
GLuint count;
+ GLint basevertex;
};
/* Would like to call this a "vbo_index_buffer", but this would be
*/
static void
check_draw_elements_data(GLcontext *ctx, GLsizei count, GLenum elemType,
- const void *elements)
+ const void *elements, GLint basevertex)
{
struct gl_array_object *arrayObj = ctx->Array.ArrayObj;
const void *elemMap;
prim[0].start = start;
prim[0].count = count;
prim[0].indexed = 0;
+ prim[0].basevertex = 0;
vbo->draw_prims( ctx, exec->array.inputs, prim, 1, NULL,
GL_TRUE, start, start + count - 1 );
GLboolean index_bounds_valid,
GLuint start, GLuint end,
GLsizei count, GLenum type,
- const GLvoid *indices)
+ const GLvoid *indices,
+ GLint basevertex)
{
struct vbo_context *vbo = vbo_context(ctx);
struct vbo_exec_context *exec = &vbo->exec;
prim[0].start = 0;
prim[0].count = count;
prim[0].indexed = 1;
+ prim[0].basevertex = basevertex;
/* Need to give special consideration to rendering a range of
* indices starting somewhere above zero. Typically the
}
static void GLAPIENTRY
-vbo_exec_DrawRangeElements(GLenum mode,
- GLuint start, GLuint end,
- GLsizei count, GLenum type, const GLvoid *indices)
+vbo_exec_DrawRangeElementsBaseVertex(GLenum mode,
+ GLuint start, GLuint end,
+ GLsizei count, GLenum type,
+ const GLvoid *indices,
+ GLint basevertex)
{
GET_CURRENT_CONTEXT(ctx);
if (!_mesa_validate_DrawRangeElements( ctx, mode, start, end, count,
- type, indices ))
+ type, indices, basevertex ))
return;
if (end >= ctx->Array.ArrayObj->_MaxElement) {
/* the max element is out of bounds of one or more enabled arrays */
- _mesa_warning(ctx, "glDraw[Range]Elements(start %u, end %u, count %d, "
- "type 0x%x, indices=%p)\n"
+ _mesa_warning(ctx, "glDraw[Range]Elements{,BaseVertex}(start %u, end %u, "
+ "count %d, type 0x%x, indices=%p, base=%d)\n"
"\tindex=%u is out of bounds (max=%u) "
"Element Buffer %u (size %d)",
- start, end, count, type, indices, end,
+ start, end, count, type, indices, end, basevertex,
ctx->Array.ArrayObj->_MaxElement - 1,
ctx->Array.ElementArrayBufferObj->Name,
ctx->Array.ElementArrayBufferObj->Size);
return;
}
else if (0) {
- _mesa_printf("glDraw[Range]Elements"
- "(start %u, end %u, type 0x%x, count %d) ElemBuf %u\n",
+ _mesa_printf("glDraw[Range]Elements{,BaseVertex}"
+ "(start %u, end %u, type 0x%x, count %d) ElemBuf %u, "
+ "base %d\n",
start, end, type, count,
- ctx->Array.ElementArrayBufferObj->Name);
+ ctx->Array.ElementArrayBufferObj->Name,
+ basevertex);
}
#if 0
#endif
vbo_validated_drawrangeelements(ctx, mode, GL_TRUE, start, end,
- count, type, indices);
+ count, type, indices, basevertex);
+}
+
+static void GLAPIENTRY
+vbo_exec_DrawRangeElements(GLenum mode,
+ GLuint start, GLuint end,
+ GLsizei count, GLenum type,
+ const GLvoid *indices)
+{
+ vbo_exec_DrawRangeElementsBaseVertex(mode, start, end, count, type,
+ indices, 0);
}
{
GET_CURRENT_CONTEXT(ctx);
- if (!_mesa_validate_DrawElements( ctx, mode, count, type, indices ))
+ if (!_mesa_validate_DrawElements( ctx, mode, count, type, indices, 0 ))
+ return;
+
+ vbo_validated_drawrangeelements(ctx, mode, GL_FALSE, ~0, ~0,
+ count, type, indices, 0);
+}
+
+static void GLAPIENTRY
+vbo_exec_DrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type,
+ const GLvoid *indices, GLint basevertex)
+{
+ GET_CURRENT_CONTEXT(ctx);
+
+ if (!_mesa_validate_DrawElements( ctx, mode, count, type, indices,
+ basevertex ))
return;
vbo_validated_drawrangeelements(ctx, mode, GL_FALSE, ~0, ~0,
- count, type, indices);
+ count, type, indices, basevertex);
}
/* Inner support for both _mesa_DrawElements and _mesa_DrawRangeElements */
static void
vbo_validated_multidrawelements(GLcontext *ctx, GLenum mode,
const GLsizei *count, GLenum type,
- const GLvoid **indices, GLsizei primcount)
+ const GLvoid **indices, GLsizei primcount,
+ const GLint *basevertex)
{
struct vbo_context *vbo = vbo_context(ctx);
struct vbo_exec_context *exec = &vbo->exec;
prim[i].start = ((uintptr_t)indices[i] - min_index_ptr) / index_type_size;
prim[i].count = count[i];
prim[i].indexed = 1;
+ if (basevertex != NULL)
+ prim[i].basevertex = basevertex[i];
+ else
+ prim[i].basevertex = 0;
}
vbo->draw_prims(ctx, exec->array.inputs, prim, primcount, &ib,
prim[0].start = 0;
prim[0].count = count[i];
prim[0].indexed = 1;
+ if (basevertex != NULL)
+ prim[0].basevertex = basevertex[i];
+ else
+ prim[0].basevertex = 0;
}
vbo->draw_prims(ctx, exec->array.inputs, prim, 1, &ib,
ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
for (i = 0; i < primcount; i++) {
- if (!_mesa_validate_DrawElements( ctx, mode, count[i], type, indices[i] ))
+ if (!_mesa_validate_DrawElements(ctx, mode, count[i], type, indices[i],
+ 0))
return;
}
- vbo_validated_multidrawelements(ctx, mode, count, type, indices, primcount);
+ vbo_validated_multidrawelements(ctx, mode, count, type, indices, primcount,
+ NULL);
}
+static void GLAPIENTRY
+vbo_exec_MultiDrawElementsBaseVertex(GLenum mode,
+ const GLsizei *count, GLenum type,
+ const GLvoid **indices,
+ GLsizei primcount,
+ const GLsizei *basevertex)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ GLint i;
+
+ ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
+
+ for (i = 0; i < primcount; i++) {
+ if (!_mesa_validate_DrawElements(ctx, mode, count[i], type, indices[i],
+ basevertex[i]))
+ return;
+ }
+
+ vbo_validated_multidrawelements(ctx, mode, count, type, indices, primcount,
+ basevertex);
+}
/***********************************************************************
exec->vtxfmt.DrawElements = vbo_exec_DrawElements;
exec->vtxfmt.DrawRangeElements = vbo_exec_DrawRangeElements;
exec->vtxfmt.MultiDrawElementsEXT = vbo_exec_MultiDrawElements;
+ exec->vtxfmt.DrawElementsBaseVertex = vbo_exec_DrawElementsBaseVertex;
+ exec->vtxfmt.DrawRangeElementsBaseVertex = vbo_exec_DrawRangeElementsBaseVertex;
+ exec->vtxfmt.MultiDrawElementsBaseVertex = vbo_exec_MultiDrawElementsBaseVertex;
#else
exec->vtxfmt.DrawArrays = _mesa_noop_DrawArrays;
exec->vtxfmt.DrawElements = _mesa_noop_DrawElements;
exec->vtxfmt.DrawRangeElements = _mesa_noop_DrawRangeElements;
exec->vtxfmt.MultiDrawElementsEXT = _mesa_noop_MultiDrawElements;
+ exec->vtxfmt.DrawElementsBaseVertex = _mesa_noop_DrawElementsBaseVertex;
+ exec->vtxfmt.DrawRangeElementsBaseVertex = _mesa_noop_DrawRangeElementsBaseVertex;
+ exec->vtxfmt.MultiDrawElementsBaseVertex = _mesa_noop_MultiDrawElementsBaseVertex;
#endif
}
vbo_exec_DrawElements(mode, count, type, indices);
}
+void GLAPIENTRY
+_mesa_DrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type,
+ const GLvoid *indices, GLint basevertex)
+{
+ vbo_exec_DrawElementsBaseVertex(mode, count, type, indices, basevertex);
+}
+
/* This API entrypoint is not ordinarily used */
void GLAPIENTRY
vbo_exec_DrawRangeElements(mode, start, end, count, type, indices);
}
+void GLAPIENTRY
+_mesa_DrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end,
+ GLsizei count, GLenum type,
+ const GLvoid *indices, GLint basevertex)
+{
+ vbo_exec_DrawRangeElementsBaseVertex(mode, start, end, count, type,
+ indices, basevertex);
+}
+
/* GL_EXT_multi_draw_arrays */
void GLAPIENTRY
_mesa_MultiDrawElementsEXT(GLenum mode, const GLsizei *count, GLenum type,
{
vbo_exec_MultiDrawElements(mode, count, type, indices, primcount);
}
+
+void GLAPIENTRY
+_mesa_MultiDrawElementsBaseVertex(GLenum mode,
+ const GLsizei *count, GLenum type,
+ const GLvoid **indices, GLsizei primcount,
+ const GLint *basevertex)
+{
+ vbo_exec_MultiDrawElementsBaseVertex(mode, count, type, indices,
+ primcount, basevertex);
+}
if (0)
_mesa_printf("%s %d..%d\n", __FUNCTION__, min_index, max_index);
- if (ib) {
+
+ if (ib && ctx->Extensions.ARB_draw_elements_base_vertex) {
+ /* If we can just tell the hardware or the TNL to interpret our
+ * indices with a different base, do so.
+ */
+ tmp_prims = (struct _mesa_prim *)_mesa_malloc(sizeof(*prim) * nr_prims);
+
+ for (i = 0; i < nr_prims; i++) {
+ tmp_prims[i] = prim[i];
+ tmp_prims[i].basevertex -= min_index;
+ }
+
+ prim = tmp_prims;
+ } else if (ib) {
/* Unfortunately need to adjust each index individually.
*/
GLboolean map_ib = ib->obj->Name && !ib->obj->Pointer;
_mesa_compile_error( ctx, GL_INVALID_OPERATION, "glDrawRangeElements" );
}
+static void GLAPIENTRY _save_DrawElementsBaseVertex(GLenum mode,
+ GLsizei count,
+ GLenum type,
+ const GLvoid *indices,
+ GLint basevertex)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ (void) mode; (void) count; (void) type; (void) indices; (void)basevertex;
+
+ _mesa_compile_error( ctx, GL_INVALID_OPERATION, "glDrawElements" );
+}
+
+static void GLAPIENTRY _save_DrawRangeElementsBaseVertex(GLenum mode,
+ GLuint start,
+ GLuint end,
+ GLsizei count,
+ GLenum type,
+ const GLvoid *indices,
+ GLint basevertex)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ (void) mode; (void) start; (void) end; (void) count; (void) type;
+ (void) indices; (void)basevertex;
+
+ _mesa_compile_error( ctx, GL_INVALID_OPERATION, "glDrawRangeElements" );
+}
+
static void GLAPIENTRY _save_DrawArrays(GLenum mode, GLint start, GLsizei count)
{
GET_CURRENT_CONTEXT(ctx);
GET_CURRENT_CONTEXT(ctx);
GLint i;
- if (!_mesa_validate_DrawElements( ctx, mode, count, type, indices ))
+ if (!_mesa_validate_DrawElements( ctx, mode, count, type, indices, 0 ))
return;
_ae_map_vbos( ctx );
GET_CURRENT_CONTEXT(ctx);
if (_mesa_validate_DrawRangeElements( ctx, mode,
start, end,
- count, type, indices ))
+ count, type, indices, 0 ))
_save_OBE_DrawElements( mode, count, type, indices );
}
vfmt->DrawArrays = _save_DrawArrays;
vfmt->DrawElements = _save_DrawElements;
vfmt->DrawRangeElements = _save_DrawRangeElements;
+ vfmt->DrawElementsBaseVertex = _save_DrawElementsBaseVertex;
+ vfmt->DrawRangeElementsBaseVertex = _save_DrawRangeElementsBaseVertex;
/* Loops back into vfmt->DrawElements */
vfmt->MultiDrawElementsEXT = _mesa_noop_MultiDrawElements;
-
+ vfmt->MultiDrawElementsBaseVertex = _mesa_noop_MultiDrawElementsBaseVertex;
}
ctx->ListState.ListVtxfmt.DrawRangeElements = _save_OBE_DrawRangeElements;
/* loops back into _save_OBE_DrawElements */
ctx->ListState.ListVtxfmt.MultiDrawElementsEXT = _mesa_noop_MultiDrawElements;
+ ctx->ListState.ListVtxfmt.MultiDrawElementsBaseVertex = _mesa_noop_MultiDrawElementsBaseVertex;
_mesa_install_save_vtxfmt( ctx, &ctx->ListState.ListVtxfmt );
}
#include "main/glheader.h"
#include "main/imports.h"
#include "main/mtypes.h"
+#include "main/macros.h"
#include "vbo_split.h"
#include "vbo.h"
vbo_draw_func draw,
const struct split_limits *limits )
{
-
+ GLuint max_basevertex = prim->basevertex;
+ GLuint i;
+
+ for (i = 1; i < nr_prims; i++)
+ max_basevertex = MAX2(max_basevertex, prim[i].basevertex);
+
if (ib) {
if (limits->max_indices == 0) {
/* Could traverse the indices, re-emitting vertices in turn.
const struct split_limits *limits )
{
struct copy_context copy;
- GLuint i;
+ GLuint i, this_nr_prims;
+
+ for (i = 0; i < nr_prims;) {
+ /* Our SW TNL pipeline doesn't handle basevertex yet, so bind_indices
+ * will rebase the elements to the basevertex, and we'll only
+ * emit strings of prims with the same basevertex in one draw call.
+ */
+ for (this_nr_prims = 1; i + this_nr_prims < nr_prims;
+ this_nr_prims++) {
+ if (prim[i].basevertex != prim[i + this_nr_prims].basevertex)
+ break;
+ }
- memset(©, 0, sizeof(copy));
+ memset(©, 0, sizeof(copy));
- /* Require indexed primitives:
- */
- assert(ib);
-
- copy.ctx = ctx;
- copy.array = arrays;
- copy.prim = prim;
- copy.nr_prims = nr_prims;
- copy.ib = ib;
- copy.draw = draw;
- copy.limits = limits;
+ /* Require indexed primitives:
+ */
+ assert(ib);
- /* Clear the vertex cache:
- */
- for (i = 0; i < ELT_TABLE_SIZE; i++)
- copy.vert_cache[i].in = ~0;
+ copy.ctx = ctx;
+ copy.array = arrays;
+ copy.prim = &prim[i];
+ copy.nr_prims = this_nr_prims;
+ copy.ib = ib;
+ copy.draw = draw;
+ copy.limits = limits;
- replay_init(©);
- replay_elts(©);
- replay_finish(©);
+ /* Clear the vertex cache:
+ */
+ for (i = 0; i < ELT_TABLE_SIZE; i++)
+ copy.vert_cache[i].in = ~0;
+
+ replay_init(©);
+ replay_elts(©);
+ replay_finish(©);
+ }
}
.size GL_PREFIX(WaitSync), .-GL_PREFIX(WaitSync)
.p2align 4,,15
- .globl GL_PREFIX(PolygonOffsetEXT)
- .type GL_PREFIX(PolygonOffsetEXT), @function
-GL_PREFIX(PolygonOffsetEXT):
+ .globl GL_PREFIX(DrawElementsBaseVertex)
+ .type GL_PREFIX(DrawElementsBaseVertex), @function
+GL_PREFIX(DrawElementsBaseVertex):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
movq 4592(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
- subq $24, %rsp
- movq %xmm0, (%rsp)
- movq %xmm1, 8(%rsp)
+ pushq %rdi
+ pushq %rsi
+ pushq %rdx
+ pushq %rcx
+ pushq %r8
call _x86_64_get_dispatch@PLT
- movq 8(%rsp), %xmm1
- movq (%rsp), %xmm0
- addq $24, %rsp
+ popq %r8
+ popq %rcx
+ popq %rdx
+ popq %rsi
+ popq %rdi
movq 4592(%rax), %r11
jmp *%r11
#else
movq 4592(%rax), %r11
jmp *%r11
1:
- subq $24, %rsp
- movq %xmm0, (%rsp)
- movq %xmm1, 8(%rsp)
+ pushq %rdi
+ pushq %rsi
+ pushq %rdx
+ pushq %rcx
+ pushq %r8
call _glapi_get_dispatch
- movq 8(%rsp), %xmm1
- movq (%rsp), %xmm0
- addq $24, %rsp
+ popq %r8
+ popq %rcx
+ popq %rdx
+ popq %rsi
+ popq %rdi
movq 4592(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
- .size GL_PREFIX(PolygonOffsetEXT), .-GL_PREFIX(PolygonOffsetEXT)
+ .size GL_PREFIX(DrawElementsBaseVertex), .-GL_PREFIX(DrawElementsBaseVertex)
.p2align 4,,15
- .globl GL_PREFIX(_dispatch_stub_575)
- .type GL_PREFIX(_dispatch_stub_575), @function
- HIDDEN(GL_PREFIX(_dispatch_stub_575))
-GL_PREFIX(_dispatch_stub_575):
+ .globl GL_PREFIX(DrawRangeElementsBaseVertex)
+ .type GL_PREFIX(DrawRangeElementsBaseVertex), @function
+GL_PREFIX(DrawRangeElementsBaseVertex):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
movq 4600(%rax), %r11
#elif defined(PTHREADS)
pushq %rdi
pushq %rsi
+ pushq %rdx
+ pushq %rcx
+ pushq %r8
+ pushq %r9
pushq %rbp
call _x86_64_get_dispatch@PLT
popq %rbp
+ popq %r9
+ popq %r8
+ popq %rcx
+ popq %rdx
popq %rsi
popq %rdi
movq 4600(%rax), %r11
1:
pushq %rdi
pushq %rsi
+ pushq %rdx
+ pushq %rcx
+ pushq %r8
+ pushq %r9
pushq %rbp
call _glapi_get_dispatch
popq %rbp
+ popq %r9
+ popq %r8
+ popq %rcx
+ popq %rdx
popq %rsi
popq %rdi
movq 4600(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
- .size GL_PREFIX(_dispatch_stub_575), .-GL_PREFIX(_dispatch_stub_575)
+ .size GL_PREFIX(DrawRangeElementsBaseVertex), .-GL_PREFIX(DrawRangeElementsBaseVertex)
.p2align 4,,15
- .globl GL_PREFIX(_dispatch_stub_576)
- .type GL_PREFIX(_dispatch_stub_576), @function
- HIDDEN(GL_PREFIX(_dispatch_stub_576))
-GL_PREFIX(_dispatch_stub_576):
+ .globl GL_PREFIX(MultiDrawElementsBaseVertex)
+ .type GL_PREFIX(MultiDrawElementsBaseVertex), @function
+GL_PREFIX(MultiDrawElementsBaseVertex):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
movq 4608(%rax), %r11
#elif defined(PTHREADS)
pushq %rdi
pushq %rsi
+ pushq %rdx
+ pushq %rcx
+ pushq %r8
+ pushq %r9
pushq %rbp
call _x86_64_get_dispatch@PLT
popq %rbp
+ popq %r9
+ popq %r8
+ popq %rcx
+ popq %rdx
popq %rsi
popq %rdi
movq 4608(%rax), %r11
1:
pushq %rdi
pushq %rsi
+ pushq %rdx
+ pushq %rcx
+ pushq %r8
+ pushq %r9
pushq %rbp
call _glapi_get_dispatch
popq %rbp
+ popq %r9
+ popq %r8
+ popq %rcx
+ popq %rdx
popq %rsi
popq %rdi
movq 4608(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
- .size GL_PREFIX(_dispatch_stub_576), .-GL_PREFIX(_dispatch_stub_576)
+ .size GL_PREFIX(MultiDrawElementsBaseVertex), .-GL_PREFIX(MultiDrawElementsBaseVertex)
.p2align 4,,15
- .globl GL_PREFIX(_dispatch_stub_577)
- .type GL_PREFIX(_dispatch_stub_577), @function
- HIDDEN(GL_PREFIX(_dispatch_stub_577))
-GL_PREFIX(_dispatch_stub_577):
+ .globl GL_PREFIX(PolygonOffsetEXT)
+ .type GL_PREFIX(PolygonOffsetEXT), @function
+GL_PREFIX(PolygonOffsetEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
movq 4616(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
subq $24, %rsp
- movq %rdi, (%rsp)
- movq %xmm0, 8(%rsp)
+ movq %xmm0, (%rsp)
+ movq %xmm1, 8(%rsp)
call _x86_64_get_dispatch@PLT
- movq 8(%rsp), %xmm0
- movq (%rsp), %rdi
+ movq 8(%rsp), %xmm1
+ movq (%rsp), %xmm0
addq $24, %rsp
movq 4616(%rax), %r11
jmp *%r11
jmp *%r11
1:
subq $24, %rsp
- movq %rdi, (%rsp)
- movq %xmm0, 8(%rsp)
+ movq %xmm0, (%rsp)
+ movq %xmm1, 8(%rsp)
call _glapi_get_dispatch
- movq 8(%rsp), %xmm0
- movq (%rsp), %rdi
+ movq 8(%rsp), %xmm1
+ movq (%rsp), %xmm0
addq $24, %rsp
movq 4616(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
- .size GL_PREFIX(_dispatch_stub_577), .-GL_PREFIX(_dispatch_stub_577)
+ .size GL_PREFIX(PolygonOffsetEXT), .-GL_PREFIX(PolygonOffsetEXT)
.p2align 4,,15
.globl GL_PREFIX(_dispatch_stub_578)
movq 4640(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
- pushq %rdi
- pushq %rsi
- pushq %rbp
+ subq $24, %rsp
+ movq %rdi, (%rsp)
+ movq %xmm0, 8(%rsp)
call _x86_64_get_dispatch@PLT
- popq %rbp
- popq %rsi
- popq %rdi
+ movq 8(%rsp), %xmm0
+ movq (%rsp), %rdi
+ addq $24, %rsp
movq 4640(%rax), %r11
jmp *%r11
#else
movq 4640(%rax), %r11
jmp *%r11
1:
- pushq %rdi
- pushq %rsi
- pushq %rbp
+ subq $24, %rsp
+ movq %rdi, (%rsp)
+ movq %xmm0, 8(%rsp)
call _glapi_get_dispatch
- popq %rbp
- popq %rsi
- popq %rdi
+ movq 8(%rsp), %xmm0
+ movq (%rsp), %rdi
+ addq $24, %rsp
movq 4640(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
+ pushq %rsi
+ pushq %rbp
call _x86_64_get_dispatch@PLT
+ popq %rbp
+ popq %rsi
popq %rdi
movq 4656(%rax), %r11
jmp *%r11
jmp *%r11
1:
pushq %rdi
+ pushq %rsi
+ pushq %rbp
call _glapi_get_dispatch
+ popq %rbp
+ popq %rsi
popq %rdi
movq 4656(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(_dispatch_stub_582), .-GL_PREFIX(_dispatch_stub_582)
+ .p2align 4,,15
+ .globl GL_PREFIX(_dispatch_stub_583)
+ .type GL_PREFIX(_dispatch_stub_583), @function
+ HIDDEN(GL_PREFIX(_dispatch_stub_583))
+GL_PREFIX(_dispatch_stub_583):
+#if defined(GLX_USE_TLS)
+ call _x86_64_get_dispatch@PLT
+ movq 4664(%rax), %r11
+ jmp *%r11
+#elif defined(PTHREADS)
+ pushq %rdi
+ pushq %rsi
+ pushq %rbp
+ call _x86_64_get_dispatch@PLT
+ popq %rbp
+ popq %rsi
+ popq %rdi
+ movq 4664(%rax), %r11
+ jmp *%r11
+#else
+ movq _glapi_Dispatch(%rip), %rax
+ testq %rax, %rax
+ je 1f
+ movq 4664(%rax), %r11
+ jmp *%r11
+1:
+ pushq %rdi
+ pushq %rsi
+ pushq %rbp
+ call _glapi_get_dispatch
+ popq %rbp
+ popq %rsi
+ popq %rdi
+ movq 4664(%rax), %r11
+ jmp *%r11
+#endif /* defined(GLX_USE_TLS) */
+ .size GL_PREFIX(_dispatch_stub_583), .-GL_PREFIX(_dispatch_stub_583)
+
+ .p2align 4,,15
+ .globl GL_PREFIX(_dispatch_stub_584)
+ .type GL_PREFIX(_dispatch_stub_584), @function
+ HIDDEN(GL_PREFIX(_dispatch_stub_584))
+GL_PREFIX(_dispatch_stub_584):
+#if defined(GLX_USE_TLS)
+ call _x86_64_get_dispatch@PLT
+ movq 4672(%rax), %r11
+ jmp *%r11
+#elif defined(PTHREADS)
+ pushq %rdi
+ pushq %rsi
+ pushq %rbp
+ call _x86_64_get_dispatch@PLT
+ popq %rbp
+ popq %rsi
+ popq %rdi
+ movq 4672(%rax), %r11
+ jmp *%r11
+#else
+ movq _glapi_Dispatch(%rip), %rax
+ testq %rax, %rax
+ je 1f
+ movq 4672(%rax), %r11
+ jmp *%r11
+1:
+ pushq %rdi
+ pushq %rsi
+ pushq %rbp
+ call _glapi_get_dispatch
+ popq %rbp
+ popq %rsi
+ popq %rdi
+ movq 4672(%rax), %r11
+ jmp *%r11
+#endif /* defined(GLX_USE_TLS) */
+ .size GL_PREFIX(_dispatch_stub_584), .-GL_PREFIX(_dispatch_stub_584)
+
+ .p2align 4,,15
+ .globl GL_PREFIX(_dispatch_stub_585)
+ .type GL_PREFIX(_dispatch_stub_585), @function
+ HIDDEN(GL_PREFIX(_dispatch_stub_585))
+GL_PREFIX(_dispatch_stub_585):
+#if defined(GLX_USE_TLS)
+ call _x86_64_get_dispatch@PLT
+ movq 4680(%rax), %r11
+ jmp *%r11
+#elif defined(PTHREADS)
+ pushq %rdi
+ call _x86_64_get_dispatch@PLT
+ popq %rdi
+ movq 4680(%rax), %r11
+ jmp *%r11
+#else
+ movq _glapi_Dispatch(%rip), %rax
+ testq %rax, %rax
+ je 1f
+ movq 4680(%rax), %r11
+ jmp *%r11
+1:
+ pushq %rdi
+ call _glapi_get_dispatch
+ popq %rdi
+ movq 4680(%rax), %r11
+ jmp *%r11
+#endif /* defined(GLX_USE_TLS) */
+ .size GL_PREFIX(_dispatch_stub_585), .-GL_PREFIX(_dispatch_stub_585)
+
.p2align 4,,15
.globl GL_PREFIX(ColorPointerEXT)
.type GL_PREFIX(ColorPointerEXT), @function
GL_PREFIX(ColorPointerEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 4664(%rax), %r11
+ movq 4688(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 4664(%rax), %r11
+ movq 4688(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 4664(%rax), %r11
+ movq 4688(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 4664(%rax), %r11
+ movq 4688(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(ColorPointerEXT), .-GL_PREFIX(ColorPointerEXT)
GL_PREFIX(EdgeFlagPointerEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 4672(%rax), %r11
+ movq 4696(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 4672(%rax), %r11
+ movq 4696(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 4672(%rax), %r11
+ movq 4696(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 4672(%rax), %r11
+ movq 4696(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(EdgeFlagPointerEXT), .-GL_PREFIX(EdgeFlagPointerEXT)
GL_PREFIX(IndexPointerEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 4680(%rax), %r11
+ movq 4704(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 4680(%rax), %r11
+ movq 4704(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 4680(%rax), %r11
+ movq 4704(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 4680(%rax), %r11
+ movq 4704(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(IndexPointerEXT), .-GL_PREFIX(IndexPointerEXT)
GL_PREFIX(NormalPointerEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 4688(%rax), %r11
+ movq 4712(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 4688(%rax), %r11
+ movq 4712(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 4688(%rax), %r11
+ movq 4712(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 4688(%rax), %r11
+ movq 4712(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(NormalPointerEXT), .-GL_PREFIX(NormalPointerEXT)
GL_PREFIX(TexCoordPointerEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 4696(%rax), %r11
+ movq 4720(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 4696(%rax), %r11
+ movq 4720(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 4696(%rax), %r11
+ movq 4720(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 4696(%rax), %r11
+ movq 4720(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(TexCoordPointerEXT), .-GL_PREFIX(TexCoordPointerEXT)
GL_PREFIX(VertexPointerEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 4704(%rax), %r11
+ movq 4728(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 4704(%rax), %r11
+ movq 4728(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 4704(%rax), %r11
+ movq 4728(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 4704(%rax), %r11
+ movq 4728(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(VertexPointerEXT), .-GL_PREFIX(VertexPointerEXT)
GL_PREFIX(PointParameterfEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 4712(%rax), %r11
+ movq 4736(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
subq $24, %rsp
movq 8(%rsp), %xmm0
movq (%rsp), %rdi
addq $24, %rsp
- movq 4712(%rax), %r11
+ movq 4736(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 4712(%rax), %r11
+ movq 4736(%rax), %r11
jmp *%r11
1:
subq $24, %rsp
movq 8(%rsp), %xmm0
movq (%rsp), %rdi
addq $24, %rsp
- movq 4712(%rax), %r11
+ movq 4736(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(PointParameterfEXT), .-GL_PREFIX(PointParameterfEXT)
GL_PREFIX(PointParameterfvEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 4720(%rax), %r11
+ movq 4744(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 4720(%rax), %r11
+ movq 4744(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 4720(%rax), %r11
+ movq 4744(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 4720(%rax), %r11
+ movq 4744(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(PointParameterfvEXT), .-GL_PREFIX(PointParameterfvEXT)
GL_PREFIX(LockArraysEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 4728(%rax), %r11
+ movq 4752(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 4728(%rax), %r11
+ movq 4752(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 4728(%rax), %r11
+ movq 4752(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 4728(%rax), %r11
+ movq 4752(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(LockArraysEXT), .-GL_PREFIX(LockArraysEXT)
GL_PREFIX(UnlockArraysEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 4736(%rax), %r11
+ movq 4760(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rbp
call _x86_64_get_dispatch@PLT
popq %rbp
- movq 4736(%rax), %r11
+ movq 4760(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 4736(%rax), %r11
+ movq 4760(%rax), %r11
jmp *%r11
1:
pushq %rbp
call _glapi_get_dispatch
popq %rbp
- movq 4736(%rax), %r11
+ movq 4760(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(UnlockArraysEXT), .-GL_PREFIX(UnlockArraysEXT)
.p2align 4,,15
- .globl GL_PREFIX(_dispatch_stub_593)
- .type GL_PREFIX(_dispatch_stub_593), @function
- HIDDEN(GL_PREFIX(_dispatch_stub_593))
-GL_PREFIX(_dispatch_stub_593):
+ .globl GL_PREFIX(_dispatch_stub_596)
+ .type GL_PREFIX(_dispatch_stub_596), @function
+ HIDDEN(GL_PREFIX(_dispatch_stub_596))
+GL_PREFIX(_dispatch_stub_596):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 4744(%rax), %r11
+ movq 4768(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 4744(%rax), %r11
+ movq 4768(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 4744(%rax), %r11
+ movq 4768(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 4744(%rax), %r11
+ movq 4768(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
- .size GL_PREFIX(_dispatch_stub_593), .-GL_PREFIX(_dispatch_stub_593)
+ .size GL_PREFIX(_dispatch_stub_596), .-GL_PREFIX(_dispatch_stub_596)
.p2align 4,,15
- .globl GL_PREFIX(_dispatch_stub_594)
- .type GL_PREFIX(_dispatch_stub_594), @function
- HIDDEN(GL_PREFIX(_dispatch_stub_594))
-GL_PREFIX(_dispatch_stub_594):
+ .globl GL_PREFIX(_dispatch_stub_597)
+ .type GL_PREFIX(_dispatch_stub_597), @function
+ HIDDEN(GL_PREFIX(_dispatch_stub_597))
+GL_PREFIX(_dispatch_stub_597):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 4752(%rax), %r11
+ movq 4776(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 4752(%rax), %r11
+ movq 4776(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 4752(%rax), %r11
+ movq 4776(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 4752(%rax), %r11
+ movq 4776(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
- .size GL_PREFIX(_dispatch_stub_594), .-GL_PREFIX(_dispatch_stub_594)
+ .size GL_PREFIX(_dispatch_stub_597), .-GL_PREFIX(_dispatch_stub_597)
.p2align 4,,15
.globl GL_PREFIX(SecondaryColor3bEXT)
GL_PREFIX(SecondaryColor3bEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 4760(%rax), %r11
+ movq 4784(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 4760(%rax), %r11
+ movq 4784(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 4760(%rax), %r11
+ movq 4784(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 4760(%rax), %r11
+ movq 4784(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(SecondaryColor3bEXT), .-GL_PREFIX(SecondaryColor3bEXT)
GL_PREFIX(SecondaryColor3bvEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 4768(%rax), %r11
+ movq 4792(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
call _x86_64_get_dispatch@PLT
popq %rdi
- movq 4768(%rax), %r11
+ movq 4792(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 4768(%rax), %r11
+ movq 4792(%rax), %r11
jmp *%r11
1:
pushq %rdi
call _glapi_get_dispatch
popq %rdi
- movq 4768(%rax), %r11
+ movq 4792(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(SecondaryColor3bvEXT), .-GL_PREFIX(SecondaryColor3bvEXT)
GL_PREFIX(SecondaryColor3dEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 4776(%rax), %r11
+ movq 4800(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
subq $24, %rsp
movq 8(%rsp), %xmm1
movq (%rsp), %xmm0
addq $24, %rsp
- movq 4776(%rax), %r11
+ movq 4800(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 4776(%rax), %r11
+ movq 4800(%rax), %r11
jmp *%r11
1:
subq $24, %rsp
movq 8(%rsp), %xmm1
movq (%rsp), %xmm0
addq $24, %rsp
- movq 4776(%rax), %r11
+ movq 4800(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(SecondaryColor3dEXT), .-GL_PREFIX(SecondaryColor3dEXT)
GL_PREFIX(SecondaryColor3dvEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 4784(%rax), %r11
+ movq 4808(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
call _x86_64_get_dispatch@PLT
popq %rdi
- movq 4784(%rax), %r11
+ movq 4808(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 4784(%rax), %r11
+ movq 4808(%rax), %r11
jmp *%r11
1:
pushq %rdi
call _glapi_get_dispatch
popq %rdi
- movq 4784(%rax), %r11
+ movq 4808(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(SecondaryColor3dvEXT), .-GL_PREFIX(SecondaryColor3dvEXT)
GL_PREFIX(SecondaryColor3fEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 4792(%rax), %r11
+ movq 4816(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
subq $24, %rsp
movq 8(%rsp), %xmm1
movq (%rsp), %xmm0
addq $24, %rsp
- movq 4792(%rax), %r11
+ movq 4816(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 4792(%rax), %r11
+ movq 4816(%rax), %r11
jmp *%r11
1:
subq $24, %rsp
movq 8(%rsp), %xmm1
movq (%rsp), %xmm0
addq $24, %rsp
- movq 4792(%rax), %r11
+ movq 4816(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(SecondaryColor3fEXT), .-GL_PREFIX(SecondaryColor3fEXT)
GL_PREFIX(SecondaryColor3fvEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 4800(%rax), %r11
+ movq 4824(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
call _x86_64_get_dispatch@PLT
popq %rdi
- movq 4800(%rax), %r11
+ movq 4824(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 4800(%rax), %r11
+ movq 4824(%rax), %r11
jmp *%r11
1:
pushq %rdi
call _glapi_get_dispatch
popq %rdi
- movq 4800(%rax), %r11
+ movq 4824(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(SecondaryColor3fvEXT), .-GL_PREFIX(SecondaryColor3fvEXT)
GL_PREFIX(SecondaryColor3iEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 4808(%rax), %r11
+ movq 4832(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 4808(%rax), %r11
+ movq 4832(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 4808(%rax), %r11
+ movq 4832(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 4808(%rax), %r11
+ movq 4832(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(SecondaryColor3iEXT), .-GL_PREFIX(SecondaryColor3iEXT)
GL_PREFIX(SecondaryColor3ivEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 4816(%rax), %r11
+ movq 4840(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
call _x86_64_get_dispatch@PLT
popq %rdi
- movq 4816(%rax), %r11
+ movq 4840(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 4816(%rax), %r11
+ movq 4840(%rax), %r11
jmp *%r11
1:
pushq %rdi
call _glapi_get_dispatch
popq %rdi
- movq 4816(%rax), %r11
+ movq 4840(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(SecondaryColor3ivEXT), .-GL_PREFIX(SecondaryColor3ivEXT)
GL_PREFIX(SecondaryColor3sEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 4824(%rax), %r11
+ movq 4848(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 4824(%rax), %r11
+ movq 4848(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 4824(%rax), %r11
+ movq 4848(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 4824(%rax), %r11
+ movq 4848(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(SecondaryColor3sEXT), .-GL_PREFIX(SecondaryColor3sEXT)
GL_PREFIX(SecondaryColor3svEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 4832(%rax), %r11
+ movq 4856(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
call _x86_64_get_dispatch@PLT
popq %rdi
- movq 4832(%rax), %r11
+ movq 4856(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 4832(%rax), %r11
+ movq 4856(%rax), %r11
jmp *%r11
1:
pushq %rdi
call _glapi_get_dispatch
popq %rdi
- movq 4832(%rax), %r11
+ movq 4856(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(SecondaryColor3svEXT), .-GL_PREFIX(SecondaryColor3svEXT)
GL_PREFIX(SecondaryColor3ubEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 4840(%rax), %r11
+ movq 4864(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 4840(%rax), %r11
+ movq 4864(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 4840(%rax), %r11
+ movq 4864(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 4840(%rax), %r11
+ movq 4864(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(SecondaryColor3ubEXT), .-GL_PREFIX(SecondaryColor3ubEXT)
GL_PREFIX(SecondaryColor3ubvEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 4848(%rax), %r11
+ movq 4872(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
call _x86_64_get_dispatch@PLT
popq %rdi
- movq 4848(%rax), %r11
+ movq 4872(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 4848(%rax), %r11
+ movq 4872(%rax), %r11
jmp *%r11
1:
pushq %rdi
call _glapi_get_dispatch
popq %rdi
- movq 4848(%rax), %r11
+ movq 4872(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(SecondaryColor3ubvEXT), .-GL_PREFIX(SecondaryColor3ubvEXT)
GL_PREFIX(SecondaryColor3uiEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 4856(%rax), %r11
+ movq 4880(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 4856(%rax), %r11
+ movq 4880(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 4856(%rax), %r11
+ movq 4880(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 4856(%rax), %r11
+ movq 4880(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(SecondaryColor3uiEXT), .-GL_PREFIX(SecondaryColor3uiEXT)
GL_PREFIX(SecondaryColor3uivEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 4864(%rax), %r11
+ movq 4888(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
call _x86_64_get_dispatch@PLT
popq %rdi
- movq 4864(%rax), %r11
+ movq 4888(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 4864(%rax), %r11
+ movq 4888(%rax), %r11
jmp *%r11
1:
pushq %rdi
call _glapi_get_dispatch
popq %rdi
- movq 4864(%rax), %r11
+ movq 4888(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(SecondaryColor3uivEXT), .-GL_PREFIX(SecondaryColor3uivEXT)
GL_PREFIX(SecondaryColor3usEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 4872(%rax), %r11
+ movq 4896(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 4872(%rax), %r11
+ movq 4896(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 4872(%rax), %r11
+ movq 4896(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 4872(%rax), %r11
+ movq 4896(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(SecondaryColor3usEXT), .-GL_PREFIX(SecondaryColor3usEXT)
GL_PREFIX(SecondaryColor3usvEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 4880(%rax), %r11
+ movq 4904(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
call _x86_64_get_dispatch@PLT
popq %rdi
- movq 4880(%rax), %r11
+ movq 4904(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 4880(%rax), %r11
+ movq 4904(%rax), %r11
jmp *%r11
1:
pushq %rdi
call _glapi_get_dispatch
popq %rdi
- movq 4880(%rax), %r11
+ movq 4904(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(SecondaryColor3usvEXT), .-GL_PREFIX(SecondaryColor3usvEXT)
GL_PREFIX(SecondaryColorPointerEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 4888(%rax), %r11
+ movq 4912(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 4888(%rax), %r11
+ movq 4912(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 4888(%rax), %r11
+ movq 4912(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 4888(%rax), %r11
+ movq 4912(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(SecondaryColorPointerEXT), .-GL_PREFIX(SecondaryColorPointerEXT)
GL_PREFIX(MultiDrawArraysEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 4896(%rax), %r11
+ movq 4920(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 4896(%rax), %r11
+ movq 4920(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 4896(%rax), %r11
+ movq 4920(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 4896(%rax), %r11
+ movq 4920(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(MultiDrawArraysEXT), .-GL_PREFIX(MultiDrawArraysEXT)
GL_PREFIX(MultiDrawElementsEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 4904(%rax), %r11
+ movq 4928(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 4904(%rax), %r11
+ movq 4928(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 4904(%rax), %r11
+ movq 4928(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 4904(%rax), %r11
+ movq 4928(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(MultiDrawElementsEXT), .-GL_PREFIX(MultiDrawElementsEXT)
GL_PREFIX(FogCoordPointerEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 4912(%rax), %r11
+ movq 4936(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 4912(%rax), %r11
+ movq 4936(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 4912(%rax), %r11
+ movq 4936(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 4912(%rax), %r11
+ movq 4936(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(FogCoordPointerEXT), .-GL_PREFIX(FogCoordPointerEXT)
GL_PREFIX(FogCoorddEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 4920(%rax), %r11
+ movq 4944(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
subq $8, %rsp
call _x86_64_get_dispatch@PLT
movq (%rsp), %xmm0
addq $8, %rsp
- movq 4920(%rax), %r11
+ movq 4944(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 4920(%rax), %r11
+ movq 4944(%rax), %r11
jmp *%r11
1:
subq $8, %rsp
call _glapi_get_dispatch
movq (%rsp), %xmm0
addq $8, %rsp
- movq 4920(%rax), %r11
+ movq 4944(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(FogCoorddEXT), .-GL_PREFIX(FogCoorddEXT)
GL_PREFIX(FogCoorddvEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 4928(%rax), %r11
+ movq 4952(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
call _x86_64_get_dispatch@PLT
popq %rdi
- movq 4928(%rax), %r11
+ movq 4952(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 4928(%rax), %r11
+ movq 4952(%rax), %r11
jmp *%r11
1:
pushq %rdi
call _glapi_get_dispatch
popq %rdi
- movq 4928(%rax), %r11
+ movq 4952(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(FogCoorddvEXT), .-GL_PREFIX(FogCoorddvEXT)
GL_PREFIX(FogCoordfEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 4936(%rax), %r11
+ movq 4960(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
subq $8, %rsp
call _x86_64_get_dispatch@PLT
movq (%rsp), %xmm0
addq $8, %rsp
- movq 4936(%rax), %r11
+ movq 4960(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 4936(%rax), %r11
+ movq 4960(%rax), %r11
jmp *%r11
1:
subq $8, %rsp
call _glapi_get_dispatch
movq (%rsp), %xmm0
addq $8, %rsp
- movq 4936(%rax), %r11
+ movq 4960(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(FogCoordfEXT), .-GL_PREFIX(FogCoordfEXT)
GL_PREFIX(FogCoordfvEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 4944(%rax), %r11
+ movq 4968(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
call _x86_64_get_dispatch@PLT
popq %rdi
- movq 4944(%rax), %r11
+ movq 4968(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 4944(%rax), %r11
+ movq 4968(%rax), %r11
jmp *%r11
1:
pushq %rdi
call _glapi_get_dispatch
popq %rdi
- movq 4944(%rax), %r11
+ movq 4968(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(FogCoordfvEXT), .-GL_PREFIX(FogCoordfvEXT)
.p2align 4,,15
- .globl GL_PREFIX(_dispatch_stub_619)
- .type GL_PREFIX(_dispatch_stub_619), @function
- HIDDEN(GL_PREFIX(_dispatch_stub_619))
-GL_PREFIX(_dispatch_stub_619):
+ .globl GL_PREFIX(_dispatch_stub_622)
+ .type GL_PREFIX(_dispatch_stub_622), @function
+ HIDDEN(GL_PREFIX(_dispatch_stub_622))
+GL_PREFIX(_dispatch_stub_622):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 4952(%rax), %r11
+ movq 4976(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
call _x86_64_get_dispatch@PLT
popq %rdi
- movq 4952(%rax), %r11
+ movq 4976(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 4952(%rax), %r11
+ movq 4976(%rax), %r11
jmp *%r11
1:
pushq %rdi
call _glapi_get_dispatch
popq %rdi
- movq 4952(%rax), %r11
+ movq 4976(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
- .size GL_PREFIX(_dispatch_stub_619), .-GL_PREFIX(_dispatch_stub_619)
+ .size GL_PREFIX(_dispatch_stub_622), .-GL_PREFIX(_dispatch_stub_622)
.p2align 4,,15
.globl GL_PREFIX(BlendFuncSeparateEXT)
GL_PREFIX(BlendFuncSeparateEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 4960(%rax), %r11
+ movq 4984(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 4960(%rax), %r11
+ movq 4984(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 4960(%rax), %r11
+ movq 4984(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 4960(%rax), %r11
+ movq 4984(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(BlendFuncSeparateEXT), .-GL_PREFIX(BlendFuncSeparateEXT)
GL_PREFIX(FlushVertexArrayRangeNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 4968(%rax), %r11
+ movq 4992(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rbp
call _x86_64_get_dispatch@PLT
popq %rbp
- movq 4968(%rax), %r11
+ movq 4992(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 4968(%rax), %r11
+ movq 4992(%rax), %r11
jmp *%r11
1:
pushq %rbp
call _glapi_get_dispatch
popq %rbp
- movq 4968(%rax), %r11
+ movq 4992(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(FlushVertexArrayRangeNV), .-GL_PREFIX(FlushVertexArrayRangeNV)
GL_PREFIX(VertexArrayRangeNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 4976(%rax), %r11
+ movq 5000(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 4976(%rax), %r11
+ movq 5000(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 4976(%rax), %r11
+ movq 5000(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 4976(%rax), %r11
+ movq 5000(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(VertexArrayRangeNV), .-GL_PREFIX(VertexArrayRangeNV)
GL_PREFIX(CombinerInputNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 4984(%rax), %r11
+ movq 5008(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 4984(%rax), %r11
+ movq 5008(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 4984(%rax), %r11
+ movq 5008(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 4984(%rax), %r11
+ movq 5008(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(CombinerInputNV), .-GL_PREFIX(CombinerInputNV)
GL_PREFIX(CombinerOutputNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 4992(%rax), %r11
+ movq 5016(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 4992(%rax), %r11
+ movq 5016(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 4992(%rax), %r11
+ movq 5016(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 4992(%rax), %r11
+ movq 5016(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(CombinerOutputNV), .-GL_PREFIX(CombinerOutputNV)
GL_PREFIX(CombinerParameterfNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5000(%rax), %r11
+ movq 5024(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
subq $24, %rsp
movq 8(%rsp), %xmm0
movq (%rsp), %rdi
addq $24, %rsp
- movq 5000(%rax), %r11
+ movq 5024(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5000(%rax), %r11
+ movq 5024(%rax), %r11
jmp *%r11
1:
subq $24, %rsp
movq 8(%rsp), %xmm0
movq (%rsp), %rdi
addq $24, %rsp
- movq 5000(%rax), %r11
+ movq 5024(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(CombinerParameterfNV), .-GL_PREFIX(CombinerParameterfNV)
GL_PREFIX(CombinerParameterfvNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5008(%rax), %r11
+ movq 5032(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5008(%rax), %r11
+ movq 5032(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5008(%rax), %r11
+ movq 5032(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5008(%rax), %r11
+ movq 5032(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(CombinerParameterfvNV), .-GL_PREFIX(CombinerParameterfvNV)
GL_PREFIX(CombinerParameteriNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5016(%rax), %r11
+ movq 5040(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5016(%rax), %r11
+ movq 5040(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5016(%rax), %r11
+ movq 5040(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5016(%rax), %r11
+ movq 5040(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(CombinerParameteriNV), .-GL_PREFIX(CombinerParameteriNV)
GL_PREFIX(CombinerParameterivNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5024(%rax), %r11
+ movq 5048(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5024(%rax), %r11
+ movq 5048(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5024(%rax), %r11
+ movq 5048(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5024(%rax), %r11
+ movq 5048(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(CombinerParameterivNV), .-GL_PREFIX(CombinerParameterivNV)
GL_PREFIX(FinalCombinerInputNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5032(%rax), %r11
+ movq 5056(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5032(%rax), %r11
+ movq 5056(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5032(%rax), %r11
+ movq 5056(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5032(%rax), %r11
+ movq 5056(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(FinalCombinerInputNV), .-GL_PREFIX(FinalCombinerInputNV)
GL_PREFIX(GetCombinerInputParameterfvNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5040(%rax), %r11
+ movq 5064(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5040(%rax), %r11
+ movq 5064(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5040(%rax), %r11
+ movq 5064(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5040(%rax), %r11
+ movq 5064(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(GetCombinerInputParameterfvNV), .-GL_PREFIX(GetCombinerInputParameterfvNV)
GL_PREFIX(GetCombinerInputParameterivNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5048(%rax), %r11
+ movq 5072(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5048(%rax), %r11
+ movq 5072(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5048(%rax), %r11
+ movq 5072(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5048(%rax), %r11
+ movq 5072(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(GetCombinerInputParameterivNV), .-GL_PREFIX(GetCombinerInputParameterivNV)
GL_PREFIX(GetCombinerOutputParameterfvNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5056(%rax), %r11
+ movq 5080(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5056(%rax), %r11
+ movq 5080(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5056(%rax), %r11
+ movq 5080(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5056(%rax), %r11
+ movq 5080(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(GetCombinerOutputParameterfvNV), .-GL_PREFIX(GetCombinerOutputParameterfvNV)
GL_PREFIX(GetCombinerOutputParameterivNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5064(%rax), %r11
+ movq 5088(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5064(%rax), %r11
+ movq 5088(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5064(%rax), %r11
+ movq 5088(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5064(%rax), %r11
+ movq 5088(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(GetCombinerOutputParameterivNV), .-GL_PREFIX(GetCombinerOutputParameterivNV)
GL_PREFIX(GetFinalCombinerInputParameterfvNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5072(%rax), %r11
+ movq 5096(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5072(%rax), %r11
+ movq 5096(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5072(%rax), %r11
+ movq 5096(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5072(%rax), %r11
+ movq 5096(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(GetFinalCombinerInputParameterfvNV), .-GL_PREFIX(GetFinalCombinerInputParameterfvNV)
GL_PREFIX(GetFinalCombinerInputParameterivNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5080(%rax), %r11
+ movq 5104(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5080(%rax), %r11
+ movq 5104(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5080(%rax), %r11
+ movq 5104(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5080(%rax), %r11
+ movq 5104(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(GetFinalCombinerInputParameterivNV), .-GL_PREFIX(GetFinalCombinerInputParameterivNV)
GL_PREFIX(ResizeBuffersMESA):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5088(%rax), %r11
+ movq 5112(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rbp
call _x86_64_get_dispatch@PLT
popq %rbp
- movq 5088(%rax), %r11
+ movq 5112(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5088(%rax), %r11
+ movq 5112(%rax), %r11
jmp *%r11
1:
pushq %rbp
call _glapi_get_dispatch
popq %rbp
- movq 5088(%rax), %r11
+ movq 5112(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(ResizeBuffersMESA), .-GL_PREFIX(ResizeBuffersMESA)
GL_PREFIX(WindowPos2dMESA):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5096(%rax), %r11
+ movq 5120(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
subq $24, %rsp
movq 8(%rsp), %xmm1
movq (%rsp), %xmm0
addq $24, %rsp
- movq 5096(%rax), %r11
+ movq 5120(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5096(%rax), %r11
+ movq 5120(%rax), %r11
jmp *%r11
1:
subq $24, %rsp
movq 8(%rsp), %xmm1
movq (%rsp), %xmm0
addq $24, %rsp
- movq 5096(%rax), %r11
+ movq 5120(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(WindowPos2dMESA), .-GL_PREFIX(WindowPos2dMESA)
GL_PREFIX(WindowPos2dvMESA):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5104(%rax), %r11
+ movq 5128(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
call _x86_64_get_dispatch@PLT
popq %rdi
- movq 5104(%rax), %r11
+ movq 5128(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5104(%rax), %r11
+ movq 5128(%rax), %r11
jmp *%r11
1:
pushq %rdi
call _glapi_get_dispatch
popq %rdi
- movq 5104(%rax), %r11
+ movq 5128(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(WindowPos2dvMESA), .-GL_PREFIX(WindowPos2dvMESA)
GL_PREFIX(WindowPos2fMESA):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5112(%rax), %r11
+ movq 5136(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
subq $24, %rsp
movq 8(%rsp), %xmm1
movq (%rsp), %xmm0
addq $24, %rsp
- movq 5112(%rax), %r11
+ movq 5136(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5112(%rax), %r11
+ movq 5136(%rax), %r11
jmp *%r11
1:
subq $24, %rsp
movq 8(%rsp), %xmm1
movq (%rsp), %xmm0
addq $24, %rsp
- movq 5112(%rax), %r11
+ movq 5136(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(WindowPos2fMESA), .-GL_PREFIX(WindowPos2fMESA)
GL_PREFIX(WindowPos2fvMESA):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5120(%rax), %r11
+ movq 5144(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
call _x86_64_get_dispatch@PLT
popq %rdi
- movq 5120(%rax), %r11
+ movq 5144(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5120(%rax), %r11
+ movq 5144(%rax), %r11
jmp *%r11
1:
pushq %rdi
call _glapi_get_dispatch
popq %rdi
- movq 5120(%rax), %r11
+ movq 5144(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(WindowPos2fvMESA), .-GL_PREFIX(WindowPos2fvMESA)
GL_PREFIX(WindowPos2iMESA):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5128(%rax), %r11
+ movq 5152(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5128(%rax), %r11
+ movq 5152(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5128(%rax), %r11
+ movq 5152(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5128(%rax), %r11
+ movq 5152(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(WindowPos2iMESA), .-GL_PREFIX(WindowPos2iMESA)
GL_PREFIX(WindowPos2ivMESA):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5136(%rax), %r11
+ movq 5160(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
call _x86_64_get_dispatch@PLT
popq %rdi
- movq 5136(%rax), %r11
+ movq 5160(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5136(%rax), %r11
+ movq 5160(%rax), %r11
jmp *%r11
1:
pushq %rdi
call _glapi_get_dispatch
popq %rdi
- movq 5136(%rax), %r11
+ movq 5160(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(WindowPos2ivMESA), .-GL_PREFIX(WindowPos2ivMESA)
GL_PREFIX(WindowPos2sMESA):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5144(%rax), %r11
+ movq 5168(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5144(%rax), %r11
+ movq 5168(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5144(%rax), %r11
+ movq 5168(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5144(%rax), %r11
+ movq 5168(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(WindowPos2sMESA), .-GL_PREFIX(WindowPos2sMESA)
GL_PREFIX(WindowPos2svMESA):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5152(%rax), %r11
+ movq 5176(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
call _x86_64_get_dispatch@PLT
popq %rdi
- movq 5152(%rax), %r11
+ movq 5176(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5152(%rax), %r11
+ movq 5176(%rax), %r11
jmp *%r11
1:
pushq %rdi
call _glapi_get_dispatch
popq %rdi
- movq 5152(%rax), %r11
+ movq 5176(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(WindowPos2svMESA), .-GL_PREFIX(WindowPos2svMESA)
GL_PREFIX(WindowPos3dMESA):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5160(%rax), %r11
+ movq 5184(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
subq $24, %rsp
movq 8(%rsp), %xmm1
movq (%rsp), %xmm0
addq $24, %rsp
- movq 5160(%rax), %r11
+ movq 5184(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5160(%rax), %r11
+ movq 5184(%rax), %r11
jmp *%r11
1:
subq $24, %rsp
movq 8(%rsp), %xmm1
movq (%rsp), %xmm0
addq $24, %rsp
- movq 5160(%rax), %r11
+ movq 5184(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(WindowPos3dMESA), .-GL_PREFIX(WindowPos3dMESA)
GL_PREFIX(WindowPos3dvMESA):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5168(%rax), %r11
+ movq 5192(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
call _x86_64_get_dispatch@PLT
popq %rdi
- movq 5168(%rax), %r11
+ movq 5192(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5168(%rax), %r11
+ movq 5192(%rax), %r11
jmp *%r11
1:
pushq %rdi
call _glapi_get_dispatch
popq %rdi
- movq 5168(%rax), %r11
+ movq 5192(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(WindowPos3dvMESA), .-GL_PREFIX(WindowPos3dvMESA)
GL_PREFIX(WindowPos3fMESA):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5176(%rax), %r11
+ movq 5200(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
subq $24, %rsp
movq 8(%rsp), %xmm1
movq (%rsp), %xmm0
addq $24, %rsp
- movq 5176(%rax), %r11
+ movq 5200(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5176(%rax), %r11
+ movq 5200(%rax), %r11
jmp *%r11
1:
subq $24, %rsp
movq 8(%rsp), %xmm1
movq (%rsp), %xmm0
addq $24, %rsp
- movq 5176(%rax), %r11
+ movq 5200(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(WindowPos3fMESA), .-GL_PREFIX(WindowPos3fMESA)
GL_PREFIX(WindowPos3fvMESA):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5184(%rax), %r11
+ movq 5208(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
call _x86_64_get_dispatch@PLT
popq %rdi
- movq 5184(%rax), %r11
+ movq 5208(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5184(%rax), %r11
+ movq 5208(%rax), %r11
jmp *%r11
1:
pushq %rdi
call _glapi_get_dispatch
popq %rdi
- movq 5184(%rax), %r11
+ movq 5208(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(WindowPos3fvMESA), .-GL_PREFIX(WindowPos3fvMESA)
GL_PREFIX(WindowPos3iMESA):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5192(%rax), %r11
+ movq 5216(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5192(%rax), %r11
+ movq 5216(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5192(%rax), %r11
+ movq 5216(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5192(%rax), %r11
+ movq 5216(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(WindowPos3iMESA), .-GL_PREFIX(WindowPos3iMESA)
GL_PREFIX(WindowPos3ivMESA):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5200(%rax), %r11
+ movq 5224(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
call _x86_64_get_dispatch@PLT
popq %rdi
- movq 5200(%rax), %r11
+ movq 5224(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5200(%rax), %r11
+ movq 5224(%rax), %r11
jmp *%r11
1:
pushq %rdi
call _glapi_get_dispatch
popq %rdi
- movq 5200(%rax), %r11
+ movq 5224(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(WindowPos3ivMESA), .-GL_PREFIX(WindowPos3ivMESA)
GL_PREFIX(WindowPos3sMESA):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5208(%rax), %r11
+ movq 5232(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5208(%rax), %r11
+ movq 5232(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5208(%rax), %r11
+ movq 5232(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5208(%rax), %r11
+ movq 5232(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(WindowPos3sMESA), .-GL_PREFIX(WindowPos3sMESA)
GL_PREFIX(WindowPos3svMESA):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5216(%rax), %r11
+ movq 5240(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
call _x86_64_get_dispatch@PLT
popq %rdi
- movq 5216(%rax), %r11
+ movq 5240(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5216(%rax), %r11
+ movq 5240(%rax), %r11
jmp *%r11
1:
pushq %rdi
call _glapi_get_dispatch
popq %rdi
- movq 5216(%rax), %r11
+ movq 5240(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(WindowPos3svMESA), .-GL_PREFIX(WindowPos3svMESA)
GL_PREFIX(WindowPos4dMESA):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5224(%rax), %r11
+ movq 5248(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
subq $40, %rsp
movq 8(%rsp), %xmm1
movq (%rsp), %xmm0
addq $40, %rsp
- movq 5224(%rax), %r11
+ movq 5248(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5224(%rax), %r11
+ movq 5248(%rax), %r11
jmp *%r11
1:
subq $40, %rsp
movq 8(%rsp), %xmm1
movq (%rsp), %xmm0
addq $40, %rsp
- movq 5224(%rax), %r11
+ movq 5248(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(WindowPos4dMESA), .-GL_PREFIX(WindowPos4dMESA)
GL_PREFIX(WindowPos4dvMESA):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5232(%rax), %r11
+ movq 5256(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
call _x86_64_get_dispatch@PLT
popq %rdi
- movq 5232(%rax), %r11
+ movq 5256(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5232(%rax), %r11
+ movq 5256(%rax), %r11
jmp *%r11
1:
pushq %rdi
call _glapi_get_dispatch
popq %rdi
- movq 5232(%rax), %r11
+ movq 5256(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(WindowPos4dvMESA), .-GL_PREFIX(WindowPos4dvMESA)
GL_PREFIX(WindowPos4fMESA):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5240(%rax), %r11
+ movq 5264(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
subq $40, %rsp
movq 8(%rsp), %xmm1
movq (%rsp), %xmm0
addq $40, %rsp
- movq 5240(%rax), %r11
+ movq 5264(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5240(%rax), %r11
+ movq 5264(%rax), %r11
jmp *%r11
1:
subq $40, %rsp
movq 8(%rsp), %xmm1
movq (%rsp), %xmm0
addq $40, %rsp
- movq 5240(%rax), %r11
+ movq 5264(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(WindowPos4fMESA), .-GL_PREFIX(WindowPos4fMESA)
GL_PREFIX(WindowPos4fvMESA):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5248(%rax), %r11
+ movq 5272(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
call _x86_64_get_dispatch@PLT
popq %rdi
- movq 5248(%rax), %r11
+ movq 5272(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5248(%rax), %r11
+ movq 5272(%rax), %r11
jmp *%r11
1:
pushq %rdi
call _glapi_get_dispatch
popq %rdi
- movq 5248(%rax), %r11
+ movq 5272(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(WindowPos4fvMESA), .-GL_PREFIX(WindowPos4fvMESA)
GL_PREFIX(WindowPos4iMESA):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5256(%rax), %r11
+ movq 5280(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5256(%rax), %r11
+ movq 5280(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5256(%rax), %r11
+ movq 5280(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5256(%rax), %r11
+ movq 5280(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(WindowPos4iMESA), .-GL_PREFIX(WindowPos4iMESA)
GL_PREFIX(WindowPos4ivMESA):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5264(%rax), %r11
+ movq 5288(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
call _x86_64_get_dispatch@PLT
popq %rdi
- movq 5264(%rax), %r11
+ movq 5288(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5264(%rax), %r11
+ movq 5288(%rax), %r11
jmp *%r11
1:
pushq %rdi
call _glapi_get_dispatch
popq %rdi
- movq 5264(%rax), %r11
+ movq 5288(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(WindowPos4ivMESA), .-GL_PREFIX(WindowPos4ivMESA)
GL_PREFIX(WindowPos4sMESA):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5272(%rax), %r11
+ movq 5296(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5272(%rax), %r11
+ movq 5296(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5272(%rax), %r11
+ movq 5296(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5272(%rax), %r11
+ movq 5296(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(WindowPos4sMESA), .-GL_PREFIX(WindowPos4sMESA)
GL_PREFIX(WindowPos4svMESA):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5280(%rax), %r11
+ movq 5304(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
call _x86_64_get_dispatch@PLT
popq %rdi
- movq 5280(%rax), %r11
+ movq 5304(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5280(%rax), %r11
+ movq 5304(%rax), %r11
jmp *%r11
1:
pushq %rdi
call _glapi_get_dispatch
popq %rdi
- movq 5280(%rax), %r11
+ movq 5304(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(WindowPos4svMESA), .-GL_PREFIX(WindowPos4svMESA)
.p2align 4,,15
- .globl GL_PREFIX(_dispatch_stub_661)
- .type GL_PREFIX(_dispatch_stub_661), @function
- HIDDEN(GL_PREFIX(_dispatch_stub_661))
-GL_PREFIX(_dispatch_stub_661):
+ .globl GL_PREFIX(_dispatch_stub_664)
+ .type GL_PREFIX(_dispatch_stub_664), @function
+ HIDDEN(GL_PREFIX(_dispatch_stub_664))
+GL_PREFIX(_dispatch_stub_664):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5288(%rax), %r11
+ movq 5312(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5288(%rax), %r11
+ movq 5312(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5288(%rax), %r11
+ movq 5312(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5288(%rax), %r11
+ movq 5312(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
- .size GL_PREFIX(_dispatch_stub_661), .-GL_PREFIX(_dispatch_stub_661)
+ .size GL_PREFIX(_dispatch_stub_664), .-GL_PREFIX(_dispatch_stub_664)
.p2align 4,,15
- .globl GL_PREFIX(_dispatch_stub_662)
- .type GL_PREFIX(_dispatch_stub_662), @function
- HIDDEN(GL_PREFIX(_dispatch_stub_662))
-GL_PREFIX(_dispatch_stub_662):
+ .globl GL_PREFIX(_dispatch_stub_665)
+ .type GL_PREFIX(_dispatch_stub_665), @function
+ HIDDEN(GL_PREFIX(_dispatch_stub_665))
+GL_PREFIX(_dispatch_stub_665):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5296(%rax), %r11
+ movq 5320(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5296(%rax), %r11
+ movq 5320(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5296(%rax), %r11
+ movq 5320(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5296(%rax), %r11
+ movq 5320(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
- .size GL_PREFIX(_dispatch_stub_662), .-GL_PREFIX(_dispatch_stub_662)
+ .size GL_PREFIX(_dispatch_stub_665), .-GL_PREFIX(_dispatch_stub_665)
.p2align 4,,15
- .globl GL_PREFIX(_dispatch_stub_663)
- .type GL_PREFIX(_dispatch_stub_663), @function
- HIDDEN(GL_PREFIX(_dispatch_stub_663))
-GL_PREFIX(_dispatch_stub_663):
+ .globl GL_PREFIX(_dispatch_stub_666)
+ .type GL_PREFIX(_dispatch_stub_666), @function
+ HIDDEN(GL_PREFIX(_dispatch_stub_666))
+GL_PREFIX(_dispatch_stub_666):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5304(%rax), %r11
+ movq 5328(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5304(%rax), %r11
+ movq 5328(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5304(%rax), %r11
+ movq 5328(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5304(%rax), %r11
+ movq 5328(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
- .size GL_PREFIX(_dispatch_stub_663), .-GL_PREFIX(_dispatch_stub_663)
+ .size GL_PREFIX(_dispatch_stub_666), .-GL_PREFIX(_dispatch_stub_666)
.p2align 4,,15
- .globl GL_PREFIX(_dispatch_stub_664)
- .type GL_PREFIX(_dispatch_stub_664), @function
- HIDDEN(GL_PREFIX(_dispatch_stub_664))
-GL_PREFIX(_dispatch_stub_664):
+ .globl GL_PREFIX(_dispatch_stub_667)
+ .type GL_PREFIX(_dispatch_stub_667), @function
+ HIDDEN(GL_PREFIX(_dispatch_stub_667))
+GL_PREFIX(_dispatch_stub_667):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5312(%rax), %r11
+ movq 5336(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
call _x86_64_get_dispatch@PLT
popq %rdi
- movq 5312(%rax), %r11
+ movq 5336(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5312(%rax), %r11
+ movq 5336(%rax), %r11
jmp *%r11
1:
pushq %rdi
call _glapi_get_dispatch
popq %rdi
- movq 5312(%rax), %r11
+ movq 5336(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
- .size GL_PREFIX(_dispatch_stub_664), .-GL_PREFIX(_dispatch_stub_664)
+ .size GL_PREFIX(_dispatch_stub_667), .-GL_PREFIX(_dispatch_stub_667)
.p2align 4,,15
- .globl GL_PREFIX(_dispatch_stub_665)
- .type GL_PREFIX(_dispatch_stub_665), @function
- HIDDEN(GL_PREFIX(_dispatch_stub_665))
-GL_PREFIX(_dispatch_stub_665):
+ .globl GL_PREFIX(_dispatch_stub_668)
+ .type GL_PREFIX(_dispatch_stub_668), @function
+ HIDDEN(GL_PREFIX(_dispatch_stub_668))
+GL_PREFIX(_dispatch_stub_668):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5320(%rax), %r11
+ movq 5344(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5320(%rax), %r11
+ movq 5344(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5320(%rax), %r11
+ movq 5344(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5320(%rax), %r11
+ movq 5344(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
- .size GL_PREFIX(_dispatch_stub_665), .-GL_PREFIX(_dispatch_stub_665)
+ .size GL_PREFIX(_dispatch_stub_668), .-GL_PREFIX(_dispatch_stub_668)
.p2align 4,,15
- .globl GL_PREFIX(_dispatch_stub_666)
- .type GL_PREFIX(_dispatch_stub_666), @function
- HIDDEN(GL_PREFIX(_dispatch_stub_666))
-GL_PREFIX(_dispatch_stub_666):
+ .globl GL_PREFIX(_dispatch_stub_669)
+ .type GL_PREFIX(_dispatch_stub_669), @function
+ HIDDEN(GL_PREFIX(_dispatch_stub_669))
+GL_PREFIX(_dispatch_stub_669):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5328(%rax), %r11
+ movq 5352(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5328(%rax), %r11
+ movq 5352(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5328(%rax), %r11
+ movq 5352(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5328(%rax), %r11
+ movq 5352(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
- .size GL_PREFIX(_dispatch_stub_666), .-GL_PREFIX(_dispatch_stub_666)
+ .size GL_PREFIX(_dispatch_stub_669), .-GL_PREFIX(_dispatch_stub_669)
.p2align 4,,15
- .globl GL_PREFIX(_dispatch_stub_667)
- .type GL_PREFIX(_dispatch_stub_667), @function
- HIDDEN(GL_PREFIX(_dispatch_stub_667))
-GL_PREFIX(_dispatch_stub_667):
+ .globl GL_PREFIX(_dispatch_stub_670)
+ .type GL_PREFIX(_dispatch_stub_670), @function
+ HIDDEN(GL_PREFIX(_dispatch_stub_670))
+GL_PREFIX(_dispatch_stub_670):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5336(%rax), %r11
+ movq 5360(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
call _x86_64_get_dispatch@PLT
popq %rdi
- movq 5336(%rax), %r11
+ movq 5360(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5336(%rax), %r11
+ movq 5360(%rax), %r11
jmp *%r11
1:
pushq %rdi
call _glapi_get_dispatch
popq %rdi
- movq 5336(%rax), %r11
+ movq 5360(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
- .size GL_PREFIX(_dispatch_stub_667), .-GL_PREFIX(_dispatch_stub_667)
+ .size GL_PREFIX(_dispatch_stub_670), .-GL_PREFIX(_dispatch_stub_670)
.p2align 4,,15
- .globl GL_PREFIX(_dispatch_stub_668)
- .type GL_PREFIX(_dispatch_stub_668), @function
- HIDDEN(GL_PREFIX(_dispatch_stub_668))
-GL_PREFIX(_dispatch_stub_668):
+ .globl GL_PREFIX(_dispatch_stub_671)
+ .type GL_PREFIX(_dispatch_stub_671), @function
+ HIDDEN(GL_PREFIX(_dispatch_stub_671))
+GL_PREFIX(_dispatch_stub_671):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5344(%rax), %r11
+ movq 5368(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5344(%rax), %r11
+ movq 5368(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5344(%rax), %r11
+ movq 5368(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5344(%rax), %r11
+ movq 5368(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
- .size GL_PREFIX(_dispatch_stub_668), .-GL_PREFIX(_dispatch_stub_668)
+ .size GL_PREFIX(_dispatch_stub_671), .-GL_PREFIX(_dispatch_stub_671)
.p2align 4,,15
- .globl GL_PREFIX(_dispatch_stub_669)
- .type GL_PREFIX(_dispatch_stub_669), @function
- HIDDEN(GL_PREFIX(_dispatch_stub_669))
-GL_PREFIX(_dispatch_stub_669):
+ .globl GL_PREFIX(_dispatch_stub_672)
+ .type GL_PREFIX(_dispatch_stub_672), @function
+ HIDDEN(GL_PREFIX(_dispatch_stub_672))
+GL_PREFIX(_dispatch_stub_672):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5352(%rax), %r11
+ movq 5376(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
call _x86_64_get_dispatch@PLT
popq %rdi
- movq 5352(%rax), %r11
+ movq 5376(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5352(%rax), %r11
+ movq 5376(%rax), %r11
jmp *%r11
1:
pushq %rdi
call _glapi_get_dispatch
popq %rdi
- movq 5352(%rax), %r11
+ movq 5376(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
- .size GL_PREFIX(_dispatch_stub_669), .-GL_PREFIX(_dispatch_stub_669)
+ .size GL_PREFIX(_dispatch_stub_672), .-GL_PREFIX(_dispatch_stub_672)
.p2align 4,,15
.globl GL_PREFIX(AreProgramsResidentNV)
GL_PREFIX(AreProgramsResidentNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5360(%rax), %r11
+ movq 5384(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5360(%rax), %r11
+ movq 5384(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5360(%rax), %r11
+ movq 5384(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5360(%rax), %r11
+ movq 5384(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(AreProgramsResidentNV), .-GL_PREFIX(AreProgramsResidentNV)
GL_PREFIX(BindProgramNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5368(%rax), %r11
+ movq 5392(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5368(%rax), %r11
+ movq 5392(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5368(%rax), %r11
+ movq 5392(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5368(%rax), %r11
+ movq 5392(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(BindProgramNV), .-GL_PREFIX(BindProgramNV)
GL_PREFIX(DeleteProgramsNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5376(%rax), %r11
+ movq 5400(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5376(%rax), %r11
+ movq 5400(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5376(%rax), %r11
+ movq 5400(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5376(%rax), %r11
+ movq 5400(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(DeleteProgramsNV), .-GL_PREFIX(DeleteProgramsNV)
GL_PREFIX(ExecuteProgramNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5384(%rax), %r11
+ movq 5408(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5384(%rax), %r11
+ movq 5408(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5384(%rax), %r11
+ movq 5408(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5384(%rax), %r11
+ movq 5408(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(ExecuteProgramNV), .-GL_PREFIX(ExecuteProgramNV)
GL_PREFIX(GenProgramsNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5392(%rax), %r11
+ movq 5416(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5392(%rax), %r11
+ movq 5416(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5392(%rax), %r11
+ movq 5416(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5392(%rax), %r11
+ movq 5416(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(GenProgramsNV), .-GL_PREFIX(GenProgramsNV)
GL_PREFIX(GetProgramParameterdvNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5400(%rax), %r11
+ movq 5424(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5400(%rax), %r11
+ movq 5424(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5400(%rax), %r11
+ movq 5424(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5400(%rax), %r11
+ movq 5424(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(GetProgramParameterdvNV), .-GL_PREFIX(GetProgramParameterdvNV)
GL_PREFIX(GetProgramParameterfvNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5408(%rax), %r11
+ movq 5432(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5408(%rax), %r11
+ movq 5432(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5408(%rax), %r11
+ movq 5432(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5408(%rax), %r11
+ movq 5432(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(GetProgramParameterfvNV), .-GL_PREFIX(GetProgramParameterfvNV)
GL_PREFIX(GetProgramStringNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5416(%rax), %r11
+ movq 5440(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5416(%rax), %r11
+ movq 5440(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5416(%rax), %r11
+ movq 5440(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5416(%rax), %r11
+ movq 5440(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(GetProgramStringNV), .-GL_PREFIX(GetProgramStringNV)
GL_PREFIX(GetProgramivNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5424(%rax), %r11
+ movq 5448(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5424(%rax), %r11
+ movq 5448(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5424(%rax), %r11
+ movq 5448(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5424(%rax), %r11
+ movq 5448(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(GetProgramivNV), .-GL_PREFIX(GetProgramivNV)
GL_PREFIX(GetTrackMatrixivNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5432(%rax), %r11
+ movq 5456(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5432(%rax), %r11
+ movq 5456(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5432(%rax), %r11
+ movq 5456(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5432(%rax), %r11
+ movq 5456(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(GetTrackMatrixivNV), .-GL_PREFIX(GetTrackMatrixivNV)
GL_PREFIX(GetVertexAttribPointervNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5440(%rax), %r11
+ movq 5464(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5440(%rax), %r11
+ movq 5464(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5440(%rax), %r11
+ movq 5464(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5440(%rax), %r11
+ movq 5464(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(GetVertexAttribPointervNV), .-GL_PREFIX(GetVertexAttribPointervNV)
GL_PREFIX(GetVertexAttribdvNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5448(%rax), %r11
+ movq 5472(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5448(%rax), %r11
+ movq 5472(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5448(%rax), %r11
+ movq 5472(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5448(%rax), %r11
+ movq 5472(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(GetVertexAttribdvNV), .-GL_PREFIX(GetVertexAttribdvNV)
GL_PREFIX(GetVertexAttribfvNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5456(%rax), %r11
+ movq 5480(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5456(%rax), %r11
+ movq 5480(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5456(%rax), %r11
+ movq 5480(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5456(%rax), %r11
+ movq 5480(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(GetVertexAttribfvNV), .-GL_PREFIX(GetVertexAttribfvNV)
GL_PREFIX(GetVertexAttribivNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5464(%rax), %r11
+ movq 5488(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5464(%rax), %r11
+ movq 5488(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5464(%rax), %r11
+ movq 5488(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5464(%rax), %r11
+ movq 5488(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(GetVertexAttribivNV), .-GL_PREFIX(GetVertexAttribivNV)
GL_PREFIX(IsProgramNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5472(%rax), %r11
+ movq 5496(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
call _x86_64_get_dispatch@PLT
popq %rdi
- movq 5472(%rax), %r11
+ movq 5496(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5472(%rax), %r11
+ movq 5496(%rax), %r11
jmp *%r11
1:
pushq %rdi
call _glapi_get_dispatch
popq %rdi
- movq 5472(%rax), %r11
+ movq 5496(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(IsProgramNV), .-GL_PREFIX(IsProgramNV)
GL_PREFIX(LoadProgramNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5480(%rax), %r11
+ movq 5504(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5480(%rax), %r11
+ movq 5504(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5480(%rax), %r11
+ movq 5504(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5480(%rax), %r11
+ movq 5504(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(LoadProgramNV), .-GL_PREFIX(LoadProgramNV)
GL_PREFIX(ProgramParameters4dvNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5488(%rax), %r11
+ movq 5512(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5488(%rax), %r11
+ movq 5512(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5488(%rax), %r11
+ movq 5512(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5488(%rax), %r11
+ movq 5512(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(ProgramParameters4dvNV), .-GL_PREFIX(ProgramParameters4dvNV)
GL_PREFIX(ProgramParameters4fvNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5496(%rax), %r11
+ movq 5520(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5496(%rax), %r11
+ movq 5520(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5496(%rax), %r11
+ movq 5520(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5496(%rax), %r11
+ movq 5520(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(ProgramParameters4fvNV), .-GL_PREFIX(ProgramParameters4fvNV)
GL_PREFIX(RequestResidentProgramsNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5504(%rax), %r11
+ movq 5528(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5504(%rax), %r11
+ movq 5528(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5504(%rax), %r11
+ movq 5528(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5504(%rax), %r11
+ movq 5528(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(RequestResidentProgramsNV), .-GL_PREFIX(RequestResidentProgramsNV)
GL_PREFIX(TrackMatrixNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5512(%rax), %r11
+ movq 5536(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5512(%rax), %r11
+ movq 5536(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5512(%rax), %r11
+ movq 5536(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5512(%rax), %r11
+ movq 5536(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(TrackMatrixNV), .-GL_PREFIX(TrackMatrixNV)
GL_PREFIX(VertexAttrib1dNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5520(%rax), %r11
+ movq 5544(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
subq $24, %rsp
movq 8(%rsp), %xmm0
movq (%rsp), %rdi
addq $24, %rsp
- movq 5520(%rax), %r11
+ movq 5544(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5520(%rax), %r11
+ movq 5544(%rax), %r11
jmp *%r11
1:
subq $24, %rsp
movq 8(%rsp), %xmm0
movq (%rsp), %rdi
addq $24, %rsp
- movq 5520(%rax), %r11
+ movq 5544(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(VertexAttrib1dNV), .-GL_PREFIX(VertexAttrib1dNV)
GL_PREFIX(VertexAttrib1dvNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5528(%rax), %r11
+ movq 5552(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5528(%rax), %r11
+ movq 5552(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5528(%rax), %r11
+ movq 5552(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5528(%rax), %r11
+ movq 5552(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(VertexAttrib1dvNV), .-GL_PREFIX(VertexAttrib1dvNV)
GL_PREFIX(VertexAttrib1fNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5536(%rax), %r11
+ movq 5560(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
subq $24, %rsp
movq 8(%rsp), %xmm0
movq (%rsp), %rdi
addq $24, %rsp
- movq 5536(%rax), %r11
+ movq 5560(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5536(%rax), %r11
+ movq 5560(%rax), %r11
jmp *%r11
1:
subq $24, %rsp
movq 8(%rsp), %xmm0
movq (%rsp), %rdi
addq $24, %rsp
- movq 5536(%rax), %r11
+ movq 5560(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(VertexAttrib1fNV), .-GL_PREFIX(VertexAttrib1fNV)
GL_PREFIX(VertexAttrib1fvNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5544(%rax), %r11
+ movq 5568(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5544(%rax), %r11
+ movq 5568(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5544(%rax), %r11
+ movq 5568(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5544(%rax), %r11
+ movq 5568(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(VertexAttrib1fvNV), .-GL_PREFIX(VertexAttrib1fvNV)
GL_PREFIX(VertexAttrib1sNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5552(%rax), %r11
+ movq 5576(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5552(%rax), %r11
+ movq 5576(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5552(%rax), %r11
+ movq 5576(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5552(%rax), %r11
+ movq 5576(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(VertexAttrib1sNV), .-GL_PREFIX(VertexAttrib1sNV)
GL_PREFIX(VertexAttrib1svNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5560(%rax), %r11
+ movq 5584(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5560(%rax), %r11
+ movq 5584(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5560(%rax), %r11
+ movq 5584(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5560(%rax), %r11
+ movq 5584(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(VertexAttrib1svNV), .-GL_PREFIX(VertexAttrib1svNV)
GL_PREFIX(VertexAttrib2dNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5568(%rax), %r11
+ movq 5592(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
subq $24, %rsp
movq 8(%rsp), %xmm0
movq (%rsp), %rdi
addq $24, %rsp
- movq 5568(%rax), %r11
+ movq 5592(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5568(%rax), %r11
+ movq 5592(%rax), %r11
jmp *%r11
1:
subq $24, %rsp
movq 8(%rsp), %xmm0
movq (%rsp), %rdi
addq $24, %rsp
- movq 5568(%rax), %r11
+ movq 5592(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(VertexAttrib2dNV), .-GL_PREFIX(VertexAttrib2dNV)
GL_PREFIX(VertexAttrib2dvNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5576(%rax), %r11
+ movq 5600(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5576(%rax), %r11
+ movq 5600(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5576(%rax), %r11
+ movq 5600(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5576(%rax), %r11
+ movq 5600(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(VertexAttrib2dvNV), .-GL_PREFIX(VertexAttrib2dvNV)
GL_PREFIX(VertexAttrib2fNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5584(%rax), %r11
+ movq 5608(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
subq $24, %rsp
movq 8(%rsp), %xmm0
movq (%rsp), %rdi
addq $24, %rsp
- movq 5584(%rax), %r11
+ movq 5608(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5584(%rax), %r11
+ movq 5608(%rax), %r11
jmp *%r11
1:
subq $24, %rsp
movq 8(%rsp), %xmm0
movq (%rsp), %rdi
addq $24, %rsp
- movq 5584(%rax), %r11
+ movq 5608(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(VertexAttrib2fNV), .-GL_PREFIX(VertexAttrib2fNV)
GL_PREFIX(VertexAttrib2fvNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5592(%rax), %r11
+ movq 5616(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5592(%rax), %r11
+ movq 5616(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5592(%rax), %r11
+ movq 5616(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5592(%rax), %r11
+ movq 5616(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(VertexAttrib2fvNV), .-GL_PREFIX(VertexAttrib2fvNV)
GL_PREFIX(VertexAttrib2sNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5600(%rax), %r11
+ movq 5624(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5600(%rax), %r11
+ movq 5624(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5600(%rax), %r11
+ movq 5624(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5600(%rax), %r11
+ movq 5624(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(VertexAttrib2sNV), .-GL_PREFIX(VertexAttrib2sNV)
GL_PREFIX(VertexAttrib2svNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5608(%rax), %r11
+ movq 5632(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5608(%rax), %r11
+ movq 5632(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5608(%rax), %r11
+ movq 5632(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5608(%rax), %r11
+ movq 5632(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(VertexAttrib2svNV), .-GL_PREFIX(VertexAttrib2svNV)
GL_PREFIX(VertexAttrib3dNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5616(%rax), %r11
+ movq 5640(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
subq $40, %rsp
movq 8(%rsp), %xmm0
movq (%rsp), %rdi
addq $40, %rsp
- movq 5616(%rax), %r11
+ movq 5640(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5616(%rax), %r11
+ movq 5640(%rax), %r11
jmp *%r11
1:
subq $40, %rsp
movq 8(%rsp), %xmm0
movq (%rsp), %rdi
addq $40, %rsp
- movq 5616(%rax), %r11
+ movq 5640(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(VertexAttrib3dNV), .-GL_PREFIX(VertexAttrib3dNV)
GL_PREFIX(VertexAttrib3dvNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5624(%rax), %r11
+ movq 5648(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5624(%rax), %r11
+ movq 5648(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5624(%rax), %r11
+ movq 5648(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5624(%rax), %r11
+ movq 5648(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(VertexAttrib3dvNV), .-GL_PREFIX(VertexAttrib3dvNV)
GL_PREFIX(VertexAttrib3fNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5632(%rax), %r11
+ movq 5656(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
subq $40, %rsp
movq 8(%rsp), %xmm0
movq (%rsp), %rdi
addq $40, %rsp
- movq 5632(%rax), %r11
+ movq 5656(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5632(%rax), %r11
+ movq 5656(%rax), %r11
jmp *%r11
1:
subq $40, %rsp
movq 8(%rsp), %xmm0
movq (%rsp), %rdi
addq $40, %rsp
- movq 5632(%rax), %r11
+ movq 5656(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(VertexAttrib3fNV), .-GL_PREFIX(VertexAttrib3fNV)
GL_PREFIX(VertexAttrib3fvNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5640(%rax), %r11
+ movq 5664(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5640(%rax), %r11
+ movq 5664(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5640(%rax), %r11
+ movq 5664(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5640(%rax), %r11
+ movq 5664(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(VertexAttrib3fvNV), .-GL_PREFIX(VertexAttrib3fvNV)
GL_PREFIX(VertexAttrib3sNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5648(%rax), %r11
+ movq 5672(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5648(%rax), %r11
+ movq 5672(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5648(%rax), %r11
+ movq 5672(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5648(%rax), %r11
+ movq 5672(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(VertexAttrib3sNV), .-GL_PREFIX(VertexAttrib3sNV)
GL_PREFIX(VertexAttrib3svNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5656(%rax), %r11
+ movq 5680(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5656(%rax), %r11
+ movq 5680(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5656(%rax), %r11
+ movq 5680(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5656(%rax), %r11
+ movq 5680(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(VertexAttrib3svNV), .-GL_PREFIX(VertexAttrib3svNV)
GL_PREFIX(VertexAttrib4dNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5664(%rax), %r11
+ movq 5688(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
subq $40, %rsp
movq 8(%rsp), %xmm0
movq (%rsp), %rdi
addq $40, %rsp
- movq 5664(%rax), %r11
+ movq 5688(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5664(%rax), %r11
+ movq 5688(%rax), %r11
jmp *%r11
1:
subq $40, %rsp
movq 8(%rsp), %xmm0
movq (%rsp), %rdi
addq $40, %rsp
- movq 5664(%rax), %r11
+ movq 5688(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(VertexAttrib4dNV), .-GL_PREFIX(VertexAttrib4dNV)
GL_PREFIX(VertexAttrib4dvNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5672(%rax), %r11
+ movq 5696(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5672(%rax), %r11
+ movq 5696(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5672(%rax), %r11
+ movq 5696(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5672(%rax), %r11
+ movq 5696(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(VertexAttrib4dvNV), .-GL_PREFIX(VertexAttrib4dvNV)
GL_PREFIX(VertexAttrib4fNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5680(%rax), %r11
+ movq 5704(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
subq $40, %rsp
movq 8(%rsp), %xmm0
movq (%rsp), %rdi
addq $40, %rsp
- movq 5680(%rax), %r11
+ movq 5704(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5680(%rax), %r11
+ movq 5704(%rax), %r11
jmp *%r11
1:
subq $40, %rsp
movq 8(%rsp), %xmm0
movq (%rsp), %rdi
addq $40, %rsp
- movq 5680(%rax), %r11
+ movq 5704(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(VertexAttrib4fNV), .-GL_PREFIX(VertexAttrib4fNV)
GL_PREFIX(VertexAttrib4fvNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5688(%rax), %r11
+ movq 5712(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5688(%rax), %r11
+ movq 5712(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5688(%rax), %r11
+ movq 5712(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5688(%rax), %r11
+ movq 5712(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(VertexAttrib4fvNV), .-GL_PREFIX(VertexAttrib4fvNV)
GL_PREFIX(VertexAttrib4sNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5696(%rax), %r11
+ movq 5720(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5696(%rax), %r11
+ movq 5720(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5696(%rax), %r11
+ movq 5720(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5696(%rax), %r11
+ movq 5720(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(VertexAttrib4sNV), .-GL_PREFIX(VertexAttrib4sNV)
GL_PREFIX(VertexAttrib4svNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5704(%rax), %r11
+ movq 5728(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5704(%rax), %r11
+ movq 5728(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5704(%rax), %r11
+ movq 5728(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5704(%rax), %r11
+ movq 5728(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(VertexAttrib4svNV), .-GL_PREFIX(VertexAttrib4svNV)
GL_PREFIX(VertexAttrib4ubNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5712(%rax), %r11
+ movq 5736(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5712(%rax), %r11
+ movq 5736(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5712(%rax), %r11
+ movq 5736(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5712(%rax), %r11
+ movq 5736(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(VertexAttrib4ubNV), .-GL_PREFIX(VertexAttrib4ubNV)
GL_PREFIX(VertexAttrib4ubvNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5720(%rax), %r11
+ movq 5744(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5720(%rax), %r11
+ movq 5744(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5720(%rax), %r11
+ movq 5744(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5720(%rax), %r11
+ movq 5744(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(VertexAttrib4ubvNV), .-GL_PREFIX(VertexAttrib4ubvNV)
GL_PREFIX(VertexAttribPointerNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5728(%rax), %r11
+ movq 5752(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5728(%rax), %r11
+ movq 5752(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5728(%rax), %r11
+ movq 5752(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5728(%rax), %r11
+ movq 5752(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(VertexAttribPointerNV), .-GL_PREFIX(VertexAttribPointerNV)
GL_PREFIX(VertexAttribs1dvNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5736(%rax), %r11
+ movq 5760(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5736(%rax), %r11
+ movq 5760(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5736(%rax), %r11
+ movq 5760(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5736(%rax), %r11
+ movq 5760(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(VertexAttribs1dvNV), .-GL_PREFIX(VertexAttribs1dvNV)
GL_PREFIX(VertexAttribs1fvNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5744(%rax), %r11
+ movq 5768(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5744(%rax), %r11
+ movq 5768(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5744(%rax), %r11
+ movq 5768(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5744(%rax), %r11
+ movq 5768(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(VertexAttribs1fvNV), .-GL_PREFIX(VertexAttribs1fvNV)
GL_PREFIX(VertexAttribs1svNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5752(%rax), %r11
+ movq 5776(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5752(%rax), %r11
+ movq 5776(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5752(%rax), %r11
+ movq 5776(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5752(%rax), %r11
+ movq 5776(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(VertexAttribs1svNV), .-GL_PREFIX(VertexAttribs1svNV)
GL_PREFIX(VertexAttribs2dvNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5760(%rax), %r11
+ movq 5784(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5760(%rax), %r11
+ movq 5784(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5760(%rax), %r11
+ movq 5784(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5760(%rax), %r11
+ movq 5784(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(VertexAttribs2dvNV), .-GL_PREFIX(VertexAttribs2dvNV)
GL_PREFIX(VertexAttribs2fvNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5768(%rax), %r11
+ movq 5792(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5768(%rax), %r11
+ movq 5792(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5768(%rax), %r11
+ movq 5792(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5768(%rax), %r11
+ movq 5792(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(VertexAttribs2fvNV), .-GL_PREFIX(VertexAttribs2fvNV)
GL_PREFIX(VertexAttribs2svNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5776(%rax), %r11
+ movq 5800(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5776(%rax), %r11
+ movq 5800(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5776(%rax), %r11
+ movq 5800(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5776(%rax), %r11
+ movq 5800(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(VertexAttribs2svNV), .-GL_PREFIX(VertexAttribs2svNV)
GL_PREFIX(VertexAttribs3dvNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5784(%rax), %r11
+ movq 5808(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5784(%rax), %r11
+ movq 5808(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5784(%rax), %r11
+ movq 5808(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5784(%rax), %r11
+ movq 5808(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(VertexAttribs3dvNV), .-GL_PREFIX(VertexAttribs3dvNV)
GL_PREFIX(VertexAttribs3fvNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5792(%rax), %r11
+ movq 5816(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5792(%rax), %r11
+ movq 5816(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5792(%rax), %r11
+ movq 5816(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5792(%rax), %r11
+ movq 5816(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(VertexAttribs3fvNV), .-GL_PREFIX(VertexAttribs3fvNV)
GL_PREFIX(VertexAttribs3svNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5800(%rax), %r11
+ movq 5824(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5800(%rax), %r11
+ movq 5824(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5800(%rax), %r11
+ movq 5824(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5800(%rax), %r11
+ movq 5824(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(VertexAttribs3svNV), .-GL_PREFIX(VertexAttribs3svNV)
GL_PREFIX(VertexAttribs4dvNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5808(%rax), %r11
+ movq 5832(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5808(%rax), %r11
+ movq 5832(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5808(%rax), %r11
+ movq 5832(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5808(%rax), %r11
+ movq 5832(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(VertexAttribs4dvNV), .-GL_PREFIX(VertexAttribs4dvNV)
GL_PREFIX(VertexAttribs4fvNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5816(%rax), %r11
+ movq 5840(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5816(%rax), %r11
+ movq 5840(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5816(%rax), %r11
+ movq 5840(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5816(%rax), %r11
+ movq 5840(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(VertexAttribs4fvNV), .-GL_PREFIX(VertexAttribs4fvNV)
GL_PREFIX(VertexAttribs4svNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5824(%rax), %r11
+ movq 5848(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5824(%rax), %r11
+ movq 5848(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5824(%rax), %r11
+ movq 5848(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5824(%rax), %r11
+ movq 5848(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(VertexAttribs4svNV), .-GL_PREFIX(VertexAttribs4svNV)
GL_PREFIX(VertexAttribs4ubvNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5832(%rax), %r11
+ movq 5856(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5832(%rax), %r11
+ movq 5856(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5832(%rax), %r11
+ movq 5856(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5832(%rax), %r11
+ movq 5856(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(VertexAttribs4ubvNV), .-GL_PREFIX(VertexAttribs4ubvNV)
GL_PREFIX(GetTexBumpParameterfvATI):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5840(%rax), %r11
+ movq 5864(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5840(%rax), %r11
+ movq 5864(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5840(%rax), %r11
+ movq 5864(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5840(%rax), %r11
+ movq 5864(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(GetTexBumpParameterfvATI), .-GL_PREFIX(GetTexBumpParameterfvATI)
GL_PREFIX(GetTexBumpParameterivATI):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5848(%rax), %r11
+ movq 5872(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5848(%rax), %r11
+ movq 5872(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5848(%rax), %r11
+ movq 5872(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5848(%rax), %r11
+ movq 5872(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(GetTexBumpParameterivATI), .-GL_PREFIX(GetTexBumpParameterivATI)
GL_PREFIX(TexBumpParameterfvATI):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5856(%rax), %r11
+ movq 5880(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5856(%rax), %r11
+ movq 5880(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5856(%rax), %r11
+ movq 5880(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5856(%rax), %r11
+ movq 5880(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(TexBumpParameterfvATI), .-GL_PREFIX(TexBumpParameterfvATI)
GL_PREFIX(TexBumpParameterivATI):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5864(%rax), %r11
+ movq 5888(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5864(%rax), %r11
+ movq 5888(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5864(%rax), %r11
+ movq 5888(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5864(%rax), %r11
+ movq 5888(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(TexBumpParameterivATI), .-GL_PREFIX(TexBumpParameterivATI)
GL_PREFIX(AlphaFragmentOp1ATI):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5872(%rax), %r11
+ movq 5896(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5872(%rax), %r11
+ movq 5896(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5872(%rax), %r11
+ movq 5896(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5872(%rax), %r11
+ movq 5896(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(AlphaFragmentOp1ATI), .-GL_PREFIX(AlphaFragmentOp1ATI)
GL_PREFIX(AlphaFragmentOp2ATI):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5880(%rax), %r11
+ movq 5904(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5880(%rax), %r11
+ movq 5904(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5880(%rax), %r11
+ movq 5904(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5880(%rax), %r11
+ movq 5904(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(AlphaFragmentOp2ATI), .-GL_PREFIX(AlphaFragmentOp2ATI)
GL_PREFIX(AlphaFragmentOp3ATI):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5888(%rax), %r11
+ movq 5912(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5888(%rax), %r11
+ movq 5912(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5888(%rax), %r11
+ movq 5912(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5888(%rax), %r11
+ movq 5912(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(AlphaFragmentOp3ATI), .-GL_PREFIX(AlphaFragmentOp3ATI)
GL_PREFIX(BeginFragmentShaderATI):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5896(%rax), %r11
+ movq 5920(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rbp
call _x86_64_get_dispatch@PLT
popq %rbp
- movq 5896(%rax), %r11
+ movq 5920(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5896(%rax), %r11
+ movq 5920(%rax), %r11
jmp *%r11
1:
pushq %rbp
call _glapi_get_dispatch
popq %rbp
- movq 5896(%rax), %r11
+ movq 5920(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(BeginFragmentShaderATI), .-GL_PREFIX(BeginFragmentShaderATI)
GL_PREFIX(BindFragmentShaderATI):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5904(%rax), %r11
+ movq 5928(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
call _x86_64_get_dispatch@PLT
popq %rdi
- movq 5904(%rax), %r11
+ movq 5928(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5904(%rax), %r11
+ movq 5928(%rax), %r11
jmp *%r11
1:
pushq %rdi
call _glapi_get_dispatch
popq %rdi
- movq 5904(%rax), %r11
+ movq 5928(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(BindFragmentShaderATI), .-GL_PREFIX(BindFragmentShaderATI)
GL_PREFIX(ColorFragmentOp1ATI):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5912(%rax), %r11
+ movq 5936(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5912(%rax), %r11
+ movq 5936(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5912(%rax), %r11
+ movq 5936(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5912(%rax), %r11
+ movq 5936(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(ColorFragmentOp1ATI), .-GL_PREFIX(ColorFragmentOp1ATI)
GL_PREFIX(ColorFragmentOp2ATI):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5920(%rax), %r11
+ movq 5944(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5920(%rax), %r11
+ movq 5944(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5920(%rax), %r11
+ movq 5944(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5920(%rax), %r11
+ movq 5944(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(ColorFragmentOp2ATI), .-GL_PREFIX(ColorFragmentOp2ATI)
GL_PREFIX(ColorFragmentOp3ATI):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5928(%rax), %r11
+ movq 5952(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5928(%rax), %r11
+ movq 5952(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5928(%rax), %r11
+ movq 5952(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5928(%rax), %r11
+ movq 5952(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(ColorFragmentOp3ATI), .-GL_PREFIX(ColorFragmentOp3ATI)
GL_PREFIX(DeleteFragmentShaderATI):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5936(%rax), %r11
+ movq 5960(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
call _x86_64_get_dispatch@PLT
popq %rdi
- movq 5936(%rax), %r11
+ movq 5960(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5936(%rax), %r11
+ movq 5960(%rax), %r11
jmp *%r11
1:
pushq %rdi
call _glapi_get_dispatch
popq %rdi
- movq 5936(%rax), %r11
+ movq 5960(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(DeleteFragmentShaderATI), .-GL_PREFIX(DeleteFragmentShaderATI)
GL_PREFIX(EndFragmentShaderATI):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5944(%rax), %r11
+ movq 5968(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rbp
call _x86_64_get_dispatch@PLT
popq %rbp
- movq 5944(%rax), %r11
+ movq 5968(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5944(%rax), %r11
+ movq 5968(%rax), %r11
jmp *%r11
1:
pushq %rbp
call _glapi_get_dispatch
popq %rbp
- movq 5944(%rax), %r11
+ movq 5968(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(EndFragmentShaderATI), .-GL_PREFIX(EndFragmentShaderATI)
GL_PREFIX(GenFragmentShadersATI):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5952(%rax), %r11
+ movq 5976(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
call _x86_64_get_dispatch@PLT
popq %rdi
- movq 5952(%rax), %r11
+ movq 5976(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5952(%rax), %r11
+ movq 5976(%rax), %r11
jmp *%r11
1:
pushq %rdi
call _glapi_get_dispatch
popq %rdi
- movq 5952(%rax), %r11
+ movq 5976(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(GenFragmentShadersATI), .-GL_PREFIX(GenFragmentShadersATI)
GL_PREFIX(PassTexCoordATI):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5960(%rax), %r11
+ movq 5984(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5960(%rax), %r11
+ movq 5984(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5960(%rax), %r11
+ movq 5984(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5960(%rax), %r11
+ movq 5984(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(PassTexCoordATI), .-GL_PREFIX(PassTexCoordATI)
GL_PREFIX(SampleMapATI):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5968(%rax), %r11
+ movq 5992(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5968(%rax), %r11
+ movq 5992(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5968(%rax), %r11
+ movq 5992(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 5968(%rax), %r11
+ movq 5992(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(SampleMapATI), .-GL_PREFIX(SampleMapATI)
GL_PREFIX(SetFragmentShaderConstantATI):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5976(%rax), %r11
+ movq 6000(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5976(%rax), %r11
+ movq 6000(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5976(%rax), %r11
+ movq 6000(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5976(%rax), %r11
+ movq 6000(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(SetFragmentShaderConstantATI), .-GL_PREFIX(SetFragmentShaderConstantATI)
GL_PREFIX(PointParameteriNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5984(%rax), %r11
+ movq 6008(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5984(%rax), %r11
+ movq 6008(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5984(%rax), %r11
+ movq 6008(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5984(%rax), %r11
+ movq 6008(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(PointParameteriNV), .-GL_PREFIX(PointParameteriNV)
GL_PREFIX(PointParameterivNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 5992(%rax), %r11
+ movq 6016(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5992(%rax), %r11
+ movq 6016(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 5992(%rax), %r11
+ movq 6016(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 5992(%rax), %r11
+ movq 6016(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(PointParameterivNV), .-GL_PREFIX(PointParameterivNV)
.p2align 4,,15
- .globl GL_PREFIX(_dispatch_stub_750)
- .type GL_PREFIX(_dispatch_stub_750), @function
- HIDDEN(GL_PREFIX(_dispatch_stub_750))
-GL_PREFIX(_dispatch_stub_750):
+ .globl GL_PREFIX(_dispatch_stub_753)
+ .type GL_PREFIX(_dispatch_stub_753), @function
+ HIDDEN(GL_PREFIX(_dispatch_stub_753))
+GL_PREFIX(_dispatch_stub_753):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 6000(%rax), %r11
+ movq 6024(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
call _x86_64_get_dispatch@PLT
popq %rdi
- movq 6000(%rax), %r11
+ movq 6024(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 6000(%rax), %r11
+ movq 6024(%rax), %r11
jmp *%r11
1:
pushq %rdi
call _glapi_get_dispatch
popq %rdi
- movq 6000(%rax), %r11
+ movq 6024(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
- .size GL_PREFIX(_dispatch_stub_750), .-GL_PREFIX(_dispatch_stub_750)
+ .size GL_PREFIX(_dispatch_stub_753), .-GL_PREFIX(_dispatch_stub_753)
.p2align 4,,15
- .globl GL_PREFIX(_dispatch_stub_751)
- .type GL_PREFIX(_dispatch_stub_751), @function
- HIDDEN(GL_PREFIX(_dispatch_stub_751))
-GL_PREFIX(_dispatch_stub_751):
+ .globl GL_PREFIX(_dispatch_stub_754)
+ .type GL_PREFIX(_dispatch_stub_754), @function
+ HIDDEN(GL_PREFIX(_dispatch_stub_754))
+GL_PREFIX(_dispatch_stub_754):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 6008(%rax), %r11
+ movq 6032(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
call _x86_64_get_dispatch@PLT
popq %rdi
- movq 6008(%rax), %r11
+ movq 6032(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 6008(%rax), %r11
+ movq 6032(%rax), %r11
jmp *%r11
1:
pushq %rdi
call _glapi_get_dispatch
popq %rdi
- movq 6008(%rax), %r11
+ movq 6032(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
- .size GL_PREFIX(_dispatch_stub_751), .-GL_PREFIX(_dispatch_stub_751)
+ .size GL_PREFIX(_dispatch_stub_754), .-GL_PREFIX(_dispatch_stub_754)
.p2align 4,,15
- .globl GL_PREFIX(_dispatch_stub_752)
- .type GL_PREFIX(_dispatch_stub_752), @function
- HIDDEN(GL_PREFIX(_dispatch_stub_752))
-GL_PREFIX(_dispatch_stub_752):
+ .globl GL_PREFIX(_dispatch_stub_755)
+ .type GL_PREFIX(_dispatch_stub_755), @function
+ HIDDEN(GL_PREFIX(_dispatch_stub_755))
+GL_PREFIX(_dispatch_stub_755):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 6016(%rax), %r11
+ movq 6040(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 6016(%rax), %r11
+ movq 6040(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 6016(%rax), %r11
+ movq 6040(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 6016(%rax), %r11
+ movq 6040(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
- .size GL_PREFIX(_dispatch_stub_752), .-GL_PREFIX(_dispatch_stub_752)
+ .size GL_PREFIX(_dispatch_stub_755), .-GL_PREFIX(_dispatch_stub_755)
.p2align 4,,15
- .globl GL_PREFIX(_dispatch_stub_753)
- .type GL_PREFIX(_dispatch_stub_753), @function
- HIDDEN(GL_PREFIX(_dispatch_stub_753))
-GL_PREFIX(_dispatch_stub_753):
+ .globl GL_PREFIX(_dispatch_stub_756)
+ .type GL_PREFIX(_dispatch_stub_756), @function
+ HIDDEN(GL_PREFIX(_dispatch_stub_756))
+GL_PREFIX(_dispatch_stub_756):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 6024(%rax), %r11
+ movq 6048(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 6024(%rax), %r11
+ movq 6048(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 6024(%rax), %r11
+ movq 6048(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 6024(%rax), %r11
+ movq 6048(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
- .size GL_PREFIX(_dispatch_stub_753), .-GL_PREFIX(_dispatch_stub_753)
+ .size GL_PREFIX(_dispatch_stub_756), .-GL_PREFIX(_dispatch_stub_756)
.p2align 4,,15
- .globl GL_PREFIX(_dispatch_stub_754)
- .type GL_PREFIX(_dispatch_stub_754), @function
- HIDDEN(GL_PREFIX(_dispatch_stub_754))
-GL_PREFIX(_dispatch_stub_754):
+ .globl GL_PREFIX(_dispatch_stub_757)
+ .type GL_PREFIX(_dispatch_stub_757), @function
+ HIDDEN(GL_PREFIX(_dispatch_stub_757))
+GL_PREFIX(_dispatch_stub_757):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 6032(%rax), %r11
+ movq 6056(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
call _x86_64_get_dispatch@PLT
popq %rdi
- movq 6032(%rax), %r11
+ movq 6056(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 6032(%rax), %r11
+ movq 6056(%rax), %r11
jmp *%r11
1:
pushq %rdi
call _glapi_get_dispatch
popq %rdi
- movq 6032(%rax), %r11
+ movq 6056(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
- .size GL_PREFIX(_dispatch_stub_754), .-GL_PREFIX(_dispatch_stub_754)
+ .size GL_PREFIX(_dispatch_stub_757), .-GL_PREFIX(_dispatch_stub_757)
.p2align 4,,15
.globl GL_PREFIX(GetProgramNamedParameterdvNV)
GL_PREFIX(GetProgramNamedParameterdvNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 6040(%rax), %r11
+ movq 6064(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 6040(%rax), %r11
+ movq 6064(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 6040(%rax), %r11
+ movq 6064(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 6040(%rax), %r11
+ movq 6064(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(GetProgramNamedParameterdvNV), .-GL_PREFIX(GetProgramNamedParameterdvNV)
GL_PREFIX(GetProgramNamedParameterfvNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 6048(%rax), %r11
+ movq 6072(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 6048(%rax), %r11
+ movq 6072(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 6048(%rax), %r11
+ movq 6072(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 6048(%rax), %r11
+ movq 6072(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(GetProgramNamedParameterfvNV), .-GL_PREFIX(GetProgramNamedParameterfvNV)
GL_PREFIX(ProgramNamedParameter4dNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 6056(%rax), %r11
+ movq 6080(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
subq $56, %rsp
movq 8(%rsp), %rsi
movq (%rsp), %rdi
addq $56, %rsp
- movq 6056(%rax), %r11
+ movq 6080(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 6056(%rax), %r11
+ movq 6080(%rax), %r11
jmp *%r11
1:
subq $56, %rsp
movq 8(%rsp), %rsi
movq (%rsp), %rdi
addq $56, %rsp
- movq 6056(%rax), %r11
+ movq 6080(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(ProgramNamedParameter4dNV), .-GL_PREFIX(ProgramNamedParameter4dNV)
GL_PREFIX(ProgramNamedParameter4dvNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 6064(%rax), %r11
+ movq 6088(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 6064(%rax), %r11
+ movq 6088(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 6064(%rax), %r11
+ movq 6088(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 6064(%rax), %r11
+ movq 6088(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(ProgramNamedParameter4dvNV), .-GL_PREFIX(ProgramNamedParameter4dvNV)
GL_PREFIX(ProgramNamedParameter4fNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 6072(%rax), %r11
+ movq 6096(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
subq $56, %rsp
movq 8(%rsp), %rsi
movq (%rsp), %rdi
addq $56, %rsp
- movq 6072(%rax), %r11
+ movq 6096(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 6072(%rax), %r11
+ movq 6096(%rax), %r11
jmp *%r11
1:
subq $56, %rsp
movq 8(%rsp), %rsi
movq (%rsp), %rdi
addq $56, %rsp
- movq 6072(%rax), %r11
+ movq 6096(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(ProgramNamedParameter4fNV), .-GL_PREFIX(ProgramNamedParameter4fNV)
GL_PREFIX(ProgramNamedParameter4fvNV):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 6080(%rax), %r11
+ movq 6104(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 6080(%rax), %r11
+ movq 6104(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 6080(%rax), %r11
+ movq 6104(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 6080(%rax), %r11
+ movq 6104(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(ProgramNamedParameter4fvNV), .-GL_PREFIX(ProgramNamedParameter4fvNV)
.p2align 4,,15
- .globl GL_PREFIX(_dispatch_stub_761)
- .type GL_PREFIX(_dispatch_stub_761), @function
- HIDDEN(GL_PREFIX(_dispatch_stub_761))
-GL_PREFIX(_dispatch_stub_761):
+ .globl GL_PREFIX(_dispatch_stub_764)
+ .type GL_PREFIX(_dispatch_stub_764), @function
+ HIDDEN(GL_PREFIX(_dispatch_stub_764))
+GL_PREFIX(_dispatch_stub_764):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 6088(%rax), %r11
+ movq 6112(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 6088(%rax), %r11
+ movq 6112(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 6088(%rax), %r11
+ movq 6112(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 6088(%rax), %r11
+ movq 6112(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
- .size GL_PREFIX(_dispatch_stub_761), .-GL_PREFIX(_dispatch_stub_761)
+ .size GL_PREFIX(_dispatch_stub_764), .-GL_PREFIX(_dispatch_stub_764)
.p2align 4,,15
- .globl GL_PREFIX(_dispatch_stub_762)
- .type GL_PREFIX(_dispatch_stub_762), @function
- HIDDEN(GL_PREFIX(_dispatch_stub_762))
-GL_PREFIX(_dispatch_stub_762):
+ .globl GL_PREFIX(_dispatch_stub_765)
+ .type GL_PREFIX(_dispatch_stub_765), @function
+ HIDDEN(GL_PREFIX(_dispatch_stub_765))
+GL_PREFIX(_dispatch_stub_765):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 6096(%rax), %r11
+ movq 6120(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 6096(%rax), %r11
+ movq 6120(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 6096(%rax), %r11
+ movq 6120(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 6096(%rax), %r11
+ movq 6120(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
- .size GL_PREFIX(_dispatch_stub_762), .-GL_PREFIX(_dispatch_stub_762)
+ .size GL_PREFIX(_dispatch_stub_765), .-GL_PREFIX(_dispatch_stub_765)
.p2align 4,,15
.globl GL_PREFIX(BindFramebufferEXT)
GL_PREFIX(BindFramebufferEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 6104(%rax), %r11
+ movq 6128(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 6104(%rax), %r11
+ movq 6128(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 6104(%rax), %r11
+ movq 6128(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 6104(%rax), %r11
+ movq 6128(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(BindFramebufferEXT), .-GL_PREFIX(BindFramebufferEXT)
GL_PREFIX(BindRenderbufferEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 6112(%rax), %r11
+ movq 6136(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 6112(%rax), %r11
+ movq 6136(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 6112(%rax), %r11
+ movq 6136(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 6112(%rax), %r11
+ movq 6136(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(BindRenderbufferEXT), .-GL_PREFIX(BindRenderbufferEXT)
GL_PREFIX(CheckFramebufferStatusEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 6120(%rax), %r11
+ movq 6144(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
call _x86_64_get_dispatch@PLT
popq %rdi
- movq 6120(%rax), %r11
+ movq 6144(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 6120(%rax), %r11
+ movq 6144(%rax), %r11
jmp *%r11
1:
pushq %rdi
call _glapi_get_dispatch
popq %rdi
- movq 6120(%rax), %r11
+ movq 6144(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(CheckFramebufferStatusEXT), .-GL_PREFIX(CheckFramebufferStatusEXT)
GL_PREFIX(DeleteFramebuffersEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 6128(%rax), %r11
+ movq 6152(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 6128(%rax), %r11
+ movq 6152(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 6128(%rax), %r11
+ movq 6152(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 6128(%rax), %r11
+ movq 6152(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(DeleteFramebuffersEXT), .-GL_PREFIX(DeleteFramebuffersEXT)
GL_PREFIX(DeleteRenderbuffersEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 6136(%rax), %r11
+ movq 6160(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 6136(%rax), %r11
+ movq 6160(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 6136(%rax), %r11
+ movq 6160(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 6136(%rax), %r11
+ movq 6160(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(DeleteRenderbuffersEXT), .-GL_PREFIX(DeleteRenderbuffersEXT)
GL_PREFIX(FramebufferRenderbufferEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 6144(%rax), %r11
+ movq 6168(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 6144(%rax), %r11
+ movq 6168(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 6144(%rax), %r11
+ movq 6168(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 6144(%rax), %r11
+ movq 6168(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(FramebufferRenderbufferEXT), .-GL_PREFIX(FramebufferRenderbufferEXT)
GL_PREFIX(FramebufferTexture1DEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 6152(%rax), %r11
+ movq 6176(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 6152(%rax), %r11
+ movq 6176(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 6152(%rax), %r11
+ movq 6176(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 6152(%rax), %r11
+ movq 6176(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(FramebufferTexture1DEXT), .-GL_PREFIX(FramebufferTexture1DEXT)
GL_PREFIX(FramebufferTexture2DEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 6160(%rax), %r11
+ movq 6184(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 6160(%rax), %r11
+ movq 6184(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 6160(%rax), %r11
+ movq 6184(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 6160(%rax), %r11
+ movq 6184(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(FramebufferTexture2DEXT), .-GL_PREFIX(FramebufferTexture2DEXT)
GL_PREFIX(FramebufferTexture3DEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 6168(%rax), %r11
+ movq 6192(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 6168(%rax), %r11
+ movq 6192(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 6168(%rax), %r11
+ movq 6192(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 6168(%rax), %r11
+ movq 6192(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(FramebufferTexture3DEXT), .-GL_PREFIX(FramebufferTexture3DEXT)
GL_PREFIX(GenFramebuffersEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 6176(%rax), %r11
+ movq 6200(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 6176(%rax), %r11
+ movq 6200(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 6176(%rax), %r11
+ movq 6200(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 6176(%rax), %r11
+ movq 6200(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(GenFramebuffersEXT), .-GL_PREFIX(GenFramebuffersEXT)
GL_PREFIX(GenRenderbuffersEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 6184(%rax), %r11
+ movq 6208(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 6184(%rax), %r11
+ movq 6208(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 6184(%rax), %r11
+ movq 6208(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rbp
popq %rsi
popq %rdi
- movq 6184(%rax), %r11
+ movq 6208(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(GenRenderbuffersEXT), .-GL_PREFIX(GenRenderbuffersEXT)
GL_PREFIX(GenerateMipmapEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 6192(%rax), %r11
+ movq 6216(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
call _x86_64_get_dispatch@PLT
popq %rdi
- movq 6192(%rax), %r11
+ movq 6216(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 6192(%rax), %r11
+ movq 6216(%rax), %r11
jmp *%r11
1:
pushq %rdi
call _glapi_get_dispatch
popq %rdi
- movq 6192(%rax), %r11
+ movq 6216(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(GenerateMipmapEXT), .-GL_PREFIX(GenerateMipmapEXT)
GL_PREFIX(GetFramebufferAttachmentParameterivEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 6200(%rax), %r11
+ movq 6224(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 6200(%rax), %r11
+ movq 6224(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 6200(%rax), %r11
+ movq 6224(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 6200(%rax), %r11
+ movq 6224(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(GetFramebufferAttachmentParameterivEXT), .-GL_PREFIX(GetFramebufferAttachmentParameterivEXT)
GL_PREFIX(GetRenderbufferParameterivEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 6208(%rax), %r11
+ movq 6232(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 6208(%rax), %r11
+ movq 6232(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 6208(%rax), %r11
+ movq 6232(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 6208(%rax), %r11
+ movq 6232(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(GetRenderbufferParameterivEXT), .-GL_PREFIX(GetRenderbufferParameterivEXT)
GL_PREFIX(IsFramebufferEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 6216(%rax), %r11
+ movq 6240(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
call _x86_64_get_dispatch@PLT
popq %rdi
- movq 6216(%rax), %r11
+ movq 6240(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 6216(%rax), %r11
+ movq 6240(%rax), %r11
jmp *%r11
1:
pushq %rdi
call _glapi_get_dispatch
popq %rdi
- movq 6216(%rax), %r11
+ movq 6240(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(IsFramebufferEXT), .-GL_PREFIX(IsFramebufferEXT)
GL_PREFIX(IsRenderbufferEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 6224(%rax), %r11
+ movq 6248(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
call _x86_64_get_dispatch@PLT
popq %rdi
- movq 6224(%rax), %r11
+ movq 6248(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 6224(%rax), %r11
+ movq 6248(%rax), %r11
jmp *%r11
1:
pushq %rdi
call _glapi_get_dispatch
popq %rdi
- movq 6224(%rax), %r11
+ movq 6248(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(IsRenderbufferEXT), .-GL_PREFIX(IsRenderbufferEXT)
GL_PREFIX(RenderbufferStorageEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 6232(%rax), %r11
+ movq 6256(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 6232(%rax), %r11
+ movq 6256(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 6232(%rax), %r11
+ movq 6256(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 6232(%rax), %r11
+ movq 6256(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(RenderbufferStorageEXT), .-GL_PREFIX(RenderbufferStorageEXT)
.p2align 4,,15
- .globl GL_PREFIX(_dispatch_stub_780)
- .type GL_PREFIX(_dispatch_stub_780), @function
- HIDDEN(GL_PREFIX(_dispatch_stub_780))
-GL_PREFIX(_dispatch_stub_780):
+ .globl GL_PREFIX(_dispatch_stub_783)
+ .type GL_PREFIX(_dispatch_stub_783), @function
+ HIDDEN(GL_PREFIX(_dispatch_stub_783))
+GL_PREFIX(_dispatch_stub_783):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 6240(%rax), %r11
+ movq 6264(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 6240(%rax), %r11
+ movq 6264(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 6240(%rax), %r11
+ movq 6264(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 6240(%rax), %r11
+ movq 6264(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
- .size GL_PREFIX(_dispatch_stub_780), .-GL_PREFIX(_dispatch_stub_780)
+ .size GL_PREFIX(_dispatch_stub_783), .-GL_PREFIX(_dispatch_stub_783)
.p2align 4,,15
- .globl GL_PREFIX(_dispatch_stub_781)
- .type GL_PREFIX(_dispatch_stub_781), @function
- HIDDEN(GL_PREFIX(_dispatch_stub_781))
-GL_PREFIX(_dispatch_stub_781):
+ .globl GL_PREFIX(_dispatch_stub_784)
+ .type GL_PREFIX(_dispatch_stub_784), @function
+ HIDDEN(GL_PREFIX(_dispatch_stub_784))
+GL_PREFIX(_dispatch_stub_784):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 6248(%rax), %r11
+ movq 6272(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 6248(%rax), %r11
+ movq 6272(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 6248(%rax), %r11
+ movq 6272(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 6248(%rax), %r11
+ movq 6272(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
- .size GL_PREFIX(_dispatch_stub_781), .-GL_PREFIX(_dispatch_stub_781)
+ .size GL_PREFIX(_dispatch_stub_784), .-GL_PREFIX(_dispatch_stub_784)
.p2align 4,,15
- .globl GL_PREFIX(_dispatch_stub_782)
- .type GL_PREFIX(_dispatch_stub_782), @function
- HIDDEN(GL_PREFIX(_dispatch_stub_782))
-GL_PREFIX(_dispatch_stub_782):
+ .globl GL_PREFIX(_dispatch_stub_785)
+ .type GL_PREFIX(_dispatch_stub_785), @function
+ HIDDEN(GL_PREFIX(_dispatch_stub_785))
+GL_PREFIX(_dispatch_stub_785):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 6256(%rax), %r11
+ movq 6280(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 6256(%rax), %r11
+ movq 6280(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 6256(%rax), %r11
+ movq 6280(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 6256(%rax), %r11
+ movq 6280(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
- .size GL_PREFIX(_dispatch_stub_782), .-GL_PREFIX(_dispatch_stub_782)
+ .size GL_PREFIX(_dispatch_stub_785), .-GL_PREFIX(_dispatch_stub_785)
.p2align 4,,15
.globl GL_PREFIX(FramebufferTextureLayerEXT)
GL_PREFIX(FramebufferTextureLayerEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 6264(%rax), %r11
+ movq 6288(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 6264(%rax), %r11
+ movq 6288(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 6264(%rax), %r11
+ movq 6288(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 6264(%rax), %r11
+ movq 6288(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(FramebufferTextureLayerEXT), .-GL_PREFIX(FramebufferTextureLayerEXT)
GL_PREFIX(ProvokingVertexEXT):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 6272(%rax), %r11
+ movq 6296(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
call _x86_64_get_dispatch@PLT
popq %rdi
- movq 6272(%rax), %r11
+ movq 6296(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 6272(%rax), %r11
+ movq 6296(%rax), %r11
jmp *%r11
1:
pushq %rdi
call _glapi_get_dispatch
popq %rdi
- movq 6272(%rax), %r11
+ movq 6296(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
.size GL_PREFIX(ProvokingVertexEXT), .-GL_PREFIX(ProvokingVertexEXT)
.p2align 4,,15
- .globl GL_PREFIX(_dispatch_stub_785)
- .type GL_PREFIX(_dispatch_stub_785), @function
- HIDDEN(GL_PREFIX(_dispatch_stub_785))
-GL_PREFIX(_dispatch_stub_785):
+ .globl GL_PREFIX(_dispatch_stub_788)
+ .type GL_PREFIX(_dispatch_stub_788), @function
+ HIDDEN(GL_PREFIX(_dispatch_stub_788))
+GL_PREFIX(_dispatch_stub_788):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 6280(%rax), %r11
+ movq 6304(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 6280(%rax), %r11
+ movq 6304(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 6280(%rax), %r11
+ movq 6304(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 6280(%rax), %r11
+ movq 6304(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
- .size GL_PREFIX(_dispatch_stub_785), .-GL_PREFIX(_dispatch_stub_785)
+ .size GL_PREFIX(_dispatch_stub_788), .-GL_PREFIX(_dispatch_stub_788)
.p2align 4,,15
- .globl GL_PREFIX(_dispatch_stub_786)
- .type GL_PREFIX(_dispatch_stub_786), @function
- HIDDEN(GL_PREFIX(_dispatch_stub_786))
-GL_PREFIX(_dispatch_stub_786):
+ .globl GL_PREFIX(_dispatch_stub_789)
+ .type GL_PREFIX(_dispatch_stub_789), @function
+ HIDDEN(GL_PREFIX(_dispatch_stub_789))
+GL_PREFIX(_dispatch_stub_789):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 6288(%rax), %r11
+ movq 6312(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 6288(%rax), %r11
+ movq 6312(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 6288(%rax), %r11
+ movq 6312(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 6288(%rax), %r11
+ movq 6312(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
- .size GL_PREFIX(_dispatch_stub_786), .-GL_PREFIX(_dispatch_stub_786)
+ .size GL_PREFIX(_dispatch_stub_789), .-GL_PREFIX(_dispatch_stub_789)
.p2align 4,,15
- .globl GL_PREFIX(_dispatch_stub_787)
- .type GL_PREFIX(_dispatch_stub_787), @function
- HIDDEN(GL_PREFIX(_dispatch_stub_787))
-GL_PREFIX(_dispatch_stub_787):
+ .globl GL_PREFIX(_dispatch_stub_790)
+ .type GL_PREFIX(_dispatch_stub_790), @function
+ HIDDEN(GL_PREFIX(_dispatch_stub_790))
+GL_PREFIX(_dispatch_stub_790):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 6296(%rax), %r11
+ movq 6320(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 6296(%rax), %r11
+ movq 6320(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 6296(%rax), %r11
+ movq 6320(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 6296(%rax), %r11
+ movq 6320(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
- .size GL_PREFIX(_dispatch_stub_787), .-GL_PREFIX(_dispatch_stub_787)
+ .size GL_PREFIX(_dispatch_stub_790), .-GL_PREFIX(_dispatch_stub_790)
.p2align 4,,15
- .globl GL_PREFIX(_dispatch_stub_788)
- .type GL_PREFIX(_dispatch_stub_788), @function
- HIDDEN(GL_PREFIX(_dispatch_stub_788))
-GL_PREFIX(_dispatch_stub_788):
+ .globl GL_PREFIX(_dispatch_stub_791)
+ .type GL_PREFIX(_dispatch_stub_791), @function
+ HIDDEN(GL_PREFIX(_dispatch_stub_791))
+GL_PREFIX(_dispatch_stub_791):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 6304(%rax), %r11
+ movq 6328(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 6304(%rax), %r11
+ movq 6328(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 6304(%rax), %r11
+ movq 6328(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 6304(%rax), %r11
+ movq 6328(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
- .size GL_PREFIX(_dispatch_stub_788), .-GL_PREFIX(_dispatch_stub_788)
+ .size GL_PREFIX(_dispatch_stub_791), .-GL_PREFIX(_dispatch_stub_791)
.p2align 4,,15
- .globl GL_PREFIX(_dispatch_stub_789)
- .type GL_PREFIX(_dispatch_stub_789), @function
- HIDDEN(GL_PREFIX(_dispatch_stub_789))
-GL_PREFIX(_dispatch_stub_789):
+ .globl GL_PREFIX(_dispatch_stub_792)
+ .type GL_PREFIX(_dispatch_stub_792), @function
+ HIDDEN(GL_PREFIX(_dispatch_stub_792))
+GL_PREFIX(_dispatch_stub_792):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 6312(%rax), %r11
+ movq 6336(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 6312(%rax), %r11
+ movq 6336(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 6312(%rax), %r11
+ movq 6336(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 6312(%rax), %r11
+ movq 6336(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
- .size GL_PREFIX(_dispatch_stub_789), .-GL_PREFIX(_dispatch_stub_789)
+ .size GL_PREFIX(_dispatch_stub_792), .-GL_PREFIX(_dispatch_stub_792)
.p2align 4,,15
- .globl GL_PREFIX(_dispatch_stub_790)
- .type GL_PREFIX(_dispatch_stub_790), @function
- HIDDEN(GL_PREFIX(_dispatch_stub_790))
-GL_PREFIX(_dispatch_stub_790):
+ .globl GL_PREFIX(_dispatch_stub_793)
+ .type GL_PREFIX(_dispatch_stub_793), @function
+ HIDDEN(GL_PREFIX(_dispatch_stub_793))
+GL_PREFIX(_dispatch_stub_793):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 6320(%rax), %r11
+ movq 6344(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 6320(%rax), %r11
+ movq 6344(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 6320(%rax), %r11
+ movq 6344(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 6320(%rax), %r11
+ movq 6344(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
- .size GL_PREFIX(_dispatch_stub_790), .-GL_PREFIX(_dispatch_stub_790)
+ .size GL_PREFIX(_dispatch_stub_793), .-GL_PREFIX(_dispatch_stub_793)
.p2align 4,,15
- .globl GL_PREFIX(_dispatch_stub_791)
- .type GL_PREFIX(_dispatch_stub_791), @function
- HIDDEN(GL_PREFIX(_dispatch_stub_791))
-GL_PREFIX(_dispatch_stub_791):
+ .globl GL_PREFIX(_dispatch_stub_794)
+ .type GL_PREFIX(_dispatch_stub_794), @function
+ HIDDEN(GL_PREFIX(_dispatch_stub_794))
+GL_PREFIX(_dispatch_stub_794):
#if defined(GLX_USE_TLS)
call _x86_64_get_dispatch@PLT
- movq 6328(%rax), %r11
+ movq 6352(%rax), %r11
jmp *%r11
#elif defined(PTHREADS)
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 6328(%rax), %r11
+ movq 6352(%rax), %r11
jmp *%r11
#else
movq _glapi_Dispatch(%rip), %rax
testq %rax, %rax
je 1f
- movq 6328(%rax), %r11
+ movq 6352(%rax), %r11
jmp *%r11
1:
pushq %rdi
popq %rdx
popq %rsi
popq %rdi
- movq 6328(%rax), %r11
+ movq 6352(%rax), %r11
jmp *%r11
#endif /* defined(GLX_USE_TLS) */
- .size GL_PREFIX(_dispatch_stub_791), .-GL_PREFIX(_dispatch_stub_791)
+ .size GL_PREFIX(_dispatch_stub_794), .-GL_PREFIX(_dispatch_stub_794)
.globl GL_PREFIX(ArrayElementEXT) ; .set GL_PREFIX(ArrayElementEXT), GL_PREFIX(ArrayElement)
.globl GL_PREFIX(BindTextureEXT) ; .set GL_PREFIX(BindTextureEXT), GL_PREFIX(BindTexture)
.globl GL_PREFIX(IsProgramARB) ; .set GL_PREFIX(IsProgramARB), GL_PREFIX(IsProgramNV)
.globl GL_PREFIX(PointParameteri) ; .set GL_PREFIX(PointParameteri), GL_PREFIX(PointParameteriNV)
.globl GL_PREFIX(PointParameteriv) ; .set GL_PREFIX(PointParameteriv), GL_PREFIX(PointParameterivNV)
- .globl GL_PREFIX(DeleteVertexArrays) ; .set GL_PREFIX(DeleteVertexArrays), GL_PREFIX(_dispatch_stub_752)
- .globl GL_PREFIX(IsVertexArray) ; .set GL_PREFIX(IsVertexArray), GL_PREFIX(_dispatch_stub_754)
- .globl GL_PREFIX(BlendEquationSeparate) ; .set GL_PREFIX(BlendEquationSeparate), GL_PREFIX(_dispatch_stub_762)
+ .globl GL_PREFIX(DeleteVertexArrays) ; .set GL_PREFIX(DeleteVertexArrays), GL_PREFIX(_dispatch_stub_755)
+ .globl GL_PREFIX(IsVertexArray) ; .set GL_PREFIX(IsVertexArray), GL_PREFIX(_dispatch_stub_757)
+ .globl GL_PREFIX(BlendEquationSeparate) ; .set GL_PREFIX(BlendEquationSeparate), GL_PREFIX(_dispatch_stub_765)
.globl GL_PREFIX(BindFramebuffer) ; .set GL_PREFIX(BindFramebuffer), GL_PREFIX(BindFramebufferEXT)
.globl GL_PREFIX(BindRenderbuffer) ; .set GL_PREFIX(BindRenderbuffer), GL_PREFIX(BindRenderbufferEXT)
.globl GL_PREFIX(CheckFramebufferStatus) ; .set GL_PREFIX(CheckFramebufferStatus), GL_PREFIX(CheckFramebufferStatusEXT)
.globl GL_PREFIX(IsFramebuffer) ; .set GL_PREFIX(IsFramebuffer), GL_PREFIX(IsFramebufferEXT)
.globl GL_PREFIX(IsRenderbuffer) ; .set GL_PREFIX(IsRenderbuffer), GL_PREFIX(IsRenderbufferEXT)
.globl GL_PREFIX(RenderbufferStorage) ; .set GL_PREFIX(RenderbufferStorage), GL_PREFIX(RenderbufferStorageEXT)
- .globl GL_PREFIX(BlitFramebuffer) ; .set GL_PREFIX(BlitFramebuffer), GL_PREFIX(_dispatch_stub_780)
+ .globl GL_PREFIX(BlitFramebuffer) ; .set GL_PREFIX(BlitFramebuffer), GL_PREFIX(_dispatch_stub_783)
.globl GL_PREFIX(FramebufferTextureLayer) ; .set GL_PREFIX(FramebufferTextureLayer), GL_PREFIX(FramebufferTextureLayerEXT)
#if defined(GLX_USE_TLS) && defined(__linux__)
GL_STUB(GetSynciv, _gloffset_GetSynciv, GetSynciv@20)
GL_STUB(IsSync, _gloffset_IsSync, IsSync@4)
GL_STUB(WaitSync, _gloffset_WaitSync, WaitSync@12)
+ GL_STUB(DrawElementsBaseVertex, _gloffset_DrawElementsBaseVertex, DrawElementsBaseVertex@20)
+ GL_STUB(DrawRangeElementsBaseVertex, _gloffset_DrawRangeElementsBaseVertex, DrawRangeElementsBaseVertex@28)
+ GL_STUB(MultiDrawElementsBaseVertex, _gloffset_MultiDrawElementsBaseVertex, MultiDrawElementsBaseVertex@24)
GL_STUB(PolygonOffsetEXT, _gloffset_PolygonOffsetEXT, PolygonOffsetEXT@8)
- GL_STUB(_dispatch_stub_575, _gloffset_GetPixelTexGenParameterfvSGIS, _dispatch_stub_575@8)
- HIDDEN(GL_PREFIX(_dispatch_stub_575, _dispatch_stub_575@8))
- GL_STUB(_dispatch_stub_576, _gloffset_GetPixelTexGenParameterivSGIS, _dispatch_stub_576@8)
- HIDDEN(GL_PREFIX(_dispatch_stub_576, _dispatch_stub_576@8))
- GL_STUB(_dispatch_stub_577, _gloffset_PixelTexGenParameterfSGIS, _dispatch_stub_577@8)
- HIDDEN(GL_PREFIX(_dispatch_stub_577, _dispatch_stub_577@8))
- GL_STUB(_dispatch_stub_578, _gloffset_PixelTexGenParameterfvSGIS, _dispatch_stub_578@8)
+ GL_STUB(_dispatch_stub_578, _gloffset_GetPixelTexGenParameterfvSGIS, _dispatch_stub_578@8)
HIDDEN(GL_PREFIX(_dispatch_stub_578, _dispatch_stub_578@8))
- GL_STUB(_dispatch_stub_579, _gloffset_PixelTexGenParameteriSGIS, _dispatch_stub_579@8)
+ GL_STUB(_dispatch_stub_579, _gloffset_GetPixelTexGenParameterivSGIS, _dispatch_stub_579@8)
HIDDEN(GL_PREFIX(_dispatch_stub_579, _dispatch_stub_579@8))
- GL_STUB(_dispatch_stub_580, _gloffset_PixelTexGenParameterivSGIS, _dispatch_stub_580@8)
+ GL_STUB(_dispatch_stub_580, _gloffset_PixelTexGenParameterfSGIS, _dispatch_stub_580@8)
HIDDEN(GL_PREFIX(_dispatch_stub_580, _dispatch_stub_580@8))
- GL_STUB(_dispatch_stub_581, _gloffset_SampleMaskSGIS, _dispatch_stub_581@8)
+ GL_STUB(_dispatch_stub_581, _gloffset_PixelTexGenParameterfvSGIS, _dispatch_stub_581@8)
HIDDEN(GL_PREFIX(_dispatch_stub_581, _dispatch_stub_581@8))
- GL_STUB(_dispatch_stub_582, _gloffset_SamplePatternSGIS, _dispatch_stub_582@4)
- HIDDEN(GL_PREFIX(_dispatch_stub_582, _dispatch_stub_582@4))
+ GL_STUB(_dispatch_stub_582, _gloffset_PixelTexGenParameteriSGIS, _dispatch_stub_582@8)
+ HIDDEN(GL_PREFIX(_dispatch_stub_582, _dispatch_stub_582@8))
+ GL_STUB(_dispatch_stub_583, _gloffset_PixelTexGenParameterivSGIS, _dispatch_stub_583@8)
+ HIDDEN(GL_PREFIX(_dispatch_stub_583, _dispatch_stub_583@8))
+ GL_STUB(_dispatch_stub_584, _gloffset_SampleMaskSGIS, _dispatch_stub_584@8)
+ HIDDEN(GL_PREFIX(_dispatch_stub_584, _dispatch_stub_584@8))
+ GL_STUB(_dispatch_stub_585, _gloffset_SamplePatternSGIS, _dispatch_stub_585@4)
+ HIDDEN(GL_PREFIX(_dispatch_stub_585, _dispatch_stub_585@4))
GL_STUB(ColorPointerEXT, _gloffset_ColorPointerEXT, ColorPointerEXT@20)
GL_STUB(EdgeFlagPointerEXT, _gloffset_EdgeFlagPointerEXT, EdgeFlagPointerEXT@12)
GL_STUB(IndexPointerEXT, _gloffset_IndexPointerEXT, IndexPointerEXT@16)
GL_STUB(PointParameterfvEXT, _gloffset_PointParameterfvEXT, PointParameterfvEXT@8)
GL_STUB(LockArraysEXT, _gloffset_LockArraysEXT, LockArraysEXT@8)
GL_STUB(UnlockArraysEXT, _gloffset_UnlockArraysEXT, UnlockArraysEXT@0)
- GL_STUB(_dispatch_stub_593, _gloffset_CullParameterdvEXT, _dispatch_stub_593@8)
- HIDDEN(GL_PREFIX(_dispatch_stub_593, _dispatch_stub_593@8))
- GL_STUB(_dispatch_stub_594, _gloffset_CullParameterfvEXT, _dispatch_stub_594@8)
- HIDDEN(GL_PREFIX(_dispatch_stub_594, _dispatch_stub_594@8))
+ GL_STUB(_dispatch_stub_596, _gloffset_CullParameterdvEXT, _dispatch_stub_596@8)
+ HIDDEN(GL_PREFIX(_dispatch_stub_596, _dispatch_stub_596@8))
+ GL_STUB(_dispatch_stub_597, _gloffset_CullParameterfvEXT, _dispatch_stub_597@8)
+ HIDDEN(GL_PREFIX(_dispatch_stub_597, _dispatch_stub_597@8))
GL_STUB(SecondaryColor3bEXT, _gloffset_SecondaryColor3bEXT, SecondaryColor3bEXT@12)
GL_STUB(SecondaryColor3bvEXT, _gloffset_SecondaryColor3bvEXT, SecondaryColor3bvEXT@4)
GL_STUB(SecondaryColor3dEXT, _gloffset_SecondaryColor3dEXT, SecondaryColor3dEXT@24)
GL_STUB(FogCoorddvEXT, _gloffset_FogCoorddvEXT, FogCoorddvEXT@4)
GL_STUB(FogCoordfEXT, _gloffset_FogCoordfEXT, FogCoordfEXT@4)
GL_STUB(FogCoordfvEXT, _gloffset_FogCoordfvEXT, FogCoordfvEXT@4)
- GL_STUB(_dispatch_stub_619, _gloffset_PixelTexGenSGIX, _dispatch_stub_619@4)
- HIDDEN(GL_PREFIX(_dispatch_stub_619, _dispatch_stub_619@4))
+ GL_STUB(_dispatch_stub_622, _gloffset_PixelTexGenSGIX, _dispatch_stub_622@4)
+ HIDDEN(GL_PREFIX(_dispatch_stub_622, _dispatch_stub_622@4))
GL_STUB(BlendFuncSeparateEXT, _gloffset_BlendFuncSeparateEXT, BlendFuncSeparateEXT@16)
GL_STUB(FlushVertexArrayRangeNV, _gloffset_FlushVertexArrayRangeNV, FlushVertexArrayRangeNV@0)
GL_STUB(VertexArrayRangeNV, _gloffset_VertexArrayRangeNV, VertexArrayRangeNV@8)
GL_STUB(WindowPos4ivMESA, _gloffset_WindowPos4ivMESA, WindowPos4ivMESA@4)
GL_STUB(WindowPos4sMESA, _gloffset_WindowPos4sMESA, WindowPos4sMESA@16)
GL_STUB(WindowPos4svMESA, _gloffset_WindowPos4svMESA, WindowPos4svMESA@4)
- GL_STUB(_dispatch_stub_661, _gloffset_MultiModeDrawArraysIBM, _dispatch_stub_661@20)
- HIDDEN(GL_PREFIX(_dispatch_stub_661, _dispatch_stub_661@20))
- GL_STUB(_dispatch_stub_662, _gloffset_MultiModeDrawElementsIBM, _dispatch_stub_662@24)
- HIDDEN(GL_PREFIX(_dispatch_stub_662, _dispatch_stub_662@24))
- GL_STUB(_dispatch_stub_663, _gloffset_DeleteFencesNV, _dispatch_stub_663@8)
- HIDDEN(GL_PREFIX(_dispatch_stub_663, _dispatch_stub_663@8))
- GL_STUB(_dispatch_stub_664, _gloffset_FinishFenceNV, _dispatch_stub_664@4)
- HIDDEN(GL_PREFIX(_dispatch_stub_664, _dispatch_stub_664@4))
- GL_STUB(_dispatch_stub_665, _gloffset_GenFencesNV, _dispatch_stub_665@8)
- HIDDEN(GL_PREFIX(_dispatch_stub_665, _dispatch_stub_665@8))
- GL_STUB(_dispatch_stub_666, _gloffset_GetFenceivNV, _dispatch_stub_666@12)
- HIDDEN(GL_PREFIX(_dispatch_stub_666, _dispatch_stub_666@12))
- GL_STUB(_dispatch_stub_667, _gloffset_IsFenceNV, _dispatch_stub_667@4)
+ GL_STUB(_dispatch_stub_664, _gloffset_MultiModeDrawArraysIBM, _dispatch_stub_664@20)
+ HIDDEN(GL_PREFIX(_dispatch_stub_664, _dispatch_stub_664@20))
+ GL_STUB(_dispatch_stub_665, _gloffset_MultiModeDrawElementsIBM, _dispatch_stub_665@24)
+ HIDDEN(GL_PREFIX(_dispatch_stub_665, _dispatch_stub_665@24))
+ GL_STUB(_dispatch_stub_666, _gloffset_DeleteFencesNV, _dispatch_stub_666@8)
+ HIDDEN(GL_PREFIX(_dispatch_stub_666, _dispatch_stub_666@8))
+ GL_STUB(_dispatch_stub_667, _gloffset_FinishFenceNV, _dispatch_stub_667@4)
HIDDEN(GL_PREFIX(_dispatch_stub_667, _dispatch_stub_667@4))
- GL_STUB(_dispatch_stub_668, _gloffset_SetFenceNV, _dispatch_stub_668@8)
+ GL_STUB(_dispatch_stub_668, _gloffset_GenFencesNV, _dispatch_stub_668@8)
HIDDEN(GL_PREFIX(_dispatch_stub_668, _dispatch_stub_668@8))
- GL_STUB(_dispatch_stub_669, _gloffset_TestFenceNV, _dispatch_stub_669@4)
- HIDDEN(GL_PREFIX(_dispatch_stub_669, _dispatch_stub_669@4))
+ GL_STUB(_dispatch_stub_669, _gloffset_GetFenceivNV, _dispatch_stub_669@12)
+ HIDDEN(GL_PREFIX(_dispatch_stub_669, _dispatch_stub_669@12))
+ GL_STUB(_dispatch_stub_670, _gloffset_IsFenceNV, _dispatch_stub_670@4)
+ HIDDEN(GL_PREFIX(_dispatch_stub_670, _dispatch_stub_670@4))
+ GL_STUB(_dispatch_stub_671, _gloffset_SetFenceNV, _dispatch_stub_671@8)
+ HIDDEN(GL_PREFIX(_dispatch_stub_671, _dispatch_stub_671@8))
+ GL_STUB(_dispatch_stub_672, _gloffset_TestFenceNV, _dispatch_stub_672@4)
+ HIDDEN(GL_PREFIX(_dispatch_stub_672, _dispatch_stub_672@4))
GL_STUB(AreProgramsResidentNV, _gloffset_AreProgramsResidentNV, AreProgramsResidentNV@12)
GL_STUB(BindProgramNV, _gloffset_BindProgramNV, BindProgramNV@8)
GL_STUB(DeleteProgramsNV, _gloffset_DeleteProgramsNV, DeleteProgramsNV@8)
GL_STUB(SetFragmentShaderConstantATI, _gloffset_SetFragmentShaderConstantATI, SetFragmentShaderConstantATI@8)
GL_STUB(PointParameteriNV, _gloffset_PointParameteriNV, PointParameteriNV@8)
GL_STUB(PointParameterivNV, _gloffset_PointParameterivNV, PointParameterivNV@8)
- GL_STUB(_dispatch_stub_750, _gloffset_ActiveStencilFaceEXT, _dispatch_stub_750@4)
- HIDDEN(GL_PREFIX(_dispatch_stub_750, _dispatch_stub_750@4))
- GL_STUB(_dispatch_stub_751, _gloffset_BindVertexArrayAPPLE, _dispatch_stub_751@4)
- HIDDEN(GL_PREFIX(_dispatch_stub_751, _dispatch_stub_751@4))
- GL_STUB(_dispatch_stub_752, _gloffset_DeleteVertexArraysAPPLE, _dispatch_stub_752@8)
- HIDDEN(GL_PREFIX(_dispatch_stub_752, _dispatch_stub_752@8))
- GL_STUB(_dispatch_stub_753, _gloffset_GenVertexArraysAPPLE, _dispatch_stub_753@8)
- HIDDEN(GL_PREFIX(_dispatch_stub_753, _dispatch_stub_753@8))
- GL_STUB(_dispatch_stub_754, _gloffset_IsVertexArrayAPPLE, _dispatch_stub_754@4)
+ GL_STUB(_dispatch_stub_753, _gloffset_ActiveStencilFaceEXT, _dispatch_stub_753@4)
+ HIDDEN(GL_PREFIX(_dispatch_stub_753, _dispatch_stub_753@4))
+ GL_STUB(_dispatch_stub_754, _gloffset_BindVertexArrayAPPLE, _dispatch_stub_754@4)
HIDDEN(GL_PREFIX(_dispatch_stub_754, _dispatch_stub_754@4))
+ GL_STUB(_dispatch_stub_755, _gloffset_DeleteVertexArraysAPPLE, _dispatch_stub_755@8)
+ HIDDEN(GL_PREFIX(_dispatch_stub_755, _dispatch_stub_755@8))
+ GL_STUB(_dispatch_stub_756, _gloffset_GenVertexArraysAPPLE, _dispatch_stub_756@8)
+ HIDDEN(GL_PREFIX(_dispatch_stub_756, _dispatch_stub_756@8))
+ GL_STUB(_dispatch_stub_757, _gloffset_IsVertexArrayAPPLE, _dispatch_stub_757@4)
+ HIDDEN(GL_PREFIX(_dispatch_stub_757, _dispatch_stub_757@4))
GL_STUB(GetProgramNamedParameterdvNV, _gloffset_GetProgramNamedParameterdvNV, GetProgramNamedParameterdvNV@16)
GL_STUB(GetProgramNamedParameterfvNV, _gloffset_GetProgramNamedParameterfvNV, GetProgramNamedParameterfvNV@16)
GL_STUB(ProgramNamedParameter4dNV, _gloffset_ProgramNamedParameter4dNV, ProgramNamedParameter4dNV@44)
GL_STUB(ProgramNamedParameter4dvNV, _gloffset_ProgramNamedParameter4dvNV, ProgramNamedParameter4dvNV@16)
GL_STUB(ProgramNamedParameter4fNV, _gloffset_ProgramNamedParameter4fNV, ProgramNamedParameter4fNV@28)
GL_STUB(ProgramNamedParameter4fvNV, _gloffset_ProgramNamedParameter4fvNV, ProgramNamedParameter4fvNV@16)
- GL_STUB(_dispatch_stub_761, _gloffset_DepthBoundsEXT, _dispatch_stub_761@16)
- HIDDEN(GL_PREFIX(_dispatch_stub_761, _dispatch_stub_761@16))
- GL_STUB(_dispatch_stub_762, _gloffset_BlendEquationSeparateEXT, _dispatch_stub_762@8)
- HIDDEN(GL_PREFIX(_dispatch_stub_762, _dispatch_stub_762@8))
+ GL_STUB(_dispatch_stub_764, _gloffset_DepthBoundsEXT, _dispatch_stub_764@16)
+ HIDDEN(GL_PREFIX(_dispatch_stub_764, _dispatch_stub_764@16))
+ GL_STUB(_dispatch_stub_765, _gloffset_BlendEquationSeparateEXT, _dispatch_stub_765@8)
+ HIDDEN(GL_PREFIX(_dispatch_stub_765, _dispatch_stub_765@8))
GL_STUB(BindFramebufferEXT, _gloffset_BindFramebufferEXT, BindFramebufferEXT@8)
GL_STUB(BindRenderbufferEXT, _gloffset_BindRenderbufferEXT, BindRenderbufferEXT@8)
GL_STUB(CheckFramebufferStatusEXT, _gloffset_CheckFramebufferStatusEXT, CheckFramebufferStatusEXT@4)
GL_STUB(IsFramebufferEXT, _gloffset_IsFramebufferEXT, IsFramebufferEXT@4)
GL_STUB(IsRenderbufferEXT, _gloffset_IsRenderbufferEXT, IsRenderbufferEXT@4)
GL_STUB(RenderbufferStorageEXT, _gloffset_RenderbufferStorageEXT, RenderbufferStorageEXT@16)
- GL_STUB(_dispatch_stub_780, _gloffset_BlitFramebufferEXT, _dispatch_stub_780@40)
- HIDDEN(GL_PREFIX(_dispatch_stub_780, _dispatch_stub_780@40))
- GL_STUB(_dispatch_stub_781, _gloffset_BufferParameteriAPPLE, _dispatch_stub_781@12)
- HIDDEN(GL_PREFIX(_dispatch_stub_781, _dispatch_stub_781@12))
- GL_STUB(_dispatch_stub_782, _gloffset_FlushMappedBufferRangeAPPLE, _dispatch_stub_782@12)
- HIDDEN(GL_PREFIX(_dispatch_stub_782, _dispatch_stub_782@12))
+ GL_STUB(_dispatch_stub_783, _gloffset_BlitFramebufferEXT, _dispatch_stub_783@40)
+ HIDDEN(GL_PREFIX(_dispatch_stub_783, _dispatch_stub_783@40))
+ GL_STUB(_dispatch_stub_784, _gloffset_BufferParameteriAPPLE, _dispatch_stub_784@12)
+ HIDDEN(GL_PREFIX(_dispatch_stub_784, _dispatch_stub_784@12))
+ GL_STUB(_dispatch_stub_785, _gloffset_FlushMappedBufferRangeAPPLE, _dispatch_stub_785@12)
+ HIDDEN(GL_PREFIX(_dispatch_stub_785, _dispatch_stub_785@12))
GL_STUB(FramebufferTextureLayerEXT, _gloffset_FramebufferTextureLayerEXT, FramebufferTextureLayerEXT@20)
GL_STUB(ProvokingVertexEXT, _gloffset_ProvokingVertexEXT, ProvokingVertexEXT@4)
- GL_STUB(_dispatch_stub_785, _gloffset_GetTexParameterPointervAPPLE, _dispatch_stub_785@12)
- HIDDEN(GL_PREFIX(_dispatch_stub_785, _dispatch_stub_785@12))
- GL_STUB(_dispatch_stub_786, _gloffset_TextureRangeAPPLE, _dispatch_stub_786@12)
- HIDDEN(GL_PREFIX(_dispatch_stub_786, _dispatch_stub_786@12))
- GL_STUB(_dispatch_stub_787, _gloffset_StencilFuncSeparateATI, _dispatch_stub_787@16)
- HIDDEN(GL_PREFIX(_dispatch_stub_787, _dispatch_stub_787@16))
- GL_STUB(_dispatch_stub_788, _gloffset_ProgramEnvParameters4fvEXT, _dispatch_stub_788@16)
- HIDDEN(GL_PREFIX(_dispatch_stub_788, _dispatch_stub_788@16))
- GL_STUB(_dispatch_stub_789, _gloffset_ProgramLocalParameters4fvEXT, _dispatch_stub_789@16)
- HIDDEN(GL_PREFIX(_dispatch_stub_789, _dispatch_stub_789@16))
- GL_STUB(_dispatch_stub_790, _gloffset_GetQueryObjecti64vEXT, _dispatch_stub_790@12)
- HIDDEN(GL_PREFIX(_dispatch_stub_790, _dispatch_stub_790@12))
- GL_STUB(_dispatch_stub_791, _gloffset_GetQueryObjectui64vEXT, _dispatch_stub_791@12)
- HIDDEN(GL_PREFIX(_dispatch_stub_791, _dispatch_stub_791@12))
+ GL_STUB(_dispatch_stub_788, _gloffset_GetTexParameterPointervAPPLE, _dispatch_stub_788@12)
+ HIDDEN(GL_PREFIX(_dispatch_stub_788, _dispatch_stub_788@12))
+ GL_STUB(_dispatch_stub_789, _gloffset_TextureRangeAPPLE, _dispatch_stub_789@12)
+ HIDDEN(GL_PREFIX(_dispatch_stub_789, _dispatch_stub_789@12))
+ GL_STUB(_dispatch_stub_790, _gloffset_StencilFuncSeparateATI, _dispatch_stub_790@16)
+ HIDDEN(GL_PREFIX(_dispatch_stub_790, _dispatch_stub_790@16))
+ GL_STUB(_dispatch_stub_791, _gloffset_ProgramEnvParameters4fvEXT, _dispatch_stub_791@16)
+ HIDDEN(GL_PREFIX(_dispatch_stub_791, _dispatch_stub_791@16))
+ GL_STUB(_dispatch_stub_792, _gloffset_ProgramLocalParameters4fvEXT, _dispatch_stub_792@16)
+ HIDDEN(GL_PREFIX(_dispatch_stub_792, _dispatch_stub_792@16))
+ GL_STUB(_dispatch_stub_793, _gloffset_GetQueryObjecti64vEXT, _dispatch_stub_793@12)
+ HIDDEN(GL_PREFIX(_dispatch_stub_793, _dispatch_stub_793@12))
+ GL_STUB(_dispatch_stub_794, _gloffset_GetQueryObjectui64vEXT, _dispatch_stub_794@12)
+ HIDDEN(GL_PREFIX(_dispatch_stub_794, _dispatch_stub_794@12))
GL_STUB_ALIAS(ArrayElementEXT, _gloffset_ArrayElement, ArrayElementEXT@4, ArrayElement, ArrayElement@4)
GL_STUB_ALIAS(BindTextureEXT, _gloffset_BindTexture, BindTextureEXT@8, BindTexture, BindTexture@8)
GL_STUB_ALIAS(DrawArraysEXT, _gloffset_DrawArrays, DrawArraysEXT@12, DrawArrays, DrawArrays@12)
GLvector4f *proj_vec,
GLubyte clipMask[],
GLubyte *orMask,
- GLubyte *andMask );
+ GLubyte *andMask,
+ GLboolean viewport_z_clip );
extern GLvector4f * _ASMAPI
_mesa_x86_cliptest_points4_np( GLvector4f *clip_vec,
GLvector4f *proj_vec,
GLubyte clipMask[],
GLubyte *orMask,
- GLubyte *andMask );
+ GLubyte *andMask,
+ GLboolean viewport_z_clip );
extern void _ASMAPI
_mesa_v16_x86_cliptest_points4( GLfloat *first_vert,
GLfloat *last_vert,
GLubyte *or_mask,
GLubyte *and_mask,
- GLubyte *clip_mask );
+ GLubyte *clip_mask,
+ GLboolean viewport_z_clip );
extern void _ASMAPI
_mesa_v16_x86_general_xform( GLfloat *dest,
projects / mesa.git / commitdiff