indirect.c

Mesa is an open-source implementation of the OpenGL specification - a system for rendering interacti

__indirect_glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
{
    __GLXcontext *const gc = __glXGetCurrentContext();
    const GLuint cmdlen = 20;
    emit_header(gc->pc, X_GLrop_Color4uiv, cmdlen);
    (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4);
    (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4);
    (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4);
    (void) memcpy((void *) (gc->pc + 16), (void *) (&alpha), 4);
    gc->pc += cmdlen;
    if (__builtin_expect(gc->pc > gc->limit, 0)) {
        (void) __glXFlushRenderBuffer(gc, gc->pc);
    }
}

#define X_GLrop_Color4uiv 20
void
__indirect_glColor4uiv(const GLuint * v)
{
    generic_16_byte(X_GLrop_Color4uiv, v);
}

#define X_GLrop_Color4usv 21
void
__indirect_glColor4us(GLushort red, GLushort green, GLushort blue,
                      GLushort alpha)
{
    __GLXcontext *const gc = __glXGetCurrentContext();
    const GLuint cmdlen = 12;
    emit_header(gc->pc, X_GLrop_Color4usv, cmdlen);
    (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 2);
    (void) memcpy((void *) (gc->pc + 6), (void *) (&green), 2);
    (void) memcpy((void *) (gc->pc + 8), (void *) (&blue), 2);
    (void) memcpy((void *) (gc->pc + 10), (void *) (&alpha), 2);
    gc->pc += cmdlen;
    if (__builtin_expect(gc->pc > gc->limit, 0)) {
        (void) __glXFlushRenderBuffer(gc, gc->pc);
    }
}

#define X_GLrop_Color4usv 21
void
__indirect_glColor4usv(const GLushort * v)
{
    generic_8_byte(X_GLrop_Color4usv, v);
}

#define X_GLrop_EdgeFlagv 22
void
__indirect_glEdgeFlag(GLboolean flag)
{
    __GLXcontext *const gc = __glXGetCurrentContext();
    const GLuint cmdlen = 8;
    emit_header(gc->pc, X_GLrop_EdgeFlagv, cmdlen);
    (void) memcpy((void *) (gc->pc + 4), (void *) (&flag), 1);
    gc->pc += cmdlen;
    if (__builtin_expect(gc->pc > gc->limit, 0)) {
        (void) __glXFlushRenderBuffer(gc, gc->pc);
    }
}

#define X_GLrop_EdgeFlagv 22
void
__indirect_glEdgeFlagv(const GLboolean * flag)
{
    __GLXcontext *const gc = __glXGetCurrentContext();
    const GLuint cmdlen = 8;
    emit_header(gc->pc, X_GLrop_EdgeFlagv, cmdlen);
    (void) memcpy((void *) (gc->pc + 4), (void *) (flag), 1);
    gc->pc += cmdlen;
    if (__builtin_expect(gc->pc > gc->limit, 0)) {
        (void) __glXFlushRenderBuffer(gc, gc->pc);
    }
}

#define X_GLrop_End 23
void
__indirect_glEnd(void)
{
    __GLXcontext *const gc = __glXGetCurrentContext();
    const GLuint cmdlen = 4;
    emit_header(gc->pc, X_GLrop_End, cmdlen);
    gc->pc += cmdlen;
    if (__builtin_expect(gc->pc > gc->limit, 0)) {
        (void) __glXFlushRenderBuffer(gc, gc->pc);
    }
}

#define X_GLrop_Indexdv 24
void
__indirect_glIndexd(GLdouble c)
{
    __GLXcontext *const gc = __glXGetCurrentContext();
    const GLuint cmdlen = 12;
    emit_header(gc->pc, X_GLrop_Indexdv, cmdlen);
    (void) memcpy((void *) (gc->pc + 4), (void *) (&c), 8);
    gc->pc += cmdlen;
    if (__builtin_expect(gc->pc > gc->limit, 0)) {
        (void) __glXFlushRenderBuffer(gc, gc->pc);
    }
}

