ReactOS 0.4.15-dev-8419-g7f0e8a3
eval.h File Reference
#include "types.h"
Include dependency graph for eval.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions

void gl_init_eval (void)
 
void gl_free_control_points (GLcontext *ctx, GLenum target, GLfloat *data)
 
GLfloatgl_copy_map_points1f (GLenum target, GLint ustride, GLint uorder, const GLfloat *points)
 
GLfloatgl_copy_map_points1d (GLenum target, GLint ustride, GLint uorder, const GLdouble *points)
 
GLfloatgl_copy_map_points2f (GLenum target, GLint ustride, GLint uorder, GLint vstride, GLint vorder, const GLfloat *points)
 
GLfloatgl_copy_map_points2d (GLenum target, GLint ustride, GLint uorder, GLint vstride, GLint vorder, const GLdouble *points)
 
void gl_Map1f (GLcontext *ctx, GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points, GLboolean retain)
 
void gl_Map2f (GLcontext *ctx, GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points, GLboolean retain)
 
void gl_EvalCoord1f (GLcontext *ctx, GLfloat u)
 
void gl_EvalCoord2f (GLcontext *ctx, GLfloat u, GLfloat v)
 
void gl_MapGrid1f (GLcontext *ctx, GLint un, GLfloat u1, GLfloat u2)
 
