Home | History | Annotate | Download | only in glx 
      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 
     33 /*
     34 ** Routines to pack evaluator maps into the transport buffer.  Maps are
     35 ** allowed to have extra arbitrary data, so these routines extract just
     36 ** the information that the GL needs.
     37 */
     38 
     39 void
     40 __glFillMap1f(GLint k, GLint order, GLint stride,
     41               const GLfloat * points, GLubyte * pc)
     42 {
     43    if (stride == k) {
     44       /* Just copy the data */
     45       __GLX_PUT_FLOAT_ARRAY(0, points, order * k);
     46    }
     47    else {
     48       GLint i;
     49 
     50       for (i = 0; i < order; i++) {
     51          __GLX_PUT_FLOAT_ARRAY(0, points, k);
     52          points += stride;
     53          pc += k * __GLX_SIZE_FLOAT32;
     54       }
     55    }
     56 }
     57 
     58 void
     59 __glFillMap1d(GLint k, GLint order, GLint stride,
     60               const GLdouble * points, GLubyte * pc)
     61 {
     62    if (stride == k) {
     63       /* Just copy the data */
     64       __GLX_PUT_DOUBLE_ARRAY(0, points, order * k);
     65    }
     66    else {
     67       GLint i;
     68       for (i = 0; i < order; i++) {
     69          __GLX_PUT_DOUBLE_ARRAY(0, points, k);
     70          points += stride;
     71          pc += k * __GLX_SIZE_FLOAT64;
     72       }
     73    }
     74 }
     75 
     76 void
     77 __glFillMap2f(GLint k, GLint majorOrder, GLint minorOrder,
     78               GLint majorStride, GLint minorStride,
     79               const GLfloat * points, GLfloat * data)
     80 {
     81    GLint i, j, x;
     82 
     83    if ((minorStride == k) && (majorStride == minorOrder * k)) {
     84       /* Just copy the data */
     85       __GLX_MEM_COPY(data, points, majorOrder * majorStride *
     86                      __GLX_SIZE_FLOAT32);
     87       return;
     88    }
     89    for (i = 0; i < majorOrder; i++) {
     90       for (j = 0; j < minorOrder; j++) {
     91          for (x = 0; x < k; x++) {
     92             data[x] = points[x];
     93          }
     94          points += minorStride;
     95          data += k;
     96       }
     97       points += majorStride - minorStride * minorOrder;
     98    }
     99 }
    100 
    101 void
    102 __glFillMap2d(GLint k, GLint majorOrder, GLint minorOrder,
    103               GLint majorStride, GLint minorStride,
    104               const GLdouble * points, GLdouble * data)
    105 {
    106    int i, j, x;
    107 
    108    if ((minorStride == k) && (majorStride == minorOrder * k)) {
    109       /* Just copy the data */
    110       __GLX_MEM_COPY(data, points, majorOrder * majorStride *
    111                      __GLX_SIZE_FLOAT64);
    112       return;
    113    }
    114 
    115 #ifdef __GLX_ALIGN64
    116    x = k * __GLX_SIZE_FLOAT64;
    117 #endif
    118    for (i = 0; i < majorOrder; i++) {
    119       for (j = 0; j < minorOrder; j++) {
    120 #ifdef __GLX_ALIGN64
    121          __GLX_MEM_COPY(data, points, x);
    122 #else
    123          for (x = 0; x < k; x++) {
    124             data[x] = points[x];
    125          }
    126 #endif
    127          points += minorStride;
    128          data += k;
    129       }
    130       points += majorStride - minorStride * minorOrder;
    131    }
    132 }
    133