#define X_GLrop_Indexdv 24
void
__indirect_glIndexdv(const GLdouble * c)
{
    generic_8_byte(X_GLrop_Indexdv, c);
}

#define X_GLrop_Indexfv 25
void
__indirect_glIndexf(GLfloat c)
{
    __GLXcontext *const gc = __glXGetCurrentContext();
    const GLuint cmdlen = 8;
    emit_header(gc->pc, X_GLrop_Indexfv, cmdlen);
    (void) memcpy((void *) (gc->pc + 4), (void *) (&c), 4);
    gc->pc += cmdlen;
    if (__builtin_expect(gc->pc > gc->limit, 0)) {
        (void) __glXFlushRenderBuffer(gc, gc->pc);
    }
}

#define X_GLrop_Indexfv 25
void
__indirect_glIndexfv(const GLfloat * c)
{
    generic_4_byte(X_GLrop_Indexfv, c);
}

#define X_GLrop_Indexiv 26
void
__indirect_glIndexi(GLint c)
{
    __GLXcontext *const gc = __glXGetCurrentContext();
    const GLuint cmdlen = 8;
    emit_header(gc->pc, X_GLrop_Indexiv, cmdlen);
    (void) memcpy((void *) (gc->pc + 4), (void *) (&c), 4);
    gc->pc += cmdlen;
    if (__builtin_expect(gc->pc > gc->limit, 0)) {
        (void) __glXFlushRenderBuffer(gc, gc->pc);
    }
}

#define X_GLrop_Indexiv 26
void
__indirect_glIndexiv(const GLint * c)
{
    generic_4_byte(X_GLrop_Indexiv, c);
}

#define X_GLrop_Indexsv 27
void
__indirect_glIndexs(GLshort c)
{
    __GLXcontext *const gc = __glXGetCurrentContext();
    const GLuint cmdlen = 8;
    emit_header(gc->pc, X_GLrop_Indexsv, cmdlen);
    (void) memcpy((void *) (gc->pc + 4), (void *) (&c), 2);
    gc->pc += cmdlen;
    if (__builtin_expect(gc->pc > gc->limit, 0)) {
        (void) __glXFlushRenderBuffer(gc, gc->pc);
    }
}

#define X_GLrop_Indexsv 27
void
__indirect_glIndexsv(const GLshort * c)
{
    __GLXcontext *const gc = __glXGetCurrentContext();
    const GLuint cmdlen = 8;
    emit_header(gc->pc, X_GLrop_Indexsv, cmdlen);
    (void) memcpy((void *) (gc->pc + 4), (void *) (c), 2);
    gc->pc += cmdlen;
    if (__builtin_expect(gc->pc > gc->limit, 0)) {
        (void) __glXFlushRenderBuffer(gc, gc->pc);
    }
}

#define X_GLrop_Normal3bv 28
void
__indirect_glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
{
    __GLXcontext *const gc = __glXGetCurrentContext();
    const GLuint cmdlen = 8;
    emit_header(gc->pc, X_GLrop_Normal3bv, cmdlen);
    (void) memcpy((void *) (gc->pc + 4), (void *) (&nx), 1);
    (void) memcpy((void *) (gc->pc + 5), (void *) (&ny), 1);
    (void) memcpy((void *) (gc->pc + 6), (void *) (&nz), 1);
    gc->pc += cmdlen;
    if (__builtin_expect(gc->pc > gc->limit, 0)) {
        (void) __glXFlushRenderBuffer(gc, gc->pc);
    }
}

#define X_GLrop_Normal3bv 28
void
__indirect_glNormal3bv(const GLbyte *v)
{
    generic_3_byte(X_GLrop_Normal3bv, v);
}

#define X_GLrop_Normal3dv 29
void
__indirect_glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
{
    __GLXcontext *const gc = __glXGetCurrentContext();
    const GLuint cmdlen = 28;
    emit_header(gc->pc, X_GLrop_Normal3dv, cmdlen);
    (void) memcpy((void *) (gc->pc + 4), (void *) (&nx), 8);
    (void) memcpy((void *) (gc->pc + 12), (void *) (&ny), 8);
    (void) memcpy((void *) (gc->pc + 20), (void *) (&nz), 8);
    gc->pc += cmdlen;
    if (__builtin_expect(gc->pc > gc->limit, 0)) {
        (void) __glXFlushRenderBuffer(gc, gc->pc);
    }
}

