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 } 884