indirect.c

mesa-6.5-minigui源码

    const GLuint cmdlen = 16;
    emit_header(gc->pc, X_GLrop_TexCoord3iv, cmdlen);
    (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
    (void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4);
    (void) memcpy((void *)(gc->pc + 12), (void *)(&r), 4);
    gc->pc += cmdlen;
    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}

#define X_GLrop_TexCoord3iv 59
void
__indirect_glTexCoord3iv(const GLint * v)
{
    generic_12_byte( X_GLrop_TexCoord3iv, v );
}

#define X_GLrop_TexCoord3sv 60
void
__indirect_glTexCoord3s(GLshort s, GLshort t, GLshort r)
{
    __GLXcontext * const gc = __glXGetCurrentContext();
    const GLuint cmdlen = 12;
    emit_header(gc->pc, X_GLrop_TexCoord3sv, cmdlen);
    (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 2);
    (void) memcpy((void *)(gc->pc + 6), (void *)(&t), 2);
    (void) memcpy((void *)(gc->pc + 8), (void *)(&r), 2);
    gc->pc += cmdlen;
    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}

#define X_GLrop_TexCoord3sv 60
void
__indirect_glTexCoord3sv(const GLshort * v)
{
    generic_6_byte( X_GLrop_TexCoord3sv, v );
}