void gl_MapGrid2f (GLcontext *ctx, GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
 
void gl_GetMapdv (GLcontext *ctx, GLenum target, GLenum query, GLdouble *v)
 
void gl_GetMapfv (GLcontext *ctx, GLenum target, GLenum query, GLfloat *v)
 
void gl_GetMapiv (GLcontext *ctx, GLenum target, GLenum query, GLint *v)
 
void gl_EvalPoint1 (GLcontext *ctx, GLint i)
 
void gl_EvalPoint2 (GLcontext *ctx, GLint i, GLint j)
 
void gl_EvalMesh1 (GLcontext *ctx, GLenum mode, GLint i1, GLint i2)
 
void gl_EvalMesh2 (GLcontext *ctx, GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
 

Function Documentation

◆ gl_copy_map_points1d()

GLfloat * gl_copy_map_points1d ( GLenum  target,
GLint  ustride,
GLint  uorder,
const GLdouble points 
)

Definition at line 613 of file eval.c.

616{
617 GLfloat *buffer, *p;
619
620 if (!points || size==0) {
621 return NULL;
622 }
623
624 buffer = (GLfloat *) malloc(uorder * size * sizeof(GLfloat));
625
626 if(buffer)
627 for(i=0, p=buffer; i<uorder; i++, points+=ustride)
628 for(k=0; k<size; k++)
629 *p++ = (GLfloat) points[k];
630
631 return buffer;
632}
#define malloc
Definition: debug_ros.c:4
#define NULL
Definition: types.h:112
float GLfloat
Definition: gl.h:161
unsigned int GLuint
Definition: gl.h:159
GLsizeiptr size
Definition: glext.h:5919
GLdouble GLdouble GLint ustride
Definition: glext.h:8308
GLuint buffer
Definition: glext.h:5915
GLenum GLenum GLuint components
Definition: glext.h:9620
GLdouble GLdouble GLint GLint uorder
Definition: glext.h:8308
GLfloat GLfloat p
Definition: glext.h:8902
GLsizei const GLfloat * points
Definition: glext.h:8112
GLenum target
Definition: glext.h:7315
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
int k
Definition: mpi.c:3369

Referenced by _mesa_Map1d().

◆ gl_copy_map_points1f()

GLfloat * gl_copy_map_points1f ( GLenum  target,
GLint  ustride,
GLint  uorder,
const GLfloat points 
)

Definition at line 587 of file eval.c.

590{
591 GLfloat *buffer, *p;
593
594 if (!points || size==0) {
595 return NULL;
596 }
597
598 buffer = (GLfloat *) malloc(uorder * size * sizeof(GLfloat));
599
600 if(buffer)
601 for(i=0, p=buffer; i<uorder; i++, points+=ustride)
602 for(k=0; k<size; k++)
603 *p++ = points[k];
604
605 return buffer;
606}

Referenced by _mesa_Map1f().

◆ gl_copy_map_points2d()

GLfloat * gl_copy_map_points2d ( GLenum  target,
GLint  ustride,
GLint  uorder,
GLint  vstride,
GLint  vorder,
const GLdouble points 
)

Definition at line 689 of file eval.c.

693{
694 GLfloat *buffer, *p;
695 GLuint i, j, k, size, hsize, dsize;
696 GLint uinc;
697
699
700 if (!points || size==0) {
701 return NULL;
702 }
703
704 /* max(uorder, vorder) additional points are used in */
705 /* horner evaluation and uorder*vorder additional */
706 /* values are needed for de Casteljau */
707 dsize = (uorder == 2 && vorder == 2)? 0 : uorder*vorder;
708 hsize = (uorder > vorder ? uorder : vorder)*size;
709
710 if(hsize>dsize)
711 buffer = (GLfloat *) malloc((uorder*vorder*size+hsize)*sizeof(GLfloat));
712 else
713 buffer = (GLfloat *) malloc((uorder*vorder*size+dsize)*sizeof(GLfloat));
714
715 /* compute the increment value for the u-loop */
716 uinc = ustride - vorder*vstride;
717
718 if (buffer)
719 for (i=0, p=buffer; i<uorder; i++, points += uinc)
720 for (j=0; j<vorder; j++, points += vstride)
721 for (k=0; k<size; k++)
722 *p++ = (GLfloat) points[k];
723
724 return buffer;
725}
int GLint
Definition: gl.h:156
GLdouble GLdouble GLint GLint GLdouble GLdouble GLint GLint vorder
Definition: glext.h:8308
GLdouble GLdouble GLint GLint GLdouble GLdouble GLint vstride
Definition: glext.h:8308
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250

Referenced by _mesa_Map2d().

◆ gl_copy_map_points2f()

GLfloat * gl_copy_map_points2f ( GLenum  target,
GLint  ustride,
GLint  uorder,
GLint  vstride,
GLint  vorder,
const GLfloat points 
)

Definition at line 646 of file eval.c.

650{
651 GLfloat *buffer, *p;
652 GLuint i, j, k, size, dsize, hsize;
653 GLint uinc;
654
656
657 if (!points || size==0) {
658 return NULL;
659 }
660
661 /* max(uorder, vorder) additional points are used in */
662 /* horner evaluation and uorder*vorder additional */
663 /* values are needed for de Casteljau */
664 dsize = (uorder == 2 && vorder == 2)? 0 : uorder*vorder;
665 hsize = (uorder > vorder ? uorder : vorder)*size;
666
667 if(hsize>dsize)
668 buffer = (GLfloat *) malloc((uorder*vorder*size+hsize)*sizeof(GLfloat));
669 else
670 buffer = (GLfloat *) malloc((uorder*vorder*size+dsize)*sizeof(GLfloat));
671
672 /* compute the increment value for the u-loop */
673 uinc = ustride - vorder*vstride;
674
675 if (buffer)
676 for (i=0, p=buffer; i<uorder; i++, points += uinc)
677 for (j=0; j<vorder; j++, points += vstride)
678 for (k=0; k<size; k++)
679 *p++ = points[k];
680
681 return buffer;
682}

Referenced by _mesa_Map2f().

◆ gl_EvalCoord1f()

void gl_EvalCoord1f ( GLcontext ctx,
GLfloat  u 
)

Vertex

Color Index

Color

Normal Vector

Texture Coordinates

Definition at line 1978 of file eval.c.

1979{
1980 GLfloat vertex[4];
1981 GLfloat normal[3];
1982 GLfloat fcolor[4];
1983 GLubyte icolor[4];
1984 GLubyte *colorptr;
1985 GLfloat texcoord[4];
1986 GLuint index;
1987 register GLfloat uu;
1988
1990 if (ctx->Eval.Map1Vertex4)
1991 {
1992 struct gl_1d_map *map = &ctx->EvalMap.Map1Vertex4;
1993 uu = (u - map->u1) / (map->u2 - map->u1);
1994 horner_bezier_curve(map->Points, vertex, uu, 4, map->Order);
1995 }
1996 else if (ctx->Eval.Map1Vertex3)
1997 {
1998 struct gl_1d_map *map = &ctx->EvalMap.Map1Vertex3;
1999 uu = (u - map->u1) / (map->u2 - map->u1);
2000 horner_bezier_curve(map->Points, vertex, uu, 3, map->Order);
2001 vertex[3] = 1.0;
2002 }
2003
2005 if (ctx->Eval.Map1Index)
2006 {
2007 struct gl_1d_map *map = &ctx->EvalMap.Map1Index;
2008 GLfloat findex;
2009 uu = (u - map->u1) / (map->u2 - map->u1);
2010 horner_bezier_curve(map->Points, &findex, uu, 1, map->Order);
2011 index = (GLuint) (GLint) findex;
2012 }
2013 else {
2014 index = ctx->Current.Index;
2015 }
2016
2018 if (ctx->Eval.Map1Color4) {
2019 struct gl_1d_map *map = &ctx->EvalMap.Map1Color4;
2020 uu = (u - map->u1) / (map->u2 - map->u1);
2021 horner_bezier_curve(map->Points, fcolor, uu, 4, map->Order);
2022 icolor[0] = (GLint) (fcolor[0] * ctx->Visual->RedScale);
2023 icolor[1] = (GLint) (fcolor[1] * ctx->Visual->GreenScale);
2024 icolor[2] = (GLint) (fcolor[2] * ctx->Visual->BlueScale);
2025 icolor[3] = (GLint) (fcolor[3] * ctx->Visual->AlphaScale);
2026 colorptr = icolor;
2027 }
2028 else {
2029 GLubyte col[4];
2030 COPY_4V(col, ctx->Current.ByteColor );
2031 colorptr = col;
2032 }
2033
2035 if (ctx->Eval.Map1Normal) {
2036 struct gl_1d_map *map = &ctx->EvalMap.Map1Normal;
2037 uu = (u - map->u1) / (map->u2 - map->u1);
2038 horner_bezier_curve(map->Points, normal, uu, 3, map->Order);
2039 }
2040 else {
2041 normal[0] = ctx->Current.Normal[0];
2042 normal[1] = ctx->Current.Normal[1];
2043 normal[2] = ctx->Current.Normal[2];
2044 }
2045
2047 if (ctx->Eval.Map1TextureCoord4) {
2048 struct gl_1d_map *map = &ctx->EvalMap.Map1Texture4;
2049 uu = (u - map->u1) / (map->u2 - map->u1);
2050 horner_bezier_curve(map->Points, texcoord, uu, 4, map->Order);
2051 }
2052 else if (ctx->Eval.Map1TextureCoord3) {
2053 struct gl_1d_map *map = &ctx->EvalMap.Map1Texture3;
2054 uu = (u - map->u1) / (map->u2 - map->u1);
2055 horner_bezier_curve(map->Points, texcoord, uu, 3, map->Order);
2056 texcoord[3] = 1.0;
2057 }
2058 else if (ctx->Eval.Map1TextureCoord2) {
2059 struct gl_1d_map *map = &ctx->EvalMap.Map1Texture2;
2060 uu = (u - map->u1) / (map->u2 - map->u1);
2061 horner_bezier_curve(map->Points, texcoord, uu, 2, map->Order);
2062 texcoord[2] = 0.0;
2063 texcoord[3] = 1.0;
2064 }
2065 else if (ctx->Eval.Map1TextureCoord1) {
2066 struct gl_1d_map *map = &ctx->EvalMap.Map1Texture1;
2067 uu = (u - map->u1) / (map->u2 - map->u1);
2068 horner_bezier_curve(map->Points, texcoord, uu, 1, map->Order);
2069 texcoord[1] = 0.0;
2070 texcoord[2] = 0.0;
2071 texcoord[3] = 1.0;
2072 }
2073 else {
2074 texcoord[0] = ctx->Current.TexCoord[0];
2075 texcoord[1] = ctx->Current.TexCoord[1];
2076 texcoord[2] = ctx->Current.TexCoord[2];
2077 texcoord[3] = ctx->Current.TexCoord[3];
2078 }
2079
2080 gl_eval_vertex( ctx, vertex, normal, colorptr, index, texcoord );
2081}
#define index(s, c)
Definition: various.h:29
Definition: _map.h:48
static void horner_bezier_curve(GLfloat *cp, GLfloat *out, GLfloat t, GLuint dim, GLuint order)
Definition: eval.c:131
unsigned char GLubyte
Definition: gl.h:157
GLuint index
Definition: glext.h:6031
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble * u
Definition: glfuncs.h:240
#define COPY_4V(DST, SRC)
Definition: macros.h:102
@ normal
Definition: optimize.h:166
Definition: mesh.c:4558
void gl_eval_vertex(GLcontext *ctx, const GLfloat vertex[4], const GLfloat normal[3], const GLubyte color[4], GLuint index, const GLfloat texcoord[4])
Definition: vbfill.c:1290

Referenced by execute_list(), gl_EvalMesh1(), gl_EvalPoint1(), and init_exec_pointers().

◆ gl_EvalCoord2f()

void gl_EvalCoord2f ( GLcontext ctx,
GLfloat  u,
GLfloat  v 
)

Vertex

Color Index

Color

Normal

Texture Coordinates

Definition at line 2084 of file eval.c.

2085{
2086 GLfloat vertex[4];
2087 GLfloat normal[3];
2088 GLfloat fcolor[4];
2089 GLubyte icolor[4];
2090 GLubyte *colorptr;
2091 GLfloat texcoord[4];
2092 GLuint index;
2093 register GLfloat uu, vv;
2094
2095#define CROSS_PROD(n, u, v) \
2096 (n)[0] = (u)[1]*(v)[2] - (u)[2]*(v)[1]; \
2097 (n)[1] = (u)[2]*(v)[0] - (u)[0]*(v)[2]; \
2098 (n)[2] = (u)[0]*(v)[1] - (u)[1]*(v)[0]
2099
2101 if(ctx->Eval.Map2Vertex4) {
2102 struct gl_2d_map *map = &ctx->EvalMap.Map2Vertex4;
2103 uu = (u - map->u1) / (map->u2 - map->u1);
2104 vv = (v - map->v1) / (map->v2 - map->v1);
2105
2106 if (ctx->Eval.AutoNormal) {
2107 GLfloat du[4], dv[4];
2108
2109 de_casteljau_surf(map->Points, vertex, du, dv, uu, vv, 4,
2110 map->Uorder, map->Vorder);
2111
2112 CROSS_PROD(normal, du, dv);
2114 }
2115 else {
2116 horner_bezier_surf(map->Points, vertex, uu, vv, 4,
2117 map->Uorder, map->Vorder);
2118 }
2119 }
2120 else if (ctx->Eval.Map2Vertex3) {
2121 struct gl_2d_map *map = &ctx->EvalMap.Map2Vertex3;
2122 uu = (u - map->u1) / (map->u2 - map->u1);
2123 vv = (v - map->v1) / (map->v2 - map->v1);
2124 if (ctx->Eval.AutoNormal) {
2125 GLfloat du[3], dv[3];
2126 de_casteljau_surf(map->Points, vertex, du, dv, uu, vv, 3,
2127 map->Uorder, map->Vorder);
2128 CROSS_PROD(normal, du, dv);
2130 }
2131 else {
2132 horner_bezier_surf(map->Points, vertex, uu, vv, 3,
2133 map->Uorder, map->Vorder);
2134 }
2135 vertex[3] = 1.0;
2136 }
2137#undef CROSS_PROD
2138
2140 if (ctx->Eval.Map2Index) {
2141 GLfloat findex;
2142 struct gl_2d_map *map = &ctx->EvalMap.Map2Index;
2143 uu = (u - map->u1) / (map->u2 - map->u1);
2144 vv = (v - map->v1) / (map->v2 - map->v1);
2145 horner_bezier_surf(map->Points, &findex, uu, vv, 1,
2146 map->Uorder, map->Vorder);
2147 index = (GLuint) (GLint) findex;
2148 }
2149 else {
2150 index = ctx->Current.Index;
2151 }
2152
2154 if (ctx->Eval.Map2Color4) {
2155 struct gl_2d_map *map = &ctx->EvalMap.Map2Color4;
2156 uu = (u - map->u1) / (map->u2 - map->u1);
2157 vv = (v - map->v1) / (map->v2 - map->v1);
2158 horner_bezier_surf(map->Points, fcolor, uu, vv, 4,
2159 map->Uorder, map->Vorder);
2160 icolor[0] = (GLint) (fcolor[0] * ctx->Visual->RedScale);
2161 icolor[1] = (GLint) (fcolor[1] * ctx->Visual->GreenScale);
2162 icolor[2] = (GLint) (fcolor[2] * ctx->Visual->BlueScale);
2163 icolor[3] = (GLint) (fcolor[3] * ctx->Visual->AlphaScale);
2164 colorptr = icolor;
2165 }
2166 else {
2167 GLubyte col[4];
2168 COPY_4V(col, ctx->Current.ByteColor );
2169 colorptr = col;
2170 }
2171
2173 if (!ctx->Eval.AutoNormal
2174 || (!ctx->Eval.Map2Vertex3 && !ctx->Eval.Map2Vertex4)) {
2175 if (ctx->Eval.Map2Normal) {
2176 struct gl_2d_map *map = &ctx->EvalMap.Map2Normal;
2177 uu = (u - map->u1) / (map->u2 - map->u1);
2178 vv = (v - map->v1) / (map->v2 - map->v1);
2179 horner_bezier_surf(map->Points, normal, uu, vv, 3,
2180 map->Uorder, map->Vorder);
2181 }
2182 else {
2183 normal[0] = ctx->Current.Normal[0];
2184 normal[1] = ctx->Current.Normal[1];
2185 normal[2] = ctx->Current.Normal[2];
2186 }
2187 }
2188
2190 if (ctx->Eval.Map2TextureCoord4) {
2191 struct gl_2d_map *map = &ctx->EvalMap.Map2Texture4;
2192 uu = (u - map->u1) / (map->u2 - map->u1);
2193 vv = (v - map->v1) / (map->v2 - map->v1);
2194 horner_bezier_surf(map->Points, texcoord, uu, vv, 4,
2195 map->Uorder, map->Vorder);
2196 }
2197 else if (ctx->Eval.Map2TextureCoord3) {
2198 struct gl_2d_map *map = &ctx->EvalMap.Map2Texture3;
2199 uu = (u - map->u1) / (map->u2 - map->u1);
2200 vv = (v - map->v1) / (map->v2 - map->v1);
2201 horner_bezier_surf(map->Points, texcoord, uu, vv, 3,
2202 map->Uorder, map->Vorder);
2203 texcoord[3] = 1.0;
2204 }
2205 else if (ctx->Eval.Map2TextureCoord2) {
2206 struct gl_2d_map *map = &ctx->EvalMap.Map2Texture2;
2207 uu = (u - map->u1) / (map->u2 - map->u1);
2208 vv = (v - map->v1) / (map->v2 - map->v1);
2209 horner_bezier_surf(map->Points, texcoord, uu, vv, 2,
2210 map->Uorder, map->Vorder);
2211 texcoord[2] = 0.0;
2212 texcoord[3] = 1.0;
2213 }
2214 else if (ctx->Eval.Map2TextureCoord1) {
2215 struct gl_2d_map *map = &ctx->EvalMap.Map2Texture1;
2216 uu = (u - map->u1) / (map->u2 - map->u1);
2217 vv = (v - map->v1) / (map->v2 - map->v1);
2218 horner_bezier_surf(map->Points, texcoord, uu, vv, 1,
2219 map->Uorder, map->Vorder);
2220 texcoord[1] = 0.0;
2221 texcoord[2] = 0.0;
2222 texcoord[3] = 1.0;
2223 }
2224 else
2225 {
2226 texcoord[0] = ctx->Current.TexCoord[0];
2227 texcoord[1] = ctx->Current.TexCoord[1];
2228 texcoord[2] = ctx->Current.TexCoord[2];
2229 texcoord[3] = ctx->Current.TexCoord[3];
2230 }
2231
2232 gl_eval_vertex( ctx, vertex, normal, colorptr, index, texcoord );
2233}
#define CROSS_PROD(n, u, v)
static void de_casteljau_surf(GLfloat *cn, GLfloat *out, GLfloat *du, GLfloat *dv, GLfloat u, GLfloat v, GLuint dim, GLuint uorder, GLuint vorder)
Definition: eval.c:258
static void horner_bezier_surf(GLfloat *cn, GLfloat *out, GLfloat u, GLfloat v, GLuint dim, GLuint uorder, GLuint vorder)
Definition: eval.c:176
const GLdouble * v
Definition: gl.h:2040
#define NORMALIZE_3FV(V)
Definition: mmath.h:68

Referenced by execute_list(), gl_EvalMesh2(), gl_EvalPoint2(), and init_exec_pointers().

◆ gl_EvalMesh1()

void gl_EvalMesh1 ( GLcontext ctx,
GLenum  mode,
GLint  i1,
GLint  i2 
)

Definition at line 2330 of file eval.c.

2331{
2332 GLint i;
2333 GLfloat u, du;
2334 GLenum prim;
2335
2336 if (INSIDE_BEGIN_END(ctx)) {
2337 gl_error( ctx, GL_INVALID_OPERATION, "glEvalMesh1" );
2338 return;
2339 }
2340
2341 switch (mode) {
2342 case GL_POINT:
2343 prim = GL_POINTS;
2344 break;
2345 case GL_LINE:
2347 break;
2348 default:
2349 gl_error( ctx, GL_INVALID_ENUM, "glEvalMesh1(mode)" );
2350 return;
2351 }
2352
2353 du = (ctx->Eval.MapGrid1u2 - ctx->Eval.MapGrid1u1)
2354 / (GLfloat) ctx->Eval.MapGrid1un;
2355
2356 gl_Begin( ctx, prim );
2357 for (i=i1;i<=i2;i++) {
2358 if (i==0) {
2359 u = ctx->Eval.MapGrid1u1;
2360 }
2361 else if (i==ctx->Eval.MapGrid1un) {
2362 u = ctx->Eval.MapGrid1u2;
2363 }
2364 else {
2365 u = i * du + ctx->Eval.MapGrid1u1;
2366 }
2367 gl_EvalCoord1f( ctx, u );
2368 }
2369 gl_End(ctx);
2370}
void gl_error(GLcontext *ctx, GLenum error, const char *s)
Definition: context.c:1421
void gl_EvalCoord1f(GLcontext *ctx, GLfloat u)
Definition: eval.c:1978
#define GL_POINT
Definition: gl.h:265
#define GL_LINE_STRIP
Definition: gl.h:193
#define GL_INVALID_OPERATION
Definition: gl.h:696
unsigned int GLenum
Definition: gl.h:150
#define GL_POINTS
Definition: gl.h:190
#define GL_LINE
Definition: gl.h:266
#define GL_INVALID_ENUM
Definition: gl.h:694
GLenum mode
Definition: glext.h:6217
#define INSIDE_BEGIN_END(CTX)
Definition: macros.h:135
LOCAL int prim(arg_t *ap)
Definition: match.c:440
void gl_End(GLcontext *ctx)
Definition: vbfill.c:1424
void gl_Begin(GLcontext *ctx, GLenum p)
Definition: vbfill.c:1341

Referenced by execute_list(), and init_exec_pointers().

◆ gl_EvalMesh2()

void gl_EvalMesh2 ( GLcontext ctx,
GLenum  mode,
GLint  i1,
GLint  i2,
GLint  j1,
GLint  j2 
)

Definition at line 2374 of file eval.c.

2375{
2376 GLint i, j;
2377 GLfloat u, du, v, dv, v1, v2;
2378
2379 if (INSIDE_BEGIN_END(ctx)) {
2380 gl_error( ctx, GL_INVALID_OPERATION, "glEvalMesh2" );
2381 return;
2382 }
2383
2384 du = (ctx->Eval.MapGrid2u2 - ctx->Eval.MapGrid2u1)
2385 / (GLfloat) ctx->Eval.MapGrid2un;
2386 dv = (ctx->Eval.MapGrid2v2 - ctx->Eval.MapGrid2v1)
2387 / (GLfloat) ctx->Eval.MapGrid2vn;
2388
2389#define I_TO_U( I, U ) \
2390 if ((I)==0) { \
2391 U = ctx->Eval.MapGrid2u1; \
2392 } \
2393 else if ((I)==ctx->Eval.MapGrid2un) { \
2394 U = ctx->Eval.MapGrid2u2; \
2395 } \
2396 else { \
2397 U = (I) * du + ctx->Eval.MapGrid2u1;\
2398 }
2399
2400#define J_TO_V( J, V ) \
2401 if ((J)==0) { \
2402 V = ctx->Eval.MapGrid2v1; \
2403 } \
2404 else if ((J)==ctx->Eval.MapGrid2vn) { \
2405 V = ctx->Eval.MapGrid2v2; \
2406 } \
2407 else { \
2408 V = (J) * dv + ctx->Eval.MapGrid2v1;\
2409 }
2410
2411 switch (mode) {
2412 case GL_POINT:
2414 for (j=j1;j<=j2;j++) {
2415 J_TO_V( j, v );
2416 for (i=i1;i<=i2;i++) {
2417 I_TO_U( i, u );
2418 gl_EvalCoord2f( ctx, u, v );
2419 }
2420 }
2421 gl_End(ctx);
2422 break;
2423 case GL_LINE:
2424 for (j=j1;j<=j2;j++) {
2425 J_TO_V( j, v );
2427 for (i=i1;i<=i2;i++) {
2428 I_TO_U( i, u );
2429 gl_EvalCoord2f( ctx, u, v );
2430 }
2431 gl_End(ctx);
2432 }
2433 for (i=i1;i<=i2;i++) {
2434 I_TO_U( i, u );
2436 for (j=j1;j<=j2;j++) {
2437 J_TO_V( j, v );
2438 gl_EvalCoord2f( ctx, u, v );
2439 }
2440 gl_End(ctx);
2441 }
2442 break;
2443 case GL_FILL:
2444 for (j=j1;j<j2;j++) {
2445 /* NOTE: a quad strip can't be used because the four */
2446 /* can't be guaranteed to be coplanar! */
2448 J_TO_V( j, v1 );
2449 J_TO_V( j+1, v2 );
2450 for (i=i1;i<=i2;i++) {
2451 I_TO_U( i, u );
2452 gl_EvalCoord2f( ctx, u, v1 );
2453 gl_EvalCoord2f( ctx, u, v2 );
2454 }
2455 gl_End(ctx);
2456 }
2457 break;
2458 default:
2459 gl_error( ctx, GL_INVALID_ENUM, "glEvalMesh2(mode)" );
2460 return;
2461 }
2462
2463#undef I_TO_U
2464#undef J_TO_V
2465}
#define I_TO_U(I, U)
#define J_TO_V(J, V)
void gl_EvalCoord2f(GLcontext *ctx, GLfloat u, GLfloat v)
Definition: eval.c:2084
#define GL_FILL
Definition: gl.h:267
#define GL_TRIANGLE_STRIP
Definition: gl.h:195
GLfloat GLfloat v1
Definition: glext.h:6062
GLfloat GLfloat GLfloat v2
Definition: glext.h:6063

Referenced by execute_list(), and init_exec_pointers().

◆ gl_EvalPoint1()

void gl_EvalPoint1 ( GLcontext ctx,
GLint  i 
)

Definition at line 2276 of file eval.c.

2277{
2278 GLfloat u, du;
2279
2280 if (i==0) {
2281 u = ctx->Eval.MapGrid1u1;
2282 }
2283 else if (i==ctx->Eval.MapGrid1un) {
2284 u = ctx->Eval.MapGrid1u2;
2285 }
2286 else {
2287 du = (ctx->Eval.MapGrid1u2 - ctx->Eval.MapGrid1u1)
2288 / (GLfloat) ctx->Eval.MapGrid1un;
2289 u = i * du + ctx->Eval.MapGrid1u1;
2290 }
2291 gl_EvalCoord1f( ctx, u );
2292}

Referenced by execute_list(), and init_exec_pointers().

◆ gl_EvalPoint2()

void gl_EvalPoint2 ( GLcontext ctx,
GLint  i,
GLint  j 
)

Definition at line 2296 of file eval.c.

2297{
2298 GLfloat u, du;
2299 GLfloat v, dv;
2300
2301 if (i==0) {
2302 u = ctx->Eval.MapGrid2u1;
2303 }
2304 else if (i==ctx->Eval.MapGrid2un) {
2305 u = ctx->Eval.MapGrid2u2;
2306 }
2307 else {
2308 du = (ctx->Eval.MapGrid2u2 - ctx->Eval.MapGrid2u1)
2309 / (GLfloat) ctx->Eval.MapGrid2un;
2310 u = i * du + ctx->Eval.MapGrid2u1;
2311 }
2312
2313 if (j==0) {
2314 v = ctx->Eval.MapGrid2v1;
2315 }
2316 else if (j==ctx->Eval.MapGrid2vn) {
2317 v = ctx->Eval.MapGrid2v2;
2318 }
2319 else {
2320 dv = (ctx->Eval.MapGrid2v2 - ctx->Eval.MapGrid2v1)
2321 / (GLfloat) ctx->Eval.MapGrid2vn;
2322 v = j * dv + ctx->Eval.MapGrid2v1;
2323 }
2324
2325 gl_EvalCoord2f( ctx, u, v );
2326}

Referenced by execute_list(), and init_exec_pointers().

◆ gl_free_control_points()

void gl_free_control_points ( GLcontext ctx,
GLenum  target,
GLfloat data 
)

Definition at line 732 of file eval.c.

733{
734 struct gl_1d_map *map1 = NULL;
735 struct gl_2d_map *map2 = NULL;
736
737 switch (target) {
738 case GL_MAP1_VERTEX_3:
739 map1 = &ctx->EvalMap.Map1Vertex3;
740 break;
741 case GL_MAP1_VERTEX_4:
742 map1 = &ctx->EvalMap.Map1Vertex4;
743 break;
744 case GL_MAP1_INDEX:
745 map1 = &ctx->EvalMap.Map1Index;
746 break;
747 case GL_MAP1_COLOR_4:
748 map1 = &ctx->EvalMap.Map1Color4;
749 break;
750 case GL_MAP1_NORMAL:
751 map1 = &ctx->EvalMap.Map1Normal;
752 break;
754 map1 = &ctx->EvalMap.Map1Texture1;
755 break;
757 map1 = &ctx->EvalMap.Map1Texture2;
758 break;
760 map1 = &ctx->EvalMap.Map1Texture3;
761 break;
763 map1 = &ctx->EvalMap.Map1Texture4;
764 break;
765 case GL_MAP2_VERTEX_3:
766 map2 = &ctx->EvalMap.Map2Vertex3;
767 break;
768 case GL_MAP2_VERTEX_4:
769 map2 = &ctx->EvalMap.Map2Vertex4;
770 break;
771 case GL_MAP2_INDEX:
772 map2 = &ctx->EvalMap.Map2Index;
773 break;
774 case GL_MAP2_COLOR_4:
775 map2 = &ctx->EvalMap.Map2Color4;
776 break;
777 case GL_MAP2_NORMAL:
778 map2 = &ctx->EvalMap.Map2Normal;
779 break;
781 map2 = &ctx->EvalMap.Map2Texture1;
782 break;
784 map2 = &ctx->EvalMap.Map2Texture2;
785 break;
787 map2 = &ctx->EvalMap.Map2Texture3;
788 break;
790 map2 = &ctx->EvalMap.Map2Texture4;
791 break;
792 default:
793 gl_error( ctx, GL_INVALID_ENUM, "gl_free_control_points" );
794 return;
795 }
796
797 if (map1) {
798 if (data==map1->Points) {
799 /* The control points in the display list are currently */
800 /* being used so we can mark them as discard-able. */
801 map1->Retain = GL_FALSE;
802 }
803 else {
804 /* The control points in the display list are not currently */
805 /* being used. */
806 free( data );
807 }
808 }
809 if (map2) {
810 if (data==map2->Points) {
811 /* The control points in the display list are currently */
812 /* being used so we can mark them as discard-able. */
813 map2->Retain = GL_FALSE;
814 }
815 else {
816 /* The control points in the display list are not currently */
817 /* being used. */
818 free( data );
819 }
820 }
821
822}
#define free
Definition: debug_ros.c:5
#define GL_MAP2_NORMAL
Definition: gl.h:562
#define GL_MAP1_TEXTURE_COORD_3
Definition: gl.h:556
#define GL_MAP2_INDEX
Definition: gl.h:561
#define GL_MAP2_TEXTURE_COORD_2
Definition: gl.h:564
#define GL_MAP1_VERTEX_3
Definition: gl.h:558
#define GL_MAP1_TEXTURE_COORD_2
Definition: gl.h:555
#define GL_MAP2_TEXTURE_COORD_4
Definition: gl.h:566
#define GL_MAP2_COLOR_4
Definition: gl.h:560
#define GL_MAP1_TEXTURE_COORD_1
Definition: gl.h:554
#define GL_MAP2_VERTEX_4
Definition: gl.h:568
#define GL_MAP1_INDEX
Definition: gl.h:552
#define GL_MAP2_VERTEX_3
Definition: gl.h:567
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
#define GL_MAP1_TEXTURE_COORD_4
Definition: gl.h:557
#define GL_MAP1_COLOR_4
Definition: gl.h:551
#define GL_FALSE
Definition: gl.h:173
#define GL_MAP2_TEXTURE_COORD_1
Definition: gl.h:563
#define GL_MAP2_TEXTURE_COORD_3
Definition: gl.h:565
#define GL_MAP1_NORMAL
Definition: gl.h:553
#define GL_MAP1_VERTEX_4
Definition: gl.h:559
GLfloat * Points
Definition: types.h:1040
GLboolean Retain
Definition: types.h:1041
GLboolean Retain
Definition: types.h:1054
GLfloat * Points
Definition: types.h:1053

Referenced by gl_destroy_list().

◆ gl_GetMapdv()

void gl_GetMapdv ( GLcontext ctx,
GLenum  target,
GLenum  query,
GLdouble v 
)

Definition at line 1170 of file eval.c.

1171{
1172 GLuint i, n;
1173 GLfloat *data;
1174
1175 switch (query) {
1176 case GL_COEFF:
1177 switch (target) {
1178 case GL_MAP1_COLOR_4:
1179 data = ctx->EvalMap.Map1Color4.Points;
1180 n = ctx->EvalMap.Map1Color4.Order * 4;
1181 break;
1182 case GL_MAP1_INDEX:
1183 data = ctx->EvalMap.Map1Index.Points;
1184 n = ctx->EvalMap.Map1Index.Order;
1185 break;
1186 case GL_MAP1_NORMAL:
1187 data = ctx->EvalMap.Map1Normal.Points;
1188 n = ctx->EvalMap.Map1Normal.Order * 3;
1189 break;
1191 data = ctx->EvalMap.Map1Texture1.Points;
1192 n = ctx->EvalMap.Map1Texture1.Order * 1;
1193 break;
1195 data = ctx->EvalMap.Map1Texture2.Points;
1196 n = ctx->EvalMap.Map1Texture2.Order * 2;
1197 break;
1199 data = ctx->EvalMap.Map1Texture3.Points;
1200 n = ctx->EvalMap.Map1Texture3.Order * 3;
1201 break;
1203 data = ctx->EvalMap.Map1Texture4.Points;
1204 n = ctx->EvalMap.Map1Texture4.Order * 4;
1205 break;
1206 case GL_MAP1_VERTEX_3:
1207 data = ctx->EvalMap.Map1Vertex3.Points;
1208 n = ctx->EvalMap.Map1Vertex3.Order * 3;
1209 break;
1210 case GL_MAP1_VERTEX_4:
1211 data = ctx->EvalMap.Map1Vertex4.Points;
1212 n = ctx->EvalMap.Map1Vertex4.Order * 4;
1213 break;
1214 case GL_MAP2_COLOR_4:
1215 data = ctx->EvalMap.Map2Color4.Points;
1216 n = ctx->EvalMap.Map2Color4.Uorder
1217 * ctx->EvalMap.Map2Color4.Vorder * 4;
1218 break;
1219 case GL_MAP2_INDEX:
1220 data = ctx->EvalMap.Map2Index.Points;
1221 n = ctx->EvalMap.Map2Index.Uorder
1222 * ctx->EvalMap.Map2Index.Vorder;
1223 break;
1224 case GL_MAP2_NORMAL:
1225 data = ctx->EvalMap.Map2Normal.Points;
1226 n = ctx->EvalMap.Map2Normal.Uorder
1227 * ctx->EvalMap.Map2Normal.Vorder * 3;
1228 break;
1230 data = ctx->EvalMap.Map2Texture1.Points;
1231 n = ctx->EvalMap.Map2Texture1.Uorder
1232 * ctx->EvalMap.Map2Texture1.Vorder * 1;
1233 break;
1235 data = ctx->EvalMap.Map2Texture2.Points;
1236 n = ctx->EvalMap.Map2Texture2.Uorder
1237 * ctx->EvalMap.Map2Texture2.Vorder * 2;
1238 break;
1240 data = ctx->EvalMap.Map2Texture3.Points;
1241 n = ctx->EvalMap.Map2Texture3.Uorder
1242 * ctx->EvalMap.Map2Texture3.Vorder * 3;
1243 break;
1245 data = ctx->EvalMap.Map2Texture4.Points;
1246 n = ctx->EvalMap.Map2Texture4.Uorder
1247 * ctx->EvalMap.Map2Texture4.Vorder * 4;
1248 break;
1249 case GL_MAP2_VERTEX_3:
1250 data = ctx->EvalMap.Map2Vertex3.Points;
1251 n = ctx->EvalMap.Map2Vertex3.Uorder
1252 * ctx->EvalMap.Map2Vertex3.Vorder * 3;
1253 break;
1254 case GL_MAP2_VERTEX_4:
1255 data = ctx->EvalMap.Map2Vertex4.Points;
1256 n = ctx->EvalMap.Map2Vertex4.Uorder
1257 * ctx->EvalMap.Map2Vertex4.Vorder * 4;
1258 break;
1259 default:
1260 gl_error( ctx, GL_INVALID_ENUM, "glGetMapdv(target)" );
1261 }
1262 if (data) {
1263 for (i=0;i<n;i++) {
1264 v[i] = data[i];
1265 }
1266 }
1267 break;
1268 case GL_ORDER:
1269 switch (target) {
1270 case GL_MAP1_COLOR_4:
1271 *v = ctx->EvalMap.Map1Color4.Order;
1272 break;
1273 case GL_MAP1_INDEX:
1274 *v = ctx->EvalMap.Map1Index.Order;
1275 break;
1276 case GL_MAP1_NORMAL:
1277 *v = ctx->EvalMap.Map1Normal.Order;
1278 break;
1280 *v = ctx->EvalMap.Map1Texture1.Order;
1281 break;
1283 *v = ctx->EvalMap.Map1Texture2.Order;
1284 break;
1286 *v = ctx->EvalMap.Map1Texture3.Order;
1287 break;
1289 *v = ctx->EvalMap.Map1Texture4.Order;
1290 break;
1291 case GL_MAP1_VERTEX_3:
1292 *v = ctx->EvalMap.Map1Vertex3.Order;
1293 break;
1294 case GL_MAP1_VERTEX_4:
1295 *v = ctx->EvalMap.Map1Vertex4.Order;
1296 break;
1297 case GL_MAP2_COLOR_4:
1298 v[0] = ctx->EvalMap.Map2Color4.Uorder;
1299 v[1] = ctx->EvalMap.Map2Color4.Vorder;
1300 break;
1301 case GL_MAP2_INDEX:
1302 v[0] = ctx->EvalMap.Map2Index.Uorder;
1303 v[1] = ctx->EvalMap.Map2Index.Vorder;
1304 break;
1305 case GL_MAP2_NORMAL:
1306 v[0] = ctx->EvalMap.Map2Normal.Uorder;
1307 v[1] = ctx->EvalMap.Map2Normal.Vorder;
1308 break;
1310 v[0] = ctx->EvalMap.Map2Texture1.Uorder;
1311 v[1] = ctx->EvalMap.Map2Texture1.Vorder;
1312 break;
1314 v[0] = ctx->EvalMap.Map2Texture2.Uorder;
1315 v[1] = ctx->EvalMap.Map2Texture2.Vorder;
1316 break;
1318 v[0] = ctx->EvalMap.Map2Texture3.Uorder;
1319 v[1] = ctx->EvalMap.Map2Texture3.Vorder;
1320 break;
1322 v[0] = ctx->EvalMap.Map2Texture4.Uorder;
1323 v[1] = ctx->EvalMap.Map2Texture4.Vorder;
1324 break;
1325 case GL_MAP2_VERTEX_3:
1326 v[0] = ctx->EvalMap.Map2Vertex3.Uorder;
1327 v[1] = ctx->EvalMap.Map2Vertex3.Vorder;
1328 break;
1329 case GL_MAP2_VERTEX_4:
1330 v[0] = ctx->EvalMap.Map2Vertex4.Uorder;
1331 v[1] = ctx->EvalMap.Map2Vertex4.Vorder;
1332 break;
1333 default:
1334 gl_error( ctx, GL_INVALID_ENUM, "glGetMapdv(target)" );
1335 }
1336 break;
1337 case GL_DOMAIN:
1338 switch (target) {
1339 case GL_MAP1_COLOR_4:
1340 v[0] = ctx->EvalMap.Map1Color4.u1;
1341 v[1] = ctx->EvalMap.Map1Color4.u2;
1342 break;
1343 case GL_MAP1_INDEX:
1344 v[0] = ctx->EvalMap.Map1Index.u1;
1345 v[1] = ctx->EvalMap.Map1Index.u2;
1346 break;
1347 case GL_MAP1_NORMAL:
1348 v[0] = ctx->EvalMap.Map1Normal.u1;
1349 v[1] = ctx->EvalMap.Map1Normal.u2;
1350 break;
1352 v[0] = ctx->EvalMap.Map1Texture1.u1;
1353 v[1] = ctx->EvalMap.Map1Texture1.u2;
1354 break;
1356 v[0] = ctx->EvalMap.Map1Texture2.u1;
1357 v[1] = ctx->EvalMap.Map1Texture2.u2;
1358 break;
1360 v[0] = ctx->EvalMap.Map1Texture3.u1;
1361 v[1] = ctx->EvalMap.Map1Texture3.u2;
1362 break;
1364 v[0] = ctx->EvalMap.Map1Texture4.u1;
1365 v[1] = ctx->EvalMap.Map1Texture4.u2;
1366 break;
1367 case GL_MAP1_VERTEX_3:
1368 v[0] = ctx->EvalMap.Map1Vertex3.u1;
1369 v[1] = ctx->EvalMap.Map1Vertex3.u2;
1370 break;
1371 case GL_MAP1_VERTEX_4:
1372 v[0] = ctx->EvalMap.Map1Vertex4.u1;
1373 v[1] = ctx->EvalMap.Map1Vertex4.u2;
1374 break;
1375 case GL_MAP2_COLOR_4:
1376 v[0] = ctx->EvalMap.Map2Color4.u1;
1377 v[1] = ctx->EvalMap.Map2Color4.u2;
1378 v[2] = ctx->EvalMap.Map2Color4.v1;
1379 v[3] = ctx->EvalMap.Map2Color4.v2;
1380 break;
1381 case GL_MAP2_INDEX:
1382 v[0] = ctx->EvalMap.Map2Index.u1;
1383 v[1] = ctx->EvalMap.Map2Index.u2;
1384 v[2] = ctx->EvalMap.Map2Index.v1;
1385 v[3] = ctx->EvalMap.Map2Index.v2;
1386 break;
1387 case GL_MAP2_NORMAL:
1388 v[0] = ctx->EvalMap.Map2Normal.u1;
1389 v[1] = ctx->EvalMap.Map2Normal.u2;
1390 v[2] = ctx->EvalMap.Map2Normal.v1;
1391 v[3] = ctx->EvalMap.Map2Normal.v2;
1392 break;
1394 v[0] = ctx->EvalMap.Map2Texture1.u1;
1395 v[1] = ctx->EvalMap.Map2Texture1.u2;
1396 v[2] = ctx->EvalMap.Map2Texture1.v1;
1397 v[3] = ctx->EvalMap.Map2Texture1.v2;
1398 break;
1400 v[0] = ctx->EvalMap.Map2Texture2.u1;
1401 v[1] = ctx->EvalMap.Map2Texture2.u2;
1402 v[2] = ctx->EvalMap.Map2Texture2.v1;
1403 v[3] = ctx->EvalMap.Map2Texture2.v2;
1404 break;
1406 v[0] = ctx->EvalMap.Map2Texture3.u1;
1407 v[1] = ctx->EvalMap.Map2Texture3.u2;
1408 v[2] = ctx->EvalMap.Map2Texture3.v1;
1409 v[3] = ctx->EvalMap.Map2Texture3.v2;
1410 break;
1412 v[0] = ctx->EvalMap.Map2Texture4.u1;
1413 v[1] = ctx->EvalMap.Map2Texture4.u2;
1414 v[2] = ctx->EvalMap.Map2Texture4.v1;
1415 v[3] = ctx->EvalMap.Map2Texture4.v2;
1416 break;
1417 case GL_MAP2_VERTEX_3:
1418 v[0] = ctx->EvalMap.Map2Vertex3.u1;
1419 v[1] = ctx->EvalMap.Map2Vertex3.u2;
1420 v[2] = ctx->EvalMap.Map2Vertex3.v1;
1421 v[3] = ctx->EvalMap.Map2Vertex3.v2;
1422 break;
1423 case GL_MAP2_VERTEX_4:
1424 v[0] = ctx->EvalMap.Map2Vertex4.u1;
1425 v[1] = ctx->EvalMap.Map2Vertex4.u2;
1426 v[2] = ctx->EvalMap.Map2Vertex4.v1;
1427 v[3] = ctx->EvalMap.Map2Vertex4.v2;
1428 break;
1429 default:
1430 gl_error( ctx, GL_INVALID_ENUM, "glGetMapdv(target)" );
1431 }
1432 break;
1433 default:
1434 gl_error( ctx, GL_INVALID_ENUM, "glGetMapdv(query)" );
1435 }
1436}
#define GL_ORDER
Definition: gl.h:574
#define GL_DOMAIN
Definition: gl.h:575
#define GL_COEFF
Definition: gl.h:573
GLdouble n
Definition: glext.h:7729

Referenced by init_dlist_pointers(), and init_exec_pointers().

◆ gl_GetMapfv()

void gl_GetMapfv ( GLcontext ctx,
GLenum  target,
GLenum  query,
GLfloat v 
)

Definition at line 1439 of file eval.c.

1440{
1441 GLuint i, n;
1442 GLfloat *data;
1443
1444 switch (query) {
1445 case GL_COEFF:
1446 switch (target) {
1447 case GL_MAP1_COLOR_4:
1448 data = ctx->EvalMap.Map1Color4.Points;
1449 n = ctx->EvalMap.Map1Color4.Order * 4;
1450 break;
1451 case GL_MAP1_INDEX:
1452 data = ctx->EvalMap.Map1Index.Points;
1453 n = ctx->EvalMap.Map1Index.Order;
1454 break;
1455 case GL_MAP1_NORMAL:
1456 data = ctx->EvalMap.Map1Normal.Points;
1457 n = ctx->EvalMap.Map1Normal.Order * 3;
1458 break;
1460 data = ctx->EvalMap.Map1Texture1.Points;
1461 n = ctx->EvalMap.Map1Texture1.Order * 1;
1462 break;
1464 data = ctx->EvalMap.Map1Texture2.Points;
1465 n = ctx->EvalMap.Map1Texture2.Order * 2;
1466 break;
1468 data = ctx->EvalMap.Map1Texture3.Points;
1469 n = ctx->EvalMap.Map1Texture3.Order * 3;
1470 break;
1472 data = ctx->EvalMap.Map1Texture4.Points;
1473 n = ctx->EvalMap.Map1Texture4.Order * 4;
1474 break;
1475 case GL_MAP1_VERTEX_3:
1476 data = ctx->EvalMap.Map1Vertex3.Points;
1477 n = ctx->EvalMap.Map1Vertex3.Order * 3;
1478 break;
1479 case GL_MAP1_VERTEX_4:
1480 data = ctx->EvalMap.Map1Vertex4.Points;
1481 n = ctx->EvalMap.Map1Vertex4.Order * 4;
1482 break;
1483 case GL_MAP2_COLOR_4:
1484 data = ctx->EvalMap.Map2Color4.Points;
1485 n = ctx->EvalMap.Map2Color4.Uorder
1486 * ctx->EvalMap.Map2Color4.Vorder * 4;
1487 break;
1488 case GL_MAP2_INDEX:
1489 data = ctx->EvalMap.Map2Index.Points;
1490 n = ctx->EvalMap.Map2Index.Uorder
1491 * ctx->EvalMap.Map2Index.Vorder;
1492 break;
1493 case GL_MAP2_NORMAL:
1494 data = ctx->EvalMap.Map2Normal.Points;
1495 n = ctx->EvalMap.Map2Normal.Uorder
1496 * ctx->EvalMap.Map2Normal.Vorder * 3;
1497 break;
1499 data = ctx->EvalMap.Map2Texture1.Points;
1500 n = ctx->EvalMap.Map2Texture1.Uorder
1501 * ctx->EvalMap.Map2Texture1.Vorder * 1;
1502 break;
1504 data = ctx->EvalMap.Map2Texture2.Points;
1505 n = ctx->EvalMap.Map2Texture2.Uorder
1506 * ctx->EvalMap.Map2Texture2.Vorder * 2;
1507 break;
1509 data = ctx->EvalMap.Map2Texture3.Points;
1510 n = ctx->EvalMap.Map2Texture3.Uorder
1511 * ctx->EvalMap.Map2Texture3.Vorder * 3;
1512 break;
1514 data = ctx->EvalMap.Map2Texture4.Points;
1515 n = ctx->EvalMap.Map2Texture4.Uorder
1516 * ctx->EvalMap.Map2Texture4.Vorder * 4;
1517 break;
1518 case GL_MAP2_VERTEX_3:
1519 data = ctx->EvalMap.Map2Vertex3.Points;
1520 n = ctx->EvalMap.Map2Vertex3.Uorder
1521 * ctx->EvalMap.Map2Vertex3.Vorder * 3;
1522 break;
1523 case GL_MAP2_VERTEX_4:
1524 data = ctx->EvalMap.Map2Vertex4.Points;
1525 n = ctx->EvalMap.Map2Vertex4.Uorder
1526 * ctx->EvalMap.Map2Vertex4.Vorder * 4;
1527 break;
1528 default:
1529 gl_error( ctx, GL_INVALID_ENUM, "glGetMapfv(target)" );
1530 }
1531 if (data) {
1532 for (i=0;i<n;i++) {
1533 v[i] = data[i];
1534 }
1535 }
1536 break;
1537 case GL_ORDER:
1538 switch (target) {
1539 case GL_MAP1_COLOR_4:
1540 *v = ctx->EvalMap.Map1Color4.Order;
1541 break;
1542 case GL_MAP1_INDEX:
1543 *v = ctx->EvalMap.Map1Index.Order;
1544 break;
1545 case GL_MAP1_NORMAL:
1546 *v = ctx->EvalMap.Map1Normal.Order;
1547 break;
1549 *v = ctx->EvalMap.Map1Texture1.Order;
1550 break;
1552 *v = ctx->EvalMap.Map1Texture2.Order;
1553 break;
1555 *v = ctx->EvalMap.Map1Texture3.Order;
1556 break;
1558 *v = ctx->EvalMap.Map1Texture4.Order;
1559 break;
1560 case GL_MAP1_VERTEX_3:
1561 *v = ctx->EvalMap.Map1Vertex3.Order;
1562 break;
1563 case GL_MAP1_VERTEX_4:
1564 *v = ctx->EvalMap.Map1Vertex4.Order;
1565 break;
1566 case GL_MAP2_COLOR_4:
1567 v[0] = ctx->EvalMap.Map2Color4.Uorder;
1568 v[1] = ctx->EvalMap.Map2Color4.Vorder;
1569 break;
1570 case GL_MAP2_INDEX:
1571 v[0] = ctx->EvalMap.Map2Index.Uorder;
1572 v[1] = ctx->EvalMap.Map2Index.Vorder;
1573 break;
1574 case GL_MAP2_NORMAL:
1575 v[0] = ctx->EvalMap.Map2Normal.Uorder;
1576 v[1] = ctx->EvalMap.Map2Normal.Vorder;
1577 break;
1579 v[0] = ctx->EvalMap.Map2Texture1.Uorder;
1580 v[1] = ctx->EvalMap.Map2Texture1.Vorder;
1581 break;
1583 v[0] = ctx->EvalMap.Map2Texture2.Uorder;
1584 v[1] = ctx->EvalMap.Map2Texture2.Vorder;
1585 break;
1587 v[0] = ctx->EvalMap.Map2Texture3.Uorder;
1588 v[1] = ctx->EvalMap.Map2Texture3.Vorder;
1589 break;
1591 v[0] = ctx->EvalMap.Map2Texture4.Uorder;
1592 v[1] = ctx->EvalMap.Map2Texture4.Vorder;
1593 break;
1594 case GL_MAP2_VERTEX_3:
1595 v[0] = ctx->EvalMap.Map2Vertex3.Uorder;
1596 v[1] = ctx->EvalMap.Map2Vertex3.Vorder;
1597 break;
1598 case GL_MAP2_VERTEX_4:
1599 v[0] = ctx->EvalMap.Map2Vertex4.Uorder;
1600 v[1] = ctx->EvalMap.Map2Vertex4.Vorder;
1601 break;
1602 default:
1603 gl_error( ctx, GL_INVALID_ENUM, "glGetMapfv(target)" );
1604 }
1605 break;
1606 case GL_DOMAIN:
1607 switch (target) {
1608 case GL_MAP1_COLOR_4:
1609 v[0] = ctx->EvalMap.Map1Color4.u1;
1610 v[1] = ctx->EvalMap.Map1Color4.u2;
1611 break;
1612 case GL_MAP1_INDEX:
1613 v[0] = ctx->EvalMap.Map1Index.u1;
1614 v[1] = ctx->EvalMap.Map1Index.u2;
1615 break;
1616 case GL_MAP1_NORMAL:
1617 v[0] = ctx->EvalMap.Map1Normal.u1;
1618 v[1] = ctx->EvalMap.Map1Normal.u2;
1619 break;
1621 v[0] = ctx->EvalMap.Map1Texture1.u1;
1622 v[1] = ctx->EvalMap.Map1Texture1.u2;
1623 break;
1625 v[0] = ctx->EvalMap.Map1Texture2.u1;
1626 v[1] = ctx->EvalMap.Map1Texture2.u2;
1627 break;
1629 v[0] = ctx->EvalMap.Map1Texture3.u1;
1630 v[1] = ctx->EvalMap.Map1Texture3.u2;
1631 break;
1633 v[0] = ctx->EvalMap.Map1Texture4.u1;
1634 v[1] = ctx->EvalMap.Map1Texture4.u2;
1635 break;
1636 case GL_MAP1_VERTEX_3:
1637 v[0] = ctx->EvalMap.Map1Vertex3.u1;
1638 v[1] = ctx->EvalMap.Map1Vertex3.u2;
1639 break;
1640 case GL_MAP1_VERTEX_4:
1641 v[0] = ctx->EvalMap.Map1Vertex4.u1;
1642 v[1] = ctx->EvalMap.Map1Vertex4.u2;
1643 break;
1644 case GL_MAP2_COLOR_4:
1645 v[0] = ctx->EvalMap.Map2Color4.u1;
1646 v[1] = ctx->EvalMap.Map2Color4.u2;
1647 v[2] = ctx->EvalMap.Map2Color4.v1;
1648 v[3] = ctx->EvalMap.Map2Color4.v2;
1649 break;
1650 case GL_MAP2_INDEX:
1651 v[0] = ctx->EvalMap.Map2Index.u1;
1652 v[1] = ctx->EvalMap.Map2Index.u2;
1653 v[2] = ctx->EvalMap.Map2Index.v1;
1654 v[3] = ctx->EvalMap.Map2Index.v2;
1655 break;
1656 case GL_MAP2_NORMAL:
1657 v[0] = ctx->EvalMap.Map2Normal.u1;
1658 v[1] = ctx->EvalMap.Map2Normal.u2;
1659 v[2] = ctx->EvalMap.Map2Normal.v1;
1660 v[3] = ctx->EvalMap.Map2Normal.v2;
1661 break;
1663 v[0] = ctx->EvalMap.Map2Texture1.u1;
1664 v[1] = ctx->EvalMap.Map2Texture1.u2;
1665 v[2] = ctx->EvalMap.Map2Texture1.v1;
1666 v[3] = ctx->EvalMap.Map2Texture1.v2;
1667 break;
1669 v[0] = ctx->EvalMap.Map2Texture2.u1;
1670 v[1] = ctx->EvalMap.Map2Texture2.u2;
1671 v[2] = ctx->EvalMap.Map2Texture2.v1;
1672 v[3] = ctx->EvalMap.Map2Texture2.v2;
1673 break;
1675 v[0] = ctx->EvalMap.Map2Texture3.u1;
1676 v[1] = ctx->EvalMap.Map2Texture3.u2;
1677 v[2] = ctx->EvalMap.Map2Texture3.v1;
1678 v[3] = ctx->EvalMap.Map2Texture3.v2;
1679 break;
1681 v[0] = ctx->EvalMap.Map2Texture4.u1;
1682 v[1] = ctx->EvalMap.Map2Texture4.u2;
1683 v[2] = ctx->EvalMap.Map2Texture4.v1;
1684 v[3] = ctx->EvalMap.Map2Texture4.v2;
1685 break;
1686 case GL_MAP2_VERTEX_3:
1687 v[0] = ctx->EvalMap.Map2Vertex3.u1;
1688 v[1] = ctx->EvalMap.Map2Vertex3.u2;
1689 v[2] = ctx->EvalMap.Map2Vertex3.v1;
1690 v[3] = ctx->EvalMap.Map2Vertex3.v2;
1691 break;
1692 case GL_MAP2_VERTEX_4:
1693 v[0] = ctx->EvalMap.Map2Vertex4.u1;
1694 v[1] = ctx->EvalMap.Map2Vertex4.u2;
1695 v[2] = ctx->EvalMap.Map2Vertex4.v1;
1696 v[3] = ctx->EvalMap.Map2Vertex4.v2;
1697 break;
1698 default:
1699 gl_error( ctx, GL_INVALID_ENUM, "glGetMapfv(target)" );
1700 }
1701 break;
1702 default:
1703 gl_error( ctx, GL_INVALID_ENUM, "glGetMapfv(query)" );
1704 }
1705}

Referenced by init_dlist_pointers(), and init_exec_pointers().

◆ gl_GetMapiv()

void gl_GetMapiv ( GLcontext ctx,
GLenum  target,
GLenum  query,
GLint v 
)

Definition at line 1708 of file eval.c.

1709{
1710 GLuint i, n;
1711 GLfloat *data;
1712
1713 switch (query) {
1714 case GL_COEFF:
1715 switch (target) {
1716 case GL_MAP1_COLOR_4:
1717 data = ctx->EvalMap.Map1Color4.Points;
1718 n = ctx->EvalMap.Map1Color4.Order * 4;
1719 break;
1720 case GL_MAP1_INDEX:
1721 data = ctx->EvalMap.Map1Index.Points;
1722 n = ctx->EvalMap.Map1Index.Order;
1723 break;
1724 case GL_MAP1_NORMAL:
1725 data = ctx->EvalMap.Map1Normal.Points;
1726 n = ctx->EvalMap.Map1Normal.Order * 3;
1727 break;
1729 data = ctx->EvalMap.Map1Texture1.Points;
1730 n = ctx->EvalMap.Map1Texture1.Order * 1;
1731 break;
1733 data = ctx->EvalMap.Map1Texture2.Points;
1734 n = ctx->EvalMap.Map1Texture2.Order * 2;
1735 break;
1737 data = ctx->EvalMap.Map1Texture3.Points;
1738 n = ctx->EvalMap.Map1Texture3.Order * 3;
1739 break;
1741 data = ctx->EvalMap.Map1Texture4.Points;
1742 n = ctx->EvalMap.Map1Texture4.Order * 4;
1743 break;
1744 case GL_MAP1_VERTEX_3:
1745 data = ctx->EvalMap.Map1Vertex3.Points;
1746 n = ctx->EvalMap.Map1Vertex3.Order * 3;
1747 break;
1748 case GL_MAP1_VERTEX_4:
1749 data = ctx->EvalMap.Map1Vertex4.Points;
1750 n = ctx->EvalMap.Map1Vertex4.Order * 4;
1751 break;
1752 case GL_MAP2_COLOR_4:
1753 data = ctx->EvalMap.Map2Color4.Points;
1754 n = ctx->EvalMap.Map2Color4.Uorder
1755 * ctx->EvalMap.Map2Color4.Vorder * 4;
1756 break;
1757 case GL_MAP2_INDEX:
1758 data = ctx->EvalMap.Map2Index.Points;
1759 n = ctx->EvalMap.Map2Index.Uorder
1760 * ctx->EvalMap.Map2Index.Vorder;
1761 break;
1762 case GL_MAP2_NORMAL:
1763 data = ctx->EvalMap.Map2Normal.Points;
1764 n = ctx->EvalMap.Map2Normal.Uorder
1765 * ctx->EvalMap.Map2Normal.Vorder * 3;
1766 break;
1768 data = ctx->EvalMap.Map2Texture1.Points;
1769 n = ctx->EvalMap.Map2Texture1.Uorder
1770 * ctx->EvalMap.Map2Texture1.Vorder * 1;
1771 break;
1773 data = ctx->EvalMap.Map2Texture2.Points;
1774 n = ctx->EvalMap.Map2Texture2.Uorder
1775 * ctx->EvalMap.Map2Texture2.Vorder * 2;
1776 break;
1778 data = ctx->EvalMap.Map2Texture3.Points;
1779 n = ctx->EvalMap.Map2Texture3.Uorder
1780 * ctx->EvalMap.Map2Texture3.Vorder * 3;
1781 break;
1783 data = ctx->EvalMap.Map2Texture4.Points;
1784 n = ctx->EvalMap.Map2Texture4.Uorder
1785 * ctx->EvalMap.Map2Texture4.Vorder * 4;
1786 break;
1787 case GL_MAP2_VERTEX_3:
1788 data = ctx->EvalMap.Map2Vertex3.Points;
1789 n = ctx->EvalMap.Map2Vertex3.Uorder
1790 * ctx->EvalMap.Map2Vertex3.Vorder * 3;
1791 break;
1792 case GL_MAP2_VERTEX_4:
1793 data = ctx->EvalMap.Map2Vertex4.Points;
1794 n = ctx->EvalMap.Map2Vertex4.Uorder
1795 * ctx->EvalMap.Map2Vertex4.Vorder * 4;
1796 break;
1797 default:
1798 gl_error( ctx, GL_INVALID_ENUM, "glGetMapiv(target)" );
1799 }
1800 if (data) {
1801 for (i=0;i<n;i++) {
1802 v[i] = ROUNDF(data[i]);
1803 }
1804 }
1805 break;
1806 case GL_ORDER:
1807 switch (target) {
1808 case GL_MAP1_COLOR_4:
1809 *v = ctx->EvalMap.Map1Color4.Order;
1810 break;
1811 case GL_MAP1_INDEX:
1812 *v = ctx->EvalMap.Map1Index.Order;
1813 break;
1814 case GL_MAP1_NORMAL:
1815 *v = ctx->EvalMap.Map1Normal.Order;
1816 break;
1818 *v = ctx->EvalMap.Map1Texture1.Order;
1819 break;
1821 *v = ctx->EvalMap.Map1Texture2.Order;
1822 break;
1824 *v = ctx->EvalMap.Map1Texture3.Order;
1825 break;
1827 *v = ctx->EvalMap.Map1Texture4.Order;
1828 break;
1829 case GL_MAP1_VERTEX_3:
1830 *v = ctx->EvalMap.Map1Vertex3.Order;
1831 break;
1832 case GL_MAP1_VERTEX_4:
1833 *v = ctx->EvalMap.Map1Vertex4.Order;
1834 break;
1835 case GL_MAP2_COLOR_4:
1836 v[0] = ctx->EvalMap.Map2Color4.Uorder;
1837 v[1] = ctx->EvalMap.Map2Color4.Vorder;
1838 break;
1839 case GL_MAP2_INDEX:
1840 v[0] = ctx->EvalMap.Map2Index.Uorder;
1841 v[1] = ctx->EvalMap.Map2Index.Vorder;
1842 break;
1843 case GL_MAP2_NORMAL:
1844 v[0] = ctx->EvalMap.Map2Normal.Uorder;
1845 v[1] = ctx->EvalMap.Map2Normal.Vorder;
1846 break;
1848 v[0] = ctx->EvalMap.Map2Texture1.Uorder;
1849 v[1] = ctx->EvalMap.Map2Texture1.Vorder;
1850 break;
1852 v[0] = ctx->EvalMap.Map2Texture2.Uorder;
1853 v[1] = ctx->EvalMap.Map2Texture2.Vorder;
1854 break;
1856 v[0] = ctx->EvalMap.Map2Texture3.Uorder;
1857 v[1] = ctx->EvalMap.Map2Texture3.Vorder;
1858 break;
1860 v[0] = ctx->EvalMap.Map2Texture4.Uorder;
1861 v[1] = ctx->EvalMap.Map2Texture4.Vorder;
1862 break;
1863 case GL_MAP2_VERTEX_3:
1864 v[0] = ctx->EvalMap.Map2Vertex3.Uorder;
1865 v[1] = ctx->EvalMap.Map2Vertex3.Vorder;
1866 break;
1867 case GL_MAP2_VERTEX_4:
1868 v[0] = ctx->EvalMap.Map2Vertex4.Uorder;
1869 v[1] = ctx->EvalMap.Map2Vertex4.Vorder;
1870 break;
1871 default:
1872 gl_error( ctx, GL_INVALID_ENUM, "glGetMapiv(target)" );
1873 }
1874 break;
1875 case GL_DOMAIN:
1876 switch (target) {
1877 case GL_MAP1_COLOR_4:
1878 v[0] = ROUNDF(ctx->EvalMap.Map1Color4.u1);
1879 v[1] = ROUNDF(ctx->EvalMap.Map1Color4.u2);
1880 break;
1881 case GL_MAP1_INDEX:
1882 v[0] = ROUNDF(ctx->EvalMap.Map1Index.u1);
1883 v[1] = ROUNDF(ctx->EvalMap.Map1Index.u2);
1884 break;
1885 case GL_MAP1_NORMAL:
1886 v[0] = ROUNDF(ctx->EvalMap.Map1Normal.u1);
1887 v[1] = ROUNDF(ctx->EvalMap.Map1Normal.u2);
1888 break;
1890 v[0] = ROUNDF(ctx->EvalMap.Map1Texture1.u1);
1891 v[1] = ROUNDF(ctx->EvalMap.Map1Texture1.u2);
1892 break;
1894 v[0] = ROUNDF(ctx->EvalMap.Map1Texture2.u1);
1895 v[1] = ROUNDF(ctx->EvalMap.Map1Texture2.u2);
1896 break;
1898 v[0] = ROUNDF(ctx->EvalMap.Map1Texture3.u1);
1899 v[1] = ROUNDF(ctx->EvalMap.Map1Texture3.u2);
1900 break;
1902 v[0] = ROUNDF(ctx->EvalMap.Map1Texture4.u1);
1903 v[1] = ROUNDF(ctx->EvalMap.Map1Texture4.u2);
1904 break;
1905 case GL_MAP1_VERTEX_3:
1906 v[0] = ROUNDF(ctx->EvalMap.Map1Vertex3.u1);
1907 v[1] = ROUNDF(ctx->EvalMap.Map1Vertex3.u2);
1908 break;
1909 case GL_MAP1_VERTEX_4:
1910 v[0] = ROUNDF(ctx->EvalMap.Map1Vertex4.u1);
1911 v[1] = ROUNDF(ctx->EvalMap.Map1Vertex4.u2);
1912 break;
1913 case GL_MAP2_COLOR_4:
1914 v[0] = ROUNDF(ctx->EvalMap.Map2Color4.u1);
1915 v[1] = ROUNDF(ctx->EvalMap.Map2Color4.u2);
1916 v[2] = ROUNDF(ctx->EvalMap.Map2Color4.v1);
1917 v[3] = ROUNDF(ctx->EvalMap.Map2Color4.v2);
1918 break;
1919 case GL_MAP2_INDEX:
1920 v[0] = ROUNDF(ctx->EvalMap.Map2Index.u1);
1921 v[1] = ROUNDF(ctx->EvalMap.Map2Index.u2);
1922 v[2] = ROUNDF(ctx->EvalMap.Map2Index.v1);
1923 v[3] = ROUNDF(ctx->EvalMap.Map2Index.v2);
1924 break;
1925 case GL_MAP2_NORMAL:
1926 v[0] = ROUNDF(ctx->EvalMap.Map2Normal.u1);
1927 v[1] = ROUNDF(ctx->EvalMap.Map2Normal.u2);
1928 v[2] = ROUNDF(ctx->EvalMap.Map2Normal.v1);
1929 v[3] = ROUNDF(ctx->EvalMap.Map2Normal.v2);
1930 break;
1932 v[0] = ROUNDF(ctx->EvalMap.Map2Texture1.u1);
1933 v[1] = ROUNDF(ctx->EvalMap.Map2Texture1.u2);
1934 v[2] = ROUNDF(ctx->EvalMap.Map2Texture1.v1);
1935 v[3] = ROUNDF(ctx->EvalMap.Map2Texture1.v2);
1936 break;
1938 v[0] = ROUNDF(ctx->EvalMap.Map2Texture2.u1);
1939 v[1] = ROUNDF(ctx->EvalMap.Map2Texture2.u2);
1940 v[2] = ROUNDF(ctx->EvalMap.Map2Texture2.v1);
1941 v[3] = ROUNDF(ctx->EvalMap.Map2Texture2.v2);
1942 break;
1944 v[0] = ROUNDF(ctx->EvalMap.Map2Texture3.u1);
1945 v[1] = ROUNDF(ctx->EvalMap.Map2Texture3.u2);
1946 v[2] = ROUNDF(ctx->EvalMap.Map2Texture3.v1);
1947 v[3] = ROUNDF(ctx->EvalMap.Map2Texture3.v2);
1948 break;
1950 v[0] = ROUNDF(ctx->EvalMap.Map2Texture4.u1);
1951 v[1] = ROUNDF(ctx->EvalMap.Map2Texture4.u2);
1952 v[2] = ROUNDF(ctx->EvalMap.Map2Texture4.v1);
1953 v[3] = ROUNDF(ctx->EvalMap.Map2Texture4.v2);
1954 break;
1955 case GL_MAP2_VERTEX_3:
1956 v[0] = ROUNDF(ctx->EvalMap.Map2Vertex3.u1);
1957 v[1] = ROUNDF(ctx->EvalMap.Map2Vertex3.u2);
1958 v[2] = ROUNDF(ctx->EvalMap.Map2Vertex3.v1);
1959 v[3] = ROUNDF(ctx->EvalMap.Map2Vertex3.v2);
1960 break;
1961 case GL_MAP2_VERTEX_4:
1962 v[0] = ROUNDF(ctx->EvalMap.Map2Vertex4.u1);
1963 v[1] = ROUNDF(ctx->EvalMap.Map2Vertex4.u2);
1964 v[2] = ROUNDF(ctx->EvalMap.Map2Vertex4.v1);
1965 v[3] = ROUNDF(ctx->EvalMap.Map2Vertex4.v2);
1966 break;
1967 default:
1968 gl_error( ctx, GL_INVALID_ENUM, "glGetMapiv(target)" );
1969 }
1970 break;
1971 default:
1972 gl_error( ctx, GL_INVALID_ENUM, "glGetMapiv(query)" );
1973 }
1974}
#define ROUNDF(X)
Definition: macros.h:147

Referenced by init_dlist_pointers(), and init_exec_pointers().

◆ gl_init_eval()

void gl_init_eval ( void  )

Definition at line 89 of file eval.c.

90{
91 static int init_flag = 0;
92
93 /* Compute a table of nCr (combination) values used by the
94 * Bernstein polynomial generator.
95 */
96
97 if (init_flag==0)
98 { /* no initialization needed */
99 }
100
101 init_flag = 1;
102}

Referenced by gl_create_context().

◆ gl_Map1f()

void gl_Map1f ( GLcontext ctx,
GLenum  target,
GLfloat  u1,
GLfloat  u2,
GLint  stride,
GLint  order,
const GLfloat points,
GLboolean  retain 
)

Definition at line 836 of file eval.c.

839{
840 GLuint k;
841
842 if (!points) {
843 gl_error( ctx, GL_OUT_OF_MEMORY, "glMap1f" );
844 return;
845 }
846
847 /* may be a new stride after copying control points */
849
850 if (INSIDE_BEGIN_END(ctx)) {
851 gl_error( ctx, GL_INVALID_OPERATION, "glMap1" );
852 return;
853 }
854
855 if (u1==u2) {
856 gl_error( ctx, GL_INVALID_VALUE, "glMap1(u1,u2)" );
857 return;
858 }
859
861 gl_error( ctx, GL_INVALID_VALUE, "glMap1(order)" );
862 return;
863 }
864
865 k = components( target );
866 if (k==0) {
867 gl_error( ctx, GL_INVALID_ENUM, "glMap1(target)" );
868 }
869
870 if (stride < k) {
871 gl_error( ctx, GL_INVALID_VALUE, "glMap1(stride)" );
872 return;
873 }
874
875 switch (target) {
876 case GL_MAP1_VERTEX_3:
877 ctx->EvalMap.Map1Vertex3.Order = order;
878 ctx->EvalMap.Map1Vertex3.u1 = u1;
879 ctx->EvalMap.Map1Vertex3.u2 = u2;
880 if (ctx->EvalMap.Map1Vertex3.Points
881 && !ctx->EvalMap.Map1Vertex3.Retain) {
882 free( ctx->EvalMap.Map1Vertex3.Points );
883 }
884 ctx->EvalMap.Map1Vertex3.Points = (GLfloat *) points;
885 ctx->EvalMap.Map1Vertex3.Retain = retain;
886 break;
887 case GL_MAP1_VERTEX_4:
888 ctx->EvalMap.Map1Vertex4.Order = order;
889 ctx->EvalMap.Map1Vertex4.u1 = u1;
890 ctx->EvalMap.Map1Vertex4.u2 = u2;
891 if (ctx->EvalMap.Map1Vertex4.Points
892 && !ctx->EvalMap.Map1Vertex4.Retain) {
893 free( ctx->EvalMap.Map1Vertex4.Points );
894 }
895 ctx->EvalMap.Map1Vertex4.Points = (GLfloat *) points;
896 ctx->EvalMap.Map1Vertex4.Retain = retain;
897 break;
898 case GL_MAP1_INDEX:
899 ctx->EvalMap.Map1Index.Order = order;
900 ctx->EvalMap.Map1Index.u1 = u1;
901 ctx->EvalMap.Map1Index.u2 = u2;
902 if (ctx->EvalMap.Map1Index.Points
903 && !ctx->EvalMap.Map1Index.Retain) {
904 free( ctx->EvalMap.Map1Index.Points );
905 }
906 ctx->EvalMap.Map1Index.Points = (GLfloat *) points;
907 ctx->EvalMap.Map1Index.Retain = retain;
908 break;
909 case GL_MAP1_COLOR_4:
910 ctx->EvalMap.Map1Color4.Order = order;
911 ctx->EvalMap.Map1Color4.u1 = u1;
912 ctx->EvalMap.Map1Color4.u2 = u2;
913 if (ctx->EvalMap.Map1Color4.Points
914 && !ctx->EvalMap.Map1Color4.Retain) {
915 free( ctx->EvalMap.Map1Color4.Points );
916 }
917 ctx->EvalMap.Map1Color4.Points = (GLfloat *) points;
918 ctx->EvalMap.Map1Color4.Retain = retain;
919 break;
920 case GL_MAP1_NORMAL:
921 ctx->EvalMap.Map1Normal.Order = order;
922 ctx->EvalMap.Map1Normal.u1 = u1;
923 ctx->EvalMap.Map1Normal.u2 = u2;
924 if (ctx->EvalMap.Map1Normal.Points
925 && !ctx->EvalMap.Map1Normal.Retain) {
926 free( ctx->EvalMap.Map1Normal.Points );
927 }
928 ctx->EvalMap.Map1Normal.Points = (GLfloat *) points;
929 ctx->EvalMap.Map1Normal.Retain = retain;
930 break;
932 ctx->EvalMap.Map1Texture1.Order = order;
933 ctx->EvalMap.Map1Texture1.u1 = u1;
934 ctx->EvalMap.Map1Texture1.u2 = u2;
935 if (ctx->EvalMap.Map1Texture1.Points
936 && !ctx->EvalMap.Map1Texture1.Retain) {
937 free( ctx->EvalMap.Map1Texture1.Points );
938 }
939 ctx->EvalMap.Map1Texture1.Points = (GLfloat *) points;
940 ctx->EvalMap.Map1Texture1.Retain = retain;
941 break;
943 ctx->EvalMap.Map1Texture2.Order = order;
944 ctx->EvalMap.Map1Texture2.u1 = u1;
945 ctx->EvalMap.Map1Texture2.u2 = u2;
946 if (ctx->EvalMap.Map1Texture2.Points
947 && !ctx->EvalMap.Map1Texture2.Retain) {
948 free( ctx->EvalMap.Map1Texture2.Points );
949 }
950 ctx->EvalMap.Map1Texture2.Points = (GLfloat *) points;
951 ctx->EvalMap.Map1Texture2.Retain = retain;
952 break;
954 ctx->EvalMap.Map1Texture3.Order = order;
955 ctx->EvalMap.Map1Texture3.u1 = u1;
956 ctx->EvalMap.Map1Texture3.u2 = u2;
957 if (ctx->EvalMap.Map1Texture3.Points
958 && !ctx->EvalMap.Map1Texture3.Retain) {
959 free( ctx->EvalMap.Map1Texture3.Points );
960 }
961 ctx->EvalMap.Map1Texture3.Points = (GLfloat *) points;
962 ctx->EvalMap.Map1Texture3.Retain = retain;
963 break;
965 ctx->EvalMap.Map1Texture4.Order = order;
966 ctx->EvalMap.Map1Texture4.u1 = u1;
967 ctx->EvalMap.Map1Texture4.u2 = u2;
968 if (ctx->EvalMap.Map1Texture4.Points
969 && !ctx->EvalMap.Map1Texture4.Retain) {
970 free( ctx->EvalMap.Map1Texture4.Points );
971 }
972 ctx->EvalMap.Map1Texture4.Points = (GLfloat *) points;
973 ctx->EvalMap.Map1Texture4.Retain = retain;
974 break;
975 default:
976 gl_error( ctx, GL_INVALID_ENUM, "glMap1(target)" );
977 }
978}
#define MAX_EVAL_ORDER
Definition: config.h:105
#define GL_INVALID_VALUE
Definition: gl.h:695
#define GL_OUT_OF_MEMORY
Definition: gl.h:699
GLsizei stride
Definition: glext.h:5848
GLdouble GLdouble u2
Definition: glext.h:8308
GLuint GLdouble GLdouble GLint GLint order
Definition: glext.h:11194
GLdouble u1
Definition: glext.h:8308

Referenced by execute_list(), and init_exec_pointers().

◆ gl_Map2f()

void gl_Map2f ( GLcontext ctx,
GLenum  target,
GLfloat  u1,
GLfloat  u2,
GLint  ustride,
GLint  uorder,
GLfloat  v1,
GLfloat  v2,
GLint  vstride,
GLint  vorder,
const GLfloat points,
GLboolean  retain 
)

Definition at line 988 of file eval.c.

992{
993 GLuint k;
994
995 if (INSIDE_BEGIN_END(ctx)) {
996 gl_error( ctx, GL_INVALID_OPERATION, "glMap2" );
997 return;
998 }
999
1000 if (u1==u2) {
1001 gl_error( ctx, GL_INVALID_VALUE, "glMap2(u1,u2)" );
1002 return;
1003 }
1004
1005 if (v1==v2) {
1006 gl_error( ctx, GL_INVALID_VALUE, "glMap2(v1,v2)" );
1007 return;
1008 }
1009
1011 gl_error( ctx, GL_INVALID_VALUE, "glMap2(uorder)" );
1012 return;
1013 }
1014
1016 gl_error( ctx, GL_INVALID_VALUE, "glMap2(vorder)" );
1017 return;
1018 }
1019
1020 k = components( target );
1021 if (k==0) {
1022 gl_error( ctx, GL_INVALID_ENUM, "glMap2(target)" );
1023 }
1024
1025 if (ustride < k) {
1026 gl_error( ctx, GL_INVALID_VALUE, "glMap2(ustride)" );
1027 return;
1028 }
1029 if (vstride < k) {
1030 gl_error( ctx, GL_INVALID_VALUE, "glMap2(vstride)" );
1031 return;
1032 }
1033
1034 switch (target) {
1035 case GL_MAP2_VERTEX_3:
1036 ctx->EvalMap.Map2Vertex3.Uorder = uorder;
1037 ctx->EvalMap.Map2Vertex3.u1 = u1;
1038 ctx->EvalMap.Map2Vertex3.u2 = u2;
1039 ctx->EvalMap.Map2Vertex3.Vorder = vorder;
1040 ctx->EvalMap.Map2Vertex3.v1 = v1;
1041 ctx->EvalMap.Map2Vertex3.v2 = v2;
1042 if (ctx->EvalMap.Map2Vertex3.Points
1043 && !ctx->EvalMap.Map2Vertex3.Retain) {
1044 free( ctx->EvalMap.Map2Vertex3.Points );
1045 }
1046 ctx->EvalMap.Map2Vertex3.Retain = retain;
1047 ctx->EvalMap.Map2Vertex3.Points = (GLfloat *) points;
1048 break;
1049 case GL_MAP2_VERTEX_4:
1050 ctx->EvalMap.Map2Vertex4.Uorder = uorder;
1051 ctx->EvalMap.Map2Vertex4.u1 = u1;
1052 ctx->EvalMap.Map2Vertex4.u2 = u2;
1053 ctx->EvalMap.Map2Vertex4.Vorder = vorder;
1054 ctx->EvalMap.Map2Vertex4.v1 = v1;
1055 ctx->EvalMap.Map2Vertex4.v2 = v2;
1056 if (ctx->EvalMap.Map2Vertex4.Points
1057 && !ctx->EvalMap.Map2Vertex4.Retain) {
1058 free( ctx->EvalMap.Map2Vertex4.Points );
1059 }
1060 ctx->EvalMap.Map2Vertex4.Points = (GLfloat *) points;
1061 ctx->EvalMap.Map2Vertex4.Retain = retain;
1062 break;
1063 case GL_MAP2_INDEX:
1064 ctx->EvalMap.Map2Index.Uorder = uorder;
1065 ctx->EvalMap.Map2Index.u1 = u1;
1066 ctx->EvalMap.Map2Index.u2 = u2;
1067 ctx->EvalMap.Map2Index.Vorder = vorder;
1068 ctx->EvalMap.Map2Index.v1 = v1;
1069 ctx->EvalMap.Map2Index.v2 = v2;
1070 if (ctx->EvalMap.Map2Index.Points
1071 && !ctx->EvalMap.Map2Index.Retain) {
1072 free( ctx->EvalMap.Map2Index.Points );
1073 }
1074 ctx->EvalMap.Map2Index.Retain = retain;
1075 ctx->EvalMap.Map2Index.Points = (GLfloat *) points;
1076 break;
1077 case GL_MAP2_COLOR_4:
1078 ctx->EvalMap.Map2Color4.Uorder = uorder;
1079 ctx->EvalMap.Map2Color4.u1 = u1;
1080 ctx->EvalMap.Map2Color4.u2 = u2;
1081 ctx->EvalMap.Map2Color4.Vorder = vorder;
1082 ctx->EvalMap.Map2Color4.v1 = v1;
1083 ctx->EvalMap.Map2Color4.v2 = v2;
1084 if (ctx->EvalMap.Map2Color4.Points
1085 && !ctx->EvalMap.Map2Color4.Retain) {
1086 free( ctx->EvalMap.Map2Color4.Points );
1087 }
1088 ctx->EvalMap.Map2Color4.Retain = retain;
1089 ctx->EvalMap.Map2Color4.Points = (GLfloat *) points;
1090 break;
1091 case GL_MAP2_NORMAL:
1092 ctx->EvalMap.Map2Normal.Uorder = uorder;
1093 ctx->EvalMap.Map2Normal.u1 = u1;
1094 ctx->EvalMap.Map2Normal.u2 = u2;
1095 ctx->EvalMap.Map2Normal.Vorder = vorder;
1096 ctx->EvalMap.Map2Normal.v1 = v1;
1097 ctx->EvalMap.Map2Normal.v2 = v2;
1098 if (ctx->EvalMap.Map2Normal.Points
1099 && !ctx->EvalMap.Map2Normal.Retain) {
1100 free( ctx->EvalMap.Map2Normal.Points );
1101 }
1102 ctx->EvalMap.Map2Normal.Retain = retain;
1103 ctx->EvalMap.Map2Normal.Points = (GLfloat *) points;
1104 break;
1106 ctx->EvalMap.Map2Texture1.Uorder = uorder;
1107 ctx->EvalMap.Map2Texture1.u1 = u1;
1108 ctx->EvalMap.Map2Texture1.u2 = u2;
1109 ctx->EvalMap.Map2Texture1.Vorder = vorder;
1110 ctx->EvalMap.Map2Texture1.v1 = v1;
1111 ctx->EvalMap.Map2Texture1.v2 = v2;
1112 if (ctx->EvalMap.Map2Texture1.Points
1113 && !ctx->EvalMap.Map2Texture1.Retain) {
1114 free( ctx->EvalMap.Map2Texture1.Points );
1115 }
1116 ctx->EvalMap.Map2Texture1.Retain = retain;
1117 ctx->EvalMap.Map2Texture1.Points = (GLfloat *) points;
1118 break;
1120 ctx->EvalMap.Map2Texture2.Uorder = uorder;
1121 ctx->EvalMap.Map2Texture2.u1 = u1;
1122 ctx->EvalMap.Map2Texture2.u2 = u2;
1123 ctx->EvalMap.Map2Texture2.Vorder = vorder;
1124 ctx->EvalMap.Map2Texture2.v1 = v1;
1125 ctx->EvalMap.Map2Texture2.v2 = v2;
1126 if (ctx->EvalMap.Map2Texture2.Points
1127 && !ctx->EvalMap.Map2Texture2.Retain) {
1128 free( ctx->EvalMap.Map2Texture2.Points );
1129 }
1130 ctx->EvalMap.Map2Texture2.Retain = retain;
1131 ctx->EvalMap.Map2Texture2.Points = (GLfloat *) points;
1132 break;
1134 ctx->EvalMap.Map2Texture3.Uorder = uorder;
1135 ctx->EvalMap.Map2Texture3.u1 = u1;
1136 ctx->EvalMap.Map2Texture3.u2 = u2;
1137 ctx->EvalMap.Map2Texture3.Vorder = vorder;
1138 ctx->EvalMap.Map2Texture3.v1 = v1;
1139 ctx->EvalMap.Map2Texture3.v2 = v2;
1140 if (ctx->EvalMap.Map2Texture3.Points
1141 && !ctx->EvalMap.Map2Texture3.Retain) {
1142 free( ctx->EvalMap.Map2Texture3.Points );
1143 }
1144 ctx->EvalMap.Map2Texture3.Retain = retain;
1145 ctx->EvalMap.Map2Texture3.Points = (GLfloat *) points;
1146 break;
1148 ctx->EvalMap.Map2Texture4.Uorder = uorder;
1149 ctx->EvalMap.Map2Texture4.u1 = u1;
1150 ctx->EvalMap.Map2Texture4.u2 = u2;
1151 ctx->EvalMap.Map2Texture4.Vorder = vorder;
1152 ctx->EvalMap.Map2Texture4.v1 = v1;
1153 ctx->EvalMap.Map2Texture4.v2 = v2;
1154 if (ctx->EvalMap.Map2Texture4.Points
1155 && !ctx->EvalMap.Map2Texture4.Retain) {
1156 free( ctx->EvalMap.Map2Texture4.Points );
1157 }
1158 ctx->EvalMap.Map2Texture4.Retain = retain;
1159 ctx->EvalMap.Map2Texture4.Points = (GLfloat *) points;
1160 break;
1161 default:
1162 gl_error( ctx, GL_INVALID_ENUM, "glMap2(target)" );
1163 }
1164}

