ReactOS 0.4.16-dev-106-g10b08aa
Macros | Functions
eval.c File Reference
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include "context.h"
#include "eval.h"
#include "dlist.h"
#include "macros.h"
#include "mmath.h"
#include "types.h"
#include "vbfill.h"
Include dependency graph for eval.c:

Go to the source code of this file.

Macros

#define CN(I, J, K)   cn[(I)*uinc+(J)*dim+(K)]
 
#define DCN(I, J)   dcn[(I)*dcuinc+(J)]
 
#define CROSS_PROD(n, u, v)
 
#define I_TO_U(I, U)
 
#define J_TO_V(J, V)
 

Functions

void gl_init_eval (void)
 
static void horner_bezier_curve (GLfloat *cp, GLfloat *out, GLfloat t, GLuint dim, GLuint order)
 
static void horner_bezier_surf (GLfloat *cn, GLfloat *out, GLfloat u, GLfloat v, GLuint dim, GLuint uorder, GLuint vorder)
 
static void de_casteljau_surf (GLfloat *cn, GLfloat *out, GLfloat *du, GLfloat *dv, GLfloat u, GLfloat v, GLuint dim, GLuint uorder, GLuint vorder)
 
static GLint components (GLenum target)
 
GLfloat * gl_copy_map_points1f (GLenum target, GLint ustride, GLint uorder, const GLfloat *points)
 
GLfloat * gl_copy_map_points1d (GLenum target, GLint ustride, GLint uorder, const GLdouble *points)
 
GLfloat * gl_copy_map_points2f (GLenum target, GLint ustride, GLint uorder, GLint vstride, GLint vorder, const GLfloat *points)
 
GLfloat * gl_copy_map_points2d (GLenum target, GLint ustride, GLint uorder, GLint vstride, GLint vorder, const GLdouble *points)
 
void gl_free_control_points (GLcontext *ctx, GLenum target, GLfloat *data)
 
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_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_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_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)
 

Macro Definition Documentation

◆ CN

#define CN (   I,
  J,
  K 
)    cn[(I)*uinc+(J)*dim+(K)]

◆ CROSS_PROD

#define CROSS_PROD (   n,
  u,
  v 
)
Value:
(n)[0] = (u)[1]*(v)[2] - (u)[2]*(v)[1]; \
(n)[1] = (u)[2]*(v)[0] - (u)[0]*(v)[2]; \
(n)[2] = (u)[0]*(v)[1] - (u)[1]*(v)[0]
v
const GLdouble * v
Definition: gl.h:2040
n
GLdouble n
Definition: glext.h:7729
u
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

◆ DCN

#define DCN (   I,
  J 
)    dcn[(I)*dcuinc+(J)]

◆ I_TO_U

#define I_TO_U (   I,
  U 
)
Value:
if ((I)==0) { \
U = ctx->Eval.MapGrid2u1; \
} \
else if ((I)==ctx->Eval.MapGrid2un) { \
U = ctx->Eval.MapGrid2u2; \
} \
else { \
U = (I) * du + ctx->Eval.MapGrid2u1;\
}
U
#define U(x)
Definition: wordpad.c:45
I
#define I(s)

◆ J_TO_V

#define J_TO_V (   J,
  V 
)
Value:
if ((J)==0) { \
V = ctx->Eval.MapGrid2v1; \
} \
else if ((J)==ctx->Eval.MapGrid2vn) { \
V = ctx->Eval.MapGrid2v2; \
} \
else { \
V = (J) * dv + ctx->Eval.MapGrid2v1;\
}

Function Documentation

◆ components()

static GLint components ( GLenum  target)
static

Definition at line 549 of file eval.c.

550{
551 switch (target) {
552 case GL_MAP1_VERTEX_3: return 3;
553 case GL_MAP1_VERTEX_4: return 4;
554 case GL_MAP1_INDEX: return 1;
555 case GL_MAP1_COLOR_4: return 4;
556 case GL_MAP1_NORMAL: return 3;
557 case GL_MAP1_TEXTURE_COORD_1: return 1;
558 case GL_MAP1_TEXTURE_COORD_2: return 2;
559 case GL_MAP1_TEXTURE_COORD_3: return 3;
560 case GL_MAP1_TEXTURE_COORD_4: return 4;
561 case GL_MAP2_VERTEX_3: return 3;
562 case GL_MAP2_VERTEX_4: return 4;
563 case GL_MAP2_INDEX: return 1;
564 case GL_MAP2_COLOR_4: return 4;
565 case GL_MAP2_NORMAL: return 3;
566 case GL_MAP2_TEXTURE_COORD_1: return 1;
567 case GL_MAP2_TEXTURE_COORD_2: return 2;
568 case GL_MAP2_TEXTURE_COORD_3: return 3;
569 case GL_MAP2_TEXTURE_COORD_4: return 4;
570 default: return 0;
571 }
572}
GL_MAP2_NORMAL
#define GL_MAP2_NORMAL
Definition: gl.h:562
GL_MAP1_TEXTURE_COORD_3
#define GL_MAP1_TEXTURE_COORD_3
Definition: gl.h:556
GL_MAP2_INDEX
#define GL_MAP2_INDEX
Definition: gl.h:561
GL_MAP2_TEXTURE_COORD_2
#define GL_MAP2_TEXTURE_COORD_2
Definition: gl.h:564
GL_MAP1_VERTEX_3
#define GL_MAP1_VERTEX_3
Definition: gl.h:558
GL_MAP1_TEXTURE_COORD_2
#define GL_MAP1_TEXTURE_COORD_2
Definition: gl.h:555
GL_MAP2_TEXTURE_COORD_4
#define GL_MAP2_TEXTURE_COORD_4
Definition: gl.h:566
GL_MAP2_COLOR_4
#define GL_MAP2_COLOR_4
Definition: gl.h:560
GL_MAP1_TEXTURE_COORD_1
#define GL_MAP1_TEXTURE_COORD_1
Definition: gl.h:554
GL_MAP2_VERTEX_4
#define GL_MAP2_VERTEX_4
Definition: gl.h:568
GL_MAP1_INDEX
#define GL_MAP1_INDEX
Definition: gl.h:552
GL_MAP2_VERTEX_3
#define GL_MAP2_VERTEX_3
Definition: gl.h:567
GL_MAP1_TEXTURE_COORD_4
#define GL_MAP1_TEXTURE_COORD_4
Definition: gl.h:557
GL_MAP1_COLOR_4
#define GL_MAP1_COLOR_4
Definition: gl.h:551
GL_MAP2_TEXTURE_COORD_1
#define GL_MAP2_TEXTURE_COORD_1
Definition: gl.h:563
GL_MAP2_TEXTURE_COORD_3
#define GL_MAP2_TEXTURE_COORD_3
Definition: gl.h:565
GL_MAP1_NORMAL
#define GL_MAP1_NORMAL
Definition: gl.h:553
GL_MAP1_VERTEX_4
#define GL_MAP1_VERTEX_4
Definition: gl.h:559
target
GLenum target
Definition: glext.h:7315

