source/lighttypes.cc

   1 /* This file is part of Shapes.
   2  *
   3  * Shapes is free software: you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation, either version 3 of the License, or
   6  * any later version.
   7  *
   8  * Shapes is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with Shapes.  If not, see <http://www.gnu.org/licenses/>.
  15  *
  16  * Copyright 2008 Henrik Tidefelt
  17  */
  18
  19 #include <cmath>
  20
  21 #include "lighttypes.h"
  22 #include "astclass.h"
  23 #include "globals.h"
  24 #include "constructorrepresentation.h"
  25
  26 using namespace Shapes;
  27
  28
  29 Lang::SpecularReflection::SpecularReflection( )
  30 { }
  31
  32 Lang::SpecularReflection::~SpecularReflection( )
  33 { }
  34
  35 DISPATCHIMPL( SpecularReflection );
  36
  37 RefCountPtr< const Lang::Class > Lang::SpecularReflection::TypeID( new Lang::SystemFinalClass( strrefdup( "SpecularReflection" ) ) );
  38 TYPEINFOIMPL( SpecularReflection );
  39
  40 void
  41 Lang::SpecularReflection::gcMark( Kernel::GCMarkedSet & marked )
  42 { }
  43
  44 Lang::SpecularReflectionTerm::SpecularReflectionTerm( double weight, double exponent )
  45         : weight_( weight ), exponent_( exponent )
  46 { }
  47
  48 Lang::SpecularReflectionTerm::~SpecularReflectionTerm( )
  49 { }
  50
  51 double
  52 Lang::SpecularReflectionTerm::weight( ) const
  53 {
  54         return weight_;
  55 }
  56
  57 RefCountPtr< const Lang::SpecularReflection >
  58 Lang::SpecularReflectionTerm::multiply( double scalar ) const
  59 {
  60         return RefCountPtr< const Lang::SpecularReflection >( new Lang::SpecularReflectionTerm( scalar * weight_, exponent_ ) );
  61 }
  62
  63
  64 Concrete::Gray
  65 Lang::SpecularReflectionTerm::illuminate( const Concrete::Coords3D & point, const Concrete::Length eyez, const Concrete::UnitFloatTriple & unitNormal, const Lang::GrayLight & light ) const
  66 {
  67         return light.illuminateGray( point, eyez, unitNormal, *this );
  68 }
  69
  70 Concrete::RGB
  71 Lang::SpecularReflectionTerm::illuminate( const Concrete::Coords3D & point, const Concrete::Length eyez, const Concrete::UnitFloatTriple & unitNormal, const Lang::RGBLight & light ) const
  72 {
  73         return light.illuminateRGB( point, eyez, unitNormal, *this );
  74 }
  75
  76 Concrete::Gray
  77 Lang::SpecularReflectionTerm::illuminate( const Concrete::Coords3D & point, const Concrete::Length eyez, const Concrete::UnitFloatTriple & unitNormal, const Concrete::Gray & autoIntensity ) const
  78 {
  79         // According to my calculations, the autoIntensity seen by the eye does not change with the distance to the object;
  80         // one the size of the object changes, which will make the received power decrease with distance.
  81         return Concrete::Gray( weight_ * pow( fabs( Concrete::inner( unitNormal, ( Concrete::Coords3D( 0, 0, eyez ) - point ).direction( ) ) ), exponent_ ) * autoIntensity.gr_ );
  82 }
  83
  84 Concrete::RGB
  85 Lang::SpecularReflectionTerm::illuminate( const Concrete::Coords3D & point, const Concrete::Length eyez, const Concrete::UnitFloatTriple & unitNormal, const Concrete::RGB & autoIntensity ) const
  86 {
  87         // According to my calculations, the autoIntensity seen by the eye does not change with the distance to the object;
  88         // one the size of the object changes, which will make the received power decrease with distance.
  89         double a = weight_ * pow( fabs( Concrete::inner( unitNormal, ( Concrete::Coords3D( 0, 0, eyez ) - point ).direction( ) ) ), exponent_ );
  90         return Concrete::RGB( a * autoIntensity.r_, a * autoIntensity.g_, a * autoIntensity.b_ );
  91 }
  92
  93 double
  94 Lang::SpecularReflectionTerm::exponent( ) const
  95 {
  96         return exponent_;
  97 }
  98
  99
 100 Lang::SpecularReflectionNull::SpecularReflectionNull( )
 101 { }
 102
 103 Lang::SpecularReflectionNull::~SpecularReflectionNull( )
 104 { }
 105
 106 double
 107 Lang::SpecularReflectionNull::weight( ) const
 108 {
 109         return 0.;
 110 }
 111
 112 RefCountPtr< const Lang::SpecularReflection >
 113 Lang::SpecularReflectionNull::multiply( double scalar ) const
 114 {
 115         return Lang::THE_SPECULARREFLECTION_NULL;
 116 }
 117
 118 Concrete::Gray
 119 Lang::SpecularReflectionNull::illuminate( const Concrete::Coords3D & point, const Concrete::Length eyez, const Concrete::UnitFloatTriple & unitNormal, const Lang::GrayLight & light ) const
 120 {
 121         return Concrete::Gray( 0. );
 122 }
 123
 124 Concrete::RGB
 125 Lang::SpecularReflectionNull::illuminate( const Concrete::Coords3D & point, const Concrete::Length eyez, const Concrete::UnitFloatTriple & unitNormal, const Lang::RGBLight & light ) const
 126 {
 127         return Concrete::RGB( 0., 0., 0. );
 128 }
 129
 130 Concrete::Gray
 131 Lang::SpecularReflectionNull::illuminate( const Concrete::Coords3D & point, const Concrete::Length eyez, const Concrete::UnitFloatTriple & unitNormal, const Concrete::Gray & autoIntensity ) const
 132 {
 133         return Concrete::Gray( 0. );
 134 }
 135
 136 Concrete::RGB
 137 Lang::SpecularReflectionNull::illuminate( const Concrete::Coords3D & point, const Concrete::Length eyez, const Concrete::UnitFloatTriple & unitNormal, const Concrete::RGB & autoIntensity ) const
 138 {
 139         return Concrete::RGB( 0., 0., 0. );
 140 }
 141
 142
 143 Lang::SpecularReflectionPair::SpecularReflectionPair( const RefCountPtr< const Lang::SpecularReflection > & car, const RefCountPtr< const Lang::SpecularReflection > & cdr )
 144         : car_( car ), cdr_( cdr )
 145 { }
 146
 147 Lang::SpecularReflectionPair::~SpecularReflectionPair( )
 148 { }
 149
 150 double
 151 Lang::SpecularReflectionPair::weight( ) const
 152 {
 153         return car_->weight( ) + cdr_->weight( );
 154 }
 155
 156 RefCountPtr< const Lang::SpecularReflection >
 157 Lang::SpecularReflectionPair::multiply( double scalar ) const
 158 {
 159         return RefCountPtr< const Lang::SpecularReflection >
 160                 ( new Lang::SpecularReflectionPair( car_->multiply( scalar ), cdr_->multiply( scalar ) ) );
 161 }
 162
 163
 164 Concrete::Gray
 165 Lang::SpecularReflectionPair::illuminate( const Concrete::Coords3D & point, const Concrete::Length eyez, const Concrete::UnitFloatTriple & unitNormal, const Lang::GrayLight & light ) const
 166 {
 167         return car_->illuminate( point, eyez, unitNormal, light ).addNoCheck( cdr_->illuminate( point, eyez, unitNormal, light ) );
 168 }
 169
 170 Concrete::RGB
 171 Lang::SpecularReflectionPair::illuminate( const Concrete::Coords3D & point, const Concrete::Length eyez, const Concrete::UnitFloatTriple & unitNormal, const Lang::RGBLight & light ) const
 172 {
 173         return car_->illuminate( point, eyez, unitNormal, light ).addNoCheck( cdr_->illuminate( point, eyez, unitNormal, light ) );
 174 }
 175
 176 Concrete::Gray
 177 Lang::SpecularReflectionPair::illuminate( const Concrete::Coords3D & point, const Concrete::Length eyez, const Concrete::UnitFloatTriple & unitNormal, const Concrete::Gray & autoIntensity ) const
 178 {
 179         return car_->illuminate( point, eyez, unitNormal, autoIntensity ).addNoCheck( cdr_->illuminate( point, eyez, unitNormal, autoIntensity ) );
 180 }
 181
 182 Concrete::RGB
 183 Lang::SpecularReflectionPair::illuminate( const Concrete::Coords3D & point, const Concrete::Length eyez, const Concrete::UnitFloatTriple & unitNormal, const Concrete::RGB & autoIntensity ) const
 184 {
 185         return car_->illuminate( point, eyez, unitNormal, autoIntensity ).addNoCheck( cdr_->illuminate( point, eyez, unitNormal, autoIntensity ) );
 186 }
 187
 188
 189 Lang::LightSource::LightSource( bool shadows )
 190         : shadows_( shadows )
 191 { }
 192
 193 DISPATCHIMPL( LightSource );
 194
 195 RefCountPtr< const Lang::Class > Lang::LightSource::TypeID( new Lang::SystemFinalClass( strrefdup( "LightSource" ) ) );
 196 TYPEINFOIMPL( LightSource );
 197
 198 Lang::LightSource::~LightSource( )
 199 { }
 200
 201 RefCountPtr< const Lang::Geometric3D >
 202 Lang::LightSource::transformed( const Lang::Transform3D & tf, const RefCountPtr< const Lang::Geometric3D > & self ) const
 203 {
 204         return typed_transformed( tf );
 205 }
 206
 207 RefCountPtr< const Lang::Geometric2D >
 208 Lang::LightSource::to2D( const Kernel::PassedDyn & dyn, const RefCountPtr< const Lang::Geometric3D > & self ) const
 209 {
 210         throw Exceptions::MiscellaneousRequirement( "A LightSource cannot be viewed in 2D." );
 211 }
 212
 213 void
 214 Lang::LightSource::gcMark( Kernel::GCMarkedSet & marked )
 215 { }
 216
 217
 218 Lang::GrayLight::GrayLight( bool shadows )
 219         : Lang::LightSource( shadows )
 220 { }
 221
 222 Lang::GrayLight::~GrayLight( )
 223 { }
 224
 225
 226 Lang::RGBLight::RGBLight( bool shadows )
 227         : Lang::LightSource( shadows )
 228 { }
 229
 230 Lang::RGBLight::~RGBLight( )
 231 { }
 232
 233
 234 Lang::AmbientLightGray::AmbientLightGray( const Concrete::Gray & intensity )
 235         : Lang::GrayLight( false ), intensity_( intensity )
 236 { }
 237
 238 Lang::AmbientLightGray::~AmbientLightGray( )
 239 { }
 240
 241 RefCountPtr< const Lang::LightSource >
 242 Lang::AmbientLightGray::typed_transformed( const Lang::Transform3D & tf ) const
 243 {
 244         // It's sad that we don't have access to the self reference, so that it could be returned instead of a new object with is just a copy of ourselves.
 245         return RefCountPtr< const Lang::LightSource >( new Lang::AmbientLightGray( intensity_ ) );
 246 }
 247
 248 Concrete::RGB
 249 Lang::AmbientLightGray::illuminateRGB( const Concrete::Coords3D & point, const Concrete::Length eyez, const Concrete::UnitFloatTriple & unitNormal, const Lang::SpecularReflectionTerm & refl ) const
 250 {
 251         double a = intensity_.gr_ * refl.weight( );
 252         return Concrete::RGB( a, a, a );
 253 }
 254
 255 Concrete::Gray
 256 Lang::AmbientLightGray::illuminateGray( const Concrete::Coords3D & point, const Concrete::Length eyez, const Concrete::UnitFloatTriple & unitNormal, const Lang::SpecularReflectionTerm & refl ) const
 257 {
 258         return Concrete::Gray( intensity_.gr_ * refl.weight( ) );
 259 }
 260
 261 Lang::AmbientLightRGB::AmbientLightRGB( const Concrete::RGB & intensity )
 262         : Lang::RGBLight( false ), intensity_( intensity )
 263 { }
 264
 265 Lang::AmbientLightRGB::~AmbientLightRGB( )
 266 { }
 267
 268 RefCountPtr< const Lang::LightSource >
 269 Lang::AmbientLightRGB::typed_transformed( const Lang::Transform3D & tf ) const
 270 {
 271         return RefCountPtr< const Lang::LightSource >( new Lang::AmbientLightRGB( intensity_ ) );
 272 }
 273
 274 Concrete::RGB
 275 Lang::AmbientLightRGB::illuminateRGB( const Concrete::Coords3D & point, const Concrete::Length eyez, const Concrete::UnitFloatTriple & unitNormal, const Lang::SpecularReflectionTerm & refl ) const
 276 {
 277         const double w = refl.weight( );
 278         return Concrete::RGB( intensity_.r_ * w, intensity_.g_ * w, intensity_.b_ * w );
 279 }
 280
 281 Lang::SpecularLightGray::SpecularLightGray( const Concrete::Coords3D & p, const Concrete::Gray & intensity, Concrete::Length intensityRadius, bool shadows )
 282         : Lang::GrayLight( shadows ), p_( p ), intensity_( intensity ), intensityRadius_( intensityRadius )
 283 { }
 284
 285 Lang::SpecularLightGray::~SpecularLightGray( )
 286 { }
 287
 288 RefCountPtr< const Lang::LightSource >
 289 Lang::SpecularLightGray::typed_transformed( const Lang::Transform3D & tf ) const
 290 {
 291         return RefCountPtr< const Lang::LightSource >( new Lang::SpecularLightGray( p_.transformed( tf ), intensity_, intensityRadius_, shadows_ ) );
 292 }
 293
 294 Concrete::RGB
 295 Lang::SpecularLightGray::illuminateRGB( const Concrete::Coords3D & point, const Concrete::Length eyez, const Concrete::UnitFloatTriple & unitNormal, const Lang::SpecularReflectionTerm & refl ) const
 296 {
 297         // Refer to SpecularLightGray::illuminateGray for comments regarding this code.
 298         // This function shall be analogous to that function.
 299
 300         Concrete::Coords3D rLight = p_ - point;
 301         Concrete::Coords3D rEye = Concrete::Coords3D( Concrete::ZERO_LENGTH, Concrete::ZERO_LENGTH, eyez ) - point;
 302         Concrete::Length dLight = rLight.norm( );
 303         Concrete::Length dEye = rEye.norm( );
 304         Concrete::UnitFloatTriple rHatLight = rLight.direction( dLight );
 305         Concrete::UnitFloatTriple rHatEye = rEye.direction( dEye );
 306         Concrete::Length dTot = dLight + dEye;
 307
 308         Concrete::UnitFloatTriple rHatReflection = unitNormal.reflect( rHatLight );
 309
 310         // This breaks the Phong model, but I want reflection in all directions!
 311         // ... as long as the light and the eye are on the same side of the surface!
 312         if( ( Concrete::inner( unitNormal, rHatEye ) > 0 ) != ( Concrete::inner( unitNormal, rHatLight ) > 0 ) )
 313                 {
 314                         return Concrete::RGB( 0, 0, 0 );
 315                 }
 316         const double cPhong2 = cos( 0.5 * acos( Concrete::inner( rHatReflection, rHatEye ) ) );
 317
 318         // Just in case numeric errors make c negative anyway...
 319         if( cPhong2 <= 0 )
 320                 {
 321                         return Concrete::RGB( 0, 0, 0 );
 322                 }
 323
 324         // Further, I want something that becomes ambient when refl.exponent == 0.
 325
 326         double cAmb = 1;
 327         if( refl.exponent( ) < 1 )
 328                 {
 329                         cAmb = pow( fabs( Concrete::inner( unitNormal, rHatLight ) ), 1 - refl.exponent( ) );
 330                 }
 331
 332         double rRel = 1;
 333         if( intensityRadius_ < Concrete::HUGE_LENGTH )
 334                 {
 335                         rRel = intensityRadius_ / dTot;
 336                 }
 337
 338         double a = intensity_.mulNoCheck( refl.weight( ) * pow( cPhong2, refl.exponent( ) ) * cAmb * rRel * rRel ).gr_;
 339         return Concrete::RGB( a, a, a );
 340 }
 341
 342 Concrete::Gray
 343 Lang::SpecularLightGray::illuminateGray( const Concrete::Coords3D & point, const Concrete::Length eyez, const Concrete::UnitFloatTriple & unitNormal, const Lang::SpecularReflectionTerm & refl ) const
 344 {
 345         Concrete::Coords3D rLight = p_ - point;
 346         Concrete::Coords3D rEye = Concrete::Coords3D( Concrete::ZERO_LENGTH, Concrete::ZERO_LENGTH, eyez ) - point;
 347         Concrete::Length dLight = rLight.norm( );
 348         Concrete::Length dEye = rEye.norm( );
 349         Concrete::UnitFloatTriple rHatLight = rLight.direction( dLight );
 350         Concrete::UnitFloatTriple rHatEye = rEye.direction( dEye );
 351         Concrete::Length dTot = dLight + dEye;
 352
 353         Concrete::UnitFloatTriple rHatReflection = unitNormal.reflect( rHatLight );
 354
 355 //       std::cerr << "Point: " << Helpers::shapesFormat( point ) << std::endl ;
 356 //       std::cerr << "rLight: " << Helpers::shapesFormat( rLight ) << std::endl ;
 357 //       std::cerr << "Surface normal: " << Helpers::shapesFormat( unitNormal ) << std::endl ;
 358 //       std::cerr << "rHatReflection: " << Helpers::shapesFormat( rHatReflection ) << std::endl ;
 359 //       std::cerr << "rEye: " << Helpers::shapesFormat( rEye ) << std::endl ;
 360 //       std::cerr << "rHatEye: " << Helpers::shapesFormat( rHatEye ) << std::endl ;
 361 //       std::cerr << "Phong's angle: " << acos( Concrete::inner( rHatReflection, rHatEye ) ) << std::endl ;
 362
 363         // This breaks the Phong model, but I want reflection in all directions!
 364         // ... as long as the light and the eye are on the same side of the surface!
 365         if( ( Concrete::inner( unitNormal, rHatEye ) > 0 ) != ( Concrete::inner( unitNormal, rHatLight ) > 0 ) )
 366                 {
 367                         return Concrete::Gray( 0 );
 368                 }
 369         const double cPhong2 = cos( 0.5 * acos( Concrete::inner( rHatReflection, rHatEye ) ) );
 370
 371         // Just in case numeric errors make c negative anyway...
 372         if( cPhong2 <= 0 )
 373                 {
 374                         return Concrete::Gray( 0 );
 375                 }
 376
 377         // Further, I want something that becomes ambient when refl.exponent == 0.
 378
 379         double cAmb = 1;
 380         if( refl.exponent( ) < 1 )
 381                 {
 382                         cAmb = pow( fabs( Concrete::inner( unitNormal, rHatLight ) ), 1 - refl.exponent( ) );
 383                 }
 384
 385         double rRel = 1;
 386         if( intensityRadius_ < Concrete::HUGE_LENGTH )
 387                 {
 388                         rRel = intensityRadius_ / dTot;
 389                 }
 390
 391 //       std::cerr << "  Intensity: " << intensity_.gr_ << std::endl ;
 392 //       std::cerr << "  Phong2: " << pow( cPhong2, refl.exponent( ) ) << std::endl ;
 393 //       std::cerr << "  Amb2: " << pow( cIn, 1 / ( 1 + 10 * refl.exponent( ) ) ) << std::endl ;
 394 //       std::cerr << "  Distance factor: " << rRel * rRel << std::endl ;
 395 //       std::cerr << "  Total: " << refl.weight( ) * pow( c, refl.exponent( ) ) * rRel * rRel * intensity_.gr_ << std::endl ;
 396
 397         return intensity_.mulNoCheck( refl.weight( ) * pow( cPhong2, refl.exponent( ) ) * cAmb * rRel * rRel );
 398 }
 399
 400 Lang::SpecularLightRGB::SpecularLightRGB( const Concrete::Coords3D & p, const Concrete::RGB & intensity, Concrete::Length intensityRadius, bool shadows )
 401         : Lang::RGBLight( shadows ), p_( p ), intensity_( intensity ), intensityRadius_( intensityRadius )
 402 { }
 403
 404 Lang::SpecularLightRGB::~SpecularLightRGB( )
 405 { }
 406
 407 RefCountPtr< const Lang::LightSource >
 408 Lang::SpecularLightRGB::typed_transformed( const Lang::Transform3D & tf ) const
 409 {
 410         return RefCountPtr< const Lang::LightSource >( new Lang::SpecularLightRGB( p_.transformed( tf ), intensity_, intensityRadius_, shadows_ ) );
 411 }
 412
 413 Concrete::RGB
 414 Lang::SpecularLightRGB::illuminateRGB( const Concrete::Coords3D & point, const Concrete::Length eyez, const Concrete::UnitFloatTriple & unitNormal, const Lang::SpecularReflectionTerm & refl ) const
 415 {
 416         // Refer to SpecularLightGray::illuminateGray for comments regarding this code.
 417         // This function shall be analogous to that function.
 418
 419         Concrete::Coords3D rLight = p_ - point;
 420         Concrete::Coords3D rEye = Concrete::Coords3D( Concrete::ZERO_LENGTH, Concrete::ZERO_LENGTH, eyez ) - point;
 421         Concrete::Length dLight = rLight.norm( );
 422         Concrete::Length dEye = rEye.norm( );
 423         Concrete::UnitFloatTriple rHatLight = rLight.direction( dLight );
 424         Concrete::UnitFloatTriple rHatEye = rEye.direction( dEye );
 425         Concrete::Length dTot = dLight + dEye;
 426
 427         Concrete::UnitFloatTriple rHatReflection = unitNormal.reflect( rHatLight );
 428
 429         // This breaks the Phong model, but I want reflection in all directions!
 430         const double cPhong2 = cos( 0.5 * acos( Concrete::inner( rHatReflection, rHatEye ) ) );
 431
 432         // Just in case numeric errors make c negative anyway...
 433         if( cPhong2 <= 0 )
 434                 {
 435                         return Concrete::RGB( 0, 0, 0 );
 436                 }
 437
 438         // Further, I want something that becomes ambient when refl.exponent == 0.
 439
 440         double cAmb = 1;
 441         if( refl.exponent( ) < 1 )
 442                 {
 443                         cAmb = pow( fabs( Concrete::inner( unitNormal, rHatLight ) ), 1 - refl.exponent( ) );
 444                 }
 445
 446         double rRel = 1;
 447         if( intensityRadius_ < Concrete::HUGE_LENGTH )
 448                 {
 449                         rRel = intensityRadius_ / dTot;
 450                 }
 451
 452         return intensity_.mulNoCheck( refl.weight( ) * pow( cPhong2, refl.exponent( ) ) * cAmb * rRel * rRel );
 453 }
 454
 455 Lang::DistantLightGray::DistantLightGray( const Concrete::UnitFloatTriple & rHatLight, const Concrete::Gray & intensity, bool shadows )
 456         : Lang::GrayLight( shadows ), rHatLight_( rHatLight ), intensity_( intensity )
 457 { }
 458
 459 Lang::DistantLightGray::~DistantLightGray( )
 460 { }
 461
 462 RefCountPtr< const Lang::LightSource >
 463 Lang::DistantLightGray::typed_transformed( const Lang::Transform3D & tf ) const
 464 {
 465         return RefCountPtr< const Lang::LightSource >( new Lang::DistantLightGray( tf.transformPlaneUnitNormal( rHatLight_ ), intensity_, shadows_ ) );
 466 }
 467
 468 Concrete::RGB
 469 Lang::DistantLightGray::illuminateRGB( const Concrete::Coords3D & point, const Concrete::Length eyez, const Concrete::UnitFloatTriple & unitNormal, const Lang::SpecularReflectionTerm & refl ) const
 470 {
 471         // Compare SpecularLightGray::illuminateGray.
 472
 473         Concrete::Coords3D rEye = Concrete::Coords3D( Concrete::ZERO_LENGTH, Concrete::ZERO_LENGTH, eyez ) - point;
 474         Concrete::Length dEye = rEye.norm( );
 475         Concrete::UnitFloatTriple rHatEye = rEye.direction( dEye );
 476
 477         Concrete::UnitFloatTriple rHatReflection = unitNormal.reflect( rHatLight_ );
 478
 479         // This breaks the Phong model, but I want reflection in all directions!
 480         const double cPhong2 = cos( 0.5 * acos( Concrete::inner( rHatReflection, rHatEye ) ) );
 481
 482         // Just in case numeric errors make c negative anyway...
 483         if( cPhong2 <= 0 )
 484                 {
 485                         return Concrete::RGB( 0, 0, 0 );
 486                 }
 487
 488         // Further, I want something that becomes ambient when refl.exponent == 0.
 489
 490         double cAmb = 1;
 491         if( refl.exponent( ) < 1 )
 492                 {
 493                         cAmb = pow( fabs( Concrete::inner( unitNormal, rHatLight_ ) ), 1 - refl.exponent( ) );
 494                 }
 495
 496         double a = intensity_.mulNoCheck( refl.weight( ) * pow( cPhong2, refl.exponent( ) ) * cAmb ).gr_;
 497         return Concrete::RGB( a, a, a );
 498 }
 499
 500 Concrete::Gray
 501 Lang::DistantLightGray::illuminateGray( const Concrete::Coords3D & point, const Concrete::Length eyez, const Concrete::UnitFloatTriple & unitNormal, const Lang::SpecularReflectionTerm & refl ) const
 502 {
 503         // Compare SpecularLightGray::illuminateGray.
 504
 505         Concrete::Coords3D rEye = Concrete::Coords3D( Concrete::ZERO_LENGTH, Concrete::ZERO_LENGTH, eyez ) - point;
 506         Concrete::Length dEye = rEye.norm( );
 507         Concrete::UnitFloatTriple rHatEye = rEye.direction( dEye );
 508
 509         Concrete::UnitFloatTriple rHatReflection = unitNormal.reflect( rHatLight_ );
 510
 511         // This breaks the Phong model, but I want reflection in all directions!
 512         const double cPhong2 = cos( 0.5 * acos( Concrete::inner( rHatReflection, rHatEye ) ) );
 513
 514         // Just in case numeric errors make c negative anyway...
 515         if( cPhong2 <= 0 )
 516                 {
 517                         return Concrete::Gray( 0 );
 518                 }
 519
 520         // Further, I want something that becomes ambient when refl.exponent == 0.
 521
 522         double cAmb = 1;
 523         if( refl.exponent( ) < 1 )
 524                 {
 525                         cAmb = pow( fabs( Concrete::inner( unitNormal, rHatLight_ ) ), 1 - refl.exponent( ) );
 526                 }
 527
 528         return intensity_.mulNoCheck( refl.weight( ) * pow( cPhong2, refl.exponent( ) ) * cAmb );
 529 }
 530
 531
 532 Lang::DistantLightRGB::DistantLightRGB( const Concrete::UnitFloatTriple & rHatLight, const Concrete::RGB & intensity, bool shadows )
 533         : Lang::RGBLight( shadows ), rHatLight_( rHatLight ), intensity_( intensity )
 534 { }
 535
 536 Lang::DistantLightRGB::~DistantLightRGB( )
 537 { }
 538
 539 RefCountPtr< const Lang::LightSource >
 540 Lang::DistantLightRGB::typed_transformed( const Lang::Transform3D & tf ) const
 541 {
 542         return RefCountPtr< const Lang::LightSource >( new Lang::DistantLightRGB( tf.transformPlaneUnitNormal( rHatLight_ ), intensity_, shadows_ ) );
 543 }
 544
 545 Concrete::RGB
 546 Lang::DistantLightRGB::illuminateRGB( const Concrete::Coords3D & point, const Concrete::Length eyez, const Concrete::UnitFloatTriple & rHatLight, const Lang::SpecularReflectionTerm & refl ) const
 547 {
 548         // Compare SpecularLightGray::illuminateGray.
 549
 550         Concrete::Coords3D rEye = Concrete::Coords3D( Concrete::ZERO_LENGTH, Concrete::ZERO_LENGTH, eyez ) - point;
 551         Concrete::Length dEye = rEye.norm( );
 552         Concrete::UnitFloatTriple rHatEye = rEye.direction( dEye );
 553
 554         Concrete::UnitFloatTriple rHatReflection = rHatLight_.reflect( rHatLight_ );
 555
 556         // This breaks the Phong model, but I want reflection in all directions!
 557         const double cPhong2 = cos( 0.5 * acos( Concrete::inner( rHatReflection, rHatEye ) ) );
 558
 559         // Just in case numeric errors make c negative anyway...
 560         if( cPhong2 <= 0 )
 561                 {
 562                         return Concrete::RGB( 0, 0, 0 );
 563                 }
 564
 565         // Further, I want something that becomes ambient when refl.exponent == 0.
 566
 567         double cAmb = 1;
 568         if( refl.exponent( ) < 1 )
 569                 {
 570                         cAmb = pow( fabs( Concrete::inner( rHatLight_, rHatLight_ ) ), 1 - refl.exponent( ) );
 571                 }
 572
 573         return intensity_.mulNoCheck( refl.weight( ) * pow( cPhong2, refl.exponent( ) ) * cAmb );
 574 }
 575
 576 Lang::LightGroup::LightGroup( )
 577 { }
 578
 579 DISPATCHIMPL( LightGroup );
 580
 581 RefCountPtr< const Lang::Class > Lang::LightGroup::TypeID( new Lang::SystemFinalClass( strrefdup( "LightGroup" ) ) );
 582 TYPEINFOIMPL( LightGroup );
 583
 584 Lang::LightGroup::~LightGroup( )
 585 { }
 586
 587 RefCountPtr< const Lang::Geometric3D >
 588 Lang::LightGroup::transformed( const Lang::Transform3D & tf, const RefCountPtr< const Lang::Geometric3D > & self ) const
 589 {
 590         return typed_transformed( tf, self.down_cast< const Lang::LightGroup >( ) );
 591 }
 592
 593 RefCountPtr< const Lang::Geometric2D >
 594 Lang::LightGroup::to2D( const Kernel::PassedDyn & dyn, const RefCountPtr< const Lang::Geometric3D > & self ) const
 595 {
 596         throw Exceptions::MiscellaneousRequirement( "Lights cannot exist in 2D." );
 597 }
 598
 599
 600 Lang::LightNull::LightNull( )
 601 { }
 602
 603 Lang::LightNull::~LightNull( )
 604 { }
 605
 606 RefCountPtr< const Lang::LightGroup >
 607 Lang::LightNull::typed_transformed( const Lang::Transform3D & tf, const RefCountPtr< const Lang::LightGroup > & self ) const
 608 {
 609         return self;
 610 }
 611
 612 bool
 613 Lang::LightNull::isNull( ) const
 614 {
 615         return true;
 616 }
 617
 618 bool
 619 Lang::LightNull::containsRGB( ) const
 620 {
 621         return false;
 622 }
 623
 624 void
 625 Lang::LightNull::gcMark( Kernel::GCMarkedSet & marked )
 626 { }
 627
 628
 629 Lang::LightPair::LightPair( const RefCountPtr< const Lang::LightSource > & car, const RefCountPtr< const Lang::LightGroup > & cdr )
 630         : car_( car ), cdr_( cdr )
 631 { }
 632
 633 Lang::LightPair::~LightPair( )
 634 { }
 635
 636 RefCountPtr< const Lang::LightSource >
 637 Lang::LightPair::car( ) const
 638 {
 639         return car_;
 640 }
 641
 642 RefCountPtr< const Lang::LightGroup >
 643 Lang::LightPair::cdr( ) const
 644 {
 645         return cdr_;
 646 }
 647
 648 RefCountPtr< const Lang::LightGroup >
 649 Lang::LightPair::typed_transformed( const Lang::Transform3D & tf, const RefCountPtr< const Lang::LightGroup > & self ) const
 650 {
 651         return RefCountPtr< const Lang::LightGroup >( new Lang::LightPair( car_->typed_transformed( tf ), cdr_->typed_transformed( tf, cdr_ ) ) );
 652 }
 653
 654 bool
 655 Lang::LightPair::isNull( ) const
 656 {
 657         return false;
 658 }
 659
 660 bool
 661 Lang::LightPair::containsRGB( ) const
 662 {
 663         return ( ! car_->isGray( ) ) || cdr_->containsRGB( );
 664 }
 665
 666 void
 667 Lang::LightPair::gcMark( Kernel::GCMarkedSet & marked )
 668 {
 669         const_cast< Lang::LightSource * >( car_.getPtr( ) )->gcMark( marked );
 670         const_cast< Lang::LightGroup * >( cdr_.getPtr( ) )->gcMark( marked );
 671 }