src/glx/x11/vertarr.c

   1 /* $XFree86: xc/lib/GL/glx/vertarr.c,v 1.4 2001/03/25 05:32:00 tsi Exp $ */
   2 /*
   3 ** License Applicability. Except to the extent portions of this file are
   4 ** made subject to an alternative license as permitted in the SGI Free
   5 ** Software License B, Version 1.1 (the "License"), the contents of this
   6 ** file are subject only to the provisions of the License. You may not use
   7 ** this file except in compliance with the License. You may obtain a copy
   8 ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
   9 ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
  10 **
  11 ** http://oss.sgi.com/projects/FreeB
  12 **
  13 ** Note that, as provided in the License, the Software is distributed on an
  14 ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
  15 ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
  16 ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
  17 ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
  18 **
  19 ** Original Code. The Original Code is: OpenGL Sample Implementation,
  20 ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
  21 ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
  22 ** Copyright in any portions created by third parties is as indicated
  23 ** elsewhere herein. All Rights Reserved.
  24 **
  25 ** Additional Notice Provisions: The application programming interfaces
  26 ** established by SGI in conjunction with the Original Code are The
  27 ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
  28 ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
  29 ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
  30 ** Window System(R) (Version 1.3), released October 19, 1998. This software
  31 ** was created using the OpenGL(R) version 1.2.1 Sample Implementation
  32 ** published by SGI, but has not been independently verified as being
  33 ** compliant with the OpenGL(R) version 1.2.1 Specification.
  34 **
  35 */
  36
  37 #include "glxclient.h"
  38 #include "indirect.h"
  39 #include "indirect_vertex_array.h"
  40
  41
  42 /*****************************************************************************/
  43
  44 /**
  45  * \name Vertex array pointer bridge functions
  46  *
  47  * When EXT_vertex_array was moved into the core GL spec, the \c count
  48  * parameter was lost.  This libGL really only wants to implement the GL 1.1
  49  * version, but we need to support applications that were written to the old
  50  * interface.  These bridge functions are part of the glue that makes this
  51  * happen.
  52  */
  53 /*@{*/
  54 void __indirect_glColorPointerEXT(GLint size, GLenum type, GLsizei stride,
  55                             GLsizei count, const GLvoid * pointer )
  56 {
  57     (void) count; __indirect_glColorPointer( size, type, stride, pointer );
  58 }
  59
  60 void __indirect_glEdgeFlagPointerEXT(GLsizei stride,
  61                                GLsizei count, const GLboolean * pointer )
  62 {
  63     (void) count; __indirect_glEdgeFlagPointer( stride, pointer );
  64 }
  65
  66 void __indirect_glIndexPointerEXT(GLenum type, GLsizei stride,
  67                             GLsizei count, const GLvoid * pointer )
  68 {
  69     (void) count; __indirect_glIndexPointer( type, stride, pointer );
  70 }
  71
  72 void __indirect_glNormalPointerEXT(GLenum type, GLsizei stride, GLsizei count,
  73                              const GLvoid * pointer )
  74 {
  75     (void) count; __indirect_glNormalPointer( type, stride, pointer );
  76 }
  77
  78 void __indirect_glTexCoordPointerEXT(GLint size, GLenum type, GLsizei stride,
  79                                GLsizei count, const GLvoid * pointer )
  80 {
  81     (void) count; __indirect_glTexCoordPointer( size, type, stride, pointer );
  82 }
  83
  84 void __indirect_glVertexPointerEXT(GLint size, GLenum type, GLsizei stride,
  85                             GLsizei count, const GLvoid * pointer )
  86 {
  87     (void) count; __indirect_glVertexPointer( size, type, stride, pointer );
  88 }
  89 /*@}*/
  90
  91 /*****************************************************************************/
  92
  93 void __indirect_glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer)
  94 {
  95     __GLXcontext *gc = __glXGetCurrentContext();
  96     __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
  97     GLboolean tEnable = GL_FALSE, cEnable = GL_FALSE, nEnable = GL_FALSE;
  98     GLenum tType = GL_FLOAT, nType = GL_FLOAT, vType = GL_FLOAT;
  99     GLenum cType = GL_FALSE;
 100     GLint tSize = 0, cSize = 0, nSize = 3, vSize;
 101     int cOffset = 0, nOffset = 0, vOffset = 0;
 102     GLint trueStride, size;
 103
 104     switch (format) {
 105       case GL_V2F:
 106         vSize = 2;
 107         size = __glXTypeSize(vType) * vSize;
 108         break;
 109       case GL_V3F:
 110         vSize = 3;
 111         size = __glXTypeSize(vType) * vSize;
 112         break;
 113       case GL_C4UB_V2F:
 114         cEnable = GL_TRUE;
 115         cSize = 4;
 116         cType = GL_UNSIGNED_BYTE;
 117         vSize = 2;
 118         vOffset = __glXTypeSize(cType) * cSize;
 119         size = vOffset + __glXTypeSize(vType) * vSize;
 120         break;
 121       case GL_C4UB_V3F:
 122         cEnable = GL_TRUE;
 123         cSize = 4;
 124         cType = GL_UNSIGNED_BYTE;
 125         vSize = 3;
 126         vOffset = __glXTypeSize(vType) * cSize;
 127         size = vOffset + __glXTypeSize(vType) * vSize;
 128         break;
 129       case GL_C3F_V3F:
 130         cEnable = GL_TRUE;
 131         cSize = 3;
 132         cType = GL_FLOAT;
 133         vSize = 3;
 134         vOffset = __glXTypeSize(cType) * cSize;
 135         size = vOffset + __glXTypeSize(vType) * vSize;
 136         break;
 137       case GL_N3F_V3F:
 138         nEnable = GL_TRUE;
 139         vSize = 3;
 140         vOffset = __glXTypeSize(nType) * nSize;
 141         size = vOffset + __glXTypeSize(vType) * vSize;
 142         break;
 143       case GL_C4F_N3F_V3F:
 144         cEnable = GL_TRUE;
 145         cSize = 4;
 146         cType = GL_FLOAT;
 147         nEnable = GL_TRUE;
 148         nOffset = __glXTypeSize(cType) * cSize;
 149         vSize = 3;
 150         vOffset = nOffset + __glXTypeSize(nType) * nSize;
 151         size = vOffset + __glXTypeSize(vType) * vSize;
 152         break;
 153       case GL_T2F_V3F:
 154         tEnable = GL_TRUE;
 155         tSize = 2;
 156         vSize = 3;
 157         vOffset = __glXTypeSize(tType) * tSize;
 158         size = vOffset + __glXTypeSize(vType) * vSize;
 159         break;
 160       case GL_T4F_V4F:
 161         tEnable = GL_TRUE;
 162         tSize = 4;
 163         vSize = 4;
 164         vOffset = __glXTypeSize(tType) * tSize;
 165         size = vOffset + __glXTypeSize(vType) * vSize;
 166         break;
 167       case GL_T2F_C4UB_V3F:
 168         tEnable = GL_TRUE;
 169         tSize = 2;
 170         cEnable = GL_TRUE;
 171         cSize = 4;
 172         cType = GL_UNSIGNED_BYTE;
 173         cOffset = __glXTypeSize(tType) * tSize;
 174         vSize = 3;
 175         vOffset = cOffset + __glXTypeSize(cType) * cSize;
 176         size = vOffset + __glXTypeSize(vType) * vSize;
 177         break;
 178       case GL_T2F_C3F_V3F:
 179         tEnable = GL_TRUE;
 180         tSize = 2;
 181         cEnable = GL_TRUE;
 182         cSize = 3;
 183         cType = GL_FLOAT;
 184         cOffset = __glXTypeSize(tType) * tSize;
 185         vSize = 3;
 186         vOffset = cOffset + __glXTypeSize(cType) * cSize;
 187         size = vOffset + __glXTypeSize(vType) * vSize;
 188         break;
 189       case GL_T2F_N3F_V3F:
 190         tEnable = GL_TRUE;
 191         tSize = 2;
 192         nEnable = GL_TRUE;
 193         nOffset = __glXTypeSize(tType) * tSize;
 194         vSize = 3;
 195         vOffset = nOffset + __glXTypeSize(nType) * nSize;
 196         size = vOffset + __glXTypeSize(vType) * vSize;
 197         break;
 198       case GL_T2F_C4F_N3F_V3F:
 199         tEnable = GL_TRUE;
 200         tSize = 2;
 201         cEnable = GL_TRUE;
 202         cSize = 4;
 203         cType = GL_FLOAT;
 204         cOffset = __glXTypeSize(tType) * tSize;
 205         nEnable = GL_TRUE;
 206         nOffset = cOffset + __glXTypeSize(cType) * cSize;
 207         vSize = 3;
 208         vOffset = nOffset + __glXTypeSize(nType) * nSize;
 209         size = vOffset + __glXTypeSize(vType) * vSize;
 210         break;
 211       case GL_T4F_C4F_N3F_V4F:
 212         tEnable = GL_TRUE;
 213         tSize = 4;
 214         cEnable = GL_TRUE;
 215         cSize = 4;
 216         cType = GL_FLOAT;
 217         cOffset = __glXTypeSize(tType) * tSize;
 218         nEnable = GL_TRUE;
 219         nOffset = cOffset + __glXTypeSize(cType) * cSize;
 220         vSize = 4;
 221         vOffset = nOffset + __glXTypeSize(nType) * nSize;
 222         size = vOffset + __glXTypeSize(vType) * vSize;
 223         break;
 224       default:
 225         __glXSetError(gc, GL_INVALID_ENUM);
 226         return;
 227     }
 228
 229     trueStride = (stride == 0) ? size : stride;
 230
 231     __glXArrayDisableAll( state );
 232
 233     if (tEnable) {
 234         __indirect_glEnableClientState(GL_TEXTURE_COORD_ARRAY);
 235         __indirect_glTexCoordPointer(tSize, tType, trueStride, (const char *)pointer);
 236     }
 237     if (cEnable) {
 238         __indirect_glEnableClientState(GL_COLOR_ARRAY);
 239         __indirect_glColorPointer(cSize, cType, trueStride, (const char *)pointer+cOffset);
 240     }
 241     if (nEnable) {
 242         __indirect_glEnableClientState(GL_NORMAL_ARRAY);
 243         __indirect_glNormalPointer(nType, trueStride, (const char *)pointer+nOffset);
 244     }
 245     __indirect_glEnableClientState(GL_VERTEX_ARRAY);
 246     __indirect_glVertexPointer(vSize, vType, trueStride, (const char *)pointer+vOffset);
 247 }