◆ de_casteljau_surf()

static void de_casteljau_surf ( GLfloat *  cn,
GLfloat *  out,
GLfloat *  du,
GLfloat *  dv,
GLfloat  u,
GLfloat  v,
GLuint  dim,
GLuint  uorder,
GLuint  vorder 
)
static

Definition at line 258 of file eval.c.

261{
262 GLfloat *dcn = cn + uorder*vorder*dim;
263 GLfloat us = 1.0-u, vs = 1.0-v;
264 GLuint h, i, j, k;
265 GLuint minorder = uorder < vorder ? uorder : vorder;
266 GLuint uinc = vorder*dim;
267 GLuint dcuinc = vorder;
268
269 /* Each component is evaluated separately to save buffer space */
270 /* This does not drasticaly decrease the performance of the */
271 /* algorithm. If additional storage for (uorder-1)*(vorder-1) */
272 /* points would be available, the components could be accessed */
273 /* in the innermost loop which could lead to less cache misses. */
274
275#define CN(I,J,K) cn[(I)*uinc+(J)*dim+(K)]
276#define DCN(I, J) dcn[(I)*dcuinc+(J)]
277 if(minorder < 3)
278 {
279 if(uorder==vorder)
280 {
281 for(k=0; k<dim; k++)
282 {
283 /* Derivative direction in u */
284 du[k] = vs*(CN(1,0,k) - CN(0,0,k)) +
285 v*(CN(1,1,k) - CN(0,1,k));
286
287 /* Derivative direction in v */
288 dv[k] = us*(CN(0,1,k) - CN(0,0,k)) +
289 u*(CN(1,1,k) - CN(1,0,k));
290
291 /* bilinear de Casteljau step */
292 out[k] = us*(vs*CN(0,0,k) + v*CN(0,1,k)) +
293 u*(vs*CN(1,0,k) + v*CN(1,1,k));
294 }
295 }
296 else if(minorder == uorder)
297 {
298 for(k=0; k<dim; k++)
299 {
300 /* bilinear de Casteljau step */
301 DCN(1,0) = CN(1,0,k) - CN(0,0,k);
302 DCN(0,0) = us*CN(0,0,k) + u*CN(1,0,k);
303
304 for(j=0; j<vorder-1; j++)
305 {
306 /* for the derivative in u */
307 DCN(1,j+1) = CN(1,j+1,k) - CN(0,j+1,k);
308 DCN(1,j) = vs*DCN(1,j) + v*DCN(1,j+1);
309
310 /* for the `point' */
311 DCN(0,j+1) = us*CN(0,j+1,k) + u*CN(1,j+1,k);
312 DCN(0,j) = vs*DCN(0,j) + v*DCN(0,j+1);
313 }
314
315 /* remaining linear de Casteljau steps until the second last step */
316 for(h=minorder; h<vorder-1; h++)
317 for(j=0; j<vorder-h; j++)
318 {
319 /* for the derivative in u */
320 DCN(1,j) = vs*DCN(1,j) + v*DCN(1,j+1);
321
322 /* for the `point' */
323 DCN(0,j) = vs*DCN(0,j) + v*DCN(0,j+1);
324 }
325
326 /* derivative direction in v */
327 dv[k] = DCN(0,1) - DCN(0,0);
328
329 /* derivative direction in u */
330 du[k] = vs*DCN(1,0) + v*DCN(1,1);
331
332 /* last linear de Casteljau step */
333 out[k] = vs*DCN(0,0) + v*DCN(0,1);
334 }
335 }
336 else /* minorder == vorder */
337 {
338 for(k=0; k<dim; k++)
339 {
340 /* bilinear de Casteljau step */
341 DCN(0,1) = CN(0,1,k) - CN(0,0,k);
342 DCN(0,0) = vs*CN(0,0,k) + v*CN(0,1,k);
343 for(i=0; i<uorder-1; i++)
344 {
345 /* for the derivative in v */
346 DCN(i+1,1) = CN(i+1,1,k) - CN(i+1,0,k);
347 DCN(i,1) = us*DCN(i,1) + u*DCN(i+1,1);
348
349 /* for the `point' */
350 DCN(i+1,0) = vs*CN(i+1,0,k) + v*CN(i+1,1,k);
351 DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
352 }
353
354 /* remaining linear de Casteljau steps until the second last step */
355 for(h=minorder; h<uorder-1; h++)
356 for(i=0; i<uorder-h; i++)
357 {
358 /* for the derivative in v */
359 DCN(i,1) = us*DCN(i,1) + u*DCN(i+1,1);
360
361 /* for the `point' */
362 DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
363 }
364
365 /* derivative direction in u */
366 du[k] = DCN(1,0) - DCN(0,0);
367
368 /* derivative direction in v */
369 dv[k] = us*DCN(0,1) + u*DCN(1,1);
370
371 /* last linear de Casteljau step */
372 out[k] = us*DCN(0,0) + u*DCN(1,0);
373 }
374 }
375 }
376 else if(uorder == vorder)
377 {
378 for(k=0; k<dim; k++)
379 {
380 /* first bilinear de Casteljau step */
381 for(i=0; i<uorder-1; i++)
382 {
383 DCN(i,0) = us*CN(i,0,k) + u*CN(i+1,0,k);
384 for(j=0; j<vorder-1; j++)
385 {
386 DCN(i,j+1) = us*CN(i,j+1,k) + u*CN(i+1,j+1,k);
387 DCN(i,j) = vs*DCN(i,j) + v*DCN(i,j+1);
388 }
389 }
390
391 /* remaining bilinear de Casteljau steps until the second last step */
392 for(h=2; h<minorder-1; h++)
393 for(i=0; i<uorder-h; i++)
394 {
395 DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
396 for(j=0; j<vorder-h; j++)
397 {
398 DCN(i,j+1) = us*DCN(i,j+1) + u*DCN(i+1,j+1);
399 DCN(i,j) = vs*DCN(i,j) + v*DCN(i,j+1);
400 }
401 }
402
403 /* derivative direction in u */
404 du[k] = vs*(DCN(1,0) - DCN(0,0)) +
405 v*(DCN(1,1) - DCN(0,1));
406
407 /* derivative direction in v */
408 dv[k] = us*(DCN(0,1) - DCN(0,0)) +
409 u*(DCN(1,1) - DCN(1,0));
410
411 /* last bilinear de Casteljau step */
412 out[k] = us*(vs*DCN(0,0) + v*DCN(0,1)) +
413 u*(vs*DCN(1,0) + v*DCN(1,1));
414 }
415 }
416 else if(minorder == uorder)
417 {
418 for(k=0; k<dim; k++)
419 {
420 /* first bilinear de Casteljau step */
421 for(i=0; i<uorder-1; i++)
422 {
423 DCN(i,0) = us*CN(i,0,k) + u*CN(i+1,0,k);
424 for(j=0; j<vorder-1; j++)
425 {
426 DCN(i,j+1) = us*CN(i,j+1,k) + u*CN(i+1,j+1,k);
427 DCN(i,j) = vs*DCN(i,j) + v*DCN(i,j+1);
428 }
429 }
430
431 /* remaining bilinear de Casteljau steps until the second last step */
432 for(h=2; h<minorder-1; h++)
433 for(i=0; i<uorder-h; i++)
434 {
435 DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
436 for(j=0; j<vorder-h; j++)
437 {
438 DCN(i,j+1) = us*DCN(i,j+1) + u*DCN(i+1,j+1);
439 DCN(i,j) = vs*DCN(i,j) + v*DCN(i,j+1);
440 }
441 }
442
443 /* last bilinear de Casteljau step */
444 DCN(2,0) = DCN(1,0) - DCN(0,0);
445 DCN(0,0) = us*DCN(0,0) + u*DCN(1,0);
446 for(j=0; j<vorder-1; j++)
447 {
448 /* for the derivative in u */
449 DCN(2,j+1) = DCN(1,j+1) - DCN(0,j+1);
450 DCN(2,j) = vs*DCN(2,j) + v*DCN(2,j+1);
451
452 /* for the `point' */
453 DCN(0,j+1) = us*DCN(0,j+1 ) + u*DCN(1,j+1);
454 DCN(0,j) = vs*DCN(0,j) + v*DCN(0,j+1);
455 }
456
457 /* remaining linear de Casteljau steps until the second last step */
458 for(h=minorder; h<vorder-1; h++)
459 for(j=0; j<vorder-h; j++)
460 {
461 /* for the derivative in u */
462 DCN(2,j) = vs*DCN(2,j) + v*DCN(2,j+1);
463
464 /* for the `point' */
465 DCN(0,j) = vs*DCN(0,j) + v*DCN(0,j+1);
466 }
467
468 /* derivative direction in v */
469 dv[k] = DCN(0,1) - DCN(0,0);
470
471 /* derivative direction in u */
472 du[k] = vs*DCN(2,0) + v*DCN(2,1);
473
474 /* last linear de Casteljau step */
475 out[k] = vs*DCN(0,0) + v*DCN(0,1);
476 }
477 }
478 else /* minorder == vorder */
479 {
480 for(k=0; k<dim; k++)
481 {
482 /* first bilinear de Casteljau step */
483 for(i=0; i<uorder-1; i++)
484 {
485 DCN(i,0) = us*CN(i,0,k) + u*CN(i+1,0,k);
486 for(j=0; j<vorder-1; j++)
487 {
488 DCN(i,j+1) = us*CN(i,j+1,k) + u*CN(i+1,j+1,k);
489 DCN(i,j) = vs*DCN(i,j) + v*DCN(i,j+1);
490 }
491 }
492
493 /* remaining bilinear de Casteljau steps until the second last step */
494 for(h=2; h<minorder-1; h++)
495 for(i=0; i<uorder-h; i++)
496 {
497 DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
498 for(j=0; j<vorder-h; j++)
499 {
500 DCN(i,j+1) = us*DCN(i,j+1) + u*DCN(i+1,j+1);
501 DCN(i,j) = vs*DCN(i,j) + v*DCN(i,j+1);
502 }
503 }
504
505 /* last bilinear de Casteljau step */
506 DCN(0,2) = DCN(0,1) - DCN(0,0);
507 DCN(0,0) = vs*DCN(0,0) + v*DCN(0,1);
508 for(i=0; i<uorder-1; i++)
509 {
510 /* for the derivative in v */
511 DCN(i+1,2) = DCN(i+1,1) - DCN(i+1,0);
512 DCN(i,2) = us*DCN(i,2) + u*DCN(i+1,2);
513
514 /* for the `point' */
515 DCN(i+1,0) = vs*DCN(i+1,0) + v*DCN(i+1,1);
516 DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
517 }
518
519 /* remaining linear de Casteljau steps until the second last step */
520 for(h=minorder; h<uorder-1; h++)
521 for(i=0; i<uorder-h; i++)
522 {
523 /* for the derivative in v */
524 DCN(i,2) = us*DCN(i,2) + u*DCN(i+1,2);
525
526 /* for the `point' */
527 DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
528 }
529
530 /* derivative direction in u */
531 du[k] = DCN(1,0) - DCN(0,0);
532
533 /* derivative direction in v */
534 dv[k] = us*DCN(0,2) + u*DCN(1,2);
535
536 /* last linear de Casteljau step */
537 out[k] = us*DCN(0,0) + u*DCN(1,0);
538 }
539 }
540#undef DCN
541#undef CN
542}
DCN
#define DCN(I, J)
CN
#define CN(I, J, K)
GLfloat
float GLfloat
Definition: gl.h:161
GLuint
unsigned int GLuint
Definition: gl.h:159
uorder
GLdouble GLdouble GLint GLint uorder
Definition: glext.h:8308
vorder
GLdouble GLdouble GLint GLint GLdouble GLdouble GLint GLint vorder
Definition: glext.h:8308
h
GLfloat GLfloat GLfloat GLfloat h
Definition: glext.h:7723
i
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
j
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
cn
static BYTE cn[]
Definition: cert.c:2938
us
static const BYTE us[]
Definition: encode.c:689
vs
static vector_t * vs
Definition: server.c:127
k
int k
Definition: mpi.c:3369
out
static FILE * out
Definition: regtests2xml.c:44