#define X_GLrop_Normal3dv 29
void
__indirect_glNormal3dv(const GLdouble * v)
{
    generic_24_byte(X_GLrop_Normal3dv, v);
}

#define X_GLrop_Normal3fv 30
void
__indirect_glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
{
    __GLXcontext *const gc = __glXGetCurrentContext();
    const GLuint cmdlen = 16;
    emit_header(gc->pc, X_GLrop_Normal3fv, cmdlen);
    (void) memcpy((void *) (gc->pc + 4), (void *) (&nx), 4);
    (void) memcpy((void *) (gc->pc + 8), (void *) (&ny), 4);
    (void) memcpy((void *) (gc->pc + 12), (void *) (&nz), 4);
    gc->pc += cmdlen;
    if (__builtin_expect(gc->pc > gc->limit, 0)) {
        (void) __glXFlushRenderBuffer(gc, gc->pc);
    }
}

#define X_GLrop_Normal3fv 30
void
__indirect_glNormal3fv(const GLfloat * v)
{
    generic_12_byte(X_GLrop_Normal3fv, v);
}

#define X_GLrop_Normal3iv 31
void
__indirect_glNormal3i(GLint nx, GLint ny, GLint nz)
{
    __GLXcontext *const gc = __glXGetCurrentContext();
    const GLuint cmdlen = 16;
    emit_header(gc->pc, X_GLrop_Normal3iv, cmdlen);
    (void) memcpy((void *) (gc->pc + 4), (void *) (&nx), 4);
    (void) memcpy((void *) (gc->pc + 8), (void *) (&ny), 4);
    (void) memcpy((void *) (gc->pc + 12), (void *) (&nz), 4);
    gc->pc += cmdlen;
    if (__builtin_expect(gc->pc > gc->limit, 0)) {
        (void) __glXFlushRenderBuffer(gc, gc->pc);
    }
}

#define X_GLrop_Normal3iv 31
void
__indirect_glNormal3iv(const GLint * v)
{
    generic_12_byte(X_GLrop_Normal3iv, v);
}

#define X_GLrop_Normal3sv 32
void
__indirect_glNormal3s(GLshort nx, GLshort ny, GLshort nz)
{
    __GLXcontext *const gc = __glXGetCurrentContext();
    const GLuint cmdlen = 12;
    emit_header(gc->pc, X_GLrop_Normal3sv, cmdlen);
    (void) memcpy((void *) (gc->pc + 4), (void *) (&nx), 2);
    (void) memcpy((void *) (gc->pc + 6), (void *) (&ny), 2);
    (void) memcpy((void *) (gc->pc + 8), (void *) (&nz), 2);
    gc->pc += cmdlen;
    if (__builtin_expect(gc->pc > gc->limit, 0)) {
        (void) __glXFlushRenderBuffer(gc, gc->pc);
    }
}

#define X_GLrop_Normal3sv 32
void
__indirect_glNormal3sv(const GLshort * v)
{
    generic_6_byte(X_GLrop_Normal3sv, v);
}

#define X_GLrop_RasterPos2dv 33
void
__indirect_glRasterPos2d(GLdouble x, GLdouble y)
{
    __GLXcontext *const gc = __glXGetCurrentContext();
    const GLuint cmdlen = 20;
    emit_header(gc->pc, X_GLrop_RasterPos2dv, cmdlen);
    (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 8);
    (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 8);
    gc->pc += cmdlen;
    if (__builtin_expect(gc->pc > gc->limit, 0)) {
        (void) __glXFlushRenderBuffer(gc, gc->pc);
    }
}

#define X_GLrop_RasterPos2dv 33
void
__indirect_glRasterPos2dv(const GLdouble * v)
{
    generic_16_byte(X_GLrop_RasterPos2dv, v);
}

