src/mesa/main/es1_conversion.c

   1 #include <stdbool.h>
   2 #include "main/mfeatures.h"
   3
   4 #include "api_loopback.h"
   5 #include "api_exec.h"
   6 #include "blend.h"
   7 #include "clear.h"
   8 #include "clip.h"
   9 #include "context.h"
  10 #include "depth.h"
  11 #include "fog.h"
  12 #include "imports.h"
  13 #include "light.h"
  14 #include "lines.h"
  15 #include "matrix.h"
  16 #include "multisample.h"
  17 #include "pixelstore.h"
  18 #include "points.h"
  19 #include "polygon.h"
  20 #include "readpix.h"
  21 #include "texenv.h"
  22 #include "texgen.h"
  23 #include "texobj.h"
  24 #include "texparam.h"
  25 #include "mtypes.h"
  26 #include "viewport.h"
  27 #include "main/drawtex.h"
  28 #include "vbo/vbo.h"
  29
  30 #include "main/es1_conversion.h"
  31
  32 void GL_APIENTRY
  33 _mesa_AlphaFuncx(GLenum func, GLclampx ref)
  34 {
  35    _mesa_AlphaFunc(func, (GLclampf) (ref / 65536.0f));
  36 }
  37
  38 void GL_APIENTRY
  39 _mesa_ClearColorx(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha)
  40 {
  41    _mesa_ClearColor((GLclampf) (red / 65536.0f),
  42                     (GLclampf) (green / 65536.0f),
  43                     (GLclampf) (blue / 65536.0f),
  44                     (GLclampf) (alpha / 65536.0f));
  45 }
  46
  47 void GL_APIENTRY
  48 _mesa_ClearDepthx(GLclampx depth)
  49 {
  50    _mesa_ClearDepthf((GLclampf) (depth / 65536.0f));
  51 }
  52
  53 void GL_APIENTRY
  54 _mesa_ClipPlanef(GLenum plane, const GLfloat *equation)
  55 {
  56    unsigned int i;
  57    GLdouble converted_equation[4];
  58
  59    for (i = 0; i < Elements(converted_equation); i++) {
  60       converted_equation[i] = (GLdouble) (equation[i]);
  61    }
  62
  63    _mesa_ClipPlane(plane, converted_equation);
  64 }
  65
  66 void GL_APIENTRY
  67 _mesa_ClipPlanex(GLenum plane, const GLfixed *equation)
  68 {
  69    unsigned int i;
  70    GLdouble converted_equation[4];
  71
  72    for (i = 0; i < Elements(converted_equation); i++) {
  73       converted_equation[i] = (GLdouble) (equation[i] / 65536.0);
  74    }
  75
  76    _mesa_ClipPlane(plane, converted_equation);
  77 }
  78
  79 void GL_APIENTRY
  80 _es_Color4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
  81 {
  82     _es_Color4f((GLfloat) (red / 255.0f),
  83                 (GLfloat) (green / 255.0f),
  84                 (GLfloat) (blue / 255.0f),
  85                 (GLfloat) (alpha / 255.0f));
  86 }
  87
  88 void GL_APIENTRY
  89 _mesa_Color4x(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha)
  90 {
  91     _es_Color4f((GLfloat) (red / 65536.0f),
  92                 (GLfloat) (green / 65536.0f),
  93                 (GLfloat) (blue / 65536.0f),
  94                 (GLfloat) (alpha / 65536.0f));
  95 }
  96
  97 void GL_APIENTRY
  98 _mesa_DepthRangex(GLclampx zNear, GLclampx zFar)
  99 {
 100     _mesa_DepthRangef((GLclampf) (zNear / 65536.0f),
 101                       (GLclampf) (zFar / 65536.0f));
 102 }
 103
 104 void GL_APIENTRY
 105 _mesa_DrawTexxOES(GLfixed x, GLfixed y, GLfixed z, GLfixed w, GLfixed h)
 106 {
 107
 108     _mesa_DrawTexfOES((GLfloat) (x / 65536.0f),
 109                    (GLfloat) (y / 65536.0f),
 110                    (GLfloat) (z / 65536.0f),
 111                    (GLfloat) (w / 65536.0f),
 112                    (GLfloat) (h / 65536.0f));
 113 }
 114
 115 void GL_APIENTRY
 116 _mesa_DrawTexxvOES(const GLfixed *coords)
 117 {
 118     unsigned int i;
 119     GLfloat converted_coords[5];
 120
 121     for (i = 0; i < Elements(converted_coords); i++) {
 122         converted_coords[i] = (GLfloat) (coords[i] / 65536.0f);
 123     }
 124
 125     _mesa_DrawTexfvOES(converted_coords);
 126 }
 127
 128 void GL_APIENTRY
 129 _mesa_Fogx(GLenum pname, GLfixed param)
 130 {
 131    if (pname != GL_FOG_MODE) {
 132       _mesa_Fogf(pname, (GLfloat) (param / 65536.0f));
 133    } else {
 134       _mesa_Fogf(pname, (GLfloat) param);
 135    }
 136
 137 }
 138
 139 void GL_APIENTRY
 140 _mesa_Fogxv(GLenum pname, const GLfixed *params)
 141 {
 142    unsigned int i;
 143    unsigned int n_params = 4;
 144    GLfloat converted_params[4];
 145    bool convert_params_value = true;
 146
 147    switch(pname) {
 148    case GL_FOG_MODE:
 149       convert_params_value = false;
 150       n_params = 1;
 151       break;
 152    case GL_FOG_COLOR:
 153       n_params = 4;
 154       break;
 155    case GL_FOG_DENSITY:
 156    case GL_FOG_START:
 157    case GL_FOG_END:
 158       n_params = 1;
 159       break;
 160    default:
 161       _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM,
 162                   "glFogxv(pname=0x%x)", pname);
 163       return;
 164    }
 165
 166    if (convert_params_value) {
 167       for (i = 0; i < n_params; i++) {
 168          converted_params[i] = (GLfloat) (params[i] / 65536.0f);
 169       }
 170    } else {
 171       for (i = 0; i < n_params; i++) {
 172          converted_params[i] = (GLfloat) params[i];
 173       }
 174    }
 175
 176    _mesa_Fogfv(pname, converted_params);
 177 }
 178
 179 void GL_APIENTRY
 180 _mesa_Frustumf(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top,
 181              GLfloat zNear, GLfloat zFar)
 182 {
 183    _mesa_Frustum((GLdouble) (left),
 184                  (GLdouble) (right),
 185                  (GLdouble) (bottom),
 186                  (GLdouble) (top),
 187                  (GLdouble) (zNear),
 188                  (GLdouble) (zFar));
 189 }
 190
 191 void GL_APIENTRY
 192 _mesa_Frustumx(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top,
 193              GLfixed zNear, GLfixed zFar)
 194 {
 195    _mesa_Frustum((GLdouble) (left / 65536.0),
 196                  (GLdouble) (right / 65536.0),
 197                  (GLdouble) (bottom / 65536.0),
 198                  (GLdouble) (top / 65536.0),
 199                  (GLdouble) (zNear / 65536.0),
 200                  (GLdouble) (zFar / 65536.0));
 201 }
 202
 203 void GL_APIENTRY
 204 _mesa_GetClipPlanef(GLenum plane, GLfloat *equation)
 205 {
 206    unsigned int i;
 207    GLdouble converted_equation[4];
 208
 209    _mesa_GetClipPlane(plane, converted_equation);
 210    for (i = 0; i < Elements(converted_equation); i++) {
 211       equation[i] = (GLfloat) (converted_equation[i]);
 212    }
 213 }
 214
 215 void GL_APIENTRY
 216 _mesa_GetClipPlanex(GLenum plane, GLfixed *equation)
 217 {
 218    unsigned int i;
 219    GLdouble converted_equation[4];
 220
 221    _mesa_GetClipPlane(plane, converted_equation);
 222    for (i = 0; i < Elements(converted_equation); i++) {
 223       equation[i] = (GLfixed) (converted_equation[i] * 65536);
 224    }
 225 }
 226
 227 void GL_APIENTRY
 228 _mesa_GetLightxv(GLenum light, GLenum pname, GLfixed *params)
 229 {
 230    unsigned int i;
 231    unsigned int n_params = 4;
 232    GLfloat converted_params[4];
 233
 234    if (light < GL_LIGHT0 || light > GL_LIGHT7) {
 235       _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM,
 236                   "glGetLightxv(light=0x%x)", light);
 237       return;
 238    }
 239    switch(pname) {
 240    case GL_AMBIENT:
 241    case GL_DIFFUSE:
 242    case GL_SPECULAR:
 243    case GL_POSITION:
 244       n_params = 4;
 245       break;
 246    case GL_SPOT_DIRECTION:
 247       n_params = 3;
 248       break;
 249    case GL_SPOT_EXPONENT:
 250    case GL_SPOT_CUTOFF:
 251    case GL_CONSTANT_ATTENUATION:
 252    case GL_LINEAR_ATTENUATION:
 253    case GL_QUADRATIC_ATTENUATION:
 254       n_params = 1;
 255       break;
 256    default:
 257       _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM,
 258                   "glGetLightxv(pname=0x%x)", pname);
 259       return;
 260    }
 261
 262    _mesa_GetLightfv(light, pname, converted_params);
 263    for (i = 0; i < n_params; i++) {
 264       params[i] = (GLint) (converted_params[i] * 65536);
 265    }
 266 }
 267
 268 void GL_APIENTRY
 269 _mesa_GetMaterialxv(GLenum face, GLenum pname, GLfixed *params)
 270 {
 271    unsigned int i;
 272    unsigned int n_params = 4;
 273    GLfloat converted_params[4];
 274
 275    switch(face) {
 276    case GL_FRONT:
 277    case GL_BACK:
 278       break;
 279    default:
 280       _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM,
 281                   "glGetMaterialxv(face=0x%x)", face);
 282       return;
 283    }
 284    switch(pname) {
 285    case GL_SHININESS:
 286       n_params = 1;
 287       break;
 288    case GL_AMBIENT:
 289    case GL_DIFFUSE:
 290    case GL_SPECULAR:
 291    case GL_EMISSION:
 292       n_params = 4;
 293       break;
 294    default:
 295       _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM,
 296                   "glGetMaterialxv(pname=0x%x)", pname);
 297       return;
 298    }
 299
 300    _mesa_GetMaterialfv(face, pname, converted_params);
 301    for (i = 0; i < n_params; i++) {
 302       params[i] = (GLint) (converted_params[i] * 65536);
 303    }
 304 }
 305
 306 void GL_APIENTRY
 307 _mesa_GetTexEnvxv(GLenum target, GLenum pname, GLfixed *params)
 308 {
 309    unsigned int i;
 310    unsigned int n_params = 4;
 311    GLfloat converted_params[4];
 312    bool convert_params_value = true;
 313
 314    switch(target) {
 315    case GL_POINT_SPRITE:
 316       if (pname != GL_COORD_REPLACE) {
 317          _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM,
 318                      "glGetTexEnvxv(target=0x%x)", target);
 319          return;
 320       }
 321       break;
 322    case GL_TEXTURE_FILTER_CONTROL_EXT:
 323       if (pname != GL_TEXTURE_LOD_BIAS_EXT) {
 324          _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM,
 325                      "glGetTexEnvxv(target=0x%x)", target);
 326          return;
 327       }
 328       break;
 329    case GL_TEXTURE_ENV:
 330       if (pname != GL_TEXTURE_ENV_COLOR && pname != GL_RGB_SCALE && pname != GL_ALPHA_SCALE && pname != GL_TEXTURE_ENV_MODE && pname != GL_COMBINE_RGB && pname != GL_COMBINE_ALPHA && pname != GL_SRC0_RGB && pname != GL_SRC1_RGB && pname != GL_SRC2_RGB && pname != GL_SRC0_ALPHA && pname != GL_SRC1_ALPHA && pname != GL_SRC2_ALPHA && pname != GL_OPERAND0_RGB && pname != GL_OPERAND1_RGB && pname != GL_OPERAND2_RGB && pname != GL_OPERAND0_ALPHA && pname != GL_OPERAND1_ALPHA && pname != GL_OPERAND2_ALPHA) {
 331          _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM,
 332                      "glGetTexEnvxv(target=0x%x)", target);
 333          return;
 334       }
 335       break;
 336    default:
 337       _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM,
 338                   "glGetTexEnvxv(target=0x%x)", target);
 339       return;
 340    }
 341    switch(pname) {
 342    case GL_COORD_REPLACE:
 343       convert_params_value = false;
 344       n_params = 1;
 345       break;
 346    case GL_TEXTURE_LOD_BIAS_EXT:
 347       n_params = 1;
 348       break;
 349    case GL_TEXTURE_ENV_COLOR:
 350       n_params = 4;
 351       break;
 352    case GL_RGB_SCALE:
 353    case GL_ALPHA_SCALE:
 354       n_params = 1;
 355       break;
 356    case GL_TEXTURE_ENV_MODE:
 357    case GL_COMBINE_RGB:
 358    case GL_COMBINE_ALPHA:
 359    case GL_SRC0_RGB:
 360    case GL_SRC1_RGB:
 361    case GL_SRC2_RGB:
 362    case GL_SRC0_ALPHA:
 363    case GL_SRC1_ALPHA:
 364    case GL_SRC2_ALPHA:
 365    case GL_OPERAND0_RGB:
 366    case GL_OPERAND1_RGB:
 367    case GL_OPERAND2_RGB:
 368    case GL_OPERAND0_ALPHA:
 369    case GL_OPERAND1_ALPHA:
 370    case GL_OPERAND2_ALPHA:
 371       convert_params_value = false;
 372       n_params = 1;
 373       break;
 374    default:
 375       _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM,
 376                   "glGetTexEnvxv(pname=0x%x)", pname);
 377       return;
 378    }
 379
 380    _mesa_GetTexEnvfv(target, pname, converted_params);
 381    if (convert_params_value) {
 382       for (i = 0; i < n_params; i++) {
 383          params[i] = (GLint) (converted_params[i] * 65536);
 384       }
 385    } else {
 386       for (i = 0; i < n_params; i++) {
 387          params[i] = (GLfixed) converted_params[i];
 388       }
 389    }
 390 }
 391
 392 void GL_APIENTRY
 393 _check_GetTexGenivOES(GLenum coord, GLenum pname, GLint *params)
 394 {
 395    _mesa_GetTexGeniv(coord, pname, params);
 396 }
 397
 398 void GL_APIENTRY
 399 _mesa_GetTexGenxvOES(GLenum coord, GLenum pname, GLfixed *params)
 400 {
 401    _mesa_GetTexGeniv(coord, pname, (GLint *) params);
 402 }
 403
 404 void GL_APIENTRY
 405 _mesa_GetTexParameterxv(GLenum target, GLenum pname, GLfixed *params)
 406 {
 407    unsigned int i;
 408    unsigned int n_params = 4;
 409    GLfloat converted_params[4];
 410    bool convert_params_value = true;
 411
 412    switch(target) {
 413    case GL_TEXTURE_2D:
 414    case GL_TEXTURE_CUBE_MAP:
 415    case GL_TEXTURE_EXTERNAL_OES:
 416       break;
 417    default:
 418       _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM,
 419                   "glGetTexParameterxv(target=0x%x)", target);
 420       return;
 421    }
 422    switch(pname) {
 423    case GL_TEXTURE_WRAP_S:
 424    case GL_TEXTURE_WRAP_T:
 425    case GL_TEXTURE_MIN_FILTER:
 426    case GL_TEXTURE_MAG_FILTER:
 427    case GL_GENERATE_MIPMAP:
 428       convert_params_value = false;
 429       n_params = 1;
 430       break;
 431    case GL_TEXTURE_CROP_RECT_OES:
 432       n_params = 4;
 433       break;
 434    default:
 435       _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM,
 436                   "glGetTexParameterxv(pname=0x%x)", pname);
 437       return;
 438    }
 439
 440    _mesa_GetTexParameterfv(target, pname, converted_params);
 441    if (convert_params_value) {
 442       for (i = 0; i < n_params; i++) {
 443          params[i] = (GLint) (converted_params[i] * 65536);
 444       }
 445    } else {
 446       for (i = 0; i < n_params; i++) {
 447          params[i] = (GLfixed) converted_params[i];
 448       }
 449    }
 450 }
 451
 452 void GL_APIENTRY
 453 _mesa_LightModelx(GLenum pname, GLfixed param)
 454 {
 455    _mesa_LightModelf(pname, (GLfloat) param);
 456 }
 457
 458 void GL_APIENTRY
 459 _mesa_LightModelxv(GLenum pname, const GLfixed *params)
 460 {
 461    unsigned int i;
 462    unsigned int n_params = 4;
 463    GLfloat converted_params[4];
 464    bool convert_params_value = true;
 465
 466    switch(pname) {
 467    case GL_LIGHT_MODEL_AMBIENT:
 468       n_params = 4;
 469       break;
 470    case GL_LIGHT_MODEL_TWO_SIDE:
 471       convert_params_value = false;
 472       n_params = 1;
 473       break;
 474    default:
 475       _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM,
 476                   "glLightModelxv(pname=0x%x)", pname);
 477       return;
 478    }
 479
 480    if (convert_params_value) {
 481       for (i = 0; i < n_params; i++) {
 482          converted_params[i] = (GLfloat) (params[i] / 65536.0f);
 483       }
 484    } else {
 485       for (i = 0; i < n_params; i++) {
 486          converted_params[i] = (GLfloat) params[i];
 487       }
 488    }
 489
 490    _mesa_LightModelfv(pname, converted_params);
 491 }
 492
 493 void GL_APIENTRY
 494 _mesa_Lightx(GLenum light, GLenum pname, GLfixed param)
 495 {
 496    _mesa_Lightf(light, pname, (GLfloat) (param / 65536.0f));
 497 }
 498
 499 void GL_APIENTRY
 500 _mesa_Lightxv(GLenum light, GLenum pname, const GLfixed *params)
 501 {
 502    unsigned int i;
 503    unsigned int n_params = 4;
 504    GLfloat converted_params[4];
 505
 506    if (light < GL_LIGHT0 || light > GL_LIGHT7) {
 507       _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM,
 508                   "glLightxv(light=0x%x)", light);
 509       return;
 510    }
 511    switch(pname) {
 512    case GL_AMBIENT:
 513    case GL_DIFFUSE:
 514    case GL_SPECULAR:
 515    case GL_POSITION:
 516       n_params = 4;
 517       break;
 518    case GL_SPOT_DIRECTION:
 519       n_params = 3;
 520       break;
 521    case GL_SPOT_EXPONENT:
 522    case GL_SPOT_CUTOFF:
 523    case GL_CONSTANT_ATTENUATION:
 524    case GL_LINEAR_ATTENUATION:
 525    case GL_QUADRATIC_ATTENUATION:
 526       n_params = 1;
 527       break;
 528    default:
 529       _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM,
 530                   "glLightxv(pname=0x%x)", pname);
 531       return;
 532    }
 533
 534    for (i = 0; i < n_params; i++) {
 535       converted_params[i] = (GLfloat) (params[i] / 65536.0f);
 536    }
 537
 538    _mesa_Lightfv(light, pname, converted_params);
 539 }
 540
 541 void GL_APIENTRY
 542 _mesa_LineWidthx(GLfixed width)
 543 {
 544    _mesa_LineWidth((GLfloat) (width / 65536.0f));
 545 }
 546
 547 void GL_APIENTRY
 548 _mesa_LoadMatrixx(const GLfixed *m)
 549 {
 550    unsigned int i;
 551    GLfloat converted_m[16];
 552
 553    for (i = 0; i < Elements(converted_m); i++) {
 554       converted_m[i] = (GLfloat) (m[i] / 65536.0f);
 555    }
 556
 557    _mesa_LoadMatrixf(converted_m);
 558 }
 559
 560 void GL_APIENTRY
 561 _mesa_Materialx(GLenum face, GLenum pname, GLfixed param)
 562 {
 563    if (face != GL_FRONT_AND_BACK) {
 564       _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM,
 565                   "glMaterialx(face=0x%x)", face);
 566       return;
 567    }
 568
 569    if (pname != GL_SHININESS) {
 570       _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM,
 571                   "glMaterialx(pname=0x%x)", pname);
 572       return;
 573    }
 574
 575    _es_Materialf(face, pname, (GLfloat) (param / 65536.0f));
 576 }
 577
 578 void GL_APIENTRY
 579 _mesa_Materialxv(GLenum face, GLenum pname, const GLfixed *params)
 580 {
 581    unsigned int i;
 582    unsigned int n_params = 4;
 583    GLfloat converted_params[4];
 584
 585    if (face != GL_FRONT_AND_BACK) {
 586       _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM,
 587                   "glMaterialxv(face=0x%x)", face);
 588       return;
 589    }
 590
 591    switch(pname) {
 592    case GL_AMBIENT:
 593    case GL_DIFFUSE:
 594    case GL_AMBIENT_AND_DIFFUSE:
 595    case GL_SPECULAR:
 596    case GL_EMISSION:
 597       n_params = 4;
 598       break;
 599    case GL_SHININESS:
 600       n_params = 1;
 601       break;
 602    default:
 603       _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM,
 604                   "glMaterialxv(pname=0x%x)", pname);
 605       return;
 606    }
 607
 608    for (i = 0; i < n_params; i++) {
 609       converted_params[i] = (GLfloat) (params[i] / 65536.0f);
 610    }
 611
 612    _es_Materialfv(face, pname, converted_params);
 613 }
 614
 615 void GL_APIENTRY
 616 _mesa_MultMatrixx(const GLfixed *m)
 617 {
 618    unsigned int i;
 619    GLfloat converted_m[16];
 620
 621    for (i = 0; i < Elements(converted_m); i++) {
 622       converted_m[i] = (GLfloat) (m[i] / 65536.0f);
 623    }
 624
 625    _mesa_MultMatrixf(converted_m);
 626 }
 627
 628 void GL_APIENTRY
 629 _mesa_MultiTexCoord4x(GLenum texture, GLfixed s, GLfixed t, GLfixed r, GLfixed q)
 630 {
 631    _es_MultiTexCoord4f(texture,
 632                        (GLfloat) (s / 65536.0f),
 633                        (GLfloat) (t / 65536.0f),
 634                        (GLfloat) (r / 65536.0f),
 635                        (GLfloat) (q / 65536.0f));
 636 }
 637
 638 void GL_APIENTRY
 639 _mesa_Normal3x(GLfixed nx, GLfixed ny, GLfixed nz)
 640 {
 641    _es_Normal3f((GLfloat) (nx / 65536.0f),
 642                 (GLfloat) (ny / 65536.0f),
 643                 (GLfloat) (nz / 65536.0f));
 644 }
 645
 646 void GL_APIENTRY
 647 _mesa_Orthof(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top,
 648            GLfloat zNear, GLfloat zFar)
 649 {
 650    _mesa_Ortho((GLdouble) (left),
 651                (GLdouble) (right),
 652                (GLdouble) (bottom),
 653                (GLdouble) (top),
 654                (GLdouble) (zNear),
 655                (GLdouble) (zFar));
 656 }
 657
 658 void GL_APIENTRY
 659 _mesa_Orthox(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top,
 660            GLfixed zNear, GLfixed zFar)
 661 {
 662    _mesa_Ortho((GLdouble) (left / 65536.0),
 663                (GLdouble) (right / 65536.0),
 664                (GLdouble) (bottom / 65536.0),
 665                (GLdouble) (top / 65536.0),
 666                (GLdouble) (zNear / 65536.0),
 667                (GLdouble) (zFar / 65536.0));
 668 }
 669
 670 void GL_APIENTRY
 671 _mesa_PointParameterx(GLenum pname, GLfixed param)
 672 {
 673    _mesa_PointParameterf(pname, (GLfloat) (param / 65536.0f));
 674 }
 675
 676 void GL_APIENTRY
 677 _mesa_PointParameterxv(GLenum pname, const GLfixed *params)
 678 {
 679    unsigned int i;
 680    unsigned int n_params = 3;
 681    GLfloat converted_params[3];
 682
 683    switch(pname) {
 684    case GL_POINT_SIZE_MIN:
 685    case GL_POINT_SIZE_MAX:
 686    case GL_POINT_FADE_THRESHOLD_SIZE:
 687       n_params = 1;
 688       break;
 689    case GL_POINT_DISTANCE_ATTENUATION:
 690       n_params = 3;
 691       break;
 692    default:
 693       _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM,
 694                   "glPointParameterxv(pname=0x%x)", pname);
 695       return;
 696    }
 697
 698    for (i = 0; i < n_params; i++) {
 699       converted_params[i] = (GLfloat) (params[i] / 65536.0f);
 700    }
 701
 702    _mesa_PointParameterfv(pname, converted_params);
 703 }
 704
 705 void GL_APIENTRY
 706 _mesa_PointSizex(GLfixed size)
 707 {
 708    _mesa_PointSize((GLfloat) (size / 65536.0f));
 709 }
 710
 711 void GL_APIENTRY
 712 _mesa_PolygonOffsetx(GLfixed factor, GLfixed units)
 713 {
 714    _mesa_PolygonOffset((GLfloat) (factor / 65536.0f),
 715                        (GLfloat) (units / 65536.0f));
 716 }
 717
 718 void GL_APIENTRY
 719 _mesa_Rotatex(GLfixed angle, GLfixed x, GLfixed y, GLfixed z)
 720 {
 721    _mesa_Rotatef((GLfloat) (angle / 65536.0f),
 722                  (GLfloat) (x / 65536.0f),
 723                  (GLfloat) (y / 65536.0f),
 724                  (GLfloat) (z / 65536.0f));
 725 }
 726
 727 void GL_APIENTRY
 728 _mesa_SampleCoveragex(GLclampx value, GLboolean invert)
 729 {
 730    _mesa_SampleCoverage((GLclampf) (value / 65536.0f),
 731                            invert);
 732 }
 733
 734 void GL_APIENTRY
 735 _mesa_Scalex(GLfixed x, GLfixed y, GLfixed z)
 736 {
 737    _mesa_Scalef((GLfloat) (x / 65536.0f),
 738                 (GLfloat) (y / 65536.0f),
 739                 (GLfloat) (z / 65536.0f));
 740 }
 741
 742 void GL_APIENTRY
 743 _mesa_TexEnvx(GLenum target, GLenum pname, GLfixed param)
 744 {
 745    switch(target) {
 746    case GL_POINT_SPRITE:
 747    case GL_TEXTURE_FILTER_CONTROL_EXT:
 748    case GL_TEXTURE_ENV:
 749       break;
 750    default:
 751       _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM,
 752                   "glTexEnvx(target=0x%x)", target);
 753       return;
 754    }
 755
 756    switch(pname) {
 757    case GL_COORD_REPLACE:
 758    case GL_TEXTURE_ENV_MODE:
 759    case GL_COMBINE_RGB:
 760    case GL_COMBINE_ALPHA:
 761    case GL_SRC0_RGB:
 762    case GL_SRC1_RGB:
 763    case GL_SRC2_RGB:
 764    case GL_SRC0_ALPHA:
 765    case GL_SRC1_ALPHA:
 766    case GL_SRC2_ALPHA:
 767    case GL_OPERAND0_RGB:
 768    case GL_OPERAND1_RGB:
 769    case GL_OPERAND2_RGB:
 770    case GL_OPERAND0_ALPHA:
 771    case GL_OPERAND1_ALPHA:
 772    case GL_OPERAND2_ALPHA:
 773       _mesa_TexEnvf(target, pname, (GLfloat) param);
 774       break;
 775    case GL_TEXTURE_LOD_BIAS_EXT:
 776    case GL_RGB_SCALE:
 777    case GL_ALPHA_SCALE:
 778       _mesa_TexEnvf(target, pname, (GLfloat) (param / 65536.0f));
 779       break;
 780    default:
 781       _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM,
 782                   "glTexEnvx(pname=0x%x)", pname);
 783       return;
 784    }
 785 }
 786
 787 void GL_APIENTRY
 788 _mesa_TexEnvxv(GLenum target, GLenum pname, const GLfixed *params)
 789 {
 790    switch(target) {
 791    case GL_POINT_SPRITE:
 792    case GL_TEXTURE_FILTER_CONTROL_EXT:
 793    case GL_TEXTURE_ENV:
 794       break;
 795    default:
 796       _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM,
 797                   "glTexEnvxv(target=0x%x)", target);
 798       return;
 799    }
 800
 801    switch(pname) {
 802    case GL_COORD_REPLACE:
 803    case GL_TEXTURE_ENV_MODE:
 804    case GL_COMBINE_RGB:
 805    case GL_COMBINE_ALPHA:
 806    case GL_SRC0_RGB:
 807    case GL_SRC1_RGB:
 808    case GL_SRC2_RGB:
 809    case GL_SRC0_ALPHA:
 810    case GL_SRC1_ALPHA:
 811    case GL_SRC2_ALPHA:
 812    case GL_OPERAND0_RGB:
 813    case GL_OPERAND1_RGB:
 814    case GL_OPERAND2_RGB:
 815    case GL_OPERAND0_ALPHA:
 816    case GL_OPERAND1_ALPHA:
 817    case GL_OPERAND2_ALPHA:
 818       _mesa_TexEnvf(target, pname, (GLfloat) params[0]);
 819       break;
 820    case GL_TEXTURE_LOD_BIAS_EXT:
 821    case GL_RGB_SCALE:
 822    case GL_ALPHA_SCALE:
 823       _mesa_TexEnvf(target, pname, (GLfloat) (params[0] / 65536.0f));
 824       break;
 825    case GL_TEXTURE_ENV_COLOR: {
 826       unsigned int i;
 827       GLfloat converted_params[4];
 828
 829       for (i = 0; i < Elements(converted_params); i++) {
 830          converted_params[i] = (GLfloat) (params[i] / 65536.0f);
 831       }
 832
 833       _mesa_TexEnvfv(target, pname, converted_params);
 834       break;
 835    }
 836    default:
 837       _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM,
 838                   "glTexEnvxv(pname=0x%x)", pname);
 839       return;
 840    }
 841 }
 842
 843 void GL_APIENTRY
 844 _check_TexGeniOES(GLenum coord, GLenum pname, GLint param)
 845 {
 846    _es_TexGenf(coord, pname, (GLfloat) param);
 847 }
 848
 849 void GL_APIENTRY
 850 _check_TexGenivOES(GLenum coord, GLenum pname, const GLint *params)
 851 {
 852    _es_TexGenf(coord, pname, (GLfloat) params[0]);
 853 }
 854
 855 void GL_APIENTRY
 856 _mesa_TexGenxOES(GLenum coord, GLenum pname, GLfixed param)
 857 {
 858    _es_TexGenf(coord, pname, (GLfloat) param);
 859 }
 860
 861 void GL_APIENTRY
 862 _mesa_TexGenxvOES(GLenum coord, GLenum pname, const GLfixed *params)
 863 {
 864    _es_TexGenf(coord, pname, (GLfloat) params[0]);
 865 }
 866
 867 void GL_APIENTRY
 868 _mesa_TexParameterx(GLenum target, GLenum pname, GLfixed param)
 869 {
 870    if (pname == GL_TEXTURE_MAX_ANISOTROPY_EXT) {
 871       _mesa_TexParameterf(target, pname, (GLfloat) (param / 65536.0f));
 872    } else {
 873       _mesa_TexParameterf(target, pname, (GLfloat) param);
 874    }
 875 }
 876
 877 void GL_APIENTRY
 878 _mesa_TexParameterxv(GLenum target, GLenum pname, const GLfixed *params)
 879 {
 880    unsigned int i;
 881    unsigned int n_params = 4;
 882    GLfloat converted_params[4];
 883    bool convert_params_value = true;
 884
 885    switch(target) {
 886    case GL_TEXTURE_2D:
 887    case GL_TEXTURE_CUBE_MAP:
 888    case GL_TEXTURE_EXTERNAL_OES:
 889       break;
 890    default:
 891       _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM,
 892                   "glTexParameterxv(target=0x%x)", target);
 893       return;
 894    }
 895    switch(pname) {
 896    case GL_TEXTURE_WRAP_S:
 897    case GL_TEXTURE_WRAP_T:
 898       convert_params_value = false;
 899       n_params = 1;
 900       break;
 901    case GL_TEXTURE_MIN_FILTER:
 902    case GL_TEXTURE_MAG_FILTER:
 903    case GL_GENERATE_MIPMAP:
 904       convert_params_value = false;
 905       n_params = 1;
 906       break;
 907    case GL_TEXTURE_MAX_ANISOTROPY_EXT:
 908       n_params = 1;
 909       break;
 910    case GL_TEXTURE_CROP_RECT_OES:
 911       n_params = 4;
 912       break;
 913    default:
 914       _mesa_error(_mesa_get_current_context(), GL_INVALID_ENUM,
 915                   "glTexParameterxv(pname=0x%x)", pname);
 916       return;
 917    }
 918
 919    if (convert_params_value) {
 920       for (i = 0; i < n_params; i++) {
 921          converted_params[i] = (GLfloat) (params[i] / 65536.0f);
 922       }
 923    } else {
 924       for (i = 0; i < n_params; i++) {
 925          converted_params[i] = (GLfloat) params[i];
 926       }
 927    }
 928
 929    _mesa_TexParameterfv(target, pname, converted_params);
 930 }
 931
 932 void GL_APIENTRY
 933 _mesa_Translatex(GLfixed x, GLfixed y, GLfixed z)
 934 {
 935     _mesa_Translatef((GLfloat) (x / 65536.0f),
 936                      (GLfloat) (y / 65536.0f),
 937                      (GLfloat) (z / 65536.0f));
 938 }