Referenced by gl_EvalCoord2f().

◆ 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;
618 GLuint i, k, size = components(target);
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}
malloc
#define malloc
Definition: debug_ros.c:4
NULL
#define NULL
Definition: types.h:112
size
GLsizeiptr size
Definition: glext.h:5919
ustride
GLdouble GLdouble GLint ustride
Definition: glext.h:8308
buffer
GLuint buffer
Definition: glext.h:5915
components
GLenum GLenum GLuint components
Definition: glext.h:9620
p
GLfloat GLfloat p
Definition: glext.h:8902
points
GLsizei const GLfloat * points
Definition: glext.h:8112

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;
592 GLuint i, k, size = components(target);
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
698 size = components(target);
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}
GLint
int GLint
Definition: gl.h:156
vstride
GLdouble GLdouble GLint GLint GLdouble GLdouble GLint vstride
Definition: glext.h:8308

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
655 size = components(target);
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}
index
#define index(s, c)
Definition: various.h:29
map
Definition: _map.h:48
horner_bezier_curve
static void horner_bezier_curve(GLfloat *cp, GLfloat *out, GLfloat t, GLuint dim, GLuint order)
Definition: eval.c:131
GLubyte
unsigned char GLubyte
Definition: gl.h:157
index
GLuint index
Definition: glext.h:6031
COPY_4V
#define COPY_4V(DST, SRC)
Definition: macros.h:102
normal
@ normal
Definition: optimize.h:166
gl_1d_map
Definition: types.h:1037
vertex
Definition: mesh.c:4558
gl_eval_vertex
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);
2113 NORMALIZE_3FV(normal);
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);
2129 NORMALIZE_3FV(normal);
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}
CROSS_PROD
#define CROSS_PROD(n, u, v)
de_casteljau_surf
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
horner_bezier_surf
static void horner_bezier_surf(GLfloat *cn, GLfloat *out, GLfloat u, GLfloat v, GLuint dim, GLuint uorder, GLuint vorder)
Definition: eval.c:176
NORMALIZE_3FV
#define NORMALIZE_3FV(V)
Definition: mmath.h:68
gl_2d_map
Definition: types.h:1048

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:
2346 prim = GL_LINE_STRIP;
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}
gl_error
void gl_error(GLcontext *ctx, GLenum error, const char *s)
Definition: context.c:1421
gl_EvalCoord1f
void gl_EvalCoord1f(GLcontext *ctx, GLfloat u)
Definition: eval.c:1978
GL_POINT
#define GL_POINT
Definition: gl.h:265
GL_LINE_STRIP
#define GL_LINE_STRIP
Definition: gl.h:193
GL_INVALID_OPERATION
#define GL_INVALID_OPERATION
Definition: gl.h:696
GLenum
unsigned int GLenum
Definition: gl.h:150
GL_POINTS
#define GL_POINTS
Definition: gl.h:190
GL_LINE
#define GL_LINE
Definition: gl.h:266
GL_INVALID_ENUM
#define GL_INVALID_ENUM
Definition: gl.h:694
mode
GLenum mode
Definition: glext.h:6217
INSIDE_BEGIN_END
#define INSIDE_BEGIN_END(CTX)
Definition: macros.h:135
prim
LOCAL int prim(arg_t *ap)
Definition: match.c:440
gl_End
void gl_End(GLcontext *ctx)
Definition: vbfill.c:1424
gl_Begin
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:
2413 gl_Begin( ctx, GL_POINTS );
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 );
2426 gl_Begin( ctx, GL_LINE_STRIP );
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 );
2435 gl_Begin( ctx, GL_LINE_STRIP );
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! */
2447 gl_Begin( ctx, GL_TRIANGLE_STRIP );
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}
I_TO_U
#define I_TO_U(I, U)
J_TO_V
#define J_TO_V(J, V)
gl_EvalCoord2f
void gl_EvalCoord2f(GLcontext *ctx, GLfloat u, GLfloat v)
Definition: eval.c:2084
GL_FILL
#define GL_FILL
Definition: gl.h:267
GL_TRIANGLE_STRIP
#define GL_TRIANGLE_STRIP
Definition: gl.h:195
v1
GLfloat GLfloat v1
Definition: glext.h:6062
v2
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;
753 case GL_MAP1_TEXTURE_COORD_1:
754 map1 = &ctx->EvalMap.Map1Texture1;
755 break;
756 case GL_MAP1_TEXTURE_COORD_2:
757 map1 = &ctx->EvalMap.Map1Texture2;
758 break;
759 case GL_MAP1_TEXTURE_COORD_3:
760 map1 = &ctx->EvalMap.Map1Texture3;
761 break;
762 case GL_MAP1_TEXTURE_COORD_4:
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;
780 case GL_MAP2_TEXTURE_COORD_1:
781 map2 = &ctx->EvalMap.Map2Texture1;
782 break;
783 case GL_MAP2_TEXTURE_COORD_2:
784 map2 = &ctx->EvalMap.Map2Texture2;
785 break;
786 case GL_MAP2_TEXTURE_COORD_3:
787 map2 = &ctx->EvalMap.Map2Texture3;
788 break;
789 case GL_MAP2_TEXTURE_COORD_4:
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}
free
#define free
Definition: debug_ros.c:5
data
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
GL_FALSE
#define GL_FALSE
Definition: gl.h:173
gl_1d_map::Points
GLfloat * Points
Definition: types.h:1040
gl_1d_map::Retain
GLboolean Retain
Definition: types.h:1041
gl_2d_map::Retain
GLboolean Retain
Definition: types.h:1054
gl_2d_map::Points
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;
1190 case GL_MAP1_TEXTURE_COORD_1:
1191 data = ctx->EvalMap.Map1Texture1.Points;
1192 n = ctx->EvalMap.Map1Texture1.Order * 1;
1193 break;
1194 case GL_MAP1_TEXTURE_COORD_2:
1195 data = ctx->EvalMap.Map1Texture2.Points;
1196 n = ctx->EvalMap.Map1Texture2.Order * 2;
1197 break;
1198 case GL_MAP1_TEXTURE_COORD_3:
1199 data = ctx->EvalMap.Map1Texture3.Points;
1200 n = ctx->EvalMap.Map1Texture3.Order * 3;
1201 break;
1202 case GL_MAP1_TEXTURE_COORD_4:
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;
1229 case GL_MAP2_TEXTURE_COORD_1:
1230 data = ctx->EvalMap.Map2Texture1.Points;
1231 n = ctx->EvalMap.Map2Texture1.Uorder
1232 * ctx->EvalMap.Map2Texture1.Vorder * 1;
1233 break;
1234 case GL_MAP2_TEXTURE_COORD_2:
1235 data = ctx->EvalMap.Map2Texture2.Points;
1236 n = ctx->EvalMap.Map2Texture2.Uorder
1237 * ctx->EvalMap.Map2Texture2.Vorder * 2;
1238 break;
1239 case GL_MAP2_TEXTURE_COORD_3:
1240 data = ctx->EvalMap.Map2Texture3.Points;
1241 n = ctx->EvalMap.Map2Texture3.Uorder
1242 * ctx->EvalMap.Map2Texture3.Vorder * 3;
1243 break;
1244 case GL_MAP2_TEXTURE_COORD_4:
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;
1279 case GL_MAP1_TEXTURE_COORD_1:
1280 *v = ctx->EvalMap.Map1Texture1.Order;
1281 break;
1282 case GL_MAP1_TEXTURE_COORD_2:
1283 *v = ctx->EvalMap.Map1Texture2.Order;
1284 break;
1285 case GL_MAP1_TEXTURE_COORD_3:
1286 *v = ctx->EvalMap.Map1Texture3.Order;
1287 break;
1288 case GL_MAP1_TEXTURE_COORD_4:
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;
1309 case GL_MAP2_TEXTURE_COORD_1:
1310 v[0] = ctx->EvalMap.Map2Texture1.Uorder;
1311 v[1] = ctx->EvalMap.Map2Texture1.Vorder;
1312 break;
1313 case GL_MAP2_TEXTURE_COORD_2:
1314 v[0] = ctx->EvalMap.Map2Texture2.Uorder;
1315 v[1] = ctx->EvalMap.Map2Texture2.Vorder;
1316 break;
1317 case GL_MAP2_TEXTURE_COORD_3:
1318 v[0] = ctx->EvalMap.Map2Texture3.Uorder;
1319 v[1] = ctx->EvalMap.Map2Texture3.Vorder;
1320 break;
1321 case GL_MAP2_TEXTURE_COORD_4:
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;
1351 case GL_MAP1_TEXTURE_COORD_1:
1352 v[0] = ctx->EvalMap.Map1Texture1.u1;
1353 v[1] = ctx->EvalMap.Map1Texture1.u2;
1354 break;
1355 case GL_MAP1_TEXTURE_COORD_2:
1356 v[0] = ctx->EvalMap.Map1Texture2.u1;
1357 v[1] = ctx->EvalMap.Map1Texture2.u2;
1358 break;
1359 case GL_MAP1_TEXTURE_COORD_3:
1360 v[0] = ctx->EvalMap.Map1Texture3.u1;
1361 v[1] = ctx->EvalMap.Map1Texture3.u2;
1362 break;
1363 case GL_MAP1_TEXTURE_COORD_4:
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;
1393 case GL_MAP2_TEXTURE_COORD_1:
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;
1399 case GL_MAP2_TEXTURE_COORD_2:
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;
1405 case GL_MAP2_TEXTURE_COORD_3:
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;
1411 case GL_MAP2_TEXTURE_COORD_4:
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}
GL_ORDER
#define GL_ORDER
Definition: gl.h:574
GL_DOMAIN
#define GL_DOMAIN
Definition: gl.h:575
GL_COEFF
#define GL_COEFF
Definition: gl.h:573

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;
1459 case GL_MAP1_TEXTURE_COORD_1:
1460 data = ctx->EvalMap.Map1Texture1.Points;
1461 n = ctx->EvalMap.Map1Texture1.Order * 1;
1462 break;
1463 case GL_MAP1_TEXTURE_COORD_2:
1464 data = ctx->EvalMap.Map1Texture2.Points;
1465 n = ctx->EvalMap.Map1Texture2.Order * 2;
1466 break;
1467 case GL_MAP1_TEXTURE_COORD_3:
1468 data = ctx->EvalMap.Map1Texture3.Points;
1469 n = ctx->EvalMap.Map1Texture3.Order * 3;
1470 break;
1471 case GL_MAP1_TEXTURE_COORD_4:
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;
1498 case GL_MAP2_TEXTURE_COORD_1:
1499 data = ctx->EvalMap.Map2Texture1.Points;
1500 n = ctx->EvalMap.Map2Texture1.Uorder
1501 * ctx->EvalMap.Map2Texture1.Vorder * 1;
1502 break;
1503 case GL_MAP2_TEXTURE_COORD_2:
1504 data = ctx->EvalMap.Map2Texture2.Points;
1505 n = ctx->EvalMap.Map2Texture2.Uorder
1506 * ctx->EvalMap.Map2Texture2.Vorder * 2;
1507 break;
1508 case GL_MAP2_TEXTURE_COORD_3:
1509 data = ctx->EvalMap.Map2Texture3.Points;
1510 n = ctx->EvalMap.Map2Texture3.Uorder
1511 * ctx->EvalMap.Map2Texture3.Vorder * 3;
1512 break;
1513 case GL_MAP2_TEXTURE_COORD_4:
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;
1548 case GL_MAP1_TEXTURE_COORD_1:
1549 *v = ctx->EvalMap.Map1Texture1.Order;
1550 break;
1551 case GL_MAP1_TEXTURE_COORD_2:
1552 *v = ctx->EvalMap.Map1Texture2.Order;
1553 break;
1554 case GL_MAP1_TEXTURE_COORD_3:
1555 *v = ctx->EvalMap.Map1Texture3.Order;
1556 break;
1557 case GL_MAP1_TEXTURE_COORD_4:
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;
1578 case GL_MAP2_TEXTURE_COORD_1:
1579 v[0] = ctx->EvalMap.Map2Texture1.Uorder;
1580 v[1] = ctx->EvalMap.Map2Texture1.Vorder;
1581 break;
1582 case GL_MAP2_TEXTURE_COORD_2:
1583 v[0] = ctx->EvalMap.Map2Texture2.Uorder;
1584 v[1] = ctx->EvalMap.Map2Texture2.Vorder;
1585 break;
1586 case GL_MAP2_TEXTURE_COORD_3:
1587 v[0] = ctx->EvalMap.Map2Texture3.Uorder;
1588 v[1] = ctx->EvalMap.Map2Texture3.Vorder;
1589 break;
1590 case GL_MAP2_TEXTURE_COORD_4:
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;
1620 case GL_MAP1_TEXTURE_COORD_1:
1621 v[0] = ctx->EvalMap.Map1Texture1.u1;
1622 v[1] = ctx->EvalMap.Map1Texture1.u2;
1623 break;
1624 case GL_MAP1_TEXTURE_COORD_2:
1625 v[0] = ctx->EvalMap.Map1Texture2.u1;
1626 v[1] = ctx->EvalMap.Map1Texture2.u2;
1627 break;
1628 case GL_MAP1_TEXTURE_COORD_3:
1629 v[0] = ctx->EvalMap.Map1Texture3.u1;
1630 v[1] = ctx->EvalMap.Map1Texture3.u2;
1631 break;
1632 case GL_MAP1_TEXTURE_COORD_4:
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;
1662 case GL_MAP2_TEXTURE_COORD_1:
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;
1668 case GL_MAP2_TEXTURE_COORD_2:
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;
1674 case GL_MAP2_TEXTURE_COORD_3:
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;
1680 case GL_MAP2_TEXTURE_COORD_4:
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;
1728 case GL_MAP1_TEXTURE_COORD_1:
1729 data = ctx->EvalMap.Map1Texture1.Points;
1730 n = ctx->EvalMap.Map1Texture1.Order * 1;
1731 break;
1732 case GL_MAP1_TEXTURE_COORD_2:
1733 data = ctx->EvalMap.Map1Texture2.Points;
1734 n = ctx->EvalMap.Map1Texture2.Order * 2;
1735 break;
1736 case GL_MAP1_TEXTURE_COORD_3:
1737 data = ctx->EvalMap.Map1Texture3.Points;
1738 n = ctx->EvalMap.Map1Texture3.Order * 3;
1739 break;
1740 case GL_MAP1_TEXTURE_COORD_4:
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;
1767 case GL_MAP2_TEXTURE_COORD_1:
1768 data = ctx->EvalMap.Map2Texture1.Points;
1769 n = ctx->EvalMap.Map2Texture1.Uorder
1770 * ctx->EvalMap.Map2Texture1.Vorder * 1;
1771 break;
1772 case GL_MAP2_TEXTURE_COORD_2:
1773 data = ctx->EvalMap.Map2Texture2.Points;
1774 n = ctx->EvalMap.Map2Texture2.Uorder
1775 * ctx->EvalMap.Map2Texture2.Vorder * 2;
1776 break;
1777 case GL_MAP2_TEXTURE_COORD_3:
1778 data = ctx->EvalMap.Map2Texture3.Points;
1779 n = ctx->EvalMap.Map2Texture3.Uorder
1780 * ctx->EvalMap.Map2Texture3.Vorder * 3;
1781 break;
1782 case GL_MAP2_TEXTURE_COORD_4:
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;
1817 case GL_MAP1_TEXTURE_COORD_1:
1818 *v = ctx->EvalMap.Map1Texture1.Order;
1819 break;
1820 case GL_MAP1_TEXTURE_COORD_2:
1821 *v = ctx->EvalMap.Map1Texture2.Order;
1822 break;
1823 case GL_MAP1_TEXTURE_COORD_3:
1824 *v = ctx->EvalMap.Map1Texture3.Order;
1825 break;
1826 case GL_MAP1_TEXTURE_COORD_4:
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;
1847 case GL_MAP2_TEXTURE_COORD_1:
1848 v[0] = ctx->EvalMap.Map2Texture1.Uorder;
1849 v[1] = ctx->EvalMap.Map2Texture1.Vorder;
1850 break;
1851 case GL_MAP2_TEXTURE_COORD_2:
1852 v[0] = ctx->EvalMap.Map2Texture2.Uorder;
1853 v[1] = ctx->EvalMap.Map2Texture2.Vorder;
1854 break;
1855 case GL_MAP2_TEXTURE_COORD_3:
1856 v[0] = ctx->EvalMap.Map2Texture3.Uorder;
1857 v[1] = ctx->EvalMap.Map2Texture3.Vorder;
1858 break;
1859 case GL_MAP2_TEXTURE_COORD_4:
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;
1889 case GL_MAP1_TEXTURE_COORD_1:
1890 v[0] = ROUNDF(ctx->EvalMap.Map1Texture1.u1);
1891 v[1] = ROUNDF(ctx->EvalMap.Map1Texture1.u2);
1892 break;
1893 case GL_MAP1_TEXTURE_COORD_2:
1894 v[0] = ROUNDF(ctx->EvalMap.Map1Texture2.u1);
1895 v[1] = ROUNDF(ctx->EvalMap.Map1Texture2.u2);
1896 break;
1897 case GL_MAP1_TEXTURE_COORD_3:
1898 v[0] = ROUNDF(ctx->EvalMap.Map1Texture3.u1);
1899 v[1] = ROUNDF(ctx->EvalMap.Map1Texture3.u2);
1900 break;
1901 case GL_MAP1_TEXTURE_COORD_4:
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;
1931 case GL_MAP2_TEXTURE_COORD_1:
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;
1937 case GL_MAP2_TEXTURE_COORD_2:
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;
1943 case GL_MAP2_TEXTURE_COORD_3:
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;
1949 case GL_MAP2_TEXTURE_COORD_4:
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}
ROUNDF
#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 */
848 stride = components( target );
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
860 if (order<1 || order>MAX_EVAL_ORDER) {
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;
931 case GL_MAP1_TEXTURE_COORD_1:
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;
942 case GL_MAP1_TEXTURE_COORD_2:
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;
953 case GL_MAP1_TEXTURE_COORD_3:
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;
964 case GL_MAP1_TEXTURE_COORD_4:
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}
MAX_EVAL_ORDER
#define MAX_EVAL_ORDER
Definition: config.h:105
GL_INVALID_VALUE
#define GL_INVALID_VALUE
Definition: gl.h:695
GL_OUT_OF_MEMORY
#define GL_OUT_OF_MEMORY
Definition: gl.h:699
stride
GLsizei stride
Definition: glext.h:5848
u2
GLdouble GLdouble u2
Definition: glext.h:8308
order
GLuint GLdouble GLdouble GLint GLint order
Definition: glext.h:11194
u1
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
1010 if (uorder<1 || uorder>MAX_EVAL_ORDER) {
1011 gl_error( ctx, GL_INVALID_VALUE, "glMap2(uorder)" );
1012 return;
1013 }
1014
1015 if (vorder<1 || vorder>MAX_EVAL_ORDER) {
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;
1105 case GL_MAP2_TEXTURE_COORD_1:
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;
1119 case GL_MAP2_TEXTURE_COORD_2:
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;
1133 case GL_MAP2_TEXTURE_COORD_3:
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;
1147 case GL_MAP2_TEXTURE_COORD_4:
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}
un
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}
vn
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().

