#include "c99_math.h"
#include "glheader.h"
-#include "imports.h"
+
#include "api_arrayelt.h"
#include "api_exec.h"
#include "api_loopback.h"
#include "main/dispatch.h"
#include "vbo/vbo.h"
+#include "vbo/vbo_util.h"
+#include "util/format_r11g11b10f.h"
+#include "util/u_memory.h"
#define USE_BITMAP_ATLAS 1
OPCODE_UNIFORM_MATRIX34D,
OPCODE_UNIFORM_MATRIX43D,
+ /* GL_ARB_gpu_shader_int64 */
+ OPCODE_UNIFORM_1I64,
+ OPCODE_UNIFORM_2I64,
+ OPCODE_UNIFORM_3I64,
+ OPCODE_UNIFORM_4I64,
+ OPCODE_UNIFORM_1I64V,
+ OPCODE_UNIFORM_2I64V,
+ OPCODE_UNIFORM_3I64V,
+ OPCODE_UNIFORM_4I64V,
+ OPCODE_UNIFORM_1UI64,
+ OPCODE_UNIFORM_2UI64,
+ OPCODE_UNIFORM_3UI64,
+ OPCODE_UNIFORM_4UI64,
+ OPCODE_UNIFORM_1UI64V,
+ OPCODE_UNIFORM_2UI64V,
+ OPCODE_UNIFORM_3UI64V,
+ OPCODE_UNIFORM_4UI64V,
+ OPCODE_PROGRAM_UNIFORM_1I64,
+ OPCODE_PROGRAM_UNIFORM_2I64,
+ OPCODE_PROGRAM_UNIFORM_3I64,
+ OPCODE_PROGRAM_UNIFORM_4I64,
+ OPCODE_PROGRAM_UNIFORM_1I64V,
+ OPCODE_PROGRAM_UNIFORM_2I64V,
+ OPCODE_PROGRAM_UNIFORM_3I64V,
+ OPCODE_PROGRAM_UNIFORM_4I64V,
+ OPCODE_PROGRAM_UNIFORM_1UI64,
+ OPCODE_PROGRAM_UNIFORM_2UI64,
+ OPCODE_PROGRAM_UNIFORM_3UI64,
+ OPCODE_PROGRAM_UNIFORM_4UI64,
+ OPCODE_PROGRAM_UNIFORM_1UI64V,
+ OPCODE_PROGRAM_UNIFORM_2UI64V,
+ OPCODE_PROGRAM_UNIFORM_3UI64V,
+ OPCODE_PROGRAM_UNIFORM_4UI64V,
+
/* OpenGL 4.0 / GL_ARB_tessellation_shader */
OPCODE_PATCH_PARAMETER_I,
OPCODE_PATCH_PARAMETER_FV_INNER,
OPCODE_ATTR_2F_ARB,
OPCODE_ATTR_3F_ARB,
OPCODE_ATTR_4F_ARB,
+ OPCODE_ATTR_1I,
+ OPCODE_ATTR_2I,
+ OPCODE_ATTR_3I,
+ OPCODE_ATTR_4I,
OPCODE_ATTR_1D,
OPCODE_ATTR_2D,
OPCODE_ATTR_3D,
OPCODE_ATTR_4D,
+ OPCODE_ATTR_1UI64,
OPCODE_MATERIAL,
OPCODE_BEGIN,
OPCODE_END,
OPCODE_MATRIX_POP,
OPCODE_TEXTUREPARAMETER_F,
OPCODE_TEXTUREPARAMETER_I,
+ OPCODE_TEXTUREPARAMETER_II,
+ OPCODE_TEXTUREPARAMETER_IUI,
OPCODE_TEXTURE_IMAGE1D,
OPCODE_TEXTURE_IMAGE2D,
OPCODE_TEXTURE_IMAGE3D,
OPCODE_BIND_MULTITEXTURE,
OPCODE_MULTITEXPARAMETER_F,
OPCODE_MULTITEXPARAMETER_I,
+ OPCODE_MULTITEXPARAMETER_II,
+ OPCODE_MULTITEXPARAMETER_IUI,
OPCODE_MULTITEX_IMAGE1D,
OPCODE_MULTITEX_IMAGE2D,
OPCODE_MULTITEX_IMAGE3D,
OPCODE_COMPRESSED_MULTITEX_SUB_IMAGE_1D,
OPCODE_COMPRESSED_MULTITEX_SUB_IMAGE_2D,
OPCODE_COMPRESSED_MULTITEX_SUB_IMAGE_3D,
+ OPCODE_NAMED_PROGRAM_STRING,
+ OPCODE_NAMED_PROGRAM_LOCAL_PARAMETER,
/* The following three are meta instructions */
OPCODE_ERROR, /* raise compiled-in error */
GLuint uint32[2];
};
+union int64_pair
+{
+ GLint64 int64;
+ GLint int32[2];
+};
#define ASSIGN_DOUBLE_TO_NODES(n, idx, value) \
do { \
n[idx+1].ui = tmp.uint32[1]; \
} while (0)
+#define ASSIGN_UINT64_TO_NODES(n, idx, value) \
+ do { \
+ union uint64_pair tmp; \
+ tmp.uint64 = value; \
+ n[idx].ui = tmp.uint32[0]; \
+ n[idx+1].ui = tmp.uint32[1]; \
+ } while (0)
+
+#define ASSIGN_INT64_TO_NODES(n, idx, value) \
+ do { \
+ union int64_pair tmp; \
+ tmp.int64 = value; \
+ n[idx].i = tmp.int32[0]; \
+ n[idx+1].i = tmp.int32[1]; \
+ } while (0)
/**
* How many nodes to allocate at a time. Note that bulk vertex data
goto out_of_memory;
}
- _mesa_init_teximage_fields(ctx, atlas->texImage,
- atlas->texWidth, atlas->texHeight, 1, 0,
- GL_ALPHA, MESA_FORMAT_A_UNORM8);
+ if (ctx->Const.BitmapUsesRed)
+ _mesa_init_teximage_fields(ctx, atlas->texImage,
+ atlas->texWidth, atlas->texHeight, 1, 0,
+ GL_RED, MESA_FORMAT_R_UNORM8);
+ else
+ _mesa_init_teximage_fields(ctx, atlas->texImage,
+ atlas->texWidth, atlas->texHeight, 1, 0,
+ GL_ALPHA, MESA_FORMAT_A_UNORM8);
/* alloc image storage */
if (!ctx->Driver.AllocTextureImageBuffer(ctx, atlas->texImage)) {
case OPCODE_UNIFORM_2UIV:
case OPCODE_UNIFORM_3UIV:
case OPCODE_UNIFORM_4UIV:
+ case OPCODE_UNIFORM_1I64V:
+ case OPCODE_UNIFORM_2I64V:
+ case OPCODE_UNIFORM_3I64V:
+ case OPCODE_UNIFORM_4I64V:
+ case OPCODE_UNIFORM_1UI64V:
+ case OPCODE_UNIFORM_2UI64V:
+ case OPCODE_UNIFORM_3UI64V:
+ case OPCODE_UNIFORM_4UI64V:
free(get_pointer(&n[3]));
break;
case OPCODE_UNIFORM_MATRIX22:
case OPCODE_PROGRAM_UNIFORM_2UIV:
case OPCODE_PROGRAM_UNIFORM_3UIV:
case OPCODE_PROGRAM_UNIFORM_4UIV:
+ case OPCODE_PROGRAM_UNIFORM_1I64V:
+ case OPCODE_PROGRAM_UNIFORM_2I64V:
+ case OPCODE_PROGRAM_UNIFORM_3I64V:
+ case OPCODE_PROGRAM_UNIFORM_4I64V:
+ case OPCODE_PROGRAM_UNIFORM_1UI64V:
+ case OPCODE_PROGRAM_UNIFORM_2UI64V:
+ case OPCODE_PROGRAM_UNIFORM_3UI64V:
+ case OPCODE_PROGRAM_UNIFORM_4UI64V:
free(get_pointer(&n[4]));
break;
case OPCODE_PROGRAM_UNIFORM_MATRIX22F:
case OPCODE_COMPRESSED_MULTITEX_IMAGE_3D:
free(get_pointer(&n[10]));
break;
-
+ case OPCODE_NAMED_PROGRAM_STRING:
+ free(get_pointer(&n[5]));
+ break;
case OPCODE_CONTINUE:
n = (Node *) get_pointer(&n[1]);
free(block);
return NULL;
}
- if (!_mesa_is_bufferobj(unpack->BufferObj)) {
+ if (!unpack->BufferObj) {
/* no PBO */
GLvoid *image;
}
}
-static void GLAPIENTRY
-save_Attr1fNV(GLenum attr, GLfloat x)
-{
- GET_CURRENT_CONTEXT(ctx);
- Node *n;
- SAVE_FLUSH_VERTICES(ctx);
- n = alloc_instruction(ctx, OPCODE_ATTR_1F_NV, 2);
- if (n) {
- n[1].e = attr;
- n[2].f = x;
- }
-
- assert(attr < MAX_VERTEX_GENERIC_ATTRIBS);
- ctx->ListState.ActiveAttribSize[attr] = 1;
- ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, 0, 0, 1);
-
- if (ctx->ExecuteFlag) {
- CALL_VertexAttrib1fNV(ctx->Exec, (attr, x));
- }
-}
-
-static void GLAPIENTRY
-save_Attr2fNV(GLenum attr, GLfloat x, GLfloat y)
-{
- GET_CURRENT_CONTEXT(ctx);
- Node *n;
- SAVE_FLUSH_VERTICES(ctx);
- n = alloc_instruction(ctx, OPCODE_ATTR_2F_NV, 3);
- if (n) {
- n[1].e = attr;
- n[2].f = x;
- n[3].f = y;
- }
-
- assert(attr < MAX_VERTEX_GENERIC_ATTRIBS);
- ctx->ListState.ActiveAttribSize[attr] = 2;
- ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, 0, 1);
-
- if (ctx->ExecuteFlag) {
- CALL_VertexAttrib2fNV(ctx->Exec, (attr, x, y));
- }
-}
-
-static void GLAPIENTRY
-save_Attr3fNV(GLenum attr, GLfloat x, GLfloat y, GLfloat z)
-{
- GET_CURRENT_CONTEXT(ctx);
- Node *n;
- SAVE_FLUSH_VERTICES(ctx);
- n = alloc_instruction(ctx, OPCODE_ATTR_3F_NV, 4);
- if (n) {
- n[1].e = attr;
- n[2].f = x;
- n[3].f = y;
- n[4].f = z;
- }
-
- assert(attr < MAX_VERTEX_GENERIC_ATTRIBS);
- ctx->ListState.ActiveAttribSize[attr] = 3;
- ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, z, 1);
-
- if (ctx->ExecuteFlag) {
- CALL_VertexAttrib3fNV(ctx->Exec, (attr, x, y, z));
- }
-}
-
-static void GLAPIENTRY
-save_Attr4fNV(GLenum attr, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
- GET_CURRENT_CONTEXT(ctx);
- Node *n;
- SAVE_FLUSH_VERTICES(ctx);
- n = alloc_instruction(ctx, OPCODE_ATTR_4F_NV, 5);
- if (n) {
- n[1].e = attr;
- n[2].f = x;
- n[3].f = y;
- n[4].f = z;
- n[5].f = w;
- }
-
- assert(attr < MAX_VERTEX_GENERIC_ATTRIBS);
- ctx->ListState.ActiveAttribSize[attr] = 4;
- ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, z, w);
-
- if (ctx->ExecuteFlag) {
- CALL_VertexAttrib4fNV(ctx->Exec, (attr, x, y, z, w));
- }
-}
-
-
-static void GLAPIENTRY
-save_Attr1fARB(GLenum attr, GLfloat x)
-{
- GET_CURRENT_CONTEXT(ctx);
- Node *n;
- SAVE_FLUSH_VERTICES(ctx);
- n = alloc_instruction(ctx, OPCODE_ATTR_1F_ARB, 2);
- if (n) {
- n[1].e = attr;
- n[2].f = x;
- }
-
- assert(attr < MAX_VERTEX_GENERIC_ATTRIBS);
- ctx->ListState.ActiveAttribSize[attr] = 1;
- ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, 0, 0, 1);
-
- if (ctx->ExecuteFlag) {
- CALL_VertexAttrib1fARB(ctx->Exec, (attr, x));
- }
-}
-
-static void GLAPIENTRY
-save_Attr2fARB(GLenum attr, GLfloat x, GLfloat y)
-{
- GET_CURRENT_CONTEXT(ctx);
- Node *n;
- SAVE_FLUSH_VERTICES(ctx);
- n = alloc_instruction(ctx, OPCODE_ATTR_2F_ARB, 3);
- if (n) {
- n[1].e = attr;
- n[2].f = x;
- n[3].f = y;
- }
-
- assert(attr < MAX_VERTEX_GENERIC_ATTRIBS);
- ctx->ListState.ActiveAttribSize[attr] = 2;
- ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, 0, 1);
-
- if (ctx->ExecuteFlag) {
- CALL_VertexAttrib2fARB(ctx->Exec, (attr, x, y));
- }
-}
-
-static void GLAPIENTRY
-save_Attr3fARB(GLenum attr, GLfloat x, GLfloat y, GLfloat z)
-{
- GET_CURRENT_CONTEXT(ctx);
- Node *n;
- SAVE_FLUSH_VERTICES(ctx);
- n = alloc_instruction(ctx, OPCODE_ATTR_3F_ARB, 4);
- if (n) {
- n[1].e = attr;
- n[2].f = x;
- n[3].f = y;
- n[4].f = z;
- }
-
- assert(attr < MAX_VERTEX_GENERIC_ATTRIBS);
- ctx->ListState.ActiveAttribSize[attr] = 3;
- ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, z, 1);
-
- if (ctx->ExecuteFlag) {
- CALL_VertexAttrib3fARB(ctx->Exec, (attr, x, y, z));
- }
-}
-
-static void GLAPIENTRY
-save_Attr4fARB(GLenum attr, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
- GET_CURRENT_CONTEXT(ctx);
- Node *n;
- SAVE_FLUSH_VERTICES(ctx);
- n = alloc_instruction(ctx, OPCODE_ATTR_4F_ARB, 5);
- if (n) {
- n[1].e = attr;
- n[2].f = x;
- n[3].f = y;
- n[4].f = z;
- n[5].f = w;
- }
-
- assert(attr < MAX_VERTEX_GENERIC_ATTRIBS);
- ctx->ListState.ActiveAttribSize[attr] = 4;
- ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, z, w);
-
- if (ctx->ExecuteFlag) {
- CALL_VertexAttrib4fARB(ctx->Exec, (attr, x, y, z, w));
- }
-}
-
-
static void GLAPIENTRY
save_EvalCoord1f(GLfloat x)
{
}
}
-static void GLAPIENTRY
-save_Indexf(GLfloat x)
-{
- save_Attr1fNV(VERT_ATTRIB_COLOR_INDEX, x);
-}
-
-static void GLAPIENTRY
-save_Indexfv(const GLfloat * v)
-{
- save_Attr1fNV(VERT_ATTRIB_COLOR_INDEX, v[0]);
-}
-
-static void GLAPIENTRY
-save_EdgeFlag(GLboolean x)
-{
- save_Attr1fNV(VERT_ATTRIB_EDGEFLAG, x ? 1.0f : 0.0f);
-}
-
/**
* Compare 'count' elements of vectors 'a' and 'b'.
}
}
-
static void GLAPIENTRY
-save_Vertex2f(GLfloat x, GLfloat y)
+save_PrimitiveRestartNV(void)
{
- save_Attr2fNV(VERT_ATTRIB_POS, x, y);
+ /* Note: this is used when outside a glBegin/End pair in a display list */
+ GET_CURRENT_CONTEXT(ctx);
+ ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+ (void) alloc_instruction(ctx, OPCODE_PRIMITIVE_RESTART_NV, 0);
+ if (ctx->ExecuteFlag) {
+ CALL_PrimitiveRestartNV(ctx->Exec, ());
+ }
}
-static void GLAPIENTRY
-save_Vertex2fv(const GLfloat * v)
-{
- save_Attr2fNV(VERT_ATTRIB_POS, v[0], v[1]);
-}
static void GLAPIENTRY
-save_Vertex3f(GLfloat x, GLfloat y, GLfloat z)
+save_BlitFramebufferEXT(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
+ GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
+ GLbitfield mask, GLenum filter)
{
- save_Attr3fNV(VERT_ATTRIB_POS, x, y, z);
+ GET_CURRENT_CONTEXT(ctx);
+ Node *n;
+ ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+ n = alloc_instruction(ctx, OPCODE_BLIT_FRAMEBUFFER, 10);
+ if (n) {
+ n[1].i = srcX0;
+ n[2].i = srcY0;
+ n[3].i = srcX1;
+ n[4].i = srcY1;
+ n[5].i = dstX0;
+ n[6].i = dstY0;
+ n[7].i = dstX1;
+ n[8].i = dstY1;
+ n[9].i = mask;
+ n[10].e = filter;
+ }
+ if (ctx->ExecuteFlag) {
+ CALL_BlitFramebuffer(ctx->Exec, (srcX0, srcY0, srcX1, srcY1,
+ dstX0, dstY0, dstX1, dstY1,
+ mask, filter));
+ }
}
-static void GLAPIENTRY
-save_Vertex3fv(const GLfloat * v)
-{
- save_Attr3fNV(VERT_ATTRIB_POS, v[0], v[1], v[2]);
-}
+/** GL_EXT_provoking_vertex */
static void GLAPIENTRY
-save_Vertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+save_ProvokingVertexEXT(GLenum mode)
{
- save_Attr4fNV(VERT_ATTRIB_POS, x, y, z, w);
+ GET_CURRENT_CONTEXT(ctx);
+ Node *n;
+ ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+ n = alloc_instruction(ctx, OPCODE_PROVOKING_VERTEX, 1);
+ if (n) {
+ n[1].e = mode;
+ }
+ if (ctx->ExecuteFlag) {
+ /*CALL_ProvokingVertex(ctx->Exec, (mode));*/
+ _mesa_ProvokingVertex(mode);
+ }
}
-static void GLAPIENTRY
-save_Vertex4fv(const GLfloat * v)
-{
- save_Attr4fNV(VERT_ATTRIB_POS, v[0], v[1], v[2], v[3]);
-}
+/** GL_EXT_transform_feedback */
static void GLAPIENTRY
-save_TexCoord1f(GLfloat x)
+save_BeginTransformFeedback(GLenum mode)
{
- save_Attr1fNV(VERT_ATTRIB_TEX0, x);
+ GET_CURRENT_CONTEXT(ctx);
+ Node *n;
+ ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+ n = alloc_instruction(ctx, OPCODE_BEGIN_TRANSFORM_FEEDBACK, 1);
+ if (n) {
+ n[1].e = mode;
+ }
+ if (ctx->ExecuteFlag) {
+ CALL_BeginTransformFeedback(ctx->Exec, (mode));
+ }
}
+
+/** GL_EXT_transform_feedback */
static void GLAPIENTRY
-save_TexCoord1fv(const GLfloat * v)
+save_EndTransformFeedback(void)
{
- save_Attr1fNV(VERT_ATTRIB_TEX0, v[0]);
+ GET_CURRENT_CONTEXT(ctx);
+ ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+ (void) alloc_instruction(ctx, OPCODE_END_TRANSFORM_FEEDBACK, 0);
+ if (ctx->ExecuteFlag) {
+ CALL_EndTransformFeedback(ctx->Exec, ());
+ }
}
static void GLAPIENTRY
-save_TexCoord2f(GLfloat x, GLfloat y)
+save_BindTransformFeedback(GLenum target, GLuint name)
{
- save_Attr2fNV(VERT_ATTRIB_TEX0, x, y);
+ GET_CURRENT_CONTEXT(ctx);
+ Node *n;
+ ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+ n = alloc_instruction(ctx, OPCODE_BIND_TRANSFORM_FEEDBACK, 2);
+ if (n) {
+ n[1].e = target;
+ n[2].ui = name;
+ }
+ if (ctx->ExecuteFlag) {
+ CALL_BindTransformFeedback(ctx->Exec, (target, name));
+ }
}
static void GLAPIENTRY
-save_TexCoord2fv(const GLfloat * v)
+save_PauseTransformFeedback(void)
{
- save_Attr2fNV(VERT_ATTRIB_TEX0, v[0], v[1]);
+ GET_CURRENT_CONTEXT(ctx);
+ ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+ (void) alloc_instruction(ctx, OPCODE_PAUSE_TRANSFORM_FEEDBACK, 0);
+ if (ctx->ExecuteFlag) {
+ CALL_PauseTransformFeedback(ctx->Exec, ());
+ }
}
static void GLAPIENTRY
-save_TexCoord3f(GLfloat x, GLfloat y, GLfloat z)
+save_ResumeTransformFeedback(void)
{
- save_Attr3fNV(VERT_ATTRIB_TEX0, x, y, z);
+ GET_CURRENT_CONTEXT(ctx);
+ ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+ (void) alloc_instruction(ctx, OPCODE_RESUME_TRANSFORM_FEEDBACK, 0);
+ if (ctx->ExecuteFlag) {
+ CALL_ResumeTransformFeedback(ctx->Exec, ());
+ }
}
static void GLAPIENTRY
-save_TexCoord3fv(const GLfloat * v)
+save_DrawTransformFeedback(GLenum mode, GLuint name)
{
- save_Attr3fNV(VERT_ATTRIB_TEX0, v[0], v[1], v[2]);
+ GET_CURRENT_CONTEXT(ctx);
+ Node *n;
+ ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+ n = alloc_instruction(ctx, OPCODE_DRAW_TRANSFORM_FEEDBACK, 2);
+ if (n) {
+ n[1].e = mode;
+ n[2].ui = name;
+ }
+ if (ctx->ExecuteFlag) {
+ CALL_DrawTransformFeedback(ctx->Exec, (mode, name));
+ }
}
static void GLAPIENTRY
-save_TexCoord4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+save_DrawTransformFeedbackStream(GLenum mode, GLuint name, GLuint stream)
{
- save_Attr4fNV(VERT_ATTRIB_TEX0, x, y, z, w);
+ GET_CURRENT_CONTEXT(ctx);
+ Node *n;
+ ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+ n = alloc_instruction(ctx, OPCODE_DRAW_TRANSFORM_FEEDBACK_STREAM, 3);
+ if (n) {
+ n[1].e = mode;
+ n[2].ui = name;
+ n[3].ui = stream;
+ }
+ if (ctx->ExecuteFlag) {
+ CALL_DrawTransformFeedbackStream(ctx->Exec, (mode, name, stream));
+ }
}
static void GLAPIENTRY
-save_TexCoord4fv(const GLfloat * v)
+save_DrawTransformFeedbackInstanced(GLenum mode, GLuint name,
+ GLsizei primcount)
{
- save_Attr4fNV(VERT_ATTRIB_TEX0, v[0], v[1], v[2], v[3]);
+ GET_CURRENT_CONTEXT(ctx);
+ Node *n;
+ ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+ n = alloc_instruction(ctx, OPCODE_DRAW_TRANSFORM_FEEDBACK_INSTANCED, 3);
+ if (n) {
+ n[1].e = mode;
+ n[2].ui = name;
+ n[3].si = primcount;
+ }
+ if (ctx->ExecuteFlag) {
+ CALL_DrawTransformFeedbackInstanced(ctx->Exec, (mode, name, primcount));
+ }
}
static void GLAPIENTRY
-save_Normal3f(GLfloat x, GLfloat y, GLfloat z)
+save_DrawTransformFeedbackStreamInstanced(GLenum mode, GLuint name,
+ GLuint stream, GLsizei primcount)
{
- save_Attr3fNV(VERT_ATTRIB_NORMAL, x, y, z);
+ GET_CURRENT_CONTEXT(ctx);
+ Node *n;
+ ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+ n = alloc_instruction(ctx, OPCODE_DRAW_TRANSFORM_FEEDBACK_STREAM_INSTANCED, 4);
+ if (n) {
+ n[1].e = mode;
+ n[2].ui = name;
+ n[3].ui = stream;
+ n[4].si = primcount;
+ }
+ if (ctx->ExecuteFlag) {
+ CALL_DrawTransformFeedbackStreamInstanced(ctx->Exec, (mode, name, stream,
+ primcount));
+ }
}
static void GLAPIENTRY
-save_Normal3fv(const GLfloat * v)
+save_DispatchCompute(GLuint num_groups_x, GLuint num_groups_y,
+ GLuint num_groups_z)
{
- save_Attr3fNV(VERT_ATTRIB_NORMAL, v[0], v[1], v[2]);
+ GET_CURRENT_CONTEXT(ctx);
+ Node *n;
+ ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+ n = alloc_instruction(ctx, OPCODE_DISPATCH_COMPUTE, 3);
+ if (n) {
+ n[1].ui = num_groups_x;
+ n[2].ui = num_groups_y;
+ n[3].ui = num_groups_z;
+ }
+ if (ctx->ExecuteFlag) {
+ CALL_DispatchCompute(ctx->Exec, (num_groups_x, num_groups_y,
+ num_groups_z));
+ }
}
static void GLAPIENTRY
-save_FogCoordfEXT(GLfloat x)
+save_DispatchComputeIndirect(GLintptr indirect)
{
- save_Attr1fNV(VERT_ATTRIB_FOG, x);
+ GET_CURRENT_CONTEXT(ctx);
+ _mesa_error(ctx, GL_INVALID_OPERATION,
+ "glDispatchComputeIndirect() during display list compile");
}
-static void GLAPIENTRY
-save_FogCoordfvEXT(const GLfloat * v)
+static void ALWAYS_INLINE
+save_Attr32bit(struct gl_context *ctx, unsigned attr, unsigned size,
+ GLenum type, uint32_t x, uint32_t y, uint32_t z, uint32_t w)
{
- save_Attr1fNV(VERT_ATTRIB_FOG, v[0]);
-}
+ Node *n;
+ SAVE_FLUSH_VERTICES(ctx);
+ unsigned base_op;
+ unsigned index = attr;
-static void GLAPIENTRY
-save_Color3f(GLfloat x, GLfloat y, GLfloat z)
-{
- save_Attr3fNV(VERT_ATTRIB_COLOR0, x, y, z);
+ /* We don't care about GL_INT vs GL_UNSIGNED_INT. The idea is to get W=1
+ * right for 3 or lower number of components, so only distinguish between
+ * FLOAT and INT.
+ */
+ if (type == GL_FLOAT) {
+ if (attr >= VERT_ATTRIB_GENERIC0) {
+ base_op = OPCODE_ATTR_1F_ARB;
+ attr -= VERT_ATTRIB_GENERIC0;
+ } else {
+ base_op = OPCODE_ATTR_1F_NV;
+ }
+ } else {
+ base_op = OPCODE_ATTR_1I;
+ attr -= VERT_ATTRIB_GENERIC0;
+ }
+
+ n = alloc_instruction(ctx, base_op + size - 1, 1 + size);
+ if (n) {
+ n[1].ui = attr;
+ n[2].ui = x;
+ if (size >= 2) n[3].ui = y;
+ if (size >= 3) n[4].ui = z;
+ if (size >= 4) n[5].ui = w;
+ }
+
+ ctx->ListState.ActiveAttribSize[index] = size;
+ ASSIGN_4V(ctx->ListState.CurrentAttrib[index], x, y, z, w);
+
+ if (ctx->ExecuteFlag) {
+ if (type == GL_FLOAT) {
+ if (base_op == OPCODE_ATTR_1F_NV) {
+ if (size == 4)
+ CALL_VertexAttrib4fNV(ctx->Exec, (attr, uif(x), uif(y), uif(z), uif(w)));
+ else if (size == 3)
+ CALL_VertexAttrib3fNV(ctx->Exec, (attr, uif(x), uif(y), uif(z)));
+ else if (size == 2)
+ CALL_VertexAttrib2fNV(ctx->Exec, (attr, uif(x), uif(y)));
+ else
+ CALL_VertexAttrib1fNV(ctx->Exec, (attr, uif(x)));
+ } else {
+ if (size == 4)
+ CALL_VertexAttrib4fARB(ctx->Exec, (attr, uif(x), uif(y), uif(z), uif(w)));
+ else if (size == 3)
+ CALL_VertexAttrib3fARB(ctx->Exec, (attr, uif(x), uif(y), uif(z)));
+ else if (size == 2)
+ CALL_VertexAttrib2fARB(ctx->Exec, (attr, uif(x), uif(y)));
+ else
+ CALL_VertexAttrib1fARB(ctx->Exec, (attr, uif(x)));
+ }
+ } else {
+ if (size == 4)
+ CALL_VertexAttribI4iEXT(ctx->Exec, (attr, x, y, z, w));
+ else if (size == 3)
+ CALL_VertexAttribI3iEXT(ctx->Exec, (attr, x, y, z));
+ else if (size == 2)
+ CALL_VertexAttribI2iEXT(ctx->Exec, (attr, x, y));
+ else
+ CALL_VertexAttribI1iEXT(ctx->Exec, (attr, x));
+ }
+ }
}
-static void GLAPIENTRY
-save_Color3fv(const GLfloat * v)
+static void ALWAYS_INLINE
+save_Attr64bit(struct gl_context *ctx, unsigned attr, unsigned size,
+ GLenum type, uint64_t x, uint64_t y, uint64_t z, uint64_t w)
{
- save_Attr3fNV(VERT_ATTRIB_COLOR0, v[0], v[1], v[2]);
-}
+ Node *n;
+ SAVE_FLUSH_VERTICES(ctx);
+ unsigned base_op;
+ unsigned index = attr;
-static void GLAPIENTRY
-save_Color4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
- save_Attr4fNV(VERT_ATTRIB_COLOR0, x, y, z, w);
-}
+ if (type == GL_DOUBLE) {
+ base_op = OPCODE_ATTR_1D;
+ } else {
+ base_op = OPCODE_ATTR_1UI64;
+ assert(size == 1);
+ }
-static void GLAPIENTRY
-save_Color4fv(const GLfloat * v)
-{
- save_Attr4fNV(VERT_ATTRIB_COLOR0, v[0], v[1], v[2], v[3]);
-}
+ attr -= VERT_ATTRIB_GENERIC0;
+ n = alloc_instruction(ctx, base_op + size - 1, 1 + size * 2);
+ if (n) {
+ n[1].ui = attr;
+ ASSIGN_UINT64_TO_NODES(n, 2, x);
+ if (size >= 2) ASSIGN_UINT64_TO_NODES(n, 4, y);
+ if (size >= 3) ASSIGN_UINT64_TO_NODES(n, 6, z);
+ if (size >= 4) ASSIGN_UINT64_TO_NODES(n, 8, w);
+ }
-static void GLAPIENTRY
-save_SecondaryColor3fEXT(GLfloat x, GLfloat y, GLfloat z)
-{
- save_Attr3fNV(VERT_ATTRIB_COLOR1, x, y, z);
-}
+ ctx->ListState.ActiveAttribSize[index] = size;
+ memcpy(ctx->ListState.CurrentAttrib[index], &n[2], size * sizeof(uint64_t));
-static void GLAPIENTRY
-save_SecondaryColor3fvEXT(const GLfloat * v)
-{
- save_Attr3fNV(VERT_ATTRIB_COLOR1, v[0], v[1], v[2]);
+ if (ctx->ExecuteFlag) {
+ uint64_t v[] = {x, y, z, w};
+ if (type == GL_DOUBLE) {
+ if (size == 4)
+ CALL_VertexAttribL4dv(ctx->Exec, (attr, (GLdouble*)v));
+ else if (size == 3)
+ CALL_VertexAttribL3dv(ctx->Exec, (attr, (GLdouble*)v));
+ else if (size == 2)
+ CALL_VertexAttribL2dv(ctx->Exec, (attr, (GLdouble*)v));
+ else
+ CALL_VertexAttribL1d(ctx->Exec, (attr, UINT64_AS_DOUBLE(x)));
+ } else {
+ CALL_VertexAttribL1ui64ARB(ctx->Exec, (attr, x));
+ }
+ }
}
-
-/* Just call the respective ATTR for texcoord
+/**
+ * If index=0, does glVertexAttrib*() alias glVertex() to emit a vertex?
+ * It depends on a few things, including whether we're inside or outside
+ * of glBegin/glEnd.
*/
-static void GLAPIENTRY
-save_MultiTexCoord1f(GLenum target, GLfloat x)
+static inline bool
+is_vertex_position(const struct gl_context *ctx, GLuint index)
{
- GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0;
- save_Attr1fNV(attr, x);
+ return (index == 0 &&
+ _mesa_attr_zero_aliases_vertex(ctx) &&
+ _mesa_inside_dlist_begin_end(ctx));
}
-static void GLAPIENTRY
-save_MultiTexCoord1fv(GLenum target, const GLfloat * v)
-{
- GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0;
- save_Attr1fNV(attr, v[0]);
-}
+/**
+ * This macro is used to implement all the glVertex, glColor, glTexCoord,
+ * glVertexAttrib, etc functions.
+ * \param A VBO_ATTRIB_x attribute index
+ * \param N attribute size (1..4)
+ * \param T type (GL_FLOAT, GL_DOUBLE, GL_INT, GL_UNSIGNED_INT)
+ * \param C cast type (uint32_t or uint64_t)
+ * \param V0, V1, v2, V3 attribute value
+ */
+#define ATTR_UNION(A, N, T, C, V0, V1, V2, V3) \
+do { \
+ if (sizeof(C) == 4) { \
+ save_Attr32bit(ctx, A, N, T, V0, V1, V2, V3); \
+ } else { \
+ save_Attr64bit(ctx, A, N, T, V0, V1, V2, V3); \
+ } \
+} while (0)
+
+#undef ERROR
+#define ERROR(err) _mesa_error(ctx, err, __func__)
+#define TAG(x) save_##x
+
+#define VBO_ATTRIB_POS VERT_ATTRIB_POS
+#define VBO_ATTRIB_NORMAL VERT_ATTRIB_NORMAL
+#define VBO_ATTRIB_COLOR0 VERT_ATTRIB_COLOR0
+#define VBO_ATTRIB_COLOR1 VERT_ATTRIB_COLOR1
+#define VBO_ATTRIB_FOG VERT_ATTRIB_FOG
+#define VBO_ATTRIB_COLOR_INDEX VERT_ATTRIB_COLOR_INDEX
+#define VBO_ATTRIB_EDGEFLAG VERT_ATTRIB_EDGEFLAG
+#define VBO_ATTRIB_TEX0 VERT_ATTRIB_TEX0
+#define VBO_ATTRIB_GENERIC0 VERT_ATTRIB_GENERIC0
+#define VBO_ATTRIB_MAX VERT_ATTRIB_MAX
+
+#include "vbo/vbo_attrib_tmp.h"
static void GLAPIENTRY
-save_MultiTexCoord2f(GLenum target, GLfloat x, GLfloat y)
+save_UseProgram(GLuint program)
{
- GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0;
- save_Attr2fNV(attr, x, y);
+ GET_CURRENT_CONTEXT(ctx);
+ Node *n;
+ ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+ n = alloc_instruction(ctx, OPCODE_USE_PROGRAM, 1);
+ if (n) {
+ n[1].ui = program;
+ }
+ if (ctx->ExecuteFlag) {
+ CALL_UseProgram(ctx->Exec, (program));
+ }
}
-static void GLAPIENTRY
-save_MultiTexCoord2fv(GLenum target, const GLfloat * v)
-{
- GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0;
- save_Attr2fNV(attr, v[0], v[1]);
-}
static void GLAPIENTRY
-save_MultiTexCoord3f(GLenum target, GLfloat x, GLfloat y, GLfloat z)
+save_Uniform1fARB(GLint location, GLfloat x)
{
- GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0;
- save_Attr3fNV(attr, x, y, z);
+ GET_CURRENT_CONTEXT(ctx);
+ Node *n;
+ ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_1F, 2);
+ if (n) {
+ n[1].i = location;
+ n[2].f = x;
+ }
+ if (ctx->ExecuteFlag) {
+ CALL_Uniform1f(ctx->Exec, (location, x));
+ }
}
-static void GLAPIENTRY
-save_MultiTexCoord3fv(GLenum target, const GLfloat * v)
-{
- GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0;
- save_Attr3fNV(attr, v[0], v[1], v[2]);
-}
static void GLAPIENTRY
-save_MultiTexCoord4f(GLenum target, GLfloat x, GLfloat y,
- GLfloat z, GLfloat w)
+save_Uniform2fARB(GLint location, GLfloat x, GLfloat y)
{
- GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0;
- save_Attr4fNV(attr, x, y, z, w);
+ GET_CURRENT_CONTEXT(ctx);
+ Node *n;
+ ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_2F, 3);
+ if (n) {
+ n[1].i = location;
+ n[2].f = x;
+ n[3].f = y;
+ }
+ if (ctx->ExecuteFlag) {
+ CALL_Uniform2f(ctx->Exec, (location, x, y));
+ }
}
+
static void GLAPIENTRY
-save_MultiTexCoord4fv(GLenum target, const GLfloat * v)
+save_Uniform3fARB(GLint location, GLfloat x, GLfloat y, GLfloat z)
{
- GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0;
- save_Attr4fNV(attr, v[0], v[1], v[2], v[3]);
+ GET_CURRENT_CONTEXT(ctx);
+ Node *n;
+ ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_3F, 4);
+ if (n) {
+ n[1].i = location;
+ n[2].f = x;
+ n[3].f = y;
+ n[4].f = z;
+ }
+ if (ctx->ExecuteFlag) {
+ CALL_Uniform3f(ctx->Exec, (location, x, y, z));
+ }
}
-/**
- * Record a GL_INVALID_VALUE error when an invalid vertex attribute
- * index is found.
- */
-static void
-index_error(void)
+static void GLAPIENTRY
+save_Uniform4fARB(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
GET_CURRENT_CONTEXT(ctx);
- _mesa_error(ctx, GL_INVALID_VALUE, "VertexAttribf(index)");
+ Node *n;
+ ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_4F, 5);
+ if (n) {
+ n[1].i = location;
+ n[2].f = x;
+ n[3].f = y;
+ n[4].f = z;
+ n[5].f = w;
+ }
+ if (ctx->ExecuteFlag) {
+ CALL_Uniform4f(ctx->Exec, (location, x, y, z, w));
+ }
}
-
static void GLAPIENTRY
-save_VertexAttrib1fARB(GLuint index, GLfloat x)
+save_Uniform1fvARB(GLint location, GLsizei count, const GLfloat *v)
{
- if (index < MAX_VERTEX_GENERIC_ATTRIBS)
- save_Attr1fARB(index, x);
- else
- index_error();
+ GET_CURRENT_CONTEXT(ctx);
+ Node *n;
+ ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_1FV, 2 + POINTER_DWORDS);
+ if (n) {
+ n[1].i = location;
+ n[2].i = count;
+ save_pointer(&n[3], memdup(v, count * 1 * sizeof(GLfloat)));
+ }
+ if (ctx->ExecuteFlag) {
+ CALL_Uniform1fv(ctx->Exec, (location, count, v));
+ }
}
static void GLAPIENTRY
-save_VertexAttrib1fvARB(GLuint index, const GLfloat * v)
+save_Uniform2fvARB(GLint location, GLsizei count, const GLfloat *v)
{
- if (index < MAX_VERTEX_GENERIC_ATTRIBS)
- save_Attr1fARB(index, v[0]);
- else
- index_error();
+ GET_CURRENT_CONTEXT(ctx);
+ Node *n;
+ ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_2FV, 2 + POINTER_DWORDS);
+ if (n) {
+ n[1].i = location;
+ n[2].i = count;
+ save_pointer(&n[3], memdup(v, count * 2 * sizeof(GLfloat)));
+ }
+ if (ctx->ExecuteFlag) {
+ CALL_Uniform2fv(ctx->Exec, (location, count, v));
+ }
}
static void GLAPIENTRY
-save_VertexAttrib2fARB(GLuint index, GLfloat x, GLfloat y)
+save_Uniform3fvARB(GLint location, GLsizei count, const GLfloat *v)
{
- if (index < MAX_VERTEX_GENERIC_ATTRIBS)
- save_Attr2fARB(index, x, y);
- else
- index_error();
+ GET_CURRENT_CONTEXT(ctx);
+ Node *n;
+ ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_3FV, 2 + POINTER_DWORDS);
+ if (n) {
+ n[1].i = location;
+ n[2].i = count;
+ save_pointer(&n[3], memdup(v, count * 3 * sizeof(GLfloat)));
+ }
+ if (ctx->ExecuteFlag) {
+ CALL_Uniform3fv(ctx->Exec, (location, count, v));
+ }
}
static void GLAPIENTRY
-save_VertexAttrib2fvARB(GLuint index, const GLfloat * v)
+save_Uniform4fvARB(GLint location, GLsizei count, const GLfloat *v)
{
- if (index < MAX_VERTEX_GENERIC_ATTRIBS)
- save_Attr2fARB(index, v[0], v[1]);
- else
- index_error();
+ GET_CURRENT_CONTEXT(ctx);
+ Node *n;
+ ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_4FV, 2 + POINTER_DWORDS);
+ if (n) {
+ n[1].i = location;
+ n[2].i = count;
+ save_pointer(&n[3], memdup(v, count * 4 * sizeof(GLfloat)));
+ }
+ if (ctx->ExecuteFlag) {
+ CALL_Uniform4fv(ctx->Exec, (location, count, v));
+ }
}
-static void GLAPIENTRY
-save_VertexAttrib3fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z)
-{
- if (index < MAX_VERTEX_GENERIC_ATTRIBS)
- save_Attr3fARB(index, x, y, z);
- else
- index_error();
-}
static void GLAPIENTRY
-save_VertexAttrib3fvARB(GLuint index, const GLfloat * v)
+save_Uniform1d(GLint location, GLdouble x)
{
- if (index < MAX_VERTEX_GENERIC_ATTRIBS)
- save_Attr3fARB(index, v[0], v[1], v[2]);
- else
- index_error();
+ GET_CURRENT_CONTEXT(ctx);
+ Node *n;
+ ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_1D, 3);
+ if (n) {
+ n[1].i = location;
+ ASSIGN_DOUBLE_TO_NODES(n, 2, x);
+ }
+ if (ctx->ExecuteFlag) {
+ CALL_Uniform1d(ctx->Exec, (location, x));
+ }
}
-static void GLAPIENTRY
-save_VertexAttrib4fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z,
- GLfloat w)
-{
- if (index < MAX_VERTEX_GENERIC_ATTRIBS)
- save_Attr4fARB(index, x, y, z, w);
- else
- index_error();
-}
static void GLAPIENTRY
-save_VertexAttrib4fvARB(GLuint index, const GLfloat * v)
+save_Uniform2d(GLint location, GLdouble x, GLdouble y)
{
- if (index < MAX_VERTEX_GENERIC_ATTRIBS)
- save_Attr4fARB(index, v[0], v[1], v[2], v[3]);
- else
- index_error();
+ GET_CURRENT_CONTEXT(ctx);
+ Node *n;
+ ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_2D, 5);
+ if (n) {
+ n[1].i = location;
+ ASSIGN_DOUBLE_TO_NODES(n, 2, x);
+ ASSIGN_DOUBLE_TO_NODES(n, 4, y);
+ }
+ if (ctx->ExecuteFlag) {
+ CALL_Uniform2d(ctx->Exec, (location, x, y));
+ }
}
+
static void GLAPIENTRY
-save_VertexAttribL1d(GLuint index, GLdouble x)
+save_Uniform3d(GLint location, GLdouble x, GLdouble y, GLdouble z)
{
GET_CURRENT_CONTEXT(ctx);
-
- if (index < MAX_VERTEX_GENERIC_ATTRIBS) {
- Node *n;
- SAVE_FLUSH_VERTICES(ctx);
- n = alloc_instruction(ctx, OPCODE_ATTR_1D, 3);
- if (n) {
- n[1].ui = index;
- ASSIGN_DOUBLE_TO_NODES(n, 2, x);
- }
-
- ctx->ListState.ActiveAttribSize[index] = 1;
- memcpy(ctx->ListState.CurrentAttrib[index], &n[2], sizeof(GLdouble));
-
- if (ctx->ExecuteFlag) {
- CALL_VertexAttribL1d(ctx->Exec, (index, x));
- }
- } else {
- index_error();
+ Node *n;
+ ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_3D, 7);
+ if (n) {
+ n[1].i = location;
+ ASSIGN_DOUBLE_TO_NODES(n, 2, x);
+ ASSIGN_DOUBLE_TO_NODES(n, 4, y);
+ ASSIGN_DOUBLE_TO_NODES(n, 6, z);
+ }
+ if (ctx->ExecuteFlag) {
+ CALL_Uniform3d(ctx->Exec, (location, x, y, z));
}
}
-static void GLAPIENTRY
-save_VertexAttribL1dv(GLuint index, const GLdouble *v)
-{
- if (index < MAX_VERTEX_GENERIC_ATTRIBS)
- save_VertexAttribL1d(index, v[0]);
- else
- index_error();
-}
static void GLAPIENTRY
-save_VertexAttribL2d(GLuint index, GLdouble x, GLdouble y)
+save_Uniform4d(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
GET_CURRENT_CONTEXT(ctx);
-
- if (index < MAX_VERTEX_GENERIC_ATTRIBS) {
- Node *n;
- SAVE_FLUSH_VERTICES(ctx);
- n = alloc_instruction(ctx, OPCODE_ATTR_2D, 5);
- if (n) {
- n[1].ui = index;
- ASSIGN_DOUBLE_TO_NODES(n, 2, x);
- ASSIGN_DOUBLE_TO_NODES(n, 4, y);
- }
-
- ctx->ListState.ActiveAttribSize[index] = 2;
- memcpy(ctx->ListState.CurrentAttrib[index], &n[2],
- 2 * sizeof(GLdouble));
-
- if (ctx->ExecuteFlag) {
- CALL_VertexAttribL2d(ctx->Exec, (index, x, y));
- }
- } else {
- index_error();
+ Node *n;
+ ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_4D, 9);
+ if (n) {
+ n[1].i = location;
+ ASSIGN_DOUBLE_TO_NODES(n, 2, x);
+ ASSIGN_DOUBLE_TO_NODES(n, 4, y);
+ ASSIGN_DOUBLE_TO_NODES(n, 6, z);
+ ASSIGN_DOUBLE_TO_NODES(n, 8, w);
+ }
+ if (ctx->ExecuteFlag) {
+ CALL_Uniform4d(ctx->Exec, (location, x, y, z, w));
}
}
+
static void GLAPIENTRY
-save_VertexAttribL2dv(GLuint index, const GLdouble *v)
+save_Uniform1dv(GLint location, GLsizei count, const GLdouble *v)
{
- if (index < MAX_VERTEX_GENERIC_ATTRIBS)
- save_VertexAttribL2d(index, v[0], v[1]);
- else
- index_error();
+ GET_CURRENT_CONTEXT(ctx);
+ Node *n;
+ ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_1DV, 2 + POINTER_DWORDS);
+ if (n) {
+ n[1].i = location;
+ n[2].i = count;
+ save_pointer(&n[3], memdup(v, count * 1 * sizeof(GLdouble)));
+ }
+ if (ctx->ExecuteFlag) {
+ CALL_Uniform1dv(ctx->Exec, (location, count, v));
+ }
}
+
static void GLAPIENTRY
-save_VertexAttribL3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
+save_Uniform2dv(GLint location, GLsizei count, const GLdouble *v)
{
GET_CURRENT_CONTEXT(ctx);
-
- if (index < MAX_VERTEX_GENERIC_ATTRIBS) {
- Node *n;
- SAVE_FLUSH_VERTICES(ctx);
- n = alloc_instruction(ctx, OPCODE_ATTR_3D, 7);
- if (n) {
- n[1].ui = index;
- ASSIGN_DOUBLE_TO_NODES(n, 2, x);
- ASSIGN_DOUBLE_TO_NODES(n, 4, y);
- ASSIGN_DOUBLE_TO_NODES(n, 6, z);
- }
-
- ctx->ListState.ActiveAttribSize[index] = 3;
- memcpy(ctx->ListState.CurrentAttrib[index], &n[2],
- 3 * sizeof(GLdouble));
-
- if (ctx->ExecuteFlag) {
- CALL_VertexAttribL3d(ctx->Exec, (index, x, y, z));
- }
- } else {
- index_error();
+ Node *n;
+ ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_2DV, 2 + POINTER_DWORDS);
+ if (n) {
+ n[1].i = location;
+ n[2].i = count;
+ save_pointer(&n[3], memdup(v, count * 2 * sizeof(GLdouble)));
+ }
+ if (ctx->ExecuteFlag) {
+ CALL_Uniform2dv(ctx->Exec, (location, count, v));
}
}
+
static void GLAPIENTRY
-save_VertexAttribL3dv(GLuint index, const GLdouble *v)
+save_Uniform3dv(GLint location, GLsizei count, const GLdouble *v)
{
- if (index < MAX_VERTEX_GENERIC_ATTRIBS)
- save_VertexAttribL3d(index, v[0], v[1], v[2]);
- else
- index_error();
+ GET_CURRENT_CONTEXT(ctx);
+ Node *n;
+ ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_3DV, 2 + POINTER_DWORDS);
+ if (n) {
+ n[1].i = location;
+ n[2].i = count;
+ save_pointer(&n[3], memdup(v, count * 3 * sizeof(GLdouble)));
+ }
+ if (ctx->ExecuteFlag) {
+ CALL_Uniform3dv(ctx->Exec, (location, count, v));
+ }
}
+
static void GLAPIENTRY
-save_VertexAttribL4d(GLuint index, GLdouble x, GLdouble y, GLdouble z,
- GLdouble w)
+save_Uniform4dv(GLint location, GLsizei count, const GLdouble *v)
{
GET_CURRENT_CONTEXT(ctx);
-
- if (index < MAX_VERTEX_GENERIC_ATTRIBS) {
- Node *n;
- SAVE_FLUSH_VERTICES(ctx);
- n = alloc_instruction(ctx, OPCODE_ATTR_4D, 9);
- if (n) {
- n[1].ui = index;
- ASSIGN_DOUBLE_TO_NODES(n, 2, x);
- ASSIGN_DOUBLE_TO_NODES(n, 4, y);
- ASSIGN_DOUBLE_TO_NODES(n, 6, z);
- ASSIGN_DOUBLE_TO_NODES(n, 8, w);
- }
-
- ctx->ListState.ActiveAttribSize[index] = 4;
- memcpy(ctx->ListState.CurrentAttrib[index], &n[2],
- 4 * sizeof(GLdouble));
-
- if (ctx->ExecuteFlag) {
- CALL_VertexAttribL4d(ctx->Exec, (index, x, y, z, w));
- }
- } else {
- index_error();
+ Node *n;
+ ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_4DV, 2 + POINTER_DWORDS);
+ if (n) {
+ n[1].i = location;
+ n[2].i = count;
+ save_pointer(&n[3], memdup(v, count * 4 * sizeof(GLdouble)));
+ }
+ if (ctx->ExecuteFlag) {
+ CALL_Uniform4dv(ctx->Exec, (location, count, v));
}
}
+
static void GLAPIENTRY
-save_VertexAttribL4dv(GLuint index, const GLdouble *v)
+save_Uniform1iARB(GLint location, GLint x)
{
- if (index < MAX_VERTEX_GENERIC_ATTRIBS)
- save_VertexAttribL4d(index, v[0], v[1], v[2], v[3]);
- else
- index_error();
+ GET_CURRENT_CONTEXT(ctx);
+ Node *n;
+ ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_1I, 2);
+ if (n) {
+ n[1].i = location;
+ n[2].i = x;
+ }
+ if (ctx->ExecuteFlag) {
+ CALL_Uniform1i(ctx->Exec, (location, x));
+ }
}
static void GLAPIENTRY
-save_PrimitiveRestartNV(void)
+save_Uniform2iARB(GLint location, GLint x, GLint y)
{
- /* Note: this is used when outside a glBegin/End pair in a display list */
GET_CURRENT_CONTEXT(ctx);
+ Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- (void) alloc_instruction(ctx, OPCODE_PRIMITIVE_RESTART_NV, 0);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_2I, 3);
+ if (n) {
+ n[1].i = location;
+ n[2].i = x;
+ n[3].i = y;
+ }
if (ctx->ExecuteFlag) {
- CALL_PrimitiveRestartNV(ctx->Exec, ());
+ CALL_Uniform2i(ctx->Exec, (location, x, y));
}
}
-
static void GLAPIENTRY
-save_BlitFramebufferEXT(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
- GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
- GLbitfield mask, GLenum filter)
+save_Uniform3iARB(GLint location, GLint x, GLint y, GLint z)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_BLIT_FRAMEBUFFER, 10);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_3I, 4);
if (n) {
- n[1].i = srcX0;
- n[2].i = srcY0;
- n[3].i = srcX1;
- n[4].i = srcY1;
- n[5].i = dstX0;
- n[6].i = dstY0;
- n[7].i = dstX1;
- n[8].i = dstY1;
- n[9].i = mask;
- n[10].e = filter;
+ n[1].i = location;
+ n[2].i = x;
+ n[3].i = y;
+ n[4].i = z;
}
if (ctx->ExecuteFlag) {
- CALL_BlitFramebuffer(ctx->Exec, (srcX0, srcY0, srcX1, srcY1,
- dstX0, dstY0, dstX1, dstY1,
- mask, filter));
+ CALL_Uniform3i(ctx->Exec, (location, x, y, z));
}
}
-
-/** GL_EXT_provoking_vertex */
static void GLAPIENTRY
-save_ProvokingVertexEXT(GLenum mode)
+save_Uniform4iARB(GLint location, GLint x, GLint y, GLint z, GLint w)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_PROVOKING_VERTEX, 1);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_4I, 5);
if (n) {
- n[1].e = mode;
+ n[1].i = location;
+ n[2].i = x;
+ n[3].i = y;
+ n[4].i = z;
+ n[5].i = w;
}
if (ctx->ExecuteFlag) {
- /*CALL_ProvokingVertex(ctx->Exec, (mode));*/
- _mesa_ProvokingVertex(mode);
+ CALL_Uniform4i(ctx->Exec, (location, x, y, z, w));
}
}
-/** GL_EXT_transform_feedback */
+
static void GLAPIENTRY
-save_BeginTransformFeedback(GLenum mode)
+save_Uniform1ivARB(GLint location, GLsizei count, const GLint *v)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_BEGIN_TRANSFORM_FEEDBACK, 1);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_1IV, 2 + POINTER_DWORDS);
if (n) {
- n[1].e = mode;
+ n[1].i = location;
+ n[2].i = count;
+ save_pointer(&n[3], memdup(v, count * 1 * sizeof(GLint)));
}
if (ctx->ExecuteFlag) {
- CALL_BeginTransformFeedback(ctx->Exec, (mode));
+ CALL_Uniform1iv(ctx->Exec, (location, count, v));
}
}
-
-/** GL_EXT_transform_feedback */
static void GLAPIENTRY
-save_EndTransformFeedback(void)
+save_Uniform2ivARB(GLint location, GLsizei count, const GLint *v)
{
GET_CURRENT_CONTEXT(ctx);
+ Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- (void) alloc_instruction(ctx, OPCODE_END_TRANSFORM_FEEDBACK, 0);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_2IV, 2 + POINTER_DWORDS);
+ if (n) {
+ n[1].i = location;
+ n[2].i = count;
+ save_pointer(&n[3], memdup(v, count * 2 * sizeof(GLint)));
+ }
if (ctx->ExecuteFlag) {
- CALL_EndTransformFeedback(ctx->Exec, ());
+ CALL_Uniform2iv(ctx->Exec, (location, count, v));
}
}
static void GLAPIENTRY
-save_BindTransformFeedback(GLenum target, GLuint name)
+save_Uniform3ivARB(GLint location, GLsizei count, const GLint *v)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_BIND_TRANSFORM_FEEDBACK, 2);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_3IV, 2 + POINTER_DWORDS);
if (n) {
- n[1].e = target;
- n[2].ui = name;
+ n[1].i = location;
+ n[2].i = count;
+ save_pointer(&n[3], memdup(v, count * 3 * sizeof(GLint)));
}
if (ctx->ExecuteFlag) {
- CALL_BindTransformFeedback(ctx->Exec, (target, name));
+ CALL_Uniform3iv(ctx->Exec, (location, count, v));
}
}
static void GLAPIENTRY
-save_PauseTransformFeedback(void)
+save_Uniform4ivARB(GLint location, GLsizei count, const GLint *v)
{
GET_CURRENT_CONTEXT(ctx);
+ Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- (void) alloc_instruction(ctx, OPCODE_PAUSE_TRANSFORM_FEEDBACK, 0);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_4IV, 2 + POINTER_DWORDS);
+ if (n) {
+ n[1].i = location;
+ n[2].i = count;
+ save_pointer(&n[3], memdup(v, count * 4 * sizeof(GLfloat)));
+ }
if (ctx->ExecuteFlag) {
- CALL_PauseTransformFeedback(ctx->Exec, ());
+ CALL_Uniform4iv(ctx->Exec, (location, count, v));
}
}
+
+
static void GLAPIENTRY
-save_ResumeTransformFeedback(void)
+save_Uniform1ui(GLint location, GLuint x)
{
GET_CURRENT_CONTEXT(ctx);
+ Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- (void) alloc_instruction(ctx, OPCODE_RESUME_TRANSFORM_FEEDBACK, 0);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_1UI, 2);
+ if (n) {
+ n[1].i = location;
+ n[2].i = x;
+ }
if (ctx->ExecuteFlag) {
- CALL_ResumeTransformFeedback(ctx->Exec, ());
+ CALL_Uniform1ui(ctx->Exec, (location, x));
}
}
static void GLAPIENTRY
-save_DrawTransformFeedback(GLenum mode, GLuint name)
+save_Uniform2ui(GLint location, GLuint x, GLuint y)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_DRAW_TRANSFORM_FEEDBACK, 2);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_2UI, 3);
if (n) {
- n[1].e = mode;
- n[2].ui = name;
+ n[1].i = location;
+ n[2].i = x;
+ n[3].i = y;
}
if (ctx->ExecuteFlag) {
- CALL_DrawTransformFeedback(ctx->Exec, (mode, name));
+ CALL_Uniform2ui(ctx->Exec, (location, x, y));
}
}
static void GLAPIENTRY
-save_DrawTransformFeedbackStream(GLenum mode, GLuint name, GLuint stream)
+save_Uniform3ui(GLint location, GLuint x, GLuint y, GLuint z)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_DRAW_TRANSFORM_FEEDBACK_STREAM, 3);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_3UI, 4);
if (n) {
- n[1].e = mode;
- n[2].ui = name;
- n[3].ui = stream;
+ n[1].i = location;
+ n[2].i = x;
+ n[3].i = y;
+ n[4].i = z;
}
if (ctx->ExecuteFlag) {
- CALL_DrawTransformFeedbackStream(ctx->Exec, (mode, name, stream));
+ CALL_Uniform3ui(ctx->Exec, (location, x, y, z));
}
}
static void GLAPIENTRY
-save_DrawTransformFeedbackInstanced(GLenum mode, GLuint name,
- GLsizei primcount)
+save_Uniform4ui(GLint location, GLuint x, GLuint y, GLuint z, GLuint w)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_DRAW_TRANSFORM_FEEDBACK_INSTANCED, 3);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_4UI, 5);
if (n) {
- n[1].e = mode;
- n[2].ui = name;
- n[3].si = primcount;
+ n[1].i = location;
+ n[2].i = x;
+ n[3].i = y;
+ n[4].i = z;
+ n[5].i = w;
}
if (ctx->ExecuteFlag) {
- CALL_DrawTransformFeedbackInstanced(ctx->Exec, (mode, name, primcount));
+ CALL_Uniform4ui(ctx->Exec, (location, x, y, z, w));
}
}
+
+
static void GLAPIENTRY
-save_DrawTransformFeedbackStreamInstanced(GLenum mode, GLuint name,
- GLuint stream, GLsizei primcount)
+save_Uniform1uiv(GLint location, GLsizei count, const GLuint *v)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_DRAW_TRANSFORM_FEEDBACK_STREAM_INSTANCED, 4);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_1UIV, 2 + POINTER_DWORDS);
if (n) {
- n[1].e = mode;
- n[2].ui = name;
- n[3].ui = stream;
- n[4].si = primcount;
+ n[1].i = location;
+ n[2].i = count;
+ save_pointer(&n[3], memdup(v, count * 1 * sizeof(*v)));
}
if (ctx->ExecuteFlag) {
- CALL_DrawTransformFeedbackStreamInstanced(ctx->Exec, (mode, name, stream,
- primcount));
+ CALL_Uniform1uiv(ctx->Exec, (location, count, v));
}
}
static void GLAPIENTRY
-save_DispatchCompute(GLuint num_groups_x, GLuint num_groups_y,
- GLuint num_groups_z)
+save_Uniform2uiv(GLint location, GLsizei count, const GLuint *v)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_DISPATCH_COMPUTE, 3);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_2UIV, 2 + POINTER_DWORDS);
if (n) {
- n[1].ui = num_groups_x;
- n[2].ui = num_groups_y;
- n[3].ui = num_groups_z;
+ n[1].i = location;
+ n[2].i = count;
+ save_pointer(&n[3], memdup(v, count * 2 * sizeof(*v)));
}
if (ctx->ExecuteFlag) {
- CALL_DispatchCompute(ctx->Exec, (num_groups_x, num_groups_y,
- num_groups_z));
+ CALL_Uniform2uiv(ctx->Exec, (location, count, v));
}
}
static void GLAPIENTRY
-save_DispatchComputeIndirect(GLintptr indirect)
+save_Uniform3uiv(GLint location, GLsizei count, const GLuint *v)
{
GET_CURRENT_CONTEXT(ctx);
- _mesa_error(ctx, GL_INVALID_OPERATION,
- "glDispatchComputeIndirect() during display list compile");
+ Node *n;
+ ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_3UIV, 2 + POINTER_DWORDS);
+ if (n) {
+ n[1].i = location;
+ n[2].i = count;
+ save_pointer(&n[3], memdup(v, count * 3 * sizeof(*v)));
+ }
+ if (ctx->ExecuteFlag) {
+ CALL_Uniform3uiv(ctx->Exec, (location, count, v));
+ }
}
static void GLAPIENTRY
-save_UseProgram(GLuint program)
+save_Uniform4uiv(GLint location, GLsizei count, const GLuint *v)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_USE_PROGRAM, 1);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_4UIV, 2 + POINTER_DWORDS);
if (n) {
- n[1].ui = program;
+ n[1].i = location;
+ n[2].i = count;
+ save_pointer(&n[3], memdup(v, count * 4 * sizeof(*v)));
}
if (ctx->ExecuteFlag) {
- CALL_UseProgram(ctx->Exec, (program));
+ CALL_Uniform4uiv(ctx->Exec, (location, count, v));
}
}
+
static void GLAPIENTRY
-save_Uniform1fARB(GLint location, GLfloat x)
+save_UniformMatrix2fvARB(GLint location, GLsizei count, GLboolean transpose,
+ const GLfloat *m)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_UNIFORM_1F, 2);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX22, 3 + POINTER_DWORDS);
if (n) {
n[1].i = location;
- n[2].f = x;
+ n[2].i = count;
+ n[3].b = transpose;
+ save_pointer(&n[4], memdup(m, count * 2 * 2 * sizeof(GLfloat)));
}
if (ctx->ExecuteFlag) {
- CALL_Uniform1f(ctx->Exec, (location, x));
+ CALL_UniformMatrix2fv(ctx->Exec, (location, count, transpose, m));
}
}
-
static void GLAPIENTRY
-save_Uniform2fARB(GLint location, GLfloat x, GLfloat y)
+save_UniformMatrix3fvARB(GLint location, GLsizei count, GLboolean transpose,
+ const GLfloat *m)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_UNIFORM_2F, 3);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX33, 3 + POINTER_DWORDS);
if (n) {
n[1].i = location;
- n[2].f = x;
- n[3].f = y;
+ n[2].i = count;
+ n[3].b = transpose;
+ save_pointer(&n[4], memdup(m, count * 3 * 3 * sizeof(GLfloat)));
}
if (ctx->ExecuteFlag) {
- CALL_Uniform2f(ctx->Exec, (location, x, y));
+ CALL_UniformMatrix3fv(ctx->Exec, (location, count, transpose, m));
}
}
-
static void GLAPIENTRY
-save_Uniform3fARB(GLint location, GLfloat x, GLfloat y, GLfloat z)
+save_UniformMatrix4fvARB(GLint location, GLsizei count, GLboolean transpose,
+ const GLfloat *m)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_UNIFORM_3F, 4);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX44, 3 + POINTER_DWORDS);
if (n) {
n[1].i = location;
- n[2].f = x;
- n[3].f = y;
- n[4].f = z;
+ n[2].i = count;
+ n[3].b = transpose;
+ save_pointer(&n[4], memdup(m, count * 4 * 4 * sizeof(GLfloat)));
}
if (ctx->ExecuteFlag) {
- CALL_Uniform3f(ctx->Exec, (location, x, y, z));
+ CALL_UniformMatrix4fv(ctx->Exec, (location, count, transpose, m));
}
}
static void GLAPIENTRY
-save_Uniform4fARB(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+save_UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose,
+ const GLfloat *m)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_UNIFORM_4F, 5);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX23, 3 + POINTER_DWORDS);
if (n) {
n[1].i = location;
- n[2].f = x;
- n[3].f = y;
- n[4].f = z;
- n[5].f = w;
+ n[2].i = count;
+ n[3].b = transpose;
+ save_pointer(&n[4], memdup(m, count * 2 * 3 * sizeof(GLfloat)));
}
if (ctx->ExecuteFlag) {
- CALL_Uniform4f(ctx->Exec, (location, x, y, z, w));
+ CALL_UniformMatrix2x3fv(ctx->Exec, (location, count, transpose, m));
}
}
-
static void GLAPIENTRY
-save_Uniform1fvARB(GLint location, GLsizei count, const GLfloat *v)
+save_UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose,
+ const GLfloat *m)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_UNIFORM_1FV, 2 + POINTER_DWORDS);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX32, 3 + POINTER_DWORDS);
if (n) {
n[1].i = location;
n[2].i = count;
- save_pointer(&n[3], memdup(v, count * 1 * sizeof(GLfloat)));
+ n[3].b = transpose;
+ save_pointer(&n[4], memdup(m, count * 3 * 2 * sizeof(GLfloat)));
}
if (ctx->ExecuteFlag) {
- CALL_Uniform1fv(ctx->Exec, (location, count, v));
+ CALL_UniformMatrix3x2fv(ctx->Exec, (location, count, transpose, m));
}
}
+
static void GLAPIENTRY
-save_Uniform2fvARB(GLint location, GLsizei count, const GLfloat *v)
+save_UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose,
+ const GLfloat *m)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_UNIFORM_2FV, 2 + POINTER_DWORDS);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX24, 3 + POINTER_DWORDS);
if (n) {
n[1].i = location;
n[2].i = count;
- save_pointer(&n[3], memdup(v, count * 2 * sizeof(GLfloat)));
+ n[3].b = transpose;
+ save_pointer(&n[4], memdup(m, count * 2 * 4 * sizeof(GLfloat)));
}
if (ctx->ExecuteFlag) {
- CALL_Uniform2fv(ctx->Exec, (location, count, v));
+ CALL_UniformMatrix2x4fv(ctx->Exec, (location, count, transpose, m));
}
}
static void GLAPIENTRY
-save_Uniform3fvARB(GLint location, GLsizei count, const GLfloat *v)
+save_UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose,
+ const GLfloat *m)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_UNIFORM_3FV, 2 + POINTER_DWORDS);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX42, 3 + POINTER_DWORDS);
if (n) {
n[1].i = location;
n[2].i = count;
- save_pointer(&n[3], memdup(v, count * 3 * sizeof(GLfloat)));
+ n[3].b = transpose;
+ save_pointer(&n[4], memdup(m, count * 4 * 2 * sizeof(GLfloat)));
}
if (ctx->ExecuteFlag) {
- CALL_Uniform3fv(ctx->Exec, (location, count, v));
+ CALL_UniformMatrix4x2fv(ctx->Exec, (location, count, transpose, m));
}
}
+
static void GLAPIENTRY
-save_Uniform4fvARB(GLint location, GLsizei count, const GLfloat *v)
+save_UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose,
+ const GLfloat *m)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_UNIFORM_4FV, 2 + POINTER_DWORDS);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX34, 3 + POINTER_DWORDS);
if (n) {
n[1].i = location;
n[2].i = count;
- save_pointer(&n[3], memdup(v, count * 4 * sizeof(GLfloat)));
+ n[3].b = transpose;
+ save_pointer(&n[4], memdup(m, count * 3 * 4 * sizeof(GLfloat)));
}
if (ctx->ExecuteFlag) {
- CALL_Uniform4fv(ctx->Exec, (location, count, v));
+ CALL_UniformMatrix3x4fv(ctx->Exec, (location, count, transpose, m));
}
}
-
static void GLAPIENTRY
-save_Uniform1d(GLint location, GLdouble x)
+save_UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose,
+ const GLfloat *m)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_UNIFORM_1D, 3);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX43, 3 + POINTER_DWORDS);
if (n) {
n[1].i = location;
- ASSIGN_DOUBLE_TO_NODES(n, 2, x);
+ n[2].i = count;
+ n[3].b = transpose;
+ save_pointer(&n[4], memdup(m, count * 4 * 3 * sizeof(GLfloat)));
}
if (ctx->ExecuteFlag) {
- CALL_Uniform1d(ctx->Exec, (location, x));
+ CALL_UniformMatrix4x3fv(ctx->Exec, (location, count, transpose, m));
}
}
static void GLAPIENTRY
-save_Uniform2d(GLint location, GLdouble x, GLdouble y)
+save_UniformMatrix2dv(GLint location, GLsizei count, GLboolean transpose,
+ const GLdouble *m)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_UNIFORM_2D, 5);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX22D, 3 + POINTER_DWORDS);
if (n) {
n[1].i = location;
- ASSIGN_DOUBLE_TO_NODES(n, 2, x);
- ASSIGN_DOUBLE_TO_NODES(n, 4, y);
+ n[2].i = count;
+ n[3].b = transpose;
+ save_pointer(&n[4], memdup(m, count * 2 * 2 * sizeof(GLdouble)));
}
if (ctx->ExecuteFlag) {
- CALL_Uniform2d(ctx->Exec, (location, x, y));
+ CALL_UniformMatrix2dv(ctx->Exec, (location, count, transpose, m));
}
}
-
static void GLAPIENTRY
-save_Uniform3d(GLint location, GLdouble x, GLdouble y, GLdouble z)
+save_UniformMatrix3dv(GLint location, GLsizei count, GLboolean transpose,
+ const GLdouble *m)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_UNIFORM_3D, 7);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX33D, 3 + POINTER_DWORDS);
if (n) {
n[1].i = location;
- ASSIGN_DOUBLE_TO_NODES(n, 2, x);
- ASSIGN_DOUBLE_TO_NODES(n, 4, y);
- ASSIGN_DOUBLE_TO_NODES(n, 6, z);
+ n[2].i = count;
+ n[3].b = transpose;
+ save_pointer(&n[4], memdup(m, count * 3 * 3 * sizeof(GLdouble)));
}
if (ctx->ExecuteFlag) {
- CALL_Uniform3d(ctx->Exec, (location, x, y, z));
+ CALL_UniformMatrix3dv(ctx->Exec, (location, count, transpose, m));
}
}
-
static void GLAPIENTRY
-save_Uniform4d(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+save_UniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose,
+ const GLdouble *m)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_UNIFORM_4D, 9);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX44D, 3 + POINTER_DWORDS);
if (n) {
n[1].i = location;
- ASSIGN_DOUBLE_TO_NODES(n, 2, x);
- ASSIGN_DOUBLE_TO_NODES(n, 4, y);
- ASSIGN_DOUBLE_TO_NODES(n, 6, z);
- ASSIGN_DOUBLE_TO_NODES(n, 8, w);
+ n[2].i = count;
+ n[3].b = transpose;
+ save_pointer(&n[4], memdup(m, count * 4 * 4 * sizeof(GLdouble)));
}
if (ctx->ExecuteFlag) {
- CALL_Uniform4d(ctx->Exec, (location, x, y, z, w));
+ CALL_UniformMatrix4dv(ctx->Exec, (location, count, transpose, m));
}
}
static void GLAPIENTRY
-save_Uniform1dv(GLint location, GLsizei count, const GLdouble *v)
+save_UniformMatrix2x3dv(GLint location, GLsizei count, GLboolean transpose,
+ const GLdouble *m)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_UNIFORM_1DV, 2 + POINTER_DWORDS);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX23D, 3 + POINTER_DWORDS);
if (n) {
n[1].i = location;
n[2].i = count;
- save_pointer(&n[3], memdup(v, count * 1 * sizeof(GLdouble)));
+ n[3].b = transpose;
+ save_pointer(&n[4], memdup(m, count * 2 * 3 * sizeof(GLdouble)));
}
if (ctx->ExecuteFlag) {
- CALL_Uniform1dv(ctx->Exec, (location, count, v));
+ CALL_UniformMatrix2x3dv(ctx->Exec, (location, count, transpose, m));
}
}
static void GLAPIENTRY
-save_Uniform2dv(GLint location, GLsizei count, const GLdouble *v)
+save_UniformMatrix3x2dv(GLint location, GLsizei count, GLboolean transpose,
+ const GLdouble *m)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_UNIFORM_2DV, 2 + POINTER_DWORDS);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX32D, 3 + POINTER_DWORDS);
if (n) {
n[1].i = location;
n[2].i = count;
- save_pointer(&n[3], memdup(v, count * 2 * sizeof(GLdouble)));
+ n[3].b = transpose;
+ save_pointer(&n[4], memdup(m, count * 3 * 2 * sizeof(GLdouble)));
}
if (ctx->ExecuteFlag) {
- CALL_Uniform2dv(ctx->Exec, (location, count, v));
+ CALL_UniformMatrix3x2dv(ctx->Exec, (location, count, transpose, m));
}
}
static void GLAPIENTRY
-save_Uniform3dv(GLint location, GLsizei count, const GLdouble *v)
+save_UniformMatrix2x4dv(GLint location, GLsizei count, GLboolean transpose,
+ const GLdouble *m)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_UNIFORM_3DV, 2 + POINTER_DWORDS);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX24D, 3 + POINTER_DWORDS);
if (n) {
n[1].i = location;
n[2].i = count;
- save_pointer(&n[3], memdup(v, count * 3 * sizeof(GLdouble)));
+ n[3].b = transpose;
+ save_pointer(&n[4], memdup(m, count * 2 * 4 * sizeof(GLdouble)));
}
if (ctx->ExecuteFlag) {
- CALL_Uniform3dv(ctx->Exec, (location, count, v));
+ CALL_UniformMatrix2x4dv(ctx->Exec, (location, count, transpose, m));
}
}
-
static void GLAPIENTRY
-save_Uniform4dv(GLint location, GLsizei count, const GLdouble *v)
+save_UniformMatrix4x2dv(GLint location, GLsizei count, GLboolean transpose,
+ const GLdouble *m)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_UNIFORM_4DV, 2 + POINTER_DWORDS);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX42D, 3 + POINTER_DWORDS);
if (n) {
n[1].i = location;
n[2].i = count;
- save_pointer(&n[3], memdup(v, count * 4 * sizeof(GLdouble)));
+ n[3].b = transpose;
+ save_pointer(&n[4], memdup(m, count * 4 * 2 * sizeof(GLdouble)));
}
if (ctx->ExecuteFlag) {
- CALL_Uniform4dv(ctx->Exec, (location, count, v));
+ CALL_UniformMatrix4x2dv(ctx->Exec, (location, count, transpose, m));
}
}
static void GLAPIENTRY
-save_Uniform1iARB(GLint location, GLint x)
+save_UniformMatrix3x4dv(GLint location, GLsizei count, GLboolean transpose,
+ const GLdouble *m)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_UNIFORM_1I, 2);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX34D, 3 + POINTER_DWORDS);
if (n) {
n[1].i = location;
- n[2].i = x;
+ n[2].i = count;
+ n[3].b = transpose;
+ save_pointer(&n[4], memdup(m, count * 3 * 4 * sizeof(GLdouble)));
}
if (ctx->ExecuteFlag) {
- CALL_Uniform1i(ctx->Exec, (location, x));
+ CALL_UniformMatrix3x4dv(ctx->Exec, (location, count, transpose, m));
}
}
+
static void GLAPIENTRY
-save_Uniform2iARB(GLint location, GLint x, GLint y)
+save_UniformMatrix4x3dv(GLint location, GLsizei count, GLboolean transpose,
+ const GLdouble *m)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_UNIFORM_2I, 3);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX43D, 3 + POINTER_DWORDS);
if (n) {
n[1].i = location;
- n[2].i = x;
- n[3].i = y;
+ n[2].i = count;
+ n[3].b = transpose;
+ save_pointer(&n[4], memdup(m, count * 4 * 3 * sizeof(GLdouble)));
}
if (ctx->ExecuteFlag) {
- CALL_Uniform2i(ctx->Exec, (location, x, y));
+ CALL_UniformMatrix4x3dv(ctx->Exec, (location, count, transpose, m));
}
}
static void GLAPIENTRY
-save_Uniform3iARB(GLint location, GLint x, GLint y, GLint z)
+save_Uniform1i64ARB(GLint location, GLint64 x)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_UNIFORM_3I, 4);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_1I64, 3);
if (n) {
n[1].i = location;
- n[2].i = x;
- n[3].i = y;
- n[4].i = z;
+ ASSIGN_INT64_TO_NODES(n, 2, x);
}
if (ctx->ExecuteFlag) {
- CALL_Uniform3i(ctx->Exec, (location, x, y, z));
+ CALL_Uniform1i64ARB(ctx->Exec, (location, x));
}
}
static void GLAPIENTRY
-save_Uniform4iARB(GLint location, GLint x, GLint y, GLint z, GLint w)
+save_Uniform2i64ARB(GLint location, GLint64 x, GLint64 y)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_UNIFORM_4I, 5);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_2I64, 5);
if (n) {
n[1].i = location;
- n[2].i = x;
- n[3].i = y;
- n[4].i = z;
- n[5].i = w;
+ ASSIGN_INT64_TO_NODES(n, 2, x);
+ ASSIGN_INT64_TO_NODES(n, 4, y);
}
if (ctx->ExecuteFlag) {
- CALL_Uniform4i(ctx->Exec, (location, x, y, z, w));
+ CALL_Uniform2i64ARB(ctx->Exec, (location, x, y));
}
}
-
-
static void GLAPIENTRY
-save_Uniform1ivARB(GLint location, GLsizei count, const GLint *v)
+save_Uniform3i64ARB(GLint location, GLint64 x, GLint64 y, GLint64 z)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_UNIFORM_1IV, 2 + POINTER_DWORDS);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_3I64, 7);
if (n) {
n[1].i = location;
- n[2].i = count;
- save_pointer(&n[3], memdup(v, count * 1 * sizeof(GLint)));
+ ASSIGN_INT64_TO_NODES(n, 2, x);
+ ASSIGN_INT64_TO_NODES(n, 4, y);
+ ASSIGN_INT64_TO_NODES(n, 6, z);
}
if (ctx->ExecuteFlag) {
- CALL_Uniform1iv(ctx->Exec, (location, count, v));
+ CALL_Uniform3i64ARB(ctx->Exec, (location, x, y, z));
}
}
static void GLAPIENTRY
-save_Uniform2ivARB(GLint location, GLsizei count, const GLint *v)
+save_Uniform4i64ARB(GLint location, GLint64 x, GLint64 y, GLint64 z, GLint64 w)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_UNIFORM_2IV, 2 + POINTER_DWORDS);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_4I64, 9);
if (n) {
n[1].i = location;
- n[2].i = count;
- save_pointer(&n[3], memdup(v, count * 2 * sizeof(GLint)));
+ ASSIGN_INT64_TO_NODES(n, 2, x);
+ ASSIGN_INT64_TO_NODES(n, 4, y);
+ ASSIGN_INT64_TO_NODES(n, 6, z);
+ ASSIGN_INT64_TO_NODES(n, 8, w);
}
if (ctx->ExecuteFlag) {
- CALL_Uniform2iv(ctx->Exec, (location, count, v));
+ CALL_Uniform4i64ARB(ctx->Exec, (location, x, y, z, w));
}
}
static void GLAPIENTRY
-save_Uniform3ivARB(GLint location, GLsizei count, const GLint *v)
+save_Uniform1i64vARB(GLint location, GLsizei count, const GLint64 *v)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_UNIFORM_3IV, 2 + POINTER_DWORDS);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_1I64V, 2 + POINTER_DWORDS);
if (n) {
- n[1].i = location;
- n[2].i = count;
- save_pointer(&n[3], memdup(v, count * 3 * sizeof(GLint)));
+ n[1].i = location;
+ n[2].i = count;
+ save_pointer(&n[3], memdup(v, count * 1 * sizeof(GLint64)));
}
if (ctx->ExecuteFlag) {
- CALL_Uniform3iv(ctx->Exec, (location, count, v));
+ CALL_Uniform1i64vARB(ctx->Exec, (location, count, v));
}
}
static void GLAPIENTRY
-save_Uniform4ivARB(GLint location, GLsizei count, const GLint *v)
+save_Uniform2i64vARB(GLint location, GLsizei count, const GLint64 *v)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_UNIFORM_4IV, 2 + POINTER_DWORDS);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_2I64V, 2 + POINTER_DWORDS);
if (n) {
- n[1].i = location;
- n[2].i = count;
- save_pointer(&n[3], memdup(v, count * 4 * sizeof(GLfloat)));
+ n[1].i = location;
+ n[2].i = count;
+ save_pointer(&n[3], memdup(v, count * 2 * sizeof(GLint64)));
}
if (ctx->ExecuteFlag) {
- CALL_Uniform4iv(ctx->Exec, (location, count, v));
+ CALL_Uniform2i64vARB(ctx->Exec, (location, count, v));
}
}
-
-
static void GLAPIENTRY
-save_Uniform1ui(GLint location, GLuint x)
+save_Uniform3i64vARB(GLint location, GLsizei count, const GLint64 *v)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_UNIFORM_1UI, 2);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_3I64V, 2 + POINTER_DWORDS);
if (n) {
- n[1].i = location;
- n[2].i = x;
+ n[1].i = location;
+ n[2].i = count;
+ save_pointer(&n[3], memdup(v, count * 3 * sizeof(GLint64)));
}
if (ctx->ExecuteFlag) {
- CALL_Uniform1ui(ctx->Exec, (location, x));
+ CALL_Uniform3i64vARB(ctx->Exec, (location, count, v));
}
}
static void GLAPIENTRY
-save_Uniform2ui(GLint location, GLuint x, GLuint y)
+save_Uniform4i64vARB(GLint location, GLsizei count, const GLint64 *v)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_UNIFORM_2UI, 3);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_4I64V, 2 + POINTER_DWORDS);
if (n) {
- n[1].i = location;
- n[2].i = x;
- n[3].i = y;
+ n[1].i = location;
+ n[2].i = count;
+ save_pointer(&n[3], memdup(v, count * 4 * sizeof(GLint64)));
}
if (ctx->ExecuteFlag) {
- CALL_Uniform2ui(ctx->Exec, (location, x, y));
+ CALL_Uniform4i64vARB(ctx->Exec, (location, count, v));
}
}
static void GLAPIENTRY
-save_Uniform3ui(GLint location, GLuint x, GLuint y, GLuint z)
+save_Uniform1ui64ARB(GLint location, GLuint64 x)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_UNIFORM_3UI, 4);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_1UI64, 3);
if (n) {
n[1].i = location;
- n[2].i = x;
- n[3].i = y;
- n[4].i = z;
+ ASSIGN_UINT64_TO_NODES(n, 2, x);
}
if (ctx->ExecuteFlag) {
- CALL_Uniform3ui(ctx->Exec, (location, x, y, z));
+ CALL_Uniform1ui64ARB(ctx->Exec, (location, x));
}
}
static void GLAPIENTRY
-save_Uniform4ui(GLint location, GLuint x, GLuint y, GLuint z, GLuint w)
+save_Uniform2ui64ARB(GLint location, GLuint64 x, GLuint64 y)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_UNIFORM_4UI, 5);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_2UI64, 5);
if (n) {
n[1].i = location;
- n[2].i = x;
- n[3].i = y;
- n[4].i = z;
- n[5].i = w;
+ ASSIGN_UINT64_TO_NODES(n, 2, x);
+ ASSIGN_UINT64_TO_NODES(n, 4, y);
}
if (ctx->ExecuteFlag) {
- CALL_Uniform4ui(ctx->Exec, (location, x, y, z, w));
+ CALL_Uniform2ui64ARB(ctx->Exec, (location, x, y));
}
}
-
-
static void GLAPIENTRY
-save_Uniform1uiv(GLint location, GLsizei count, const GLuint *v)
+save_Uniform3ui64ARB(GLint location, GLuint64 x, GLuint64 y, GLuint64 z)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_UNIFORM_1UIV, 2 + POINTER_DWORDS);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_3UI64, 7);
if (n) {
n[1].i = location;
- n[2].i = count;
- save_pointer(&n[3], memdup(v, count * 1 * sizeof(*v)));
+ ASSIGN_UINT64_TO_NODES(n, 2, x);
+ ASSIGN_UINT64_TO_NODES(n, 4, y);
+ ASSIGN_UINT64_TO_NODES(n, 6, z);
}
if (ctx->ExecuteFlag) {
- CALL_Uniform1uiv(ctx->Exec, (location, count, v));
+ CALL_Uniform3ui64ARB(ctx->Exec, (location, x, y, z));
}
}
static void GLAPIENTRY
-save_Uniform2uiv(GLint location, GLsizei count, const GLuint *v)
+save_Uniform4ui64ARB(GLint location, GLuint64 x, GLuint64 y, GLuint64 z, GLuint64 w)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_UNIFORM_2UIV, 2 + POINTER_DWORDS);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_4UI64, 9);
if (n) {
n[1].i = location;
- n[2].i = count;
- save_pointer(&n[3], memdup(v, count * 2 * sizeof(*v)));
+ ASSIGN_UINT64_TO_NODES(n, 2, x);
+ ASSIGN_UINT64_TO_NODES(n, 4, y);
+ ASSIGN_UINT64_TO_NODES(n, 6, z);
+ ASSIGN_UINT64_TO_NODES(n, 8, w);
}
if (ctx->ExecuteFlag) {
- CALL_Uniform2uiv(ctx->Exec, (location, count, v));
+ CALL_Uniform4ui64ARB(ctx->Exec, (location, x, y, z, w));
}
}
static void GLAPIENTRY
-save_Uniform3uiv(GLint location, GLsizei count, const GLuint *v)
+save_Uniform1ui64vARB(GLint location, GLsizei count, const GLuint64 *v)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_UNIFORM_3UIV, 2 + POINTER_DWORDS);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_1UI64V, 2 + POINTER_DWORDS);
if (n) {
- n[1].i = location;
- n[2].i = count;
- save_pointer(&n[3], memdup(v, count * 3 * sizeof(*v)));
+ n[1].i = location;
+ n[2].i = count;
+ save_pointer(&n[3], memdup(v, count * 1 * sizeof(GLuint64)));
}
if (ctx->ExecuteFlag) {
- CALL_Uniform3uiv(ctx->Exec, (location, count, v));
+ CALL_Uniform1ui64vARB(ctx->Exec, (location, count, v));
}
}
static void GLAPIENTRY
-save_Uniform4uiv(GLint location, GLsizei count, const GLuint *v)
+save_Uniform2ui64vARB(GLint location, GLsizei count, const GLuint64 *v)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_UNIFORM_4UIV, 2 + POINTER_DWORDS);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_2UI64V, 2 + POINTER_DWORDS);
if (n) {
- n[1].i = location;
- n[2].i = count;
- save_pointer(&n[3], memdup(v, count * 4 * sizeof(*v)));
+ n[1].i = location;
+ n[2].i = count;
+ save_pointer(&n[3], memdup(v, count * 2 * sizeof(GLuint64)));
}
if (ctx->ExecuteFlag) {
- CALL_Uniform4uiv(ctx->Exec, (location, count, v));
+ CALL_Uniform2ui64vARB(ctx->Exec, (location, count, v));
}
}
-
-
static void GLAPIENTRY
-save_UniformMatrix2fvARB(GLint location, GLsizei count, GLboolean transpose,
- const GLfloat *m)
+save_Uniform3ui64vARB(GLint location, GLsizei count, const GLuint64 *v)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX22, 3 + POINTER_DWORDS);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_3UI64V, 2 + POINTER_DWORDS);
if (n) {
- n[1].i = location;
- n[2].i = count;
- n[3].b = transpose;
- save_pointer(&n[4], memdup(m, count * 2 * 2 * sizeof(GLfloat)));
+ n[1].i = location;
+ n[2].i = count;
+ save_pointer(&n[3], memdup(v, count * 3 * sizeof(GLuint64)));
}
if (ctx->ExecuteFlag) {
- CALL_UniformMatrix2fv(ctx->Exec, (location, count, transpose, m));
+ CALL_Uniform3ui64vARB(ctx->Exec, (location, count, v));
}
}
static void GLAPIENTRY
-save_UniformMatrix3fvARB(GLint location, GLsizei count, GLboolean transpose,
- const GLfloat *m)
+save_Uniform4ui64vARB(GLint location, GLsizei count, const GLuint64 *v)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX33, 3 + POINTER_DWORDS);
+ n = alloc_instruction(ctx, OPCODE_UNIFORM_4UI64V, 2 + POINTER_DWORDS);
if (n) {
- n[1].i = location;
- n[2].i = count;
- n[3].b = transpose;
- save_pointer(&n[4], memdup(m, count * 3 * 3 * sizeof(GLfloat)));
+ n[1].i = location;
+ n[2].i = count;
+ save_pointer(&n[3], memdup(v, count * 4 * sizeof(GLuint64)));
}
if (ctx->ExecuteFlag) {
- CALL_UniformMatrix3fv(ctx->Exec, (location, count, transpose, m));
+ CALL_Uniform4ui64vARB(ctx->Exec, (location, count, v));
}
}
static void GLAPIENTRY
-save_UniformMatrix4fvARB(GLint location, GLsizei count, GLboolean transpose,
- const GLfloat *m)
+save_ProgramUniform1i64ARB(GLuint program, GLint location, GLint64 x)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX44, 3 + POINTER_DWORDS);
+ n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_1I64, 4);
if (n) {
- n[1].i = location;
- n[2].i = count;
- n[3].b = transpose;
- save_pointer(&n[4], memdup(m, count * 4 * 4 * sizeof(GLfloat)));
+ n[1].ui = program;
+ n[2].i = location;
+ ASSIGN_INT64_TO_NODES(n, 3, x);
}
if (ctx->ExecuteFlag) {
- CALL_UniformMatrix4fv(ctx->Exec, (location, count, transpose, m));
+ CALL_ProgramUniform1i64ARB(ctx->Exec, (program, location, x));
}
}
-
static void GLAPIENTRY
-save_UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose,
- const GLfloat *m)
+save_ProgramUniform2i64ARB(GLuint program, GLint location, GLint64 x,
+ GLint64 y)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX23, 3 + POINTER_DWORDS);
+ n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_2I64, 6);
if (n) {
- n[1].i = location;
- n[2].i = count;
- n[3].b = transpose;
- save_pointer(&n[4], memdup(m, count * 2 * 3 * sizeof(GLfloat)));
+ n[1].ui = program;
+ n[2].i = location;
+ ASSIGN_INT64_TO_NODES(n, 3, x);
+ ASSIGN_INT64_TO_NODES(n, 5, y);
}
if (ctx->ExecuteFlag) {
- CALL_UniformMatrix2x3fv(ctx->Exec, (location, count, transpose, m));
+ CALL_ProgramUniform2i64ARB(ctx->Exec, (program, location, x, y));
}
}
static void GLAPIENTRY
-save_UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose,
- const GLfloat *m)
+save_ProgramUniform3i64ARB(GLuint program, GLint location, GLint64 x,
+ GLint64 y, GLint64 z)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX32, 3 + POINTER_DWORDS);
+ n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_3I64, 8);
if (n) {
- n[1].i = location;
- n[2].i = count;
- n[3].b = transpose;
- save_pointer(&n[4], memdup(m, count * 3 * 2 * sizeof(GLfloat)));
+ n[1].ui = program;
+ n[2].i = location;
+ ASSIGN_INT64_TO_NODES(n, 3, x);
+ ASSIGN_INT64_TO_NODES(n, 5, y);
+ ASSIGN_INT64_TO_NODES(n, 7, z);
}
if (ctx->ExecuteFlag) {
- CALL_UniformMatrix3x2fv(ctx->Exec, (location, count, transpose, m));
+ CALL_ProgramUniform3i64ARB(ctx->Exec, (program, location, x, y, z));
}
}
-
static void GLAPIENTRY
-save_UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose,
- const GLfloat *m)
+save_ProgramUniform4i64ARB(GLuint program, GLint location, GLint64 x,
+ GLint64 y, GLint64 z, GLint64 w)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX24, 3 + POINTER_DWORDS);
+ n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_4I64, 10);
if (n) {
- n[1].i = location;
- n[2].i = count;
- n[3].b = transpose;
- save_pointer(&n[4], memdup(m, count * 2 * 4 * sizeof(GLfloat)));
+ n[1].ui = program;
+ n[2].i = location;
+ ASSIGN_INT64_TO_NODES(n, 3, x);
+ ASSIGN_INT64_TO_NODES(n, 5, y);
+ ASSIGN_INT64_TO_NODES(n, 7, z);
+ ASSIGN_INT64_TO_NODES(n, 9, w);
}
if (ctx->ExecuteFlag) {
- CALL_UniformMatrix2x4fv(ctx->Exec, (location, count, transpose, m));
+ CALL_ProgramUniform4i64ARB(ctx->Exec, (program, location, x, y, z, w));
}
}
static void GLAPIENTRY
-save_UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose,
- const GLfloat *m)
+save_ProgramUniform1i64vARB(GLuint program, GLint location, GLsizei count,
+ const GLint64 *v)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX42, 3 + POINTER_DWORDS);
+ n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_1I64V, 3 + POINTER_DWORDS);
if (n) {
- n[1].i = location;
- n[2].i = count;
- n[3].b = transpose;
- save_pointer(&n[4], memdup(m, count * 4 * 2 * sizeof(GLfloat)));
+ n[1].ui = program;
+ n[2].i = location;
+ n[3].i = count;
+ save_pointer(&n[4], memdup(v, count * 1 * sizeof(GLint64)));
}
if (ctx->ExecuteFlag) {
- CALL_UniformMatrix4x2fv(ctx->Exec, (location, count, transpose, m));
+ CALL_ProgramUniform1i64vARB(ctx->Exec, (program, location, count, v));
}
}
-
static void GLAPIENTRY
-save_UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose,
- const GLfloat *m)
+save_ProgramUniform2i64vARB(GLuint program, GLint location, GLsizei count,
+ const GLint64 *v)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX34, 3 + POINTER_DWORDS);
+ n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_2I64V, 3 + POINTER_DWORDS);
if (n) {
- n[1].i = location;
- n[2].i = count;
- n[3].b = transpose;
- save_pointer(&n[4], memdup(m, count * 3 * 4 * sizeof(GLfloat)));
+ n[1].ui = program;
+ n[2].i = location;
+ n[3].i = count;
+ save_pointer(&n[4], memdup(v, count * 1 * sizeof(GLint64)));
}
if (ctx->ExecuteFlag) {
- CALL_UniformMatrix3x4fv(ctx->Exec, (location, count, transpose, m));
+ CALL_ProgramUniform2i64vARB(ctx->Exec, (program, location, count, v));
}
}
static void GLAPIENTRY
-save_UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose,
- const GLfloat *m)
+save_ProgramUniform3i64vARB(GLuint program, GLint location, GLsizei count,
+ const GLint64 *v)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX43, 3 + POINTER_DWORDS);
+ n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_3I64V, 3 + POINTER_DWORDS);
if (n) {
- n[1].i = location;
- n[2].i = count;
- n[3].b = transpose;
- save_pointer(&n[4], memdup(m, count * 4 * 3 * sizeof(GLfloat)));
+ n[1].ui = program;
+ n[2].i = location;
+ n[3].i = count;
+ save_pointer(&n[4], memdup(v, count * 1 * sizeof(GLint64)));
}
if (ctx->ExecuteFlag) {
- CALL_UniformMatrix4x3fv(ctx->Exec, (location, count, transpose, m));
+ CALL_ProgramUniform3i64vARB(ctx->Exec, (program, location, count, v));
}
}
-
static void GLAPIENTRY
-save_UniformMatrix2dv(GLint location, GLsizei count, GLboolean transpose,
- const GLdouble *m)
+save_ProgramUniform4i64vARB(GLuint program, GLint location, GLsizei count,
+ const GLint64 *v)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX22D, 3 + POINTER_DWORDS);
+ n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_4I64V, 3 + POINTER_DWORDS);
if (n) {
- n[1].i = location;
- n[2].i = count;
- n[3].b = transpose;
- save_pointer(&n[4], memdup(m, count * 2 * 2 * sizeof(GLdouble)));
+ n[1].ui = program;
+ n[2].i = location;
+ n[3].i = count;
+ save_pointer(&n[4], memdup(v, count * 1 * sizeof(GLint64)));
}
if (ctx->ExecuteFlag) {
- CALL_UniformMatrix2dv(ctx->Exec, (location, count, transpose, m));
+ CALL_ProgramUniform4i64vARB(ctx->Exec, (program, location, count, v));
}
}
static void GLAPIENTRY
-save_UniformMatrix3dv(GLint location, GLsizei count, GLboolean transpose,
- const GLdouble *m)
+save_ProgramUniform1ui64ARB(GLuint program, GLint location, GLuint64 x)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX33D, 3 + POINTER_DWORDS);
+ n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_1UI64, 4);
if (n) {
- n[1].i = location;
- n[2].i = count;
- n[3].b = transpose;
- save_pointer(&n[4], memdup(m, count * 3 * 3 * sizeof(GLdouble)));
+ n[1].ui = program;
+ n[2].i = location;
+ ASSIGN_UINT64_TO_NODES(n, 3, x);
}
if (ctx->ExecuteFlag) {
- CALL_UniformMatrix3dv(ctx->Exec, (location, count, transpose, m));
+ CALL_ProgramUniform1ui64ARB(ctx->Exec, (program, location, x));
}
}
static void GLAPIENTRY
-save_UniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose,
- const GLdouble *m)
+save_ProgramUniform2ui64ARB(GLuint program, GLint location, GLuint64 x,
+ GLuint64 y)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX44D, 3 + POINTER_DWORDS);
+ n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_2UI64, 6);
if (n) {
- n[1].i = location;
- n[2].i = count;
- n[3].b = transpose;
- save_pointer(&n[4], memdup(m, count * 4 * 4 * sizeof(GLdouble)));
+ n[1].ui = program;
+ n[2].i = location;
+ ASSIGN_UINT64_TO_NODES(n, 3, x);
+ ASSIGN_UINT64_TO_NODES(n, 5, y);
}
if (ctx->ExecuteFlag) {
- CALL_UniformMatrix4dv(ctx->Exec, (location, count, transpose, m));
+ CALL_ProgramUniform2ui64ARB(ctx->Exec, (program, location, x, y));
}
}
-
static void GLAPIENTRY
-save_UniformMatrix2x3dv(GLint location, GLsizei count, GLboolean transpose,
- const GLdouble *m)
+save_ProgramUniform3ui64ARB(GLuint program, GLint location, GLuint64 x,
+ GLuint64 y, GLuint64 z)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX23D, 3 + POINTER_DWORDS);
+ n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_3UI64, 8);
if (n) {
- n[1].i = location;
- n[2].i = count;
- n[3].b = transpose;
- save_pointer(&n[4], memdup(m, count * 2 * 3 * sizeof(GLdouble)));
+ n[1].ui = program;
+ n[2].i = location;
+ ASSIGN_UINT64_TO_NODES(n, 3, x);
+ ASSIGN_UINT64_TO_NODES(n, 5, y);
+ ASSIGN_UINT64_TO_NODES(n, 7, z);
}
if (ctx->ExecuteFlag) {
- CALL_UniformMatrix2x3dv(ctx->Exec, (location, count, transpose, m));
+ CALL_ProgramUniform3ui64ARB(ctx->Exec, (program, location, x, y, z));
}
}
-
static void GLAPIENTRY
-save_UniformMatrix3x2dv(GLint location, GLsizei count, GLboolean transpose,
- const GLdouble *m)
+save_ProgramUniform4ui64ARB(GLuint program, GLint location, GLuint64 x,
+ GLuint64 y, GLuint64 z, GLuint64 w)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX32D, 3 + POINTER_DWORDS);
+ n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_4UI64, 10);
if (n) {
- n[1].i = location;
- n[2].i = count;
- n[3].b = transpose;
- save_pointer(&n[4], memdup(m, count * 3 * 2 * sizeof(GLdouble)));
+ n[1].ui = program;
+ n[2].i = location;
+ ASSIGN_UINT64_TO_NODES(n, 3, x);
+ ASSIGN_UINT64_TO_NODES(n, 5, y);
+ ASSIGN_UINT64_TO_NODES(n, 7, z);
+ ASSIGN_UINT64_TO_NODES(n, 9, w);
}
if (ctx->ExecuteFlag) {
- CALL_UniformMatrix3x2dv(ctx->Exec, (location, count, transpose, m));
+ CALL_ProgramUniform4i64ARB(ctx->Exec, (program, location, x, y, z, w));
}
}
-
static void GLAPIENTRY
-save_UniformMatrix2x4dv(GLint location, GLsizei count, GLboolean transpose,
- const GLdouble *m)
+save_ProgramUniform1ui64vARB(GLuint program, GLint location, GLsizei count,
+ const GLuint64 *v)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX24D, 3 + POINTER_DWORDS);
+ n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_1UI64V,
+ 3 + POINTER_DWORDS);
if (n) {
- n[1].i = location;
- n[2].i = count;
- n[3].b = transpose;
- save_pointer(&n[4], memdup(m, count * 2 * 4 * sizeof(GLdouble)));
+ n[1].ui = program;
+ n[2].i = location;
+ n[3].i = count;
+ save_pointer(&n[4], memdup(v, count * 1 * sizeof(GLuint64)));
}
if (ctx->ExecuteFlag) {
- CALL_UniformMatrix2x4dv(ctx->Exec, (location, count, transpose, m));
+ CALL_ProgramUniform1ui64vARB(ctx->Exec, (program, location, count, v));
}
}
static void GLAPIENTRY
-save_UniformMatrix4x2dv(GLint location, GLsizei count, GLboolean transpose,
- const GLdouble *m)
+save_ProgramUniform2ui64vARB(GLuint program, GLint location, GLsizei count,
+ const GLuint64 *v)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX42D, 3 + POINTER_DWORDS);
+ n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_2UI64V,
+ 3 + POINTER_DWORDS);
if (n) {
- n[1].i = location;
- n[2].i = count;
- n[3].b = transpose;
- save_pointer(&n[4], memdup(m, count * 4 * 2 * sizeof(GLdouble)));
+ n[1].ui = program;
+ n[2].i = location;
+ n[3].i = count;
+ save_pointer(&n[4], memdup(v, count * 1 * sizeof(GLuint64)));
}
if (ctx->ExecuteFlag) {
- CALL_UniformMatrix4x2dv(ctx->Exec, (location, count, transpose, m));
+ CALL_ProgramUniform2ui64vARB(ctx->Exec, (program, location, count, v));
}
}
-
static void GLAPIENTRY
-save_UniformMatrix3x4dv(GLint location, GLsizei count, GLboolean transpose,
- const GLdouble *m)
+save_ProgramUniform3ui64vARB(GLuint program, GLint location, GLsizei count,
+ const GLuint64 *v)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX34D, 3 + POINTER_DWORDS);
+ n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_3UI64V,
+ 3 + POINTER_DWORDS);
if (n) {
- n[1].i = location;
- n[2].i = count;
- n[3].b = transpose;
- save_pointer(&n[4], memdup(m, count * 3 * 4 * sizeof(GLdouble)));
+ n[1].ui = program;
+ n[2].i = location;
+ n[3].i = count;
+ save_pointer(&n[4], memdup(v, count * 1 * sizeof(GLuint64)));
}
if (ctx->ExecuteFlag) {
- CALL_UniformMatrix3x4dv(ctx->Exec, (location, count, transpose, m));
+ CALL_ProgramUniform3ui64vARB(ctx->Exec, (program, location, count, v));
}
}
-
static void GLAPIENTRY
-save_UniformMatrix4x3dv(GLint location, GLsizei count, GLboolean transpose,
- const GLdouble *m)
+save_ProgramUniform4ui64vARB(GLuint program, GLint location, GLsizei count,
+ const GLuint64 *v)
{
GET_CURRENT_CONTEXT(ctx);
Node *n;
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
- n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX43D, 3 + POINTER_DWORDS);
+ n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_4UI64V,
+ 3 + POINTER_DWORDS);
if (n) {
- n[1].i = location;
- n[2].i = count;
- n[3].b = transpose;
- save_pointer(&n[4], memdup(m, count * 4 * 3 * sizeof(GLdouble)));
+ n[1].ui = program;
+ n[2].i = location;
+ n[3].i = count;
+ save_pointer(&n[4], memdup(v, count * 1 * sizeof(GLuint64)));
}
if (ctx->ExecuteFlag) {
- CALL_UniformMatrix4x3dv(ctx->Exec, (location, count, transpose, m));
+ CALL_ProgramUniform4ui64vARB(ctx->Exec, (program, location, count, v));
}
}
n[1].ui = texture;
n[2].e = target;
n[3].e = pname;
- n[4].i = params[0];
- n[5].i = params[1];
- n[6].i = params[2];
- n[7].i = params[3];
+ n[4].i = params[0];
+ n[5].i = params[1];
+ n[6].i = params[2];
+ n[7].i = params[3];
+ }
+ if (ctx->ExecuteFlag) {
+ CALL_TextureParameterivEXT(ctx->Exec, (texture, target, pname, params));
+ }
+}
+
+static void GLAPIENTRY
+save_TextureParameteriEXT(GLuint texture, GLenum target, GLenum pname, GLint param)
+{
+ GLint fparam[4];
+ fparam[0] = param;
+ fparam[1] = fparam[2] = fparam[3] = 0;
+ save_TextureParameterivEXT(texture, target, pname, fparam);
+}
+
+static void GLAPIENTRY
+save_TextureParameterIivEXT(GLuint texture, GLenum target, GLenum pname, const GLint* params)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ Node *n;
+ ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+ n = alloc_instruction(ctx, OPCODE_TEXTUREPARAMETER_II, 7);
+ if (n) {
+ n[1].ui = texture;
+ n[2].e = target;
+ n[3].e = pname;
+ n[4].i = params[0];
+ n[5].i = params[1];
+ n[6].i = params[2];
+ n[7].i = params[3];
+ }
+ if (ctx->ExecuteFlag) {
+ CALL_TextureParameterIivEXT(ctx->Exec, (texture, target, pname, params));
+ }
+}
+
+static void GLAPIENTRY
+save_TextureParameterIuivEXT(GLuint texture, GLenum target, GLenum pname, const GLuint* params)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ Node *n;
+ ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+ n = alloc_instruction(ctx, OPCODE_TEXTUREPARAMETER_IUI, 7);
+ if (n) {
+ n[1].ui = texture;
+ n[2].e = target;
+ n[3].e = pname;
+ n[4].ui = params[0];
+ n[5].ui = params[1];
+ n[6].ui = params[2];
+ n[7].ui = params[3];
}
if (ctx->ExecuteFlag) {
- CALL_TextureParameterivEXT(ctx->Exec, (texture, target, pname, params));
+ CALL_TextureParameterIuivEXT(ctx->Exec, (texture, target, pname, params));
}
}
-static void GLAPIENTRY
-save_TextureParameteriEXT(GLuint texture, GLenum target, GLenum pname, GLint param)
-{
- GLint fparam[4];
- fparam[0] = param;
- fparam[1] = fparam[2] = fparam[3] = 0;
- save_TextureParameterivEXT(texture, target, pname, fparam);
-}
static void GLAPIENTRY
save_TextureImage1DEXT(GLuint texture, GLenum target,
}
}
+static void GLAPIENTRY
+save_MultiTexParameterIivEXT(GLenum texunit, GLenum target, GLenum pname, const GLint *params)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ Node *n;
+ ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+ n = alloc_instruction(ctx, OPCODE_MULTITEXPARAMETER_II, 7);
+ if (n) {
+ n[1].e = texunit;
+ n[2].e = target;
+ n[3].e = pname;
+ n[4].i = params[0];
+ n[5].i = params[1];
+ n[6].i = params[2];
+ n[7].i = params[3];
+ }
+ if (ctx->ExecuteFlag) {
+ CALL_MultiTexParameterIivEXT(ctx->Exec, (texunit, target, pname, params));
+ }
+}
+
+static void GLAPIENTRY
+save_MultiTexParameterIuivEXT(GLenum texunit, GLenum target, GLenum pname, const GLuint *params)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ Node *n;
+ ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+ n = alloc_instruction(ctx, OPCODE_MULTITEXPARAMETER_IUI, 7);
+ if (n) {
+ n[1].e = texunit;
+ n[2].e = target;
+ n[3].e = pname;
+ n[4].ui = params[0];
+ n[5].ui = params[1];
+ n[6].ui = params[2];
+ n[7].ui = params[3];
+ }
+ if (ctx->ExecuteFlag) {
+ CALL_MultiTexParameterIuivEXT(ctx->Exec, (texunit, target, pname, params));
+ }
+}
+
static void GLAPIENTRY
save_MultiTexParameteriEXT(GLenum texunit, GLenum target, GLenum pname, GLint param)
{
}
+static void GLAPIENTRY
+save_NamedProgramStringEXT(GLuint program, GLenum target, GLenum format, GLsizei len,
+ const GLvoid * string)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ Node *n;
+
+ ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+
+ n = alloc_instruction(ctx, OPCODE_NAMED_PROGRAM_STRING, 4 + POINTER_DWORDS);
+ if (n) {
+ GLubyte *programCopy = malloc(len);
+ if (!programCopy) {
+ _mesa_error(ctx, GL_OUT_OF_MEMORY, "glNamedProgramStringEXT");
+ return;
+ }
+ memcpy(programCopy, string, len);
+ n[1].ui = program;
+ n[2].e = target;
+ n[3].e = format;
+ n[4].i = len;
+ save_pointer(&n[5], programCopy);
+ }
+ if (ctx->ExecuteFlag) {
+ CALL_NamedProgramStringEXT(ctx->Exec, (program, target, format, len, string));
+ }
+}
+
+
+static void GLAPIENTRY
+save_NamedProgramLocalParameter4fEXT(GLuint program, GLenum target, GLuint index,
+ GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ Node *n;
+ ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+ n = alloc_instruction(ctx, OPCODE_NAMED_PROGRAM_LOCAL_PARAMETER, 7);
+ if (n) {
+ n[1].ui = program;
+ n[2].e = target;
+ n[3].ui = index;
+ n[4].f = x;
+ n[5].f = y;
+ n[6].f = z;
+ n[7].f = w;
+ }
+ if (ctx->ExecuteFlag) {
+ CALL_NamedProgramLocalParameter4fEXT(ctx->Exec, (program, target, index, x, y, z, w));
+ }
+}
+
+
+static void GLAPIENTRY
+save_NamedProgramLocalParameter4fvEXT(GLuint program, GLenum target, GLuint index,
+ const GLfloat *params)
+{
+ save_NamedProgramLocalParameter4fEXT(program, target, index, params[0],
+ params[1], params[2], params[3]);
+}
+
+
+static void GLAPIENTRY
+save_NamedProgramLocalParameter4dEXT(GLuint program, GLenum target, GLuint index,
+ GLdouble x, GLdouble y,
+ GLdouble z, GLdouble w)
+{
+ save_NamedProgramLocalParameter4fEXT(program, target, index, (GLfloat) x,
+ (GLfloat) y, (GLfloat) z, (GLfloat) w);
+}
+
+
+static void GLAPIENTRY
+save_NamedProgramLocalParameter4dvEXT(GLuint program, GLenum target, GLuint index,
+ const GLdouble *params)
+{
+ save_NamedProgramLocalParameter4fEXT(program, target, index, (GLfloat) params[0],
+ (GLfloat) params[1], (GLfloat) params[2],
+ (GLfloat) params[3]);
+}
+
+
/**
* Save an error-generating command into display list.
*
(n[1].i, n[2].i, n[3].b, get_pointer(&n[4])));
break;
+ case OPCODE_UNIFORM_1I64: {
+ union int64_pair x;
+
+ x.int32[0] = n[2].i;
+ x.int32[1] = n[3].i;
+
+ CALL_Uniform1i64ARB(ctx->Exec, (n[1].i, x.int64));
+ break;
+ }
+ case OPCODE_UNIFORM_2I64: {
+ union int64_pair x;
+ union int64_pair y;
+
+ x.int32[0] = n[2].i;
+ x.int32[1] = n[3].i;
+ y.int32[0] = n[4].i;
+ y.int32[1] = n[5].i;
+
+ CALL_Uniform2i64ARB(ctx->Exec, (n[1].i, x.int64, y.int64));
+ break;
+ }
+ case OPCODE_UNIFORM_3I64: {
+ union int64_pair x;
+ union int64_pair y;
+ union int64_pair z;
+
+ x.int32[0] = n[2].i;
+ x.int32[1] = n[3].i;
+ y.int32[0] = n[4].i;
+ y.int32[1] = n[5].i;
+ z.int32[0] = n[6].i;
+ z.int32[1] = n[7].i;
+
+
+ CALL_Uniform3i64ARB(ctx->Exec, (n[1].i, x.int64, y.int64, z.int64));
+ break;
+ }
+ case OPCODE_UNIFORM_4I64: {
+ union int64_pair x;
+ union int64_pair y;
+ union int64_pair z;
+ union int64_pair w;
+
+ x.int32[0] = n[2].i;
+ x.int32[1] = n[3].i;
+ y.int32[0] = n[4].i;
+ y.int32[1] = n[5].i;
+ z.int32[0] = n[6].i;
+ z.int32[1] = n[7].i;
+ w.int32[0] = n[8].i;
+ w.int32[1] = n[9].i;
+
+ CALL_Uniform4i64ARB(ctx->Exec, (n[1].i, x.int64, y.int64, z.int64, w.int64));
+ break;
+ }
+ case OPCODE_UNIFORM_1I64V:
+ CALL_Uniform1i64vARB(ctx->Exec, (n[1].i, n[2].i, get_pointer(&n[3])));
+ break;
+ case OPCODE_UNIFORM_2I64V:
+ CALL_Uniform2i64vARB(ctx->Exec, (n[1].i, n[2].i, get_pointer(&n[3])));
+ break;
+ case OPCODE_UNIFORM_3I64V:
+ CALL_Uniform3i64vARB(ctx->Exec, (n[1].i, n[2].i, get_pointer(&n[3])));
+ break;
+ case OPCODE_UNIFORM_4I64V:
+ CALL_Uniform4i64vARB(ctx->Exec, (n[1].i, n[2].i, get_pointer(&n[3])));
+ break;
+ case OPCODE_UNIFORM_1UI64: {
+ union uint64_pair x;
+
+ x.uint32[0] = n[2].ui;
+ x.uint32[1] = n[3].ui;
+
+ CALL_Uniform1ui64ARB(ctx->Exec, (n[1].i, x.uint64));
+ break;
+ }
+ case OPCODE_UNIFORM_2UI64: {
+ union uint64_pair x;
+ union uint64_pair y;
+
+ x.uint32[0] = n[2].ui;
+ x.uint32[1] = n[3].ui;
+ y.uint32[0] = n[4].ui;
+ y.uint32[1] = n[5].ui;
+
+ CALL_Uniform2ui64ARB(ctx->Exec, (n[1].i, x.uint64, y.uint64));
+ break;
+ }
+ case OPCODE_UNIFORM_3UI64: {
+ union uint64_pair x;
+ union uint64_pair y;
+ union uint64_pair z;
+
+ x.uint32[0] = n[2].ui;
+ x.uint32[1] = n[3].ui;
+ y.uint32[0] = n[4].ui;
+ y.uint32[1] = n[5].ui;
+ z.uint32[0] = n[6].ui;
+ z.uint32[1] = n[7].ui;
+
+
+ CALL_Uniform3ui64ARB(ctx->Exec, (n[1].i, x.uint64, y.uint64,
+ z.uint64));
+ break;
+ }
+ case OPCODE_UNIFORM_4UI64: {
+ union uint64_pair x;
+ union uint64_pair y;
+ union uint64_pair z;
+ union uint64_pair w;
+
+ x.uint32[0] = n[2].ui;
+ x.uint32[1] = n[3].ui;
+ y.uint32[0] = n[4].ui;
+ y.uint32[1] = n[5].ui;
+ z.uint32[0] = n[6].ui;
+ z.uint32[1] = n[7].ui;
+ w.uint32[0] = n[8].ui;
+ w.uint32[1] = n[9].ui;
+
+ CALL_Uniform4ui64ARB(ctx->Exec, (n[1].i, x.uint64, y.uint64,
+ z.uint64, w.uint64));
+ break;
+ }
+ case OPCODE_UNIFORM_1UI64V:
+ CALL_Uniform1ui64vARB(ctx->Exec, (n[1].i, n[2].i,
+ get_pointer(&n[3])));
+ break;
+ case OPCODE_UNIFORM_2UI64V:
+ CALL_Uniform2ui64vARB(ctx->Exec, (n[1].i, n[2].i,
+ get_pointer(&n[3])));
+ break;
+ case OPCODE_UNIFORM_3UI64V:
+ CALL_Uniform3ui64vARB(ctx->Exec, (n[1].i, n[2].i,
+ get_pointer(&n[3])));
+ break;
+ case OPCODE_UNIFORM_4UI64V:
+ CALL_Uniform4ui64vARB(ctx->Exec, (n[1].i, n[2].i,
+ get_pointer(&n[3])));
+ break;
+
+ case OPCODE_PROGRAM_UNIFORM_1I64: {
+ union int64_pair x;
+
+ x.int32[0] = n[3].i;
+ x.int32[1] = n[4].i;
+
+ CALL_ProgramUniform1i64ARB(ctx->Exec, (n[1].ui, n[2].i, x.int64));
+ break;
+ }
+ case OPCODE_PROGRAM_UNIFORM_2I64: {
+ union int64_pair x;
+ union int64_pair y;
+
+ x.int32[0] = n[3].i;
+ x.int32[1] = n[4].i;
+ y.int32[0] = n[5].i;
+ y.int32[1] = n[6].i;
+
+ CALL_ProgramUniform2i64ARB(ctx->Exec, (n[1].ui, n[2].i, x.int64,
+ y.int64));
+ break;
+ }
+ case OPCODE_PROGRAM_UNIFORM_3I64: {
+ union int64_pair x;
+ union int64_pair y;
+ union int64_pair z;
+
+ x.int32[0] = n[3].i;
+ x.int32[1] = n[4].i;
+ y.int32[0] = n[5].i;
+ y.int32[1] = n[6].i;
+ z.int32[0] = n[7].i;
+ z.int32[1] = n[8].i;
+
+ CALL_ProgramUniform3i64ARB(ctx->Exec, (n[1].ui, n[2].i, x.int64,
+ y.int64, z.int64));
+ break;
+ }
+ case OPCODE_PROGRAM_UNIFORM_4I64: {
+ union int64_pair x;
+ union int64_pair y;
+ union int64_pair z;
+ union int64_pair w;
+
+ x.int32[0] = n[3].i;
+ x.int32[1] = n[4].i;
+ y.int32[0] = n[5].i;
+ y.int32[1] = n[6].i;
+ z.int32[0] = n[7].i;
+ z.int32[1] = n[8].i;
+ w.int32[0] = n[9].i;
+ w.int32[1] = n[10].i;
+
+ CALL_ProgramUniform4i64ARB(ctx->Exec, (n[1].ui, n[2].i, x.int64,
+ y.int64, z.int64, w.int64));
+ break;
+ }
+ case OPCODE_PROGRAM_UNIFORM_1I64V:
+ CALL_ProgramUniform1i64vARB(ctx->Exec, (n[1].ui, n[2].i, n[3].i,
+ get_pointer(&n[4])));
+ break;
+ case OPCODE_PROGRAM_UNIFORM_2I64V:
+ CALL_ProgramUniform2i64vARB(ctx->Exec, (n[1].ui, n[2].i, n[3].i,
+ get_pointer(&n[4])));
+ break;
+ case OPCODE_PROGRAM_UNIFORM_3I64V:
+ CALL_ProgramUniform3i64vARB(ctx->Exec, (n[1].ui, n[2].i, n[3].i,
+ get_pointer(&n[4])));
+ break;
+ case OPCODE_PROGRAM_UNIFORM_4I64V:
+ CALL_ProgramUniform4i64vARB(ctx->Exec, (n[1].ui, n[2].i, n[3].i,
+ get_pointer(&n[4])));
+ break;
+ case OPCODE_PROGRAM_UNIFORM_1UI64: {
+ union uint64_pair x;
+
+ x.uint32[0] = n[3].ui;
+ x.uint32[1] = n[4].ui;
+
+ CALL_ProgramUniform1i64ARB(ctx->Exec, (n[1].ui, n[2].i, x.uint64));
+ break;
+ }
+ case OPCODE_PROGRAM_UNIFORM_2UI64: {
+ union uint64_pair x;
+ union uint64_pair y;
+
+ x.uint32[0] = n[3].ui;
+ x.uint32[1] = n[4].ui;
+ y.uint32[0] = n[5].ui;
+ y.uint32[1] = n[6].ui;
+
+ CALL_ProgramUniform2ui64ARB(ctx->Exec, (n[1].ui, n[2].i, x.uint64,
+ y.uint64));
+ break;
+ }
+ case OPCODE_PROGRAM_UNIFORM_3UI64: {
+ union uint64_pair x;
+ union uint64_pair y;
+ union uint64_pair z;
+
+ x.uint32[0] = n[3].ui;
+ x.uint32[1] = n[4].ui;
+ y.uint32[0] = n[5].ui;
+ y.uint32[1] = n[6].ui;
+ z.uint32[0] = n[7].ui;
+ z.uint32[1] = n[8].ui;
+
+ CALL_ProgramUniform3ui64ARB(ctx->Exec, (n[1].ui, n[2].i, x.uint64,
+ y.uint64, z.uint64));
+ break;
+ }
+ case OPCODE_PROGRAM_UNIFORM_4UI64: {
+ union uint64_pair x;
+ union uint64_pair y;
+ union uint64_pair z;
+ union uint64_pair w;
+
+ x.uint32[0] = n[3].ui;
+ x.uint32[1] = n[4].ui;
+ y.uint32[0] = n[5].ui;
+ y.uint32[1] = n[6].ui;
+ z.uint32[0] = n[7].ui;
+ z.uint32[1] = n[8].ui;
+ w.uint32[0] = n[9].ui;
+ w.uint32[1] = n[10].ui;
+
+ CALL_ProgramUniform4ui64ARB(ctx->Exec, (n[1].ui, n[2].i, x.uint64,
+ y.uint64, z.uint64, w.uint64));
+ break;
+ }
+ case OPCODE_PROGRAM_UNIFORM_1UI64V:
+ CALL_ProgramUniform1ui64vARB(ctx->Exec, (n[1].ui, n[2].i, n[3].i,
+ get_pointer(&n[4])));
+ break;
+ case OPCODE_PROGRAM_UNIFORM_2UI64V:
+ CALL_ProgramUniform2ui64vARB(ctx->Exec, (n[1].ui, n[2].i, n[3].i,
+ get_pointer(&n[4])));
+ break;
+ case OPCODE_PROGRAM_UNIFORM_3UI64V:
+ CALL_ProgramUniform3ui64vARB(ctx->Exec, (n[1].ui, n[2].i, n[3].i,
+ get_pointer(&n[4])));
+ break;
+ case OPCODE_PROGRAM_UNIFORM_4UI64V:
+ CALL_ProgramUniform4ui64vARB(ctx->Exec, (n[1].ui, n[2].i, n[3].i,
+ get_pointer(&n[4])));
+ break;
+
case OPCODE_USE_PROGRAM_STAGES:
CALL_UseProgramStages(ctx->Exec, (n[1].ui, n[2].ui, n[3].ui));
break;
case OPCODE_ATTR_4F_ARB:
CALL_VertexAttrib4fvARB(ctx->Exec, (n[1].e, &n[2].f));
break;
+ case OPCODE_ATTR_1I:
+ CALL_VertexAttribI1iEXT(ctx->Exec, (n[1].e, n[2].i));
+ break;
+ case OPCODE_ATTR_2I:
+ CALL_VertexAttribI2ivEXT(ctx->Exec, (n[1].e, &n[2].i));
+ break;
+ case OPCODE_ATTR_3I:
+ CALL_VertexAttribI3ivEXT(ctx->Exec, (n[1].e, &n[2].i));
+ break;
+ case OPCODE_ATTR_4I:
+ CALL_VertexAttribI4ivEXT(ctx->Exec, (n[1].e, &n[2].i));
+ break;
case OPCODE_ATTR_1D: {
GLdouble *d = (GLdouble *) &n[2];
CALL_VertexAttribL1d(ctx->Exec, (n[1].ui, *d));
CALL_VertexAttribL4dv(ctx->Exec, (n[1].ui, d));
break;
}
+ case OPCODE_ATTR_1UI64: {
+ uint64_t *ui64 = (uint64_t *) &n[2];
+ CALL_VertexAttribL1ui64ARB(ctx->Exec, (n[1].ui, *ui64));
+ break;
+ }
case OPCODE_MATERIAL:
CALL_Materialfv(ctx->Exec, (n[1].e, n[2].e, &n[3].f));
break;
CALL_TextureParameterivEXT(ctx->Exec, (n[1].ui, n[2].e, n[3].e, params));
}
break;
+ case OPCODE_TEXTUREPARAMETER_II:
+ {
+ GLint params[4];
+ params[0] = n[4].i;
+ params[1] = n[5].i;
+ params[2] = n[6].i;
+ params[3] = n[7].i;
+ CALL_TextureParameterIivEXT(ctx->Exec, (n[1].ui, n[2].e, n[3].e, params));
+ }
+ break;
+ case OPCODE_TEXTUREPARAMETER_IUI:
+ {
+ GLuint params[4];
+ params[0] = n[4].ui;
+ params[1] = n[5].ui;
+ params[2] = n[6].ui;
+ params[3] = n[7].ui;
+ CALL_TextureParameterIuivEXT(ctx->Exec, (n[1].ui, n[2].e, n[3].e, params));
+ }
+ break;
case OPCODE_TEXTURE_IMAGE1D:
{
const struct gl_pixelstore_attrib save = ctx->Unpack;
CALL_MultiTexParameterivEXT(ctx->Exec, (n[1].e, n[2].e, n[3].e, params));
}
break;
+ case OPCODE_MULTITEXPARAMETER_II:
+ {
+ GLint params[4];
+ params[0] = n[4].i;
+ params[1] = n[5].i;
+ params[2] = n[6].i;
+ params[3] = n[7].i;
+ CALL_MultiTexParameterIivEXT(ctx->Exec, (n[1].e, n[2].e, n[3].e, params));
+ }
+ break;
+ case OPCODE_MULTITEXPARAMETER_IUI:
+ {
+ GLuint params[4];
+ params[0] = n[4].ui;
+ params[1] = n[5].ui;
+ params[2] = n[6].ui;
+ params[3] = n[7].ui;
+ CALL_MultiTexParameterIuivEXT(ctx->Exec, (n[1].e, n[2].e, n[3].e, params));
+ }
+ break;
case OPCODE_MULTITEX_IMAGE1D:
{
const struct gl_pixelstore_attrib save = ctx->Unpack;
n[9].i, n[10].e, n[11].i,
get_pointer(&n[12])));
break;
+ case OPCODE_NAMED_PROGRAM_STRING:
+ CALL_NamedProgramStringEXT(ctx->Exec,
+ (n[1].ui, n[2].e, n[3].e, n[4].i,
+ get_pointer(&n[5])));
+ break;
+ case OPCODE_NAMED_PROGRAM_LOCAL_PARAMETER:
+ CALL_NamedProgramLocalParameter4fEXT(ctx->Exec,
+ (n[1].ui, n[2].e, n[3].ui, n[4].f,
+ n[5].f, n[6].f, n[7].f));
+ break;
case OPCODE_CONTINUE:
n = (Node *) get_pointer(&n[1]);
default:
{
char msg[1000];
- _mesa_snprintf(msg, sizeof(msg), "Error in execute_list: opcode=%d",
+ snprintf(msg, sizeof(msg), "Error in execute_list: opcode=%d",
(int) opcode);
_mesa_problem(ctx, "%s", msg);
}
SET_UniformMatrix3x4dv(table, save_UniformMatrix3x4dv);
SET_UniformMatrix4x3dv(table, save_UniformMatrix4x3dv);
+ /* GL_ARB_gpu_shader_int64 */
+ SET_Uniform1i64ARB(table, save_Uniform1i64ARB);
+ SET_Uniform2i64ARB(table, save_Uniform2i64ARB);
+ SET_Uniform3i64ARB(table, save_Uniform3i64ARB);
+ SET_Uniform4i64ARB(table, save_Uniform4i64ARB);
+ SET_Uniform1i64vARB(table, save_Uniform1i64vARB);
+ SET_Uniform2i64vARB(table, save_Uniform2i64vARB);
+ SET_Uniform3i64vARB(table, save_Uniform3i64vARB);
+ SET_Uniform4i64vARB(table, save_Uniform4i64vARB);
+ SET_Uniform1ui64ARB(table, save_Uniform1ui64ARB);
+ SET_Uniform2ui64ARB(table, save_Uniform2ui64ARB);
+ SET_Uniform3ui64ARB(table, save_Uniform3ui64ARB);
+ SET_Uniform4ui64ARB(table, save_Uniform4ui64ARB);
+ SET_Uniform1ui64vARB(table, save_Uniform1ui64vARB);
+ SET_Uniform2ui64vARB(table, save_Uniform2ui64vARB);
+ SET_Uniform3ui64vARB(table, save_Uniform3ui64vARB);
+ SET_Uniform4ui64vARB(table, save_Uniform4ui64vARB);
+
+ SET_ProgramUniform1i64ARB(table, save_ProgramUniform1i64ARB);
+ SET_ProgramUniform2i64ARB(table, save_ProgramUniform2i64ARB);
+ SET_ProgramUniform3i64ARB(table, save_ProgramUniform3i64ARB);
+ SET_ProgramUniform4i64ARB(table, save_ProgramUniform4i64ARB);
+ SET_ProgramUniform1i64vARB(table, save_ProgramUniform1i64vARB);
+ SET_ProgramUniform2i64vARB(table, save_ProgramUniform2i64vARB);
+ SET_ProgramUniform3i64vARB(table, save_ProgramUniform3i64vARB);
+ SET_ProgramUniform4i64vARB(table, save_ProgramUniform4i64vARB);
+ SET_ProgramUniform1ui64ARB(table, save_ProgramUniform1ui64ARB);
+ SET_ProgramUniform2ui64ARB(table, save_ProgramUniform2ui64ARB);
+ SET_ProgramUniform3ui64ARB(table, save_ProgramUniform3ui64ARB);
+ SET_ProgramUniform4ui64ARB(table, save_ProgramUniform4ui64ARB);
+ SET_ProgramUniform1ui64vARB(table, save_ProgramUniform1ui64vARB);
+ SET_ProgramUniform2ui64vARB(table, save_ProgramUniform2ui64vARB);
+ SET_ProgramUniform3ui64vARB(table, save_ProgramUniform3ui64vARB);
+ SET_ProgramUniform4ui64vARB(table, save_ProgramUniform4ui64vARB);
+
/* These are: */
SET_BeginTransformFeedback(table, save_BeginTransformFeedback);
SET_EndTransformFeedback(table, save_EndTransformFeedback);
SET_TextureParameterivEXT(table, save_TextureParameterivEXT);
SET_TextureParameterfEXT(table, save_TextureParameterfEXT);
SET_TextureParameterfvEXT(table, save_TextureParameterfvEXT);
+ SET_TextureParameterIivEXT(table, save_TextureParameterIivEXT);
+ SET_TextureParameterIuivEXT(table, save_TextureParameterIuivEXT);
SET_TextureImage1DEXT(table, save_TextureImage1DEXT);
SET_TextureImage2DEXT(table, save_TextureImage2DEXT);
SET_TextureImage3DEXT(table, save_TextureImage3DEXT);
SET_BindMultiTextureEXT(table, save_BindMultiTextureEXT);
SET_MultiTexParameteriEXT(table, save_MultiTexParameteriEXT);
SET_MultiTexParameterivEXT(table, save_MultiTexParameterivEXT);
+ SET_MultiTexParameterIivEXT(table, save_MultiTexParameterIivEXT);
+ SET_MultiTexParameterIuivEXT(table, save_MultiTexParameterIuivEXT);
SET_MultiTexParameterfEXT(table, save_MultiTexParameterfEXT);
SET_MultiTexParameterfvEXT(table, save_MultiTexParameterfvEXT);
SET_MultiTexImage1DEXT(table, save_MultiTexImage1DEXT);
SET_CompressedMultiTexSubImage1DEXT(table, save_CompressedMultiTexSubImage1DEXT);
SET_CompressedMultiTexSubImage2DEXT(table, save_CompressedMultiTexSubImage2DEXT);
SET_CompressedMultiTexSubImage3DEXT(table, save_CompressedMultiTexSubImage3DEXT);
+ SET_NamedProgramStringEXT(table, save_NamedProgramStringEXT);
+ SET_NamedProgramLocalParameter4dEXT(table, save_NamedProgramLocalParameter4dEXT);
+ SET_NamedProgramLocalParameter4dvEXT(table, save_NamedProgramLocalParameter4dvEXT);
+ SET_NamedProgramLocalParameter4fEXT(table, save_NamedProgramLocalParameter4fEXT);
+ SET_NamedProgramLocalParameter4fvEXT(table, save_NamedProgramLocalParameter4fvEXT);
}
/***** Initialization *****/
/**********************************************************************/
-static void
-save_vtxfmt_init(GLvertexformat * vfmt)
-{
- vfmt->ArrayElement = _ae_ArrayElement;
-
- vfmt->Begin = save_Begin;
-
- vfmt->CallList = save_CallList;
- vfmt->CallLists = save_CallLists;
-
- vfmt->Color3f = save_Color3f;
- vfmt->Color3fv = save_Color3fv;
- vfmt->Color4f = save_Color4f;
- vfmt->Color4fv = save_Color4fv;
- vfmt->EdgeFlag = save_EdgeFlag;
- vfmt->End = save_End;
-
- vfmt->EvalCoord1f = save_EvalCoord1f;
- vfmt->EvalCoord1fv = save_EvalCoord1fv;
- vfmt->EvalCoord2f = save_EvalCoord2f;
- vfmt->EvalCoord2fv = save_EvalCoord2fv;
- vfmt->EvalPoint1 = save_EvalPoint1;
- vfmt->EvalPoint2 = save_EvalPoint2;
-
- vfmt->FogCoordfEXT = save_FogCoordfEXT;
- vfmt->FogCoordfvEXT = save_FogCoordfvEXT;
- vfmt->Indexf = save_Indexf;
- vfmt->Indexfv = save_Indexfv;
- vfmt->Materialfv = save_Materialfv;
- vfmt->MultiTexCoord1fARB = save_MultiTexCoord1f;
- vfmt->MultiTexCoord1fvARB = save_MultiTexCoord1fv;
- vfmt->MultiTexCoord2fARB = save_MultiTexCoord2f;
- vfmt->MultiTexCoord2fvARB = save_MultiTexCoord2fv;
- vfmt->MultiTexCoord3fARB = save_MultiTexCoord3f;
- vfmt->MultiTexCoord3fvARB = save_MultiTexCoord3fv;
- vfmt->MultiTexCoord4fARB = save_MultiTexCoord4f;
- vfmt->MultiTexCoord4fvARB = save_MultiTexCoord4fv;
- vfmt->Normal3f = save_Normal3f;
- vfmt->Normal3fv = save_Normal3fv;
- vfmt->SecondaryColor3fEXT = save_SecondaryColor3fEXT;
- vfmt->SecondaryColor3fvEXT = save_SecondaryColor3fvEXT;
- vfmt->TexCoord1f = save_TexCoord1f;
- vfmt->TexCoord1fv = save_TexCoord1fv;
- vfmt->TexCoord2f = save_TexCoord2f;
- vfmt->TexCoord2fv = save_TexCoord2fv;
- vfmt->TexCoord3f = save_TexCoord3f;
- vfmt->TexCoord3fv = save_TexCoord3fv;
- vfmt->TexCoord4f = save_TexCoord4f;
- vfmt->TexCoord4fv = save_TexCoord4fv;
- vfmt->Vertex2f = save_Vertex2f;
- vfmt->Vertex2fv = save_Vertex2fv;
- vfmt->Vertex3f = save_Vertex3f;
- vfmt->Vertex3fv = save_Vertex3fv;
- vfmt->Vertex4f = save_Vertex4f;
- vfmt->Vertex4fv = save_Vertex4fv;
- vfmt->VertexAttrib1fARB = save_VertexAttrib1fARB;
- vfmt->VertexAttrib1fvARB = save_VertexAttrib1fvARB;
- vfmt->VertexAttrib2fARB = save_VertexAttrib2fARB;
- vfmt->VertexAttrib2fvARB = save_VertexAttrib2fvARB;
- vfmt->VertexAttrib3fARB = save_VertexAttrib3fARB;
- vfmt->VertexAttrib3fvARB = save_VertexAttrib3fvARB;
- vfmt->VertexAttrib4fARB = save_VertexAttrib4fARB;
- vfmt->VertexAttrib4fvARB = save_VertexAttrib4fvARB;
- vfmt->VertexAttribL1d = save_VertexAttribL1d;
- vfmt->VertexAttribL1dv = save_VertexAttribL1dv;
- vfmt->VertexAttribL2d = save_VertexAttribL2d;
- vfmt->VertexAttribL2dv = save_VertexAttribL2dv;
- vfmt->VertexAttribL3d = save_VertexAttribL3d;
- vfmt->VertexAttribL3dv = save_VertexAttribL3dv;
- vfmt->VertexAttribL4d = save_VertexAttribL4d;
- vfmt->VertexAttribL4dv = save_VertexAttribL4dv;
-
- vfmt->PrimitiveRestartNV = save_PrimitiveRestartNV;
-}
-
-
void
_mesa_install_dlist_vtxfmt(struct _glapi_table *disp,
const GLvertexformat *vfmt)
_mesa_init_display_list(struct gl_context *ctx)
{
static GLboolean tableInitialized = GL_FALSE;
+ GLvertexformat *vfmt = &ctx->ListState.ListVtxfmt;
/* zero-out the instruction size table, just once */
if (!tableInitialized) {
/* Display List group */
ctx->List.ListBase = 0;
- save_vtxfmt_init(&ctx->ListState.ListVtxfmt);
-
InstSize[OPCODE_NOP] = 1;
+
+#define NAME_AE(x) _ae_##x
+#define NAME_CALLLIST(x) save_##x
+#define NAME(x) save_##x
+#define NAME_ES(x) save_##x##ARB
+
+#include "vbo/vbo_init_tmp.h"
}