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 "packrender.h"
  32. #include "indirect.h"
  33. #include "indirect_size.h"
  34.  
  35. /*
  36. ** This file contains routines that might need to be transported as
  37. ** GLXRender or GLXRenderLarge commands, and these commands don't
  38. ** use the pixel header.  See renderpix.c for those routines.
  39. */
  40.  
  41. void
  42. __indirect_glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride,
  43.                    GLint order, const GLdouble * pnts)
  44. {
  45.    __GLX_DECLARE_VARIABLES();
  46.    GLint k;
  47.  
  48.    __GLX_LOAD_VARIABLES();
  49.    k = __glMap1d_size(target);
  50.    if (k == 0) {
  51.       __glXSetError(gc, GL_INVALID_ENUM);
  52.       return;
  53.    }
  54.    else if (stride < k || order <= 0) {
  55.       __glXSetError(gc, GL_INVALID_VALUE);
  56.       return;
  57.    }
  58.    compsize = k * order * __GLX_SIZE_FLOAT64;
  59.    cmdlen = 28 + compsize;
  60.    if (!gc->currentDpy)
  61.       return;
  62.  
  63.    if (cmdlen <= gc->maxSmallRenderCommandSize) {
  64.       /* Use GLXRender protocol to send small command */
  65.       __GLX_BEGIN_VARIABLE(X_GLrop_Map1d, cmdlen);
  66.       __GLX_PUT_DOUBLE(4, u1);
  67.       __GLX_PUT_DOUBLE(12, u2);
  68.       __GLX_PUT_LONG(20, target);
  69.       __GLX_PUT_LONG(24, order);
  70.       /*
  71.        ** NOTE: the doubles that follow are not aligned because of 3
  72.        ** longs preceeding
  73.        */
  74.       __glFillMap1d(k, order, stride, pnts, (pc + 28));
  75.       __GLX_END(cmdlen);
  76.    }
  77.    else {
  78.       /* Use GLXRenderLarge protocol to send command */
  79.       __GLX_BEGIN_VARIABLE_LARGE(X_GLrop_Map1d, cmdlen + 4);
  80.       __GLX_PUT_DOUBLE(8, u1);
  81.       __GLX_PUT_DOUBLE(16, u2);
  82.       __GLX_PUT_LONG(24, target);
  83.       __GLX_PUT_LONG(28, order);
  84.  
  85.       /*
  86.        ** NOTE: the doubles that follow are not aligned because of 3
  87.        ** longs preceeding
  88.        */
  89.       if (stride != k) {
  90.          GLubyte *buf;
  91.  
  92.          buf = malloc(compsize);
  93.          if (!buf) {
  94.             __glXSetError(gc, GL_OUT_OF_MEMORY);
  95.             return;
  96.          }
  97.          __glFillMap1d(k, order, stride, pnts, buf);
  98.          __glXSendLargeCommand(gc, pc, 32, buf, compsize);
  99.          free((char *) buf);
  100.       }
  101.       else {
  102.          /* Data is already packed.  Just send it out */
  103.          __glXSendLargeCommand(gc, pc, 32, pnts, compsize);
  104.       }
  105.    }
  106. }
  107.  
  108. void
  109. __indirect_glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride,
  110.                    GLint order, const GLfloat * pnts)
  111. {
  112.    __GLX_DECLARE_VARIABLES();
  113.    GLint k;
  114.  
  115.    __GLX_LOAD_VARIABLES();
  116.    k = __glMap1f_size(target);
  117.    if (k == 0) {
  118.       __glXSetError(gc, GL_INVALID_ENUM);
  119.       return;
  120.    }
  121.    else if (stride < k || order <= 0) {
  122.       __glXSetError(gc, GL_INVALID_VALUE);
  123.       return;
  124.    }
  125.    compsize = k * order * __GLX_SIZE_FLOAT32;
  126.    cmdlen = 20 + compsize;
  127.    if (!gc->currentDpy)
  128.       return;
  129.  
  130.    /*
  131.     ** The order that arguments are packed is different from the order
  132.     ** for glMap1d.
  133.     */
  134.    if (cmdlen <= gc->maxSmallRenderCommandSize) {
  135.       /* Use GLXRender protocol to send small command */
  136.       __GLX_BEGIN_VARIABLE(X_GLrop_Map1f, cmdlen);
  137.       __GLX_PUT_LONG(4, target);
  138.       __GLX_PUT_FLOAT(8, u1);
  139.       __GLX_PUT_FLOAT(12, u2);
  140.       __GLX_PUT_LONG(16, order);
  141.       __glFillMap1f(k, order, stride, pnts, (GLubyte *) (pc + 20));
  142.       __GLX_END(cmdlen);
  143.    }
  144.    else {
  145.       /* Use GLXRenderLarge protocol to send command */
  146.       __GLX_BEGIN_VARIABLE_LARGE(X_GLrop_Map1f, cmdlen + 4);
  147.       __GLX_PUT_LONG(8, target);
  148.       __GLX_PUT_FLOAT(12, u1);
  149.       __GLX_PUT_FLOAT(16, u2);
  150.       __GLX_PUT_LONG(20, order);
  151.  
  152.       if (stride != k) {
  153.          GLubyte *buf;
  154.  
  155.          buf = malloc(compsize);
  156.          if (!buf) {
  157.             __glXSetError(gc, GL_OUT_OF_MEMORY);
  158.             return;
  159.          }
  160.          __glFillMap1f(k, order, stride, pnts, buf);
  161.          __glXSendLargeCommand(gc, pc, 24, buf, compsize);
  162.          free((char *) buf);
  163.       }
  164.       else {
  165.          /* Data is already packed.  Just send it out */
  166.          __glXSendLargeCommand(gc, pc, 24, pnts, compsize);
  167.       }
  168.    }
  169. }
  170.  
  171. void
  172. __indirect_glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustr,
  173.                    GLint uord, GLdouble v1, GLdouble v2, GLint vstr,
  174.                    GLint vord, const GLdouble * pnts)
  175. {
  176.    __GLX_DECLARE_VARIABLES();
  177.    GLint k;
  178.  
  179.    __GLX_LOAD_VARIABLES();
  180.    k = __glMap2d_size(target);
  181.    if (k == 0) {
  182.       __glXSetError(gc, GL_INVALID_ENUM);
  183.       return;
  184.    }
  185.    else if (vstr < k || ustr < k || vord <= 0 || uord <= 0) {
  186.       __glXSetError(gc, GL_INVALID_VALUE);
  187.       return;
  188.    }
  189.    compsize = k * uord * vord * __GLX_SIZE_FLOAT64;
  190.    cmdlen = 48 + compsize;
  191.    if (!gc->currentDpy)
  192.       return;
  193.  
  194.    if (cmdlen <= gc->maxSmallRenderCommandSize) {
  195.       /* Use GLXRender protocol to send small command */
  196.       __GLX_BEGIN_VARIABLE(X_GLrop_Map2d, cmdlen);
  197.       __GLX_PUT_DOUBLE(4, u1);
  198.       __GLX_PUT_DOUBLE(12, u2);
  199.       __GLX_PUT_DOUBLE(20, v1);
  200.       __GLX_PUT_DOUBLE(28, v2);
  201.       __GLX_PUT_LONG(36, target);
  202.       __GLX_PUT_LONG(40, uord);
  203.       __GLX_PUT_LONG(44, vord);
  204.       /*
  205.        ** Pack into a u-major ordering.
  206.        ** NOTE: the doubles that follow are not aligned because of 5
  207.        ** longs preceeding
  208.        */
  209.       __glFillMap2d(k, uord, vord, ustr, vstr, pnts, (GLdouble *) (pc + 48));
  210.       __GLX_END(cmdlen);
  211.    }
  212.    else {
  213.       /* Use GLXRenderLarge protocol to send command */
  214.       __GLX_BEGIN_VARIABLE_LARGE(X_GLrop_Map2d, cmdlen + 4);
  215.       __GLX_PUT_DOUBLE(8, u1);
  216.       __GLX_PUT_DOUBLE(16, u2);
  217.       __GLX_PUT_DOUBLE(24, v1);
  218.       __GLX_PUT_DOUBLE(32, v2);
  219.       __GLX_PUT_LONG(40, target);
  220.       __GLX_PUT_LONG(44, uord);
  221.       __GLX_PUT_LONG(48, vord);
  222.  
  223.       /*
  224.        ** NOTE: the doubles that follow are not aligned because of 5
  225.        ** longs preceeding
  226.        */
  227.       if ((vstr != k) || (ustr != k * vord)) {
  228.          GLdouble *buf;
  229.  
  230.          buf = malloc(compsize);
  231.          if (!buf) {
  232.             __glXSetError(gc, GL_OUT_OF_MEMORY);
  233.             return;
  234.          }
  235.          /*
  236.           ** Pack into a u-major ordering.
  237.           */
  238.          __glFillMap2d(k, uord, vord, ustr, vstr, pnts, buf);
  239.          __glXSendLargeCommand(gc, pc, 52, buf, compsize);
  240.          free((char *) buf);
  241.       }
  242.       else {
  243.          /* Data is already packed.  Just send it out */
  244.          __glXSendLargeCommand(gc, pc, 52, pnts, compsize);
  245.       }
  246.    }
  247. }
  248.  
  249. void
  250. __indirect_glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustr,
  251.                    GLint uord, GLfloat v1, GLfloat v2, GLint vstr, GLint vord,
  252.                    const GLfloat * pnts)
  253. {
  254.    __GLX_DECLARE_VARIABLES();
  255.    GLint k;
  256.  
  257.    __GLX_LOAD_VARIABLES();
  258.    k = __glMap2f_size(target);
  259.    if (k == 0) {
  260.       __glXSetError(gc, GL_INVALID_ENUM);
  261.       return;
  262.    }
  263.    else if (vstr < k || ustr < k || vord <= 0 || uord <= 0) {
  264.       __glXSetError(gc, GL_INVALID_VALUE);
  265.       return;
  266.    }
  267.    compsize = k * uord * vord * __GLX_SIZE_FLOAT32;
  268.    cmdlen = 32 + compsize;
  269.    if (!gc->currentDpy)
  270.       return;
  271.  
  272.    /*
  273.     ** The order that arguments are packed is different from the order
  274.     ** for glMap2d.
  275.     */
  276.    if (cmdlen <= gc->maxSmallRenderCommandSize) {
  277.       /* Use GLXRender protocol to send small command */
  278.       __GLX_BEGIN_VARIABLE(X_GLrop_Map2f, cmdlen);
  279.       __GLX_PUT_LONG(4, target);
  280.       __GLX_PUT_FLOAT(8, u1);
  281.       __GLX_PUT_FLOAT(12, u2);
  282.       __GLX_PUT_LONG(16, uord);
  283.       __GLX_PUT_FLOAT(20, v1);
  284.       __GLX_PUT_FLOAT(24, v2);
  285.       __GLX_PUT_LONG(28, vord);
  286.       /*
  287.        ** Pack into a u-major ordering.
  288.        */
  289.       __glFillMap2f(k, uord, vord, ustr, vstr, pnts, (GLfloat *) (pc + 32));
  290.       __GLX_END(cmdlen);
  291.    }
  292.    else {
  293.       /* Use GLXRenderLarge protocol to send command */
  294.       __GLX_BEGIN_VARIABLE_LARGE(X_GLrop_Map2f, cmdlen + 4);
  295.       __GLX_PUT_LONG(8, target);
  296.       __GLX_PUT_FLOAT(12, u1);
  297.       __GLX_PUT_FLOAT(16, u2);
  298.       __GLX_PUT_LONG(20, uord);
  299.       __GLX_PUT_FLOAT(24, v1);
  300.       __GLX_PUT_FLOAT(28, v2);
  301.       __GLX_PUT_LONG(32, vord);
  302.  
  303.       if ((vstr != k) || (ustr != k * vord)) {
  304.          GLfloat *buf;
  305.  
  306.          buf = malloc(compsize);
  307.          if (!buf) {
  308.             __glXSetError(gc, GL_OUT_OF_MEMORY);
  309.             return;
  310.          }
  311.          /*
  312.           ** Pack into a u-major ordering.
  313.           */
  314.          __glFillMap2f(k, uord, vord, ustr, vstr, pnts, buf);
  315.          __glXSendLargeCommand(gc, pc, 36, buf, compsize);
  316.          free((char *) buf);
  317.       }
  318.       else {
  319.          /* Data is already packed.  Just send it out */
  320.          __glXSendLargeCommand(gc, pc, 36, pnts, compsize);
  321.       }
  322.    }
  323. }
  324.  
  325. void
  326. __indirect_glEnable(GLenum cap)
  327. {
  328.    __GLX_DECLARE_VARIABLES();
  329.  
  330.    __GLX_LOAD_VARIABLES();
  331.    if (!gc->currentDpy)
  332.       return;
  333.  
  334.    switch (cap) {
  335.    case GL_COLOR_ARRAY:
  336.    case GL_EDGE_FLAG_ARRAY:
  337.    case GL_INDEX_ARRAY:
  338.    case GL_NORMAL_ARRAY:
  339.    case GL_TEXTURE_COORD_ARRAY:
  340.    case GL_VERTEX_ARRAY:
  341.    case GL_SECONDARY_COLOR_ARRAY:
  342.    case GL_FOG_COORD_ARRAY:
  343.       __indirect_glEnableClientState(cap);
  344.       return;
  345.    default:
  346.       break;
  347.    }
  348.  
  349.    __GLX_BEGIN(X_GLrop_Enable, 8);
  350.    __GLX_PUT_LONG(4, cap);
  351.    __GLX_END(8);
  352. }
  353.  
  354. void
  355. __indirect_glDisable(GLenum cap)
  356. {
  357.    __GLX_DECLARE_VARIABLES();
  358.  
  359.    __GLX_LOAD_VARIABLES();
  360.    if (!gc->currentDpy)
  361.       return;
  362.  
  363.    switch (cap) {
  364.    case GL_COLOR_ARRAY:
  365.    case GL_EDGE_FLAG_ARRAY:
  366.    case GL_INDEX_ARRAY:
  367.    case GL_NORMAL_ARRAY:
  368.    case GL_TEXTURE_COORD_ARRAY:
  369.    case GL_VERTEX_ARRAY:
  370.    case GL_SECONDARY_COLOR_ARRAY:
  371.    case GL_FOG_COORD_ARRAY:
  372.       __indirect_glDisableClientState(cap);
  373.       return;
  374.    default:
  375.       break;
  376.    }
  377.  
  378.    __GLX_BEGIN(X_GLrop_Disable, 8);
  379.    __GLX_PUT_LONG(4, cap);
  380.    __GLX_END(8);
  381. }
  382.