◆ horner_bezier_curve()

static void horner_bezier_curve ( GLfloat *  cp,
GLfloat *  out,
GLfloat  t,
GLuint  dim,
GLuint  order 
)
static

Definition at line 131 of file eval.c.

133{
134 GLfloat s, powert;
135 GLuint i, k, bincoeff;
136
137 if(order >= 2)
138 {
139 bincoeff = order-1;
140 s = 1.0-t;
141
142 for(k=0; k<dim; k++)
143 out[k] = s*cp[k] + bincoeff*t*cp[dim+k];
144
145 for(i=2, cp+=2*dim, powert=t*t; i<order; i++, powert*=t, cp +=dim)
146 {
147 bincoeff *= order-i;
148 bincoeff /= i;
149
150 for(k=0; k<dim; k++)
151 out[k] = s*out[k] + bincoeff*powert*cp[k];
152 }
153 }
154 else /* order=1 -> constant curve */
155 {
156 for(k=0; k<dim; k++)
157 out[k] = cp[k];
158 }
159}
s
GLdouble s
Definition: gl.h:2039
t
GLdouble GLdouble t
Definition: gl.h:2047
cp
POINT cp
Definition: magnifier.c:59

Referenced by gl_EvalCoord1f(), and horner_bezier_surf().

◆ horner_bezier_surf()

