Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
  3.  * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
  4.  *
  5.  * Permission is hereby granted, free of charge, to any person obtaining a
  6.  * copy of this software and associated documentation files (the "Software"),
  7.  * to deal in the Software without restriction, including without limitation
  8.  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  9.  * and/or sell copies of the Software, and to permit persons to whom the
  10.  * Software is furnished to do so, subject to the following conditions:
  11.  *
  12.  * The above copyright notice including the dates of first publication and
  13.  * either this permission notice or a reference to
  14.  * http://oss.sgi.com/projects/FreeB/
  15.  * shall be included in all copies or substantial portions of the Software.
  16.  *
  17.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18.  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  20.  * SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  21.  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
  22.  * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  23.  * SOFTWARE.
  24.  *
  25.  * Except as contained in this notice, the name of Silicon Graphics, Inc.
  26.  * shall not be used in advertising or otherwise to promote the sale, use or
  27.  * other dealings in this Software without prior written authorization from
  28.  * Silicon Graphics, Inc.
  29.  */
  30.  
  31. #include <assert.h>
  32. #include "glxclient.h"
  33. #include "indirect.h"
  34. #include "indirect_vertex_array.h"
  35.  
  36. /*****************************************************************************/
  37.  
  38. #ifndef GLX_USE_APPLEGL
  39. static void
  40. do_enable_disable(GLenum array, GLboolean val)
  41. {
  42.    struct glx_context *gc = __glXGetCurrentContext();
  43.    __GLXattribute *state = (__GLXattribute *) (gc->client_state_private);
  44.    unsigned index = 0;
  45.  
  46.    if (array == GL_TEXTURE_COORD_ARRAY) {
  47.       index = __glXGetActiveTextureUnit(state);
  48.    }
  49.  
  50.    if (!__glXSetArrayEnable(state, array, index, val)) {
  51.       __glXSetError(gc, GL_INVALID_ENUM);
  52.    }
  53. }
  54.  
  55. void
  56. __indirect_glEnableClientState(GLenum array)
  57. {
  58.    do_enable_disable(array, GL_TRUE);
  59. }
  60.  
  61. void
  62. __indirect_glDisableClientState(GLenum array)
  63. {
  64.    do_enable_disable(array, GL_FALSE);
  65. }
  66.  
  67. /************************************************************************/
  68.  
  69. void
  70. __indirect_glPushClientAttrib(GLuint mask)
  71. {
  72.    struct glx_context *gc = __glXGetCurrentContext();
  73.    __GLXattribute *state = (__GLXattribute *) (gc->client_state_private);
  74.    __GLXattribute **spp = gc->attributes.stackPointer, *sp;
  75.  
  76.    if (spp < &gc->attributes.stack[__GL_CLIENT_ATTRIB_STACK_DEPTH]) {
  77.       if (!(sp = *spp)) {
  78.          sp = malloc(sizeof(__GLXattribute));
  79.          *spp = sp;
  80.       }
  81.       sp->mask = mask;
  82.       gc->attributes.stackPointer = spp + 1;
  83.       if (mask & GL_CLIENT_PIXEL_STORE_BIT) {
  84.          sp->storePack = state->storePack;
  85.          sp->storeUnpack = state->storeUnpack;
  86.       }
  87.       if (mask & GL_CLIENT_VERTEX_ARRAY_BIT) {
  88.          __glXPushArrayState(state);
  89.       }
  90.    }
  91.    else {
  92.       __glXSetError(gc, GL_STACK_OVERFLOW);
  93.       return;
  94.    }
  95. }
  96.  
  97. void
  98. __indirect_glPopClientAttrib(void)
  99. {
  100.    struct glx_context *gc = __glXGetCurrentContext();
  101.    __GLXattribute *state = (__GLXattribute *) (gc->client_state_private);
  102.    __GLXattribute **spp = gc->attributes.stackPointer, *sp;
  103.    GLuint mask;
  104.  
  105.    if (spp > &gc->attributes.stack[0]) {
  106.       --spp;
  107.       sp = *spp;
  108.       assert(sp != 0);
  109.       mask = sp->mask;
  110.       gc->attributes.stackPointer = spp;
  111.  
  112.       if (mask & GL_CLIENT_PIXEL_STORE_BIT) {
  113.          state->storePack = sp->storePack;
  114.          state->storeUnpack = sp->storeUnpack;
  115.       }
  116.       if (mask & GL_CLIENT_VERTEX_ARRAY_BIT) {
  117.          __glXPopArrayState(state);
  118.       }
  119.  
  120.       sp->mask = 0;
  121.    }
  122.    else {
  123.       __glXSetError(gc, GL_STACK_UNDERFLOW);
  124.       return;
  125.    }
  126. }
  127. #endif
  128.  
  129. void
  130. __glFreeAttributeState(struct glx_context * gc)
  131. {
  132.    __GLXattribute *sp, **spp;
  133.  
  134.    for (spp = &gc->attributes.stack[0];
  135.         spp < &gc->attributes.stack[__GL_CLIENT_ATTRIB_STACK_DEPTH]; spp++) {
  136.       sp = *spp;
  137.       if (sp) {
  138.          free((char *) sp);
  139.       }
  140.       else {
  141.          break;
  142.       }
  143.    }
  144. }
  145.