#define X_GLrop_TexCoord4dv 61
void
__indirect_glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
{
    __GLXcontext * const gc = __glXGetCurrentContext();
    const GLuint cmdlen = 36;
    emit_header(gc->pc, X_GLrop_TexCoord4dv, cmdlen);
    (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
    (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8);
    (void) memcpy((void *)(gc->pc + 20), (void *)(&r), 8);
    (void) memcpy((void *)(gc->pc + 28), (void *)(&q), 8);
    gc->pc += cmdlen;
    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}

#define X_GLrop_TexCoord4dv 61
void
__indirect_glTexCoord4dv(const GLdouble * v)
{
    generic_32_byte( X_GLrop_TexCoord4dv, v );
}

#define X_GLrop_TexCoord4fv 62
void
__indirect_glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
{
    __GLXcontext * const gc = __glXGetCurrentContext();
    const GLuint cmdlen = 20;
    emit_header(gc->pc, X_GLrop_TexCoord4fv, cmdlen);
    (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
    (void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4);
    (void) memcpy((void *)(gc->pc + 12), (void *)(&r), 4);
    (void) memcpy((void *)(gc->pc + 16), (void *)(&q), 4);
    gc->pc += cmdlen;
    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}

#define X_GLrop_TexCoord4fv 62
void
__indirect_glTexCoord4fv(const GLfloat * v)
{
    generic_16_byte( X_GLrop_TexCoord4fv, v );
}

#define X_GLrop_TexCoord4iv 63
void
__indirect_glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
{
    __GLXcontext * const gc = __glXGetCurrentContext();
    const GLuint cmdlen = 20;
    emit_header(gc->pc, X_GLrop_TexCoord4iv, cmdlen);
    (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
    (void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4);
    (void) memcpy((void *)(gc->pc + 12), (void *)(&r), 4);
    (void) memcpy((void *)(gc->pc + 16), (void *)(&q), 4);
    gc->pc += cmdlen;
    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}

#define X_GLrop_TexCoord4iv 63
void
__indirect_glTexCoord4iv(const GLint * v)
{
    generic_16_byte( X_GLrop_TexCoord4iv, v );
}

#define X_GLrop_TexCoord4sv 64
void
__indirect_glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
{
    __GLXcontext * const gc = __glXGetCurrentContext();
    const GLuint cmdlen = 12;
    emit_header(gc->pc, X_GLrop_TexCoord4sv, cmdlen);
    (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 2);
    (void) memcpy((void *)(gc->pc + 6), (void *)(&t), 2);
    (void) memcpy((void *)(gc->pc + 8), (void *)(&r), 2);
    (void) memcpy((void *)(gc->pc + 10), (void *)(&q), 2);
    gc->pc += cmdlen;
    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}

#define X_GLrop_TexCoord4sv 64
void
__indirect_glTexCoord4sv(const GLshort * v)
{
    generic_8_byte( X_GLrop_TexCoord4sv, v );
}

#define X_GLrop_Vertex2dv 65
void
__indirect_glVertex2d(GLdouble x, GLdouble y)
{
    __GLXcontext * const gc = __glXGetCurrentContext();
    const GLuint cmdlen = 20;
    emit_header(gc->pc, X_GLrop_Vertex2dv, 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_Vertex2dv 65
void
__indirect_glVertex2dv(const GLdouble * v)
{
    generic_16_byte( X_GLrop_Vertex2dv, v );
}

#define X_GLrop_Vertex2fv 66
void
__indirect_glVertex2f(GLfloat x, GLfloat y)
{
    __GLXcontext * const gc = __glXGetCurrentContext();
    const GLuint cmdlen = 12;
    emit_header(gc->pc, X_GLrop_Vertex2fv, 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_Vertex2fv 66
void
__indirect_glVertex2fv(const GLfloat * v)
{
    generic_8_byte( X_GLrop_Vertex2fv, v );
}

#define X_GLrop_Vertex2iv 67
void
__indirect_glVertex2i(GLint x, GLint y)
{
    __GLXcontext * const gc = __glXGetCurrentContext();
    const GLuint cmdlen = 12;
    emit_header(gc->pc, X_GLrop_Vertex2iv, 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_Vertex2iv 67
void
__indirect_glVertex2iv(const GLint * v)
{
    generic_8_byte( X_GLrop_Vertex2iv, v );
}

#define X_GLrop_Vertex2sv 68
void
__indirect_glVertex2s(GLshort x, GLshort y)
{
    __GLXcontext * const gc = __glXGetCurrentContext();
    const GLuint cmdlen = 8;
    emit_header(gc->pc, X_GLrop_Vertex2sv, 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_Vertex2sv 68
void
__indirect_glVertex2sv(const GLshort * v)
{
    generic_4_byte( X_GLrop_Vertex2sv, v );
}

#define X_GLrop_Vertex3dv 69
void
__indirect_glVertex3d(GLdouble x, GLdouble y, GLdouble z)
{
    __GLXcontext * const gc = __glXGetCurrentContext();
    const GLuint cmdlen = 28;
    emit_header(gc->pc, X_GLrop_Vertex3dv, 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_Vertex3dv 69
void
__indirect_glVertex3dv(const GLdouble * v)
{
    generic_24_byte( X_GLrop_Vertex3dv, v );
}

#define X_GLrop_Vertex3fv 70
void
__indirect_glVertex3f(GLfloat x, GLfloat y, GLfloat z)
{
    __GLXcontext * const gc = __glXGetCurrentContext();
    const GLuint cmdlen = 16;
    emit_header(gc->pc, X_GLrop_Vertex3fv, 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_Vertex3fv 70
void
__indirect_glVertex3fv(const GLfloat * v)
{
    generic_12_byte( X_GLrop_Vertex3fv, v );
}

#define X_GLrop_Vertex3iv 71
void
__indirect_glVertex3i(GLint x, GLint y, GLint z)
{
    __GLXcontext * const gc = __glXGetCurrentContext();
    const GLuint cmdlen = 16;
    emit_header(gc->pc, X_GLrop_Vertex3iv, 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_Vertex3iv 71
void
__indirect_glVertex3iv(const GLint * v)
{
    generic_12_byte( X_GLrop_Vertex3iv, v );
}

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

#define X_GLrop_Vertex3sv 72
void
__indirect_glVertex3sv(const GLshort * v)
{
    generic_6_byte( X_GLrop_Vertex3sv, v );
}

#define X_GLrop_Vertex4dv 73
void
__indirect_glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
    __GLXcontext * const gc = __glXGetCurrentContext();
    const GLuint cmdlen = 36;
    emit_header(gc->pc, X_GLrop_Vertex4dv, 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);
    (void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8);
    gc->pc += cmdlen;
    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}

#define X_GLrop_Vertex4dv 73
void
__indirect_glVertex4dv(const GLdouble * v)
{
    generic_32_byte( X_GLrop_Vertex4dv, v );
}

#define X_GLrop_Vertex4fv 74
void
__indirect_glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
    __GLXcontext * const gc = __glXGetCurrentContext();
    const GLuint cmdlen = 20;
    emit_header(gc->pc, X_GLrop_Vertex4fv, 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);
    (void) memcpy((void *)(gc->pc + 16), (void *)(&w), 4);
    gc->pc += cmdlen;
    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}

#define X_GLrop_Vertex4fv 74
void
__indirect_glVertex4fv(const GLfloat * v)
{
    generic_16_byte( X_GLrop_Vertex4fv, v );
}

#define X_GLrop_Vertex4iv 75
void
__indirect_glVertex4i(GLint x, GLint y, GLint z, GLint w)
{
    __GLXcontext * const gc = __glXGetCurrentContext();
    const GLuint cmdlen = 20;
    emit_header(gc->pc, X_GLrop_Vertex4iv, 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);
    (void) memcpy((void *)(gc->pc + 16), (void *)(&w), 4);
    gc->pc += cmdlen;
    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}

#define X_GLrop_Vertex4iv 75
void
__indirect_glVertex4iv(const GLint * v)
{
    generic_16_byte( X_GLrop_Vertex4iv, v );
}

#define X_GLrop_Vertex4sv 76
void
__indirect_glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
{
    __GLXcontext * const gc = __glXGetCurrentContext();
    const GLuint cmdlen = 12;
    emit_header(gc->pc, X_GLrop_Vertex4sv, cmdlen);
    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2);
    (void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2);
    (void) memcpy((void *)(gc->pc + 8), (void *)(&z), 2);
    (void) memcpy((void *)(gc->pc + 10), (void *)(&w), 2);
    gc->pc += cmdlen;
    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}

#define X_GLrop_Vertex4sv 76
void
__indirect_glVertex4sv(const GLshort * v)
{
    generic_8_byte( X_GLrop_Vertex4sv, v );
}

#define X_GLrop_ClipPlane 77
void
__indirect_glClipPlane(GLenum plane, const GLdouble * equation)
{
    __GLXcontext * const gc = __glXGetCurrentContext();
    const GLuint cmdlen = 40;
    emit_header(gc->pc, X_GLrop_ClipPlane, cmdlen);
    (void) memcpy((void *)(gc->pc + 4), (void *)(equation), 32);
    (void) memcpy((void *)(gc->pc + 36), (void *)(&plane), 4);
    gc->pc += cmdlen;
    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}

#define X_GLrop_ColorMaterial 78
void
__indirect_glColorMaterial(GLenum face, GLenum mode)
{
    __GLXcontext * const gc = __glXGetCurrentContext();
    const GLuint cmdlen = 12;
    emit_header(gc->pc, X_GLrop_ColorMaterial, cmdlen);
    (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
    (void) memcpy((void *)(gc->pc + 8), (void *)(&