static void horner_bezier_surf ( GLfloat *  cn,
GLfloat *  out,
GLfloat  u,
GLfloat  v,
GLuint  dim,
GLuint  uorder,
GLuint  vorder 
)
static

Definition at line 176 of file eval.c.

178{
179 GLfloat *cp = cn + uorder*vorder*dim;
180 GLuint i, uinc = vorder*dim;
181
182 if(vorder > uorder)
183 {
184 if(uorder >= 2)
185 {
186 GLfloat s, poweru;
187 GLuint j, k, bincoeff;
188
189 /* Compute the control polygon for the surface-curve in u-direction */
190 for(j=0; j<vorder; j++)
191 {
192 GLfloat *ucp = &cn[j*dim];
193
194 /* Each control point is the point for parameter u on a */
195 /* curve defined by the control polygons in u-direction */
196 bincoeff = uorder-1;
197 s = 1.0-u;
198
199 for(k=0; k<dim; k++)
200 cp[j*dim+k] = s*ucp[k] + bincoeff*u*ucp[uinc+k];
201
202 for(i=2, ucp+=2*uinc, poweru=u*u; i<uorder;
203 i++, poweru*=u, ucp +=uinc)
204 {
205 bincoeff *= uorder-i;
206 bincoeff /= i;
207
208 for(k=0; k<dim; k++)
209 cp[j*dim+k] = s*cp[j*dim+k] + bincoeff*poweru*ucp[k];
210 }
211 }
212
213 /* Evaluate curve point in v */
214 horner_bezier_curve(cp, out, v, dim, vorder);
215 }
216 else /* uorder=1 -> cn defines a curve in v */
217 horner_bezier_curve(cn, out, v, dim, vorder);
218 }
219 else /* vorder <= uorder */
220 {
221 if(vorder > 1)
222 {
223 GLuint i;
224
225 /* Compute the control polygon for the surface-curve in u-direction */
226 for(i=0; i<uorder; i++, cn += uinc)
227 {
228 /* For constant i all cn[i][j] (j=0..vorder) are located */
229 /* on consecutive memory locations, so we can use */
230 /* horner_bezier_curve to compute the control points */
231
232 horner_bezier_curve(cn, &cp[i*dim], v, dim, vorder);
233 }
234
235 /* Evaluate curve point in u */
236 horner_bezier_curve(cp, out, u, dim, uorder);
237 }
238 else /* vorder=1 -> cn defines a curve in u */
239 horner_bezier_curve(cn, out, u, dim, uorder);
240 }
241}

Referenced by gl_EvalCoord2f().