#define X_GLrop_RasterPos2fv 34
void
__indirect_glRasterPos2f(GLfloat x, GLfloat y)
{
    __GLXcontext *const gc = __glXGetCurrentContext();
    const GLuint cmdlen = 12;
    emit_header(gc->pc, X_GLrop_RasterPos2fv, cmdlen);
    (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
    (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
    gc->pc += cmdlen;
    if (__builtin_expect(gc->pc > gc->limit, 0)) {
        (void) __glXFlushRenderBuffer(gc, gc->pc);
    }
}

#define X_GLrop_RasterPos2fv 34
void
__indirect_glRasterPos2fv(const GLfloat * v)
{
    generic_8_byte(X_GLrop_RasterPos2fv, v);
}

#define X_GLrop_RasterPos2iv 35
void
__indirect_glRasterPos2i(GLint x, GLint y)
{
    __GLXcontext *const gc = __glXGetCurrentContext();
    const GLuint cmdlen = 12;
    emit_header(gc->pc, X_GLrop_RasterPos2iv, cmdlen);
    (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
    (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
    gc->pc += cmdlen;
    if (__builtin_expect(gc->pc > gc->limit, 0)) {
        (void) __glXFlushRenderBuffer(gc, gc->pc);
    }
}

#define X_GLrop_RasterPos2iv 35
void
__indirect_glRasterPos2iv(const GLint * v)
{
    generic_8_byte(X_GLrop_RasterPos2iv, v);
}

#define X_GLrop_RasterPos2sv 36
void
__indirect_glRasterPos2s(GLshort x, GLshort y)
{
    __GLXcontext *const gc = __glXGetCurrentContext();
    const GLuint cmdlen = 8;
    emit_header(gc->pc, X_GLrop_RasterPos2sv, cmdlen);
    (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 2);
    (void) memcpy((void *) (gc->pc + 6), (void *) (&y), 2);
    gc->pc += cmdlen;
    if (__builtin_expect(gc->pc > gc->limit, 0)) {
        (void) __glXFlushRenderBuffer(gc, gc->pc);
    }
}

#define X_GLrop_RasterPos2sv 36
void
__indirect_glRasterPos2sv(const GLshort * v)
{
    generic_4_byte(X_GLrop_RasterPos2sv, v);
}

#define X_GLrop_RasterPos3dv 37
void
__indirect_glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
{
    __GLXcontext *const gc = __glXGetCurrentContext();
    const GLuint cmdlen = 28;
    emit_header(gc->pc, X_GLrop_RasterPos3dv, cmdlen);
    (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 8);
    (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 8);
    (void) memcpy((void *) (gc->pc + 20), (void *) (&z), 8);
    gc->pc += cmdlen;
    if (__builtin_expect(gc->pc > gc->limit, 0)) {
        (void) __glXFlushRenderBuffer(gc, gc->pc);
    }
}

#define X_GLrop_RasterPos3dv 37
void
__indirect_glRasterPos3dv(const GLdouble * v)
{
    generic_24_byte(X_GLrop_RasterPos3dv, v);
}

#define X_GLrop_RasterPos3fv 38
void
__indirect_glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
{
    __GLXcontext *const gc = __glXGetCurrentContext();
    const GLuint cmdlen = 16;
    emit_header(gc->pc, X_GLrop_RasterPos3fv, cmdlen);
    (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
    (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
    (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4);
    gc->pc += cmdlen;
    if (__builtin_expect(gc->pc > gc->limit, 0)) {
        (void) __glXFlushRenderBuffer(gc, gc->pc);
    }
}

#define X_GLrop_RasterPos3fv 38
void
__indirect_glRasterPos3fv(const GLfloat * v)
{
    generic_12_byte(X_GLrop_RasterPos3fv, v);
}

#define X_GLrop_RasterPos3iv 39
void
__indirect_glRasterPos3i(GLint x, GLint y, GLint z)
{
    __GLXcontext *const gc = __glXGetCurrentContext();
    const GLuint cmdlen = 16;