Referenced by execute_list(), and init_exec_pointers().

◆ gl_MapGrid1f()

void gl_MapGrid1f ( GLcontext ctx,
GLint  un,
GLfloat  u1,
GLfloat  u2 
)

Definition at line 2236 of file eval.c.

2237{
2238 if (INSIDE_BEGIN_END(ctx)) {
2239 gl_error( ctx, GL_INVALID_OPERATION, "glMapGrid1f" );
2240 return;
2241 }
2242 if (un<1) {
2243 gl_error( ctx, GL_INVALID_VALUE, "glMapGrid1f" );
2244 return;
2245 }
2246 ctx->Eval.MapGrid1un = un;
2247 ctx->Eval.MapGrid1u1 = u1;
2248 ctx->Eval.MapGrid1u2 = u2;
2249}
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint un
Definition: glfuncs.h:236

Referenced by execute_list(), and init_exec_pointers().

◆ gl_MapGrid2f()

void gl_MapGrid2f ( GLcontext ctx,
GLint  un,
GLfloat  u1,
GLfloat  u2,
GLint  vn,
GLfloat  v1,
GLfloat  v2 
)

Definition at line 2252 of file eval.c.

2254{
2255 if (INSIDE_BEGIN_END(ctx)) {
2256 gl_error( ctx, GL_INVALID_OPERATION, "glMapGrid2f" );
2257 return;
2258 }
2259 if (un<1) {
2260 gl_error( ctx, GL_INVALID_VALUE, "glMapGrid2f(un)" );
2261 return;
2262 }
2263 if (vn<1) {
2264 gl_error( ctx, GL_INVALID_VALUE, "glMapGrid2f(vn)" );
2265 return;
2266 }
2267 ctx->Eval.MapGrid2un = un;
2268 ctx->Eval.MapGrid2u1 = u1;
2269 ctx->Eval.MapGrid2u2 = u2;
2270 ctx->Eval.MapGrid2vn = vn;
2271 ctx->Eval.MapGrid2v1 = v1;
2272 ctx->Eval.MapGrid2v2 = v2;
2273}
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint vn
Definition: glfuncs.h:238

Referenced by execute_list(), and init_exec_pointers().