opengl/libagl/light.cpp

   1 /* libs/opengles/light.cpp
   2 **
   3 ** Copyright 2006, The Android Open Source Project
   4 **
   5 ** Licensed under the Apache License, Version 2.0 (the "License");
   6 ** you may not use this file except in compliance with the License.
   7 ** You may obtain a copy of the License at
   8 **
   9 **     http://www.apache.org/licenses/LICENSE-2.0
  10 **
  11 ** Unless required by applicable law or agreed to in writing, software
  12 ** distributed under the License is distributed on an "AS IS" BASIS,
  13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 ** See the License for the specific language governing permissions and
  15 ** limitations under the License.
  16 */
  17
  18 #include <stdio.h>
  19 #include "context.h"
  20 #include "fp.h"
  21 #include "light.h"
  22 #include "state.h"
  23 #include "matrix.h"
  24
  25
  26 #if defined(__arm__) && defined(__thumb__)
  27 #warning "light.cpp should not be compiled in thumb on ARM."
  28 #endif
  29
  30 namespace android {
  31
  32 // ----------------------------------------------------------------------------
  33
  34 static void invalidate_lighting(ogles_context_t* c);
  35 static void lightVertexValidate(ogles_context_t* c, vertex_t* v);
  36 static void lightVertexNop(ogles_context_t* c, vertex_t* v);
  37 static void lightVertex(ogles_context_t* c, vertex_t* v);
  38 static void lightVertexMaterial(ogles_context_t* c, vertex_t* v);
  39
  40 static inline void vscale3(GLfixed* d, const GLfixed* m, GLfixed s);
  41
  42 static __attribute__((noinline))
  43 void vnorm3(GLfixed* d, const GLfixed* a);
  44
  45 static inline void vsa3(GLfixed* d,
  46     const GLfixed* m, GLfixed s, const GLfixed* a);
  47 static inline void vss3(GLfixed* d,
  48     const GLfixed* m, GLfixed s, const GLfixed* a);
  49 static inline void vmla3(GLfixed* d,
  50     const GLfixed* m0, const GLfixed* m1, const GLfixed* a);
  51 static inline void vmul3(GLfixed* d,
  52     const GLfixed* m0, const GLfixed* m1);
  53
  54 static GLfixed fog_linear(ogles_context_t* c, GLfixed z);
  55 static GLfixed fog_exp(ogles_context_t* c, GLfixed z);
  56 static GLfixed fog_exp2(ogles_context_t* c, GLfixed z);
  57
  58
  59 // ----------------------------------------------------------------------------
  60
  61 static void init_white(vec4_t& c) {
  62     c.r = c.g = c.b = c.a = 0x10000;
  63 }
  64
  65 void ogles_init_light(ogles_context_t* c)
  66 {
  67     for (unsigned int i=0 ; i<OGLES_MAX_LIGHTS ; i++) {
  68         c->lighting.lights[i].ambient.a = 0x10000;
  69         c->lighting.lights[i].position.z = 0x10000;
  70         c->lighting.lights[i].spotDir.z = -0x10000;
  71         c->lighting.lights[i].spotCutoff = gglIntToFixed(180);
  72         c->lighting.lights[i].attenuation[0] = 0x10000;
  73     }
  74     init_white(c->lighting.lights[0].diffuse);
  75     init_white(c->lighting.lights[0].specular);
  76
  77     c->lighting.front.ambient.r =
  78     c->lighting.front.ambient.g =
  79     c->lighting.front.ambient.b = gglFloatToFixed(0.2f);
  80     c->lighting.front.ambient.a = 0x10000;
  81     c->lighting.front.diffuse.r =
  82     c->lighting.front.diffuse.g =
  83     c->lighting.front.diffuse.b = gglFloatToFixed(0.8f);
  84     c->lighting.front.diffuse.a = 0x10000;
  85     c->lighting.front.specular.a = 0x10000;
  86     c->lighting.front.emission.a = 0x10000;
  87
  88     c->lighting.lightModel.ambient.r =
  89     c->lighting.lightModel.ambient.g =
  90     c->lighting.lightModel.ambient.b = gglFloatToFixed(0.2f);
  91     c->lighting.lightModel.ambient.a = 0x10000;
  92
  93     c->lighting.colorMaterial.face = GL_FRONT_AND_BACK;
  94     c->lighting.colorMaterial.mode = GL_AMBIENT_AND_DIFFUSE;
  95
  96     c->fog.mode = GL_EXP;
  97     c->fog.fog = fog_exp;
  98     c->fog.density = 0x10000;
  99     c->fog.end = 0x10000;
 100     c->fog.invEndMinusStart = 0x10000;
 101
 102     invalidate_lighting(c);
 103
 104     c->rasterizer.procs.shadeModel(c, GL_SMOOTH);
 105     c->lighting.shadeModel = GL_SMOOTH;
 106 }
 107
 108 void ogles_uninit_light(ogles_context_t* c)
 109 {
 110 }
 111
 112 static inline int32_t clampF(GLfixed f) CONST;
 113 int32_t clampF(GLfixed f) {
 114     f = (f & ~(f>>31));
 115     if (f >= 0x10000)
 116         f = 0x10000;
 117     return f;
 118 }
 119
 120 static GLfixed fog_linear(ogles_context_t* c, GLfixed z) {
 121     return clampF(gglMulx((c->fog.end - ((z<0)?-z:z)), c->fog.invEndMinusStart));
 122 }
 123
 124 static GLfixed fog_exp(ogles_context_t* c, GLfixed z) {
 125     const float e = fixedToFloat(gglMulx(c->fog.density, ((z<0)?-z:z)));
 126     return clampF(gglFloatToFixed(fastexpf(-e)));
 127 }
 128
 129 static GLfixed fog_exp2(ogles_context_t* c, GLfixed z) {
 130     const float e = fixedToFloat(gglMulx(c->fog.density, z));
 131     return clampF(gglFloatToFixed(fastexpf(-e*e)));
 132 }
 133
 134 // ----------------------------------------------------------------------------
 135 #if 0
 136 #pragma mark -
 137 #pragma mark math helpers
 138 #endif
 139
 140 static inline
 141 void vscale3(GLfixed* d, const GLfixed* m, GLfixed s) {
 142     d[0] = gglMulx(m[0], s);
 143     d[1] = gglMulx(m[1], s);
 144     d[2] = gglMulx(m[2], s);
 145 }
 146
 147 static inline
 148 void vsa3(GLfixed* d, const GLfixed* m, GLfixed s, const GLfixed* a) {
 149     d[0] = gglMulAddx(m[0], s, a[0]);
 150     d[1] = gglMulAddx(m[1], s, a[1]);
 151     d[2] = gglMulAddx(m[2], s, a[2]);
 152 }
 153
 154 static inline
 155 void vss3(GLfixed* d, const GLfixed* m, GLfixed s, const GLfixed* a) {
 156     d[0] = gglMulSubx(m[0], s, a[0]);
 157     d[1] = gglMulSubx(m[1], s, a[1]);
 158     d[2] = gglMulSubx(m[2], s, a[2]);
 159 }
 160
 161 static inline
 162 void vmla3(GLfixed* d,
 163         const GLfixed* m0, const GLfixed* m1, const GLfixed* a)
 164 {
 165     d[0] = gglMulAddx(m0[0], m1[0], a[0]);
 166     d[1] = gglMulAddx(m0[1], m1[1], a[1]);
 167     d[2] = gglMulAddx(m0[2], m1[2], a[2]);
 168 }
 169
 170 static inline
 171 void vmul3(GLfixed* d, const GLfixed* m0, const GLfixed* m1) {
 172     d[0] = gglMulx(m0[0], m1[0]);
 173     d[1] = gglMulx(m0[1], m1[1]);
 174     d[2] = gglMulx(m0[2], m1[2]);
 175 }
 176
 177 void vnorm3(GLfixed* d, const GLfixed* a)
 178 {
 179     // we must take care of overflows when normalizing a vector
 180     GLfixed n;
 181     int32_t x = a[0];   x = x>=0 ? x : -x;
 182     int32_t y = a[1];   y = y>=0 ? y : -y;
 183     int32_t z = a[2];   z = z>=0 ? z : -z;
 184     if (ggl_likely(x<=0x6800 && y<=0x6800 && z<= 0x6800)) {
 185         // in this case this will all fit on 32 bits
 186         n = x*x + y*y + z*z;
 187         n = gglSqrtRecipx(n);
 188         n <<= 8;
 189     } else {
 190         // here norm^2 is at least 0x7EC00000 (>>32 == 0.495117)
 191         n = vsquare3(x, y, z);
 192         n = gglSqrtRecipx(n);
 193     }
 194     vscale3(d, a, n);
 195 }
 196
 197 // ----------------------------------------------------------------------------
 198 #if 0
 199 #pragma mark -
 200 #pragma mark lighting equations
 201 #endif
 202
 203 static inline void light_picker(ogles_context_t* c)
 204 {
 205     if (ggl_likely(!c->lighting.enable)) {
 206         c->lighting.lightVertex = lightVertexNop;
 207         return;
 208     }
 209     if (c->lighting.colorMaterial.enable) {
 210         c->lighting.lightVertex = lightVertexMaterial;
 211     } else {
 212         c->lighting.lightVertex = lightVertex;
 213     }
 214 }
 215
 216 static inline void validate_light_mvi(ogles_context_t* c)
 217 {
 218     uint32_t en = c->lighting.enabledLights;
 219     // Vector from object to viewer, in eye coordinates
 220     while (en) {
 221         const int i = 31 - gglClz(en);
 222         en &= ~(1<<i);
 223         light_t& l = c->lighting.lights[i];
 224 #if OBJECT_SPACE_LIGHTING
 225         c->transforms.mvui.point4(&c->transforms.mvui,
 226                 &l.objPosition, &l.position);
 227 #else
 228         l.objPosition = l.position;
 229 #endif
 230         vnorm3(l.normalizedObjPosition.v, l.objPosition.v);
 231     }
 232     const vec4_t eyeViewer = { 0, 0, 0x10000, 0 };
 233 #if OBJECT_SPACE_LIGHTING
 234     c->transforms.mvui.point3(&c->transforms.mvui,
 235             &c->lighting.objViewer, &eyeViewer);
 236     vnorm3(c->lighting.objViewer.v, c->lighting.objViewer.v);
 237 #else
 238     c->lighting.objViewer = eyeViewer;
 239 #endif
 240 }
 241
 242 static inline void validate_light(ogles_context_t* c)
 243 {
 244     // if colorMaterial is enabled, we get the color from the vertex
 245     if (!c->lighting.colorMaterial.enable) {
 246         material_t& material = c->lighting.front;
 247         uint32_t en = c->lighting.enabledLights;
 248         while (en) {
 249             const int i = 31 - gglClz(en);
 250             en &= ~(1<<i);
 251             light_t& l = c->lighting.lights[i];
 252             vmul3(l.implicitAmbient.v,  material.ambient.v,  l.ambient.v);
 253             vmul3(l.implicitDiffuse.v,  material.diffuse.v,  l.diffuse.v);
 254             vmul3(l.implicitSpecular.v, material.specular.v, l.specular.v);
 255
 256             // this is just a flag to tell if we have a specular component
 257             l.implicitSpecular.v[3] =
 258                     l.implicitSpecular.r |
 259                     l.implicitSpecular.g |
 260                     l.implicitSpecular.b;
 261
 262             l.rConstAttenuation = (l.attenuation[1] | l.attenuation[2])==0;
 263             if (l.rConstAttenuation)
 264                 l.rConstAttenuation = gglRecipFast(l.attenuation[0]);
 265         }
 266         // emission and ambient for the whole scene
 267         vmla3(  c->lighting.implicitSceneEmissionAndAmbient.v,
 268                 c->lighting.lightModel.ambient.v,
 269                 material.ambient.v,
 270                 material.emission.v);
 271         c->lighting.implicitSceneEmissionAndAmbient.a = material.diffuse.a;
 272     }
 273     validate_light_mvi(c);
 274 }
 275
 276 void invalidate_lighting(ogles_context_t* c)
 277 {
 278     // TODO: pick lightVertexValidate or lightVertexValidateMVI
 279     // instead of systematically the heavier lightVertexValidate()
 280     c->lighting.lightVertex = lightVertexValidate;
 281 }
 282
 283 void ogles_invalidate_lighting_mvui(ogles_context_t* c)
 284 {
 285     invalidate_lighting(c);
 286 }
 287
 288 void lightVertexNop(ogles_context_t*, vertex_t* v)
 289 {
 290     // we should never end-up here
 291 }
 292
 293 void lightVertexValidateMVI(ogles_context_t* c, vertex_t* v)
 294 {
 295     validate_light_mvi(c);
 296     light_picker(c);
 297     c->lighting.lightVertex(c, v);
 298 }
 299
 300 void lightVertexValidate(ogles_context_t* c, vertex_t* v)
 301 {
 302     validate_light(c);
 303     light_picker(c);
 304     c->lighting.lightVertex(c, v);
 305 }
 306
 307 void lightVertexMaterial(ogles_context_t* c, vertex_t* v)
 308 {
 309     // fetch the material color
 310     const GLvoid* cp = c->arrays.color.element(
 311             v->index & vertex_cache_t::INDEX_MASK);
 312     c->arrays.color.fetch(c, v->color.v, cp);
 313
 314     // acquire the color-material from the vertex
 315     material_t& material = c->lighting.front;
 316     material.ambient =
 317     material.diffuse = v->color;
 318     // implicit arguments need to be computed per/vertex
 319     uint32_t en = c->lighting.enabledLights;
 320     while (en) {
 321         const int i = 31 - gglClz(en);
 322         en &= ~(1<<i);
 323         light_t& l = c->lighting.lights[i];
 324         vmul3(l.implicitAmbient.v,  material.ambient.v,  l.ambient.v);
 325         vmul3(l.implicitDiffuse.v,  material.diffuse.v,  l.diffuse.v);
 326         vmul3(l.implicitSpecular.v, material.specular.v, l.specular.v);
 327         // this is just a flag to tell if we have a specular component
 328         l.implicitSpecular.v[3] =
 329                 l.implicitSpecular.r |
 330                 l.implicitSpecular.g |
 331                 l.implicitSpecular.b;
 332     }
 333     // emission and ambient for the whole scene
 334     vmla3(  c->lighting.implicitSceneEmissionAndAmbient.v,
 335             c->lighting.lightModel.ambient.v,
 336             material.ambient.v,
 337             material.emission.v);
 338     c->lighting.implicitSceneEmissionAndAmbient.a = material.diffuse.a;
 339
 340     // now we can light our vertex as usual
 341     lightVertex(c, v);
 342 }
 343
 344 void lightVertex(ogles_context_t* c, vertex_t* v)
 345 {
 346     // emission and ambient for the whole scene
 347     vec4_t r = c->lighting.implicitSceneEmissionAndAmbient;
 348     const vec4_t objViewer = c->lighting.objViewer;
 349
 350     uint32_t en = c->lighting.enabledLights;
 351     if (ggl_likely(en)) {
 352         // since we do the lighting in object-space, we don't need to
 353         // transform each normal. However, we might still have to normalize
 354         // it if GL_NORMALIZE is enabled.
 355         vec4_t n;
 356         c->arrays.normal.fetch(c, n.v,
 357             c->arrays.normal.element(v->index & vertex_cache_t::INDEX_MASK));
 358
 359 #if !OBJECT_SPACE_LIGHTING
 360         c->transforms.mvui.point3(&c->transforms.mvui, &n, &n);
 361 #endif
 362
 363         // TODO: right now we handle GL_RESCALE_NORMALS as if it were
 364         // GL_NORMALIZE. We could optimize this by  scaling mvui
 365         // appropriately instead.
 366         if (c->transforms.rescaleNormals)
 367             vnorm3(n.v, n.v);
 368
 369         const material_t& material = c->lighting.front;
 370         const int twoSide = c->lighting.lightModel.twoSide;
 371
 372         while (en) {
 373             const int i = 31 - gglClz(en);
 374             en &= ~(1<<i);
 375             const light_t& l = c->lighting.lights[i];
 376
 377             vec4_t d, t;
 378             GLfixed s;
 379             GLfixed sqDist = 0x10000;
 380
 381             // compute vertex-to-light vector
 382             if (ggl_unlikely(l.position.w)) {
 383                 // lightPos/1.0 - vertex/vertex.w == lightPos*vertex.w - vertex
 384 #if !OBJECT_SPACE_LIGHTING
 385                 vec4_t o;
 386                 const transform_t& mv = c->transforms.modelview.transform;
 387                 mv.point4(&mv, &o, &v->obj);
 388                 vss3(d.v, l.objPosition.v, o.w, o.v);
 389 #else
 390                 vss3(d.v, l.objPosition.v, v->obj.w, v->obj.v);
 391 #endif
 392                 sqDist = dot3(d.v, d.v);
 393                 vscale3(d.v, d.v, gglSqrtRecipx(sqDist));
 394             } else {
 395                 // TODO: avoid copy here
 396                 d = l.normalizedObjPosition;
 397             }
 398
 399             // ambient & diffuse
 400             s = dot3(n.v, d.v);
 401             s = (s<0) ? (twoSide?(-s):0) : s;
 402             vsa3(t.v, l.implicitDiffuse.v, s, l.implicitAmbient.v);
 403
 404             // specular
 405             if (ggl_unlikely(s && l.implicitSpecular.v[3])) {
 406                 vec4_t h;
 407                 h.x = d.x + objViewer.x;
 408                 h.y = d.y + objViewer.y;
 409                 h.z = d.z + objViewer.z;
 410                 vnorm3(h.v, h.v);
 411                 s = dot3(n.v, h.v);
 412                 s = (s<0) ? (twoSide?(-s):0) : s;
 413                 if (s > 0) {
 414                     s = gglPowx(s, material.shininess);
 415                     vsa3(t.v, l.implicitSpecular.v, s, t.v);
 416                 }
 417             }
 418
 419             // spot
 420             if (ggl_unlikely(l.spotCutoff != gglIntToFixed(180))) {
 421                 GLfixed spotAtt = -dot3(l.normalizedSpotDir.v, d.v);
 422                 if (spotAtt >= l.spotCutoffCosine) {
 423                     vscale3(t.v, t.v, gglPowx(spotAtt, l.spotExp));
 424                 }
 425             }
 426
 427             // attenuation
 428             if (ggl_unlikely(l.position.w)) {
 429                 if (l.rConstAttenuation) {
 430                     s = l.rConstAttenuation;
 431                 } else {
 432                     s = gglMulAddx(sqDist, l.attenuation[2], l.attenuation[0]);
 433                     if (l.attenuation[1])
 434                         s = gglMulAddx(gglSqrtx(sqDist), l.attenuation[1], s);
 435                     s = gglRecipFast(s);
 436                 }
 437                 vscale3(t.v, t.v, s);
 438             }
 439
 440             r.r += t.r;
 441             r.g += t.g;
 442             r.b += t.b;
 443         }
 444     }
 445     v->color.r = gglClampx(r.r);
 446     v->color.g = gglClampx(r.g);
 447     v->color.b = gglClampx(r.b);
 448     v->color.a = gglClampx(r.a);
 449     v->flags |= vertex_t::LIT;
 450 }
 451
 452 static void lightModelx(GLenum pname, GLfixed param, ogles_context_t* c)
 453 {
 454     if (ggl_unlikely(pname != GL_LIGHT_MODEL_TWO_SIDE)) {
 455         ogles_error(c, GL_INVALID_ENUM);
 456         return;
 457     }
 458     c->lighting.lightModel.twoSide = param ? GL_TRUE : GL_FALSE;
 459     invalidate_lighting(c);
 460 }
 461
 462 static void lightx(GLenum i, GLenum pname, GLfixed param, ogles_context_t* c)
 463 {
 464     if (ggl_unlikely(uint32_t(i-GL_LIGHT0) >= OGLES_MAX_LIGHTS)) {
 465         ogles_error(c, GL_INVALID_ENUM);
 466         return;
 467     }
 468
 469     light_t& light = c->lighting.lights[i-GL_LIGHT0];
 470     const GLfixed kDegToRad = GLfixed((M_PI * gglIntToFixed(1)) / 180.0f);
 471     switch (pname) {
 472     case GL_SPOT_EXPONENT:
 473         if (GGLfixed(param) >= gglIntToFixed(128)) {
 474             ogles_error(c, GL_INVALID_VALUE);
 475             return;
 476         }
 477         light.spotExp = param;
 478         break;
 479     case GL_SPOT_CUTOFF:
 480         if (param!=gglIntToFixed(180) && GGLfixed(param)>=gglIntToFixed(90)) {
 481             ogles_error(c, GL_INVALID_VALUE);
 482             return;
 483         }
 484         light.spotCutoff = param;
 485         light.spotCutoffCosine =
 486                 gglFloatToFixed(cosinef((M_PI/(180.0f*65536.0f))*param));
 487         break;
 488     case GL_CONSTANT_ATTENUATION:
 489         if (param < 0) {
 490             ogles_error(c, GL_INVALID_VALUE);
 491             return;
 492         }
 493         light.attenuation[0] = param;
 494         break;
 495     case GL_LINEAR_ATTENUATION:
 496         if (param < 0) {
 497             ogles_error(c, GL_INVALID_VALUE);
 498             return;
 499         }
 500         light.attenuation[1] = param;
 501         break;
 502     case GL_QUADRATIC_ATTENUATION:
 503         if (param < 0) {
 504             ogles_error(c, GL_INVALID_VALUE);
 505             return;
 506         }
 507         light.attenuation[2] = param;
 508         break;
 509     default:
 510         ogles_error(c, GL_INVALID_ENUM);
 511         return;
 512     }
 513     invalidate_lighting(c);
 514 }
 515
 516 static void lightxv(GLenum i, GLenum pname, const GLfixed *params, ogles_context_t* c)
 517 {
 518     if (ggl_unlikely(uint32_t(i-GL_LIGHT0) >= OGLES_MAX_LIGHTS)) {
 519         ogles_error(c, GL_INVALID_ENUM);
 520         return;
 521     }
 522
 523     GLfixed* what;
 524     light_t& light = c->lighting.lights[i-GL_LIGHT0];
 525     switch (pname) {
 526     case GL_AMBIENT:
 527         what = light.ambient.v;
 528         break;
 529     case GL_DIFFUSE:
 530         what = light.diffuse.v;
 531         break;
 532     case GL_SPECULAR:
 533         what = light.specular.v;
 534         break;
 535     case GL_POSITION: {
 536         ogles_validate_transform(c, transform_state_t::MODELVIEW);
 537         transform_t& mv = c->transforms.modelview.transform;
 538         mv.point4(&mv, &light.position, reinterpret_cast<vec4_t const*>(params));
 539         invalidate_lighting(c);
 540         return;
 541     }
 542     case GL_SPOT_DIRECTION: {
 543 #if OBJECT_SPACE_LIGHTING
 544         ogles_validate_transform(c, transform_state_t::MVUI);
 545         transform_t& mvui = c->transforms.mvui;
 546         mvui.point3(&mvui, &light.spotDir, reinterpret_cast<vec4_t const*>(params));
 547 #else
 548         light.spotDir = *reinterpret_cast<vec4_t const*>(params);
 549 #endif
 550         vnorm3(light.normalizedSpotDir.v, light.spotDir.v);
 551         invalidate_lighting(c);
 552         return;
 553     }
 554     default:
 555         lightx(i, pname, params[0], c);
 556         return;
 557     }
 558     what[0] = params[0];
 559     what[1] = params[1];
 560     what[2] = params[2];
 561     what[3] = params[3];
 562     invalidate_lighting(c);
 563 }
 564
 565 static void materialx(GLenum face, GLenum pname, GLfixed param, ogles_context_t* c)
 566 {
 567     if (ggl_unlikely(face != GL_FRONT_AND_BACK)) {
 568         ogles_error(c, GL_INVALID_ENUM);
 569         return;
 570     }
 571     if (ggl_unlikely(pname != GL_SHININESS)) {
 572         ogles_error(c, GL_INVALID_ENUM);
 573         return;
 574     }
 575     c->lighting.front.shininess = param;
 576     invalidate_lighting(c);
 577 }
 578
 579 static void fogx(GLenum pname, GLfixed param, ogles_context_t* c)
 580 {
 581     switch (pname) {
 582     case GL_FOG_DENSITY:
 583         if (param >= 0) {
 584             c->fog.density = param;
 585             break;
 586         }
 587         ogles_error(c, GL_INVALID_VALUE);
 588         break;
 589     case GL_FOG_START:
 590         c->fog.start = param;
 591         c->fog.invEndMinusStart = gglRecip(c->fog.end - c->fog.start);
 592         break;
 593     case GL_FOG_END:
 594         c->fog.end = param;
 595         c->fog.invEndMinusStart = gglRecip(c->fog.end - c->fog.start);
 596         break;
 597     case GL_FOG_MODE:
 598         switch (param) {
 599         case GL_LINEAR:
 600             c->fog.mode = param;
 601             c->fog.fog = fog_linear;
 602             break;
 603         case GL_EXP:
 604             c->fog.mode = param;
 605             c->fog.fog = fog_exp;
 606             break;
 607         case GL_EXP2:
 608             c->fog.mode = param;
 609             c->fog.fog = fog_exp2;
 610             break;
 611         default:
 612             ogles_error(c, GL_INVALID_ENUM);
 613             break;
 614         }
 615         break;
 616     default:
 617         ogles_error(c, GL_INVALID_ENUM);
 618         break;
 619     }
 620 }
 621
 622 // ----------------------------------------------------------------------------
 623 }; // namespace android
 624 // ----------------------------------------------------------------------------
 625
 626 using namespace android;
 627
 628 #if 0
 629 #pragma mark -
 630 #pragma mark lighting APIs
 631 #endif
 632
 633 void glShadeModel(GLenum mode)
 634 {
 635     ogles_context_t* c = ogles_context_t::get();
 636     if (ggl_unlikely(mode != GL_SMOOTH && mode != GL_FLAT)) {
 637         ogles_error(c, GL_INVALID_ENUM);
 638         return;
 639     }
 640     c->lighting.shadeModel = mode;
 641 }
 642
 643 void glLightModelf(GLenum pname, GLfloat param)
 644 {
 645     ogles_context_t* c = ogles_context_t::get();
 646     lightModelx(pname, gglFloatToFixed(param), c);
 647 }
 648
 649 void glLightModelx(GLenum pname, GLfixed param)
 650 {
 651     ogles_context_t* c = ogles_context_t::get();
 652     lightModelx(pname, param, c);
 653 }
 654
 655 void glLightModelfv(GLenum pname, const GLfloat *params)
 656 {
 657     ogles_context_t* c = ogles_context_t::get();
 658     if (pname == GL_LIGHT_MODEL_TWO_SIDE) {
 659         lightModelx(pname, gglFloatToFixed(params[0]), c);
 660         return;
 661     }
 662
 663     if (ggl_unlikely(pname != GL_LIGHT_MODEL_AMBIENT)) {
 664         ogles_error(c, GL_INVALID_ENUM);
 665         return;
 666     }
 667
 668     c->lighting.lightModel.ambient.r = gglFloatToFixed(params[0]);
 669     c->lighting.lightModel.ambient.g = gglFloatToFixed(params[1]);
 670     c->lighting.lightModel.ambient.b = gglFloatToFixed(params[2]);
 671     c->lighting.lightModel.ambient.a = gglFloatToFixed(params[3]);
 672     invalidate_lighting(c);
 673 }
 674
 675 void glLightModelxv(GLenum pname, const GLfixed *params)
 676 {
 677     ogles_context_t* c = ogles_context_t::get();
 678     if (pname == GL_LIGHT_MODEL_TWO_SIDE) {
 679         lightModelx(pname, params[0], c);
 680         return;
 681     }
 682
 683     if (ggl_unlikely(pname != GL_LIGHT_MODEL_AMBIENT)) {
 684         ogles_error(c, GL_INVALID_ENUM);
 685         return;
 686     }
 687
 688     c->lighting.lightModel.ambient.r = params[0];
 689     c->lighting.lightModel.ambient.g = params[1];
 690     c->lighting.lightModel.ambient.b = params[2];
 691     c->lighting.lightModel.ambient.a = params[3];
 692     invalidate_lighting(c);
 693 }
 694
 695 // ----------------------------------------------------------------------------
 696 #if 0
 697 #pragma mark -
 698 #endif
 699
 700 void glLightf(GLenum i, GLenum pname, GLfloat param)
 701 {
 702     ogles_context_t* c = ogles_context_t::get();
 703     lightx(i, pname, gglFloatToFixed(param), c);
 704 }
 705
 706 void glLightx(GLenum i, GLenum pname, GLfixed param)
 707 {
 708     ogles_context_t* c = ogles_context_t::get();
 709     lightx(i, pname, param, c);
 710 }
 711
 712 void glLightfv(GLenum i, GLenum pname, const GLfloat *params)
 713 {
 714     ogles_context_t* c = ogles_context_t::get();
 715     switch (pname) {
 716     case GL_SPOT_EXPONENT:
 717     case GL_SPOT_CUTOFF:
 718     case GL_CONSTANT_ATTENUATION:
 719     case GL_LINEAR_ATTENUATION:
 720     case GL_QUADRATIC_ATTENUATION:
 721         lightx(i, pname, gglFloatToFixed(params[0]), c);
 722         return;
 723     }
 724
 725     GLfixed paramsx[4];
 726     paramsx[0] = gglFloatToFixed(params[0]);
 727     paramsx[1] = gglFloatToFixed(params[1]);
 728     paramsx[2] = gglFloatToFixed(params[2]);
 729     if (pname != GL_SPOT_DIRECTION)
 730         paramsx[3] = gglFloatToFixed(params[3]);
 731
 732     lightxv(i, pname, paramsx, c);
 733 }
 734
 735 void glLightxv(GLenum i, GLenum pname, const GLfixed *params)
 736 {
 737     ogles_context_t* c = ogles_context_t::get();
 738     lightxv(i, pname, params, c);
 739 }
 740
 741 // ----------------------------------------------------------------------------
 742 #if 0
 743 #pragma mark -
 744 #endif
 745
 746 void glMaterialf(GLenum face, GLenum pname, GLfloat param)
 747 {
 748     ogles_context_t* c = ogles_context_t::get();
 749     materialx(face, pname, gglFloatToFixed(param), c);
 750 }
 751
 752 void glMaterialx(GLenum face, GLenum pname, GLfixed param)
 753 {
 754     ogles_context_t* c = ogles_context_t::get();
 755     materialx(face, pname, param, c);
 756 }
 757
 758 void glMaterialfv(
 759     GLenum face, GLenum pname, const GLfloat *params)
 760 {
 761     ogles_context_t* c = ogles_context_t::get();
 762     if (ggl_unlikely(face != GL_FRONT_AND_BACK)) {
 763         ogles_error(c, GL_INVALID_ENUM);
 764         return;
 765     }
 766     GLfixed* what=0;
 767     GLfixed* other=0;
 768     switch (pname) {
 769     case GL_AMBIENT:    what = c->lighting.front.ambient.v; break;
 770     case GL_DIFFUSE:    what = c->lighting.front.diffuse.v; break;
 771     case GL_SPECULAR:   what = c->lighting.front.specular.v; break;
 772     case GL_EMISSION:   what = c->lighting.front.emission.v; break;
 773     case GL_AMBIENT_AND_DIFFUSE:
 774         what  = c->lighting.front.ambient.v;
 775         other = c->lighting.front.diffuse.v;
 776         break;
 777     case GL_SHININESS:
 778         c->lighting.front.shininess = gglFloatToFixed(params[0]);
 779         invalidate_lighting(c);
 780         return;
 781     default:
 782         ogles_error(c, GL_INVALID_ENUM);
 783         return;
 784     }
 785     what[0] = gglFloatToFixed(params[0]);
 786     what[1] = gglFloatToFixed(params[1]);
 787     what[2] = gglFloatToFixed(params[2]);
 788     what[3] = gglFloatToFixed(params[3]);
 789     if (other) {
 790         other[0] = what[0];
 791         other[1] = what[1];
 792         other[2] = what[2];
 793         other[3] = what[3];
 794     }
 795     invalidate_lighting(c);
 796 }
 797
 798 void glMaterialxv(
 799     GLenum face, GLenum pname, const GLfixed *params)
 800 {
 801     ogles_context_t* c = ogles_context_t::get();
 802     if (ggl_unlikely(face != GL_FRONT_AND_BACK)) {
 803         ogles_error(c, GL_INVALID_ENUM);
 804         return;
 805     }
 806     GLfixed* what=0;
 807     GLfixed* other=0;
 808     switch (pname) {
 809     case GL_AMBIENT:    what = c->lighting.front.ambient.v; break;
 810     case GL_DIFFUSE:    what = c->lighting.front.diffuse.v; break;
 811     case GL_SPECULAR:   what = c->lighting.front.specular.v; break;
 812     case GL_EMISSION:   what = c->lighting.front.emission.v; break;
 813     case GL_AMBIENT_AND_DIFFUSE:
 814         what  = c->lighting.front.ambient.v;
 815         other = c->lighting.front.diffuse.v;
 816         break;
 817     case GL_SHININESS:
 818         c->lighting.front.shininess = gglFloatToFixed(params[0]);
 819         invalidate_lighting(c);
 820         return;
 821     default:
 822         ogles_error(c, GL_INVALID_ENUM);
 823         return;
 824     }
 825     what[0] = params[0];
 826     what[1] = params[1];
 827     what[2] = params[2];
 828     what[3] = params[3];
 829     if (other) {
 830         other[0] = what[0];
 831         other[1] = what[1];
 832         other[2] = what[2];
 833         other[3] = what[3];
 834     }
 835     invalidate_lighting(c);
 836 }
 837
 838 // ----------------------------------------------------------------------------
 839 #if 0
 840 #pragma mark -
 841 #pragma mark fog
 842 #endif
 843
 844 void glFogf(GLenum pname, GLfloat param) {
 845     ogles_context_t* c = ogles_context_t::get();
 846     GLfixed paramx = (GLfixed)param;
 847     if (pname != GL_FOG_MODE)
 848         paramx = gglFloatToFixed(param);
 849     fogx(pname, paramx, c);
 850 }
 851
 852 void glFogx(GLenum pname, GLfixed param) {
 853     ogles_context_t* c = ogles_context_t::get();
 854     fogx(pname, param, c);
 855 }
 856
 857 void glFogfv(GLenum pname, const GLfloat *params)
 858 {
 859     ogles_context_t* c = ogles_context_t::get();
 860     if (pname != GL_FOG_COLOR) {
 861         GLfixed paramx = (GLfixed)params[0];
 862         if (pname != GL_FOG_MODE)
 863             paramx = gglFloatToFixed(params[0]);
 864         fogx(pname, paramx, c);
 865         return;
 866     }
 867     GLfixed paramsx[4];
 868     paramsx[0] = gglFloatToFixed(params[0]);
 869     paramsx[1] = gglFloatToFixed(params[1]);
 870     paramsx[2] = gglFloatToFixed(params[2]);
 871     paramsx[3] = gglFloatToFixed(params[3]);
 872     c->rasterizer.procs.fogColor3xv(c, paramsx);
 873 }
 874
 875 void glFogxv(GLenum pname, const GLfixed *params)
 876 {
 877     ogles_context_t* c = ogles_context_t::get();
 878     if (pname != GL_FOG_COLOR) {
 879         fogx(pname, params[0], c);
 880         return;
 881     }
 882     c->rasterizer.procs.fogColor3xv(c, params);
 883 }