./rt2.7.2007.05.17/0040755000077300007650000000000010640535364011304 5ustar patpat./rt2.7.2007.05.17/Code/0040755000077300007650000000000010623061613012146 5ustar patpat./rt2.7.2007.05.17/Code/basevec.cc0100644000077300007650000000037310623060361014064 0ustar patpat#line 259 "nws/basevec.nw" #include "basevec.h" template< typename TT > const char* basevec::id = "NKVERSION: basevec<>( 2.1.2007.05.17 )"; #line 14 "nws/basevec.nw" template class basevec< double >; template class basevec< unsigned int >; ./rt2.7.2007.05.17/Code/basevec.h0100644000077300007650000000664510623061637013745 0ustar patpat#line 239 "nws/basevec.nw" #ifndef _NKLEIN_BASEVEC_H_ #define _NKLEIN_BASEVEC_H_ 1 #include #include #include #line 212 "nws/basevec.nw" template < typename TT > class basevec; #line 247 "nws/basevec.nw" #line 125 "nws/basevec.nw" template < typename TT > std::istream& operator >> ( std::istream&, basevec< TT >& ); template < typename TT > std::ostream& operator << ( std::ostream&, const basevec< TT >& ); #line 249 "nws/basevec.nw" #line 215 "nws/basevec.nw" template < typename TT > class basevec : public std::vector< TT > { public: #line 24 "nws/basevec.nw" basevec(); #line 35 "nws/basevec.nw" basevec( const TT array[], unsigned int len ); #line 50 "nws/basevec.nw" basevec( const TT value, unsigned int len ); #line 66 "nws/basevec.nw" basevec( const basevec< TT >& other ); #line 79 "nws/basevec.nw" const basevec< TT >& operator = ( const basevec< TT >& other ); #line 101 "nws/basevec.nw" basevec( const char* str ); #line 131 "nws/basevec.nw" friend std::istream& operator >> ( std::istream&, basevec< TT >& ); friend std::ostream& operator << ( std::ostream&, const basevec< TT >& ); #line 219 "nws/basevec.nw" public: static const char* id; }; #line 250 "nws/basevec.nw" #line 27 "nws/basevec.nw" template < typename TT > basevec< TT >::basevec() : std::vector< TT >() { } #line 38 "nws/basevec.nw" template < typename TT > basevec< TT >::basevec( const TT array[], unsigned int len ) : std::vector< TT >( len ) { for ( unsigned int ii=0; ii < len; ++ii ) { (*this)[ ii ] = array[ ii ]; } } #line 53 "nws/basevec.nw" template < typename TT > basevec< TT >::basevec( const TT value, unsigned int len ) : std::vector< TT >( len ) { for ( unsigned int ii=0; ii < len; ++ii ) { (*this)[ ii ] = value; } } #line 69 "nws/basevec.nw" template < typename TT > basevec< TT >::basevec( const basevec< TT >& other ) : std::vector< TT >() { *this = other; } #line 82 "nws/basevec.nw" template < typename TT > const basevec< TT >& basevec< TT >::operator = ( const basevec< TT >& other ) { unsigned int len( other.size() ); this->resize( len ); for ( unsigned int ii=0; ii < len; ++ii ) { (*this)[ ii ] = other[ ii ]; } return *this; } #line 104 "nws/basevec.nw" template < typename TT > basevec< TT >::basevec( const char* str ) : std::vector< TT >() { std::istringstream in( str ); in >> (*this); if ( ! in.good() ) { this->resize( 0 ); } } #line 142 "nws/basevec.nw" template < typename TT > std::istream& operator >> ( std::istream& in, basevec< TT >& vv ) { char bogus; unsigned int len; in.setf( std::ios::skipws ); in >> bogus; // "[" in >> len; in >> bogus >> bogus; // "]" "<" TT zero( 0U ); vv.resize( len, zero ); for (unsigned ii=0; ii < len; ++ii) { in >> vv[ii]; if (ii < len-1) { in >> bogus; // "," } } while (bogus != '>' && in.good() ) { in >> bogus; // ">" } return in; } #line 180 "nws/basevec.nw" template < typename TT > std::ostream& operator << ( std::ostream& out, const basevec< TT >& vv ) { unsigned int len = vv.size(); out.put( '[' ); out << len; out.put( ']' ).put( '<' ).put( ' ' ); for (unsigned int ii=0; ii < len; ++ii) { out << vv[ii]; if (ii < len-1) { out.put( ',' ).put( ' ' ); } } out.put( ' ' ).put( '>' ); return out; } #line 251 "nws/basevec.nw" #endif /*_NKLEIN_BASEVEC_H_*/ ./rt2.7.2007.05.17/Code/color.cc0100644000077300007650000001126110600166057013574 0ustar patpat#line 442 "nws/color.nw" #include #include #include #include "input.h" #include "color.h" #include "portal.h" const char* color::id = "NKVERSION: color( 2.1.2007.03.21 )"; #line 127 "nws/color.nw" color::color( const scene* ss ) : myScene( ss ), #line 116 "nws/color.nw" specularness( 0.1 ), transparency( 0.0 ), reflectiveness( 0.0 ), phong( 15.0 ), indexOfRefraction( 1.0 ), usesPosition( false ), usesNormal( false ), usesDirection( false ) #line 128 "nws/color.nw" { } #line 139 "nws/color.nw" color::color( const char* str, const scene* ss ) : myScene( ss ), #line 116 "nws/color.nw" specularness( 0.1 ), transparency( 0.0 ), reflectiveness( 0.0 ), phong( 15.0 ), indexOfRefraction( 1.0 ), usesPosition( false ), usesNormal( false ), usesDirection( false ) #line 141 "nws/color.nw" { std::istringstream in( str ); in >> *this; } #line 159 "nws/color.nw" void color::setDimensions( unsigned int dd ) { this->scale.resize( dd, 1.0 ); ::orthogonalize( this->orientation, dd ); this->center.resize( dd, 0.0 ); PortalMap::iterator it; for ( it = this->portals.begin(); it != this->portals.end(); ++it ) { it->second->setDimensions( dd ); } } #line 216 "nws/color.nw" void color::evaluate( const mathvec< double >& position, const mathvec< double >& normal, const mathvec< double >& direction, double contribution, unsigned int height, mathvec< double >& pixel ) const { #line 234 "nws/color.nw" if ( pixel.size() < this->channels.size() ) { pixel.resize( this->channels.size() ); } #line 243 "nws/color.nw" if ( height == 0 || contribution < 0.0001 || this->channels.size() == 0 ) { pixel *= 0.0; return; } #line 225 "nws/color.nw" #line 252 "nws/color.nw" mathvec pos; mathvec norm; mathvec dir; #line 259 "nws/color.nw" if ( this->usesPosition ) { pos = position * this->scale; pos.rotate( this->orientation ); pos += this->center; } #line 270 "nws/color.nw" if ( this->usesNormal ) { norm = normal * this->scale; norm.rotate( this->orientation ); norm.normalize(); } #line 278 "nws/color.nw" if ( this->usesDirection ) { dir = direction * this->scale; dir.rotate( this->orientation ); dir.normalize(); } #line 226 "nws/color.nw" #line 286 "nws/color.nw" PortalMap& pps( *(PortalMap*)&this->portals ); PortalMap::iterator it; for ( it = pps.begin(); it != pps.end(); ++it ) { it->second->evaluate( pos, dir, contribution, height, this->channels.size() ); } #line 227 "nws/color.nw" #line 300 "nws/color.nw" double lastVal = 0.0; for ( unsigned int ii=0; ii < this->channels.size(); ++ii ) { pixel[ii] = this->channels[ii]->evaluate( pos, norm, dir ) * contribution; lastVal = pixel[ ii ]; } for ( unsigned int ii=this->channels.size(); ii < pixel.size(); ++ii ) { pixel[ii] = lastVal; } #line 228 "nws/color.nw" } #line 320 "nws/color.nw" std::istream& operator >> ( std::istream& stream, color& cc ) { input in( stream ); while ( in.check() ) { char token[ input::MAX_TOKEN_LEN ]; if ( in.get( token, sizeof(token) ) == 0 ) { return stream; } std::string tok( token ); char semicolon; if ( tok == "portal" ) { #line 370 "nws/color.nw" if ( in.get( token, sizeof(token) ) == 0 ) { break; } std::string name( token ); portal* pp = new portal( cc.myScene ); stream >> *pp >> semicolon; cc.portals[ name ] = pp; #line 337 "nws/color.nw" } else if ( tok == "channels" || tok == "color" ) { expr::read( stream, cc.channels, cc.portals ); #line 383 "nws/color.nw" cc.usesPosition = false; cc.usesNormal = false; cc.usesDirection = false; for ( unsigned int ii=0; ii < cc.channels.size(); ++ii ) { cc.usesPosition = cc.usesPosition || cc.channels[ ii ]->usesPosition(); cc.usesNormal = cc.usesNormal || cc.channels[ ii ]->usesNormal(); cc.usesDirection = cc.usesDirection || cc.channels[ ii ]->usesDirection(); } #line 340 "nws/color.nw" stream >> semicolon; } else if ( tok == "specularness" ) { stream >> cc.specularness >> semicolon; } else if ( tok == "transparency" ) { stream >> cc.transparency >> semicolon; } else if ( tok == "reflectiveness" ) { stream >> cc.reflectiveness >> semicolon; } else if ( tok == "phong" ) { stream >> cc.phong >> semicolon; } else if ( tok == "indexOfRefraction" || tok == "ior" ) { stream >> cc.indexOfRefraction >> semicolon; } else if ( tok == "scale" ) { stream >> cc.scale >> semicolon; } else if ( tok == "orientation" ) { stream >> cc.orientation >> semicolon; } else if ( tok == "center" ) { stream >> cc.center >> semicolon; } else { in.ignore( "COLOR", tok.c_str() ); } } return stream; } ./rt2.7.2007.05.17/Code/color.h0100644000077300007650000000362610600166050013435 0ustar patpat#line 423 "nws/color.nw" #ifndef _NKLEIN_COLOR_H_ #define _NKLEIN_COLOR_H_ 1 #include #include #include #include "expr.h" #line 399 "nws/color.nw" class color { protected: #line 65 "nws/color.nw" const scene* myScene; #line 71 "nws/color.nw" basevec< expr* > channels; #line 77 "nws/color.nw" typedef std::map< std::string, class portal* > PortalMap; PortalMap portals; #line 84 "nws/color.nw" double specularness; double transparency; double reflectiveness; double phong; double indexOfRefraction; #line 98 "nws/color.nw" bool usesPosition; bool usesNormal; bool usesDirection; #line 107 "nws/color.nw" mathvec< double > scale; basevec< mathvec< double > > orientation; mathvec< double > center; #line 402 "nws/color.nw" public: #line 123 "nws/color.nw" color( const scene* ss ); #line 135 "nws/color.nw" color( const char* str, const scene* ss = 0 ); #line 155 "nws/color.nw" void setDimensions( unsigned int dd ); #line 178 "nws/color.nw" inline unsigned int getChannelCount( void ) const { return this->channels.size(); }; #line 186 "nws/color.nw" inline double getReflectiveness( void ) const { return this->reflectiveness; }; inline double getTransparency( void ) const { return this->transparency; }; inline double getIndexOfRefraction( void ) const { return this->indexOfRefraction; }; inline double getSpecularness( void ) const { return this->specularness; }; inline double getPhong( void ) const { return this->phong; }; #line 206 "nws/color.nw" void evaluate( const mathvec< double >& position, const mathvec< double >& normal, const mathvec< double >& direction, double contribution, unsigned int height, mathvec< double >& pixel ) const; #line 316 "nws/color.nw" friend std::istream& operator >> ( std::istream& in, color& cc ); #line 404 "nws/color.nw" public: static const char* id; }; #line 433 "nws/color.nw" #endif /*_NKLEIN_COLOR_H_*/ ./rt2.7.2007.05.17/Code/complement.cc0100644000077300007650000000742210600166054014622 0ustar patpat#line 305 "nws/complement.nw" #include #include #include #ifndef MAXFLOAT #include #endif #include "input.h" #include "complement.h" const char* complement::id = "NKVERSION: complement( 2.1.2007.03.21 )"; #line 49 "nws/complement.nw" complement::complement( const scene* ss ) : object( ss ) #line 38 "nws/complement.nw" , obj( 0 ) #line 51 "nws/complement.nw" { } #line 63 "nws/complement.nw" complement::~complement( void ) { delete this->obj; }; #line 77 "nws/complement.nw" void complement::setDimensions( unsigned int dd ) { if ( this->obj != 0 ) { this->obj->setDimensions( dd ); } this->object::setDimensions( dd ); } #line 101 "nws/complement.nw" bool complement::intersect( const mathvec< double >& direction, const mathvec< double >& start, intersection& hit ) const { if ( this->obj == 0 ) { return false; } #line 120 "nws/complement.nw" mathvec< double > rd = direction; rd.antirotate( this->orientation ); rd /= this->scale; rd.normalize(); mathvec< double > rp = start - this->center; rp.antirotate( this->orientation ); rp /= this->scale; #line 111 "nws/complement.nw" bool ret = this->obj->intersect( rd, rp, hit ); if ( ret ) { #line 131 "nws/complement.nw" hit.reorient( this->scale, this->orientation, this->center ); hit.setDistance( ( hit.getPosition() - start ).magnitude() ); if ( this->gotColor ) { hit.recolor( this->chroma ); } if ( hit.isInside() ) { hit.setOutside(); } else { hit.setInside(); } #line 114 "nws/complement.nw" } return ret; } #line 156 "nws/complement.nw" bool complement::intersect( const mathvec< double >& direction, const mathvec< double >& start, std::vector< intersection* >& hits ) const { if ( this->obj == 0 ) { return false; } #line 120 "nws/complement.nw" mathvec< double > rd = direction; rd.antirotate( this->orientation ); rd /= this->scale; rd.normalize(); mathvec< double > rp = start - this->center; rp.antirotate( this->orientation ); rp /= this->scale; #line 166 "nws/complement.nw" bool ret = this->obj->intersect( rd, rp, hits ); if ( ret ) { for ( unsigned int ii=0; ii < hits.size(); ++ii ) { intersection& hit( *hits[ ii ] ); #line 131 "nws/complement.nw" hit.reorient( this->scale, this->orientation, this->center ); hit.setDistance( ( hit.getPosition() - start ).magnitude() ); if ( this->gotColor ) { hit.recolor( this->chroma ); } if ( hit.isInside() ) { hit.setOutside(); } else { hit.setInside(); } #line 171 "nws/complement.nw" } } else { intersection* nn = new intersection(); this->forgeHit( direction, start, *nn ); hits.insert( hits.end(), nn ); } return true; } #line 191 "nws/complement.nw" bool complement::inside( const mathvec< double >& start ) const { if ( this->obj == 0 ) { return false; } mathvec< double > rp = start - this->center; rp.antirotate( this->orientation ); rp /= this->scale; return this->_inside( rp ); } bool complement::_inside( const mathvec< double >& rp ) const { if ( this->obj == 0 ) { return false; } return ! this->obj->inside( rp ); } #line 222 "nws/complement.nw" std::istream& operator >> ( std::istream& stream, complement& cc ) { input in( stream ); while ( in.check() ) { char token[ input::MAX_TOKEN_LEN ]; if ( in.get( token, sizeof(token) ) == 0 ) { return stream; } std::string tok( token ); char semicolon; if ( tok == "object" ) { object* nn = object::read( stream, cc.myScene ); if ( nn != 0 ) { delete cc.obj; cc.obj = nn; } else { std::cerr << "COMPLEMENT got no object!" << std::endl; } } else if ( tok == "base" ) { stream >> (object&)cc >> semicolon; } else { in.ignore( "COMPLEMENT", tok.c_str() ); } } return stream; } ./rt2.7.2007.05.17/Code/complement.h0100644000077300007650000000234510600166053014462 0ustar patpat#line 286 "nws/complement.nw" #ifndef _NKLEIN_COMPLEMENT_H_ #define _NKLEIN_COMPLEMENT_H_ 1 #include #include #include #include "object.h" #line 262 "nws/complement.nw" class complement : public object { protected: #line 35 "nws/complement.nw" object* obj; #line 265 "nws/complement.nw" public: #line 45 "nws/complement.nw" complement( const scene* ss ); #line 59 "nws/complement.nw" virtual ~complement( void ); #line 73 "nws/complement.nw" virtual void setDimensions( unsigned int dd ); #line 93 "nws/complement.nw" virtual bool intersect( const mathvec< double >& direction, const mathvec< double >& start, intersection& hit ) const; #line 148 "nws/complement.nw" virtual bool intersect( const mathvec< double >& direction, const mathvec< double >& start, std::vector< intersection* >& hits ) const; #line 186 "nws/complement.nw" virtual bool inside( const mathvec< double >& start ) const; virtual bool _inside( const mathvec< double >& rp ) const; #line 218 "nws/complement.nw" friend std::istream& operator >> ( std::istream& in, complement& cc ); #line 267 "nws/complement.nw" public: static const char* id; }; #line 296 "nws/complement.nw" #endif /*_NKLEIN_COMPLEMENT_H_*/ ./rt2.7.2007.05.17/Code/convex.cc0100644000077300007650000002611310603300031013743 0ustar patpat#line 601 "nws/convex.nw" #include #include #include #include #include "input.h" #include "cylinder.h" #include "halfspace.h" #include "inter.h" #include "convex.h" const char* convex::id = "NKVERSION: convex( 2.1.2007.03.30 )"; #line 64 "nws/convex.nw" convex::convex( const scene* ss ) : csginter( ss ), colorDistance( 0.0 ) { } #line 77 "nws/convex.nw" convex::~convex( void ) { }; #line 88 "nws/convex.nw" void convex::addPoint( const mathvec< double >& point ) { this->pts.insert( this->pts.end(), point ); }; #line 112 "nws/convex.nw" class PlaneInfo { public: PlaneInfo( const mathvec< double >& nn, const mathvec< double >& pp, double oo, std::vector< mathvec< double > >& pts ) : normal( nn ), point( pp ), offset( oo ) { this->mask.resize( pts.size() ); for ( unsigned int ii=0; ii < pts.size(); ++ii ) { double vv = ( this->normal ^ pts[ ii ] ) - this->offset; this->mask[ ii ] = ( ::fabs( vv ) < 0.000001 ); } }; public: mathvec< double > normal; mathvec< double > point; double offset; std::vector< bool > mask; bool exceeded; }; void convex::calculateBoundingPlanes( bool dbg ) { std::list< PlaneInfo > planes; #line 173 "nws/convex.nw" unsigned int nn = this->pts.size(); if ( nn == 0 ) { return; } unsigned int rr = this->pts[ 0 ].size(); for ( unsigned int ii=1; ii < nn; ++ii ) { unsigned int len = this->pts[ ii ].size(); if ( len > rr ) { rr = len; } } if ( rr > nn ) { std::cerr << "CONVEX: Not enough points to form a plane" << std::endl; return; } for ( unsigned int ii=0; ii < nn; ++ii ) { this->pts[ ii ].resize( rr, 0.0 ); } #line 143 "nws/convex.nw" #line 206 "nws/convex.nw" double radius2 = 0.0; for ( unsigned int kk=0; kk < nn; ++kk ) { const mathvec< double >& cur( this->pts[ kk ] ); double r2 = cur ^ cur; if ( r2 > radius2 ) { radius2 = r2; } } #line 144 "nws/convex.nw" #line 216 "nws/convex.nw" cylinder* sphere = new cylinder( ::sqrt( radius2 )+0.01, this->myScene ); this->objs.insert( this->objs.begin(), sphere ); #line 146 "nws/convex.nw" #line 197 "nws/convex.nw" mathvec< unsigned int > choice; choice.resize( rr ); for ( unsigned int ii=0; ii < rr; ++ii ) { unsigned int jj = rr - ii - 1; choice[ ii ] = jj; } #line 148 "nws/convex.nw" #line 221 "nws/convex.nw" do { #line 231 "nws/convex.nw" basevec< mathvec< double > > matrix; matrix.resize( rr-1 ); mathvec< double >& first( this->pts[ choice[ 0 ] ] ); for ( unsigned int ii=1; ii < rr; ++ii ) { mathvec< double >& cur( this->pts[ choice[ ii ] ] ); matrix[ ii-1 ] = cur - first; } bool plane = ::orthogonalize( matrix, rr ); #line 223 "nws/convex.nw" if ( plane ) { #line 243 "nws/convex.nw" mathvec< double > norm( matrix[ rr-1 ] ); double dd = ( norm ^ first ); #line 225 "nws/convex.nw" #line 255 "nws/convex.nw" { bool unique = true; std::list< PlaneInfo >::iterator pit = planes.begin(); while ( unique && pit != planes.end() ) { if ( ::fabs( pit->offset - dd ) < 0.000001 ) { if ( ( pit->normal - norm ).magnitude() < 0.000001 ) { unique = false; } } ++pit; } if ( unique ) { planes.insert( planes.end(), PlaneInfo( norm, first, dd, this->pts ) ); } } #line 249 "nws/convex.nw" norm *= -1.0; dd = ( norm ^ first ); #line 255 "nws/convex.nw" { bool unique = true; std::list< PlaneInfo >::iterator pit = planes.begin(); while ( unique && pit != planes.end() ) { if ( ::fabs( pit->offset - dd ) < 0.000001 ) { if ( ( pit->normal - norm ).magnitude() < 0.000001 ) { unique = false; } } ++pit; } if ( unique ) { planes.insert( planes.end(), PlaneInfo( norm, first, dd, this->pts ) ); } } #line 226 "nws/convex.nw" } } while ( planes.size() == 0 && this->incrementChoice( choice, nn ) ); #line 150 "nws/convex.nw" if ( planes.size() > 0 ) { for ( unsigned int kk=rr; kk < nn; ++kk ) { const mathvec< double >& cur( this->pts[ kk ] ); #line 275 "nws/convex.nw" std::vector< mathvec< double > > pool; std::vector< bool > pointMask( kk, false ); std::list< PlaneInfo >::iterator pit = planes.begin(); while ( pit != planes.end() ) { double diff = ( pit->normal ^ cur ) - pit->offset; pit->exceeded = ( diff > 0.000001 ); if ( pit->exceeded ) { for ( unsigned int ii=0; ii < kk; ++ii ) { if ( pit->mask[ ii ] == true && pointMask[ ii ] == false ) { pool.insert( pool.end(), this->pts[ ii ] ); pointMask[ ii ] = true; } } } std::list< PlaneInfo >::iterator last = pit++; if ( last->exceeded ) { planes.erase( last ); } } #line 154 "nws/convex.nw" if ( pool.size() >= rr-1 ) { #line 311 "nws/convex.nw" mathvec< unsigned int > choice; choice.resize( rr-1 ); for ( unsigned int ii=0; ii < rr-1; ++ii ) { unsigned int jj = rr - ii - 2; choice[ ii ] = jj; } #line 298 "nws/convex.nw" do { #line 320 "nws/convex.nw" basevec< mathvec< double > > matrix; matrix.resize( rr-1 ); mathvec< double >& first( this->pts[ kk ] ); for ( unsigned int ii=0; ii < rr-1; ++ii ) { mathvec< double >& cur( pool[ choice[ ii ] ] ); matrix[ ii ] = cur - first; } bool plane = ::orthogonalize( matrix, rr ); #line 300 "nws/convex.nw" if ( plane ) { #line 243 "nws/convex.nw" mathvec< double > norm( matrix[ rr-1 ] ); double dd = ( norm ^ first ); #line 302 "nws/convex.nw" #line 332 "nws/convex.nw" bool bounding = true; unsigned int above = 0; unsigned int below = 0; unsigned int ps = pool.size(); for ( unsigned int ii=0; bounding && ii < ps; ++ii ) { double vv = ( norm ^ pool[ ii ] ) - dd; if ( vv > 0.000001 ) { ++above; } else if ( vv < -0.000001 ) { ++below; } bounding = ( above == 0 || below == 0 ); } if ( bounding && above > 0 ) { norm *= -1.0; dd = ( norm ^ first ); } #line 303 "nws/convex.nw" if ( bounding ) { #line 255 "nws/convex.nw" { bool unique = true; std::list< PlaneInfo >::iterator pit = planes.begin(); while ( unique && pit != planes.end() ) { if ( ::fabs( pit->offset - dd ) < 0.000001 ) { if ( ( pit->normal - norm ).magnitude() < 0.000001 ) { unique = false; } } ++pit; } if ( unique ) { planes.insert( planes.end(), PlaneInfo( norm, first, dd, this->pts ) ); } } #line 305 "nws/convex.nw" } } } while ( this->incrementChoice( choice, pool.size() ) ); #line 156 "nws/convex.nw" } } #line 352 "nws/convex.nw" std::list< PlaneInfo >::iterator pit = planes.begin(); while ( pit != planes.end() ) { halfspace* hh = new halfspace( pit->point, pit->normal ); this->objs.insert( this->objs.end(), hh ); ++pit; } #line 159 "nws/convex.nw" } if ( dbg ) { std::cerr << "(" << planes.size() << ") faces" << std::endl; std::list< PlaneInfo >::const_iterator it = planes.begin(); while ( it != planes.end() ) { std::cerr << " " << it->normal << std::endl; ++it; } } } #line 367 "nws/convex.nw" bool convex::incrementChoice( mathvec< unsigned int >& choice, unsigned int nn ) { unsigned int dims = choice.size(); bool ret = false; for ( unsigned int ii=0; !ret && ii < dims; ++ii ) { if ( ++choice[ ii ] < nn - ii ) { for ( unsigned int jj=0; jj < ii; ++jj ) { unsigned int kk = ii - jj - 1; choice[ kk ] = choice[ ii ] + jj + 1; } ret = true; } } return ret; } #line 400 "nws/convex.nw" bool convex::intersect( const mathvec< double >& direction, const mathvec< double >& start, intersection& hit ) const { bool ret = this->csginter::intersect( direction, start, hit ); if ( ret && this->colorDistance > 0.000001 ) { #line 418 "nws/convex.nw" const mathvec< double >& loc = hit.getPosition(); mathvec< double > rp = loc - this->center; rp.antirotate( this->orientation ); rp /= this->scale; unsigned int clen = this->center.size(); unsigned int cmax = clen; for ( unsigned int kk=0; kk < clen; ++kk ) { if ( this->specialColors[ kk ] != 0 ) { cmax = clen - kk; break; } } unsigned int len = this->specialColors.size(); unsigned int hitCount = 0; unsigned int cindex = 0; std::vector< object* >::const_iterator jj = this->objs.begin(); for ( ++jj; hitCount < cmax && jj != this->objs.end(); ++jj ) { halfspace* hh = (halfspace*)*jj; double dd = ::fabs( hh->distance( rp ) ); if ( dd <= this->colorDistance ) { cindex = clen - ++hitCount; } } if ( cindex < len ) { color* cc = this->specialColors[ cindex ]; if ( cc != 0 ) { hit.recolor( *cc ); } } #line 409 "nws/convex.nw" } return ret; } #line 467 "nws/convex.nw" bool convex::intersect( const mathvec< double >& direction, const mathvec< double >& start, std::vector< intersection* >& hits ) const { bool ret = this->csginter::intersect( direction, start, hits ); if ( ret && this->colorDistance > 0.000001 ) { std::vector< intersection* >::iterator it; for ( it = hits.begin(); it != hits.end(); ++it ) { intersection& hit( *(*it) ); #line 418 "nws/convex.nw" const mathvec< double >& loc = hit.getPosition(); mathvec< double > rp = loc - this->center; rp.antirotate( this->orientation ); rp /= this->scale; unsigned int clen = this->center.size(); unsigned int cmax = clen; for ( unsigned int kk=0; kk < clen; ++kk ) { if ( this->specialColors[ kk ] != 0 ) { cmax = clen - kk; break; } } unsigned int len = this->specialColors.size(); unsigned int hitCount = 0; unsigned int cindex = 0; std::vector< object* >::const_iterator jj = this->objs.begin(); for ( ++jj; hitCount < cmax && jj != this->objs.end(); ++jj ) { halfspace* hh = (halfspace*)*jj; double dd = ::fabs( hh->distance( rp ) ); if ( dd <= this->colorDistance ) { cindex = clen - ++hitCount; } } if ( cindex < len ) { color* cc = this->specialColors[ cindex ]; if ( cc != 0 ) { hit.recolor( *cc ); } } #line 479 "nws/convex.nw" } } return ret; } #line 493 "nws/convex.nw" std::istream& operator >> ( std::istream& stream, convex& hh ) { input in( stream ); while ( in.check() ) { char token[ input::MAX_TOKEN_LEN ]; if ( in.get( token, sizeof(token) ) == 0 ) { return stream; } std::string tok( token ); char semicolon; #line 533 "nws/convex.nw" if ( tok == "colorDistance" ) { stream >> hh.colorDistance >> semicolon; } else if ( tok == "specialColor" ) { unsigned int ii; color* nn = new color( hh.myScene ); stream >> ii >> *nn; if ( ii >= hh.specialColors.size() ) { hh.specialColors.resize( ii+1, 0 ); } color* oo = hh.specialColors[ ii ]; if ( oo != 0 ) { delete oo; } hh.specialColors[ ii ] = nn; } #line 509 "nws/convex.nw" else if ( tok == "points" ) { basevec< mathvec< double > > pts; stream >> pts >> semicolon; for ( unsigned int ii=0; ii < pts.size(); ++ii ) { hh.addPoint( pts[ii] ); } } else if ( tok == "point" ) { mathvec< double > point; stream >> point >> semicolon; hh.addPoint( point ); } else if ( tok == "base" ) { stream >> (object&)hh >> semicolon; } else { in.ignore( "CONVEX", tok.c_str() ); } } hh.calculateBoundingPlanes(); return stream; } ./rt2.7.2007.05.17/Code/convex.h0100644000077300007650000000251510603274053013623 0ustar patpat#line 582 "nws/convex.nw" #ifndef _NKLEIN_CONVEX_H_ #define _NKLEIN_CONVEX_H_ 1 #include #include #include #include "object.h" #line 556 "nws/convex.nw" class convex : public csginter { private: #line 48 "nws/convex.nw" std::vector< mathvec< double > > pts; #line 559 "nws/convex.nw" protected: #line 52 "nws/convex.nw" double colorDistance; std::vector< color* > specialColors; #line 561 "nws/convex.nw" public: #line 60 "nws/convex.nw" convex( const scene* ss ); #line 73 "nws/convex.nw" virtual ~convex( void ); #line 84 "nws/convex.nw" void addPoint( const mathvec< double >& point ); #line 103 "nws/convex.nw" void calculateBoundingPlanes( bool dbg = false ); #line 363 "nws/convex.nw" bool incrementChoice( mathvec< unsigned int >& choice, unsigned int nn ); #line 393 "nws/convex.nw" virtual bool intersect( const mathvec< double >& direction, const mathvec< double >& start, intersection& hit ) const; #line 455 "nws/convex.nw" virtual bool intersect( const mathvec< double >& direction, const mathvec< double >& start, std::vector< intersection* >& hits ) const; #line 489 "nws/convex.nw" friend std::istream& operator >> ( std::istream& in, convex& cc ); #line 563 "nws/convex.nw" public: static const char* id; }; #line 592 "nws/convex.nw" #endif /*_NKLEIN_CONVEX_H_*/ ./rt2.7.2007.05.17/Code/coxeter.cc0100644000077300007650000001117510605624663014142 0ustar patpat#line 324 "nws/coxeter.nw" #include #include #include #include "input.h" #include "halfspace.h" #include "inter.h" #include "convex.h" #include "coxeter.h" const char* coxeter::id = "NKVERSION: coxeter( 2.1.2007.04.07 )"; #line 54 "nws/coxeter.nw" coxeter::coxeter( const scene* ss ) : convex( ss ) { } #line 67 "nws/coxeter.nw" coxeter::~coxeter( void ) { } #line 85 "nws/coxeter.nw" std::istream& operator >> ( std::istream& stream, coxeter& hh ) { input in( stream ); basevec< mathvec< unsigned int > > imat; unsigned int limit = 1024; bool debug = false; while ( in.check() ) { char token[ input::MAX_TOKEN_LEN ]; if ( in.get( token, sizeof(token) ) == 0 ) { return stream; } std::string tok( token ); char semicolon; #line 533 "nws/convex.nw" if ( tok == "colorDistance" ) { stream >> hh.colorDistance >> semicolon; } else if ( tok == "specialColor" ) { unsigned int ii; color* nn = new color( hh.myScene ); stream >> ii >> *nn; if ( ii >= hh.specialColors.size() ) { hh.specialColors.resize( ii+1, 0 ); } color* oo = hh.specialColors[ ii ]; if ( oo != 0 ) { delete oo; } hh.specialColors[ ii ] = nn; } #line 105 "nws/coxeter.nw" else if ( tok == "matrix" || tok == "incidence" ) { stream >> imat >> semicolon; } else if ( tok == "limit" ) { stream >> limit >> semicolon; } else if ( tok == "debug" ) { debug = true; stream >> semicolon; } else if ( tok == "base" ) { stream >> (object&)hh >> semicolon; } else { std::cerr << "COXETER: " << tok << std::endl; } } if ( imat.size() > 0 ) { unsigned int nn = imat.size(); #line 132 "nws/coxeter.nw" for ( unsigned int jj=0; jj < nn; ++jj ) { imat[jj].resize( nn, 0 ); } #line 122 "nws/coxeter.nw" #line 138 "nws/coxeter.nw" basevec< mathvec< double > > dd; dd.resize( nn ); for ( unsigned int jj=0; jj < nn; ++jj ) { mathvec< double >& row( dd[ jj ] ); row.resize( nn, 0.0 ); row *= 0.0; row[ jj ] = 1.0; } for ( unsigned int jj=0; jj < (nn-1); ++jj ) { for ( unsigned int ii=jj+1; ii < nn; ++ii ) { unsigned int mm = imat[ ii ][ jj ]; unsigned int m2 = imat[ jj ][ ii ]; if ( m2 > mm ) { mm = m2; } if ( mm < 2 ) { mm = 2; } double cc = ::cos( M_PI / (double)( mm ) ); dd[ ii ][ jj ] = cc; dd[ jj ][ ii ] = cc; } } #line 123 "nws/coxeter.nw" #line 167 "nws/coxeter.nw" basevec< mathvec< double > > aa; aa.resize( nn ); aa[ 0 ].resize( nn, 0.0 ); aa[ 0 ] *= 0.0; aa[ 0 ][ 0 ] = 1.0; for ( unsigned int kk=1; kk < nn; ++kk ) { mathvec< double >& cur( aa[ kk ] ); double ll = 0.0; cur.resize( nn, 0.0 ); cur *= 0.0; for ( unsigned int jj=0; jj < kk; ++jj ) { const mathvec< double >& versus( aa[ jj ] ); double ss = 0.0; for ( unsigned int ii=0; ii < jj; ++ii ) { ss += cur[ ii ] * versus[ ii ]; } cur[ jj ] = ( dd[ jj ][ kk ] - ss ) / versus[ jj ]; ll += cur[ jj ] * cur[ jj ]; } cur[ kk ] = ::sqrt( 1.0 - ll ); } #line 124 "nws/coxeter.nw" #line 196 "nws/coxeter.nw" unsigned int oldSize = 0; basevec< mathvec< double > > xx; xx.resize( xx.size() + 1 ); xx[ 0 ].resize( nn ); #line 235 "nws/coxeter.nw" mathvec< double > bb( nn ); for ( unsigned int ii=0; ii < nn; ++ii ) { bb[ ii ] = (double)imat[ ii ][ ii ]; } if ( ( bb ^ bb ) < 0.5 ) { bb[ 0 ] = 1.0; } xx[ 0 ] = bb.solve( aa ); if ( ( xx[ 0 ] ^ xx[ 0 ] ) < 0.5 ) { if ( debug ) { std::cerr << "bad solution: " << xx[0] << std::endl; } xx[ 0 ] = aa[ 0 ]; } else { xx[ 0 ].normalize(); if ( debug ) { std::cerr << aa << " * " << xx[0] << " = " << bb << std::endl; } } #line 205 "nws/coxeter.nw" unsigned int newSize = xx.size(); while ( newSize > oldSize && newSize < limit ) { unsigned int cntr = 0; for ( unsigned int jj=0; jj < nn; ++jj ) { for ( unsigned int ii=oldSize; ii < newSize; ++ii ) { mathvec< double > vv; #line 259 "nws/coxeter.nw" vv = aa[ jj ]; vv *= -2.0 * ( aa[ jj ] ^ xx[ ii ] ); vv += xx[ ii ]; #line 214 "nws/coxeter.nw" #line 265 "nws/coxeter.nw" bool unique = true; for ( unsigned int kk=0; unique && kk < newSize+cntr; ++kk ) { double dd = ( vv - xx[ kk ] ).magnitude(); unique = dd > 0.000001; } if ( unique ) { xx.resize( newSize + cntr + 1 ); xx[ newSize + cntr ] = vv; ++cntr; } #line 215 "nws/coxeter.nw" } } oldSize = newSize; newSize += cntr; } if ( debug ) { std::cerr << "(" << xx.size() << ") vertexes" << std::endl; std::cerr << xx << std::endl; } for ( unsigned int jj=0; jj < xx.size(); ++jj ) { hh.addPoint( xx[ jj ] ); } hh.calculateBoundingPlanes( debug ); #line 125 "nws/coxeter.nw" } return stream; } ./rt2.7.2007.05.17/Code/coxeter.h0100644000077300007650000000105610602337123013766 0ustar patpat#line 305 "nws/coxeter.nw" #ifndef _NKLEIN_COXETER_H_ #define _NKLEIN_COXETER_H_ 1 #include #include #include #include "object.h" #line 283 "nws/coxeter.nw" class coxeter : public convex { public: #line 50 "nws/coxeter.nw" coxeter( const scene* ss ); #line 63 "nws/coxeter.nw" virtual ~coxeter( void ); #line 81 "nws/coxeter.nw" friend std::istream& operator >> ( std::istream& in, coxeter& cc ); #line 286 "nws/coxeter.nw" public: static const char* id; }; #line 315 "nws/coxeter.nw" #endif /*_NKLEIN_COXETER_H_*/ ./rt2.7.2007.05.17/Code/cylinder.cc0100644000077300007650000002172610623062033014270 0ustar patpat#line 553 "nws/cylinder.nw" #include #include #include #ifndef MAXFLOAT #include #endif #include "input.h" #include "cylinder.h" const char* cylinder::id = "NKVERSION: cylinder( 2.1.2007.05.17 )"; #line 65 "nws/cylinder.nw" cylinder::cylinder( const scene* ss ) : object( ss ) { } #line 77 "nws/cylinder.nw" cylinder::cylinder( double radius, const scene* ss ) : object( ss ) { this->defaultScale = radius; this->roundDimensions = ~0U; } #line 92 "nws/cylinder.nw" cylinder::~cylinder( void ) { }; #line 105 "nws/cylinder.nw" void cylinder::setDimensions( unsigned int dd ) { this->sphereMask.resize( dd ); if ( this->roundDimensions == 1 ) { this->roundDimensions = 0; } if ( this->roundDimensions > dd ) { this->roundDimensions = dd; } for ( unsigned int ii=0; ii < this->roundDimensions; ++ii ) { this->sphereMask[ ii ] = 1.0; } for ( unsigned int ii=this->roundDimensions; ii < dd; ++ii ) { this->sphereMask[ ii ] = 0.0; } this->object::setDimensions( dd ); } #line 144 "nws/cylinder.nw" bool cylinder::intersect( const mathvec< double >& direction, const mathvec< double >& start, intersection& hit ) const { #line 182 "nws/cylinder.nw" mathvec< double > rd = direction; rd.antirotate( this->orientation ); rd /= this->scale; rd.normalize(); mathvec< double > rp = start - this->center; rp.antirotate( this->orientation ); rp /= this->scale; double t1 = -MAXFLOAT; double t2 = MAXFLOAT; mathvec< double > n1; mathvec< double > n2; bool hitSphere = this->sphereIntersect( rd, rp, &t1, &t2 ); bool hitCube = hitSphere && this->cubeIntersect( rd, rp, &t1, &t2, n1, n2 ); #line 152 "nws/cylinder.nw" if ( !hitSphere || !hitCube ) { if ( this->_inside( rp ) ) { this->forgeHit( direction, start, hit ); return true; } else { return false; } } if ( t1 >= 0.000001 ) { mathvec< double >& nn( n1 ); double tt = t1; double normalFactor = 1.0; #line 202 "nws/cylinder.nw" mathvec< double > spot = rp + ( rd * tt ); if ( nn.size() == 0 ) { nn = spot * this->sphereMask * normalFactor; nn.normalize(); } hit.setObjectPosition( spot ); hit.setObjectNormal( nn ); hit.setObjectDirection( rd ); hit.setPosition( spot ); hit.setNormal( nn ); hit.setDirection( rd ); hit.reorient( this->scale, this->orientation, this->center ); hit.setDistance( ( hit.getPosition() - start ).magnitude() ); hit.setObjectColor( &this->chroma ); #line 166 "nws/cylinder.nw" hit.setOutside(); } else if ( t2 >= 0.000001 ) { mathvec< double >& nn( n2 ); double tt = t2; double normalFactor = -1.0; #line 202 "nws/cylinder.nw" mathvec< double > spot = rp + ( rd * tt ); if ( nn.size() == 0 ) { nn = spot * this->sphereMask * normalFactor; nn.normalize(); } hit.setObjectPosition( spot ); hit.setObjectNormal( nn ); hit.setObjectDirection( rd ); hit.setPosition( spot ); hit.setNormal( nn ); hit.setDirection( rd ); hit.reorient( this->scale, this->orientation, this->center ); hit.setDistance( ( hit.getPosition() - start ).magnitude() ); hit.setObjectColor( &this->chroma ); #line 172 "nws/cylinder.nw" hit.setInside(); } else { return false; } return true; } #line 236 "nws/cylinder.nw" bool cylinder::intersect( const mathvec< double >& direction, const mathvec< double >& start, std::vector< intersection* >& hits ) const { #line 182 "nws/cylinder.nw" mathvec< double > rd = direction; rd.antirotate( this->orientation ); rd /= this->scale; rd.normalize(); mathvec< double > rp = start - this->center; rp.antirotate( this->orientation ); rp /= this->scale; double t1 = -MAXFLOAT; double t2 = MAXFLOAT; mathvec< double > n1; mathvec< double > n2; bool hitSphere = this->sphereIntersect( rd, rp, &t1, &t2 ); bool hitCube = hitSphere && this->cubeIntersect( rd, rp, &t1, &t2, n1, n2 ); #line 244 "nws/cylinder.nw" hits.clear(); if ( !hitSphere || !hitCube ) { if ( this->_inside( rp ) ) { intersection* hh = new intersection(); this->forgeHit( direction, start, *hh ); hits.insert( hits.end(), hh ); return true; } else { return false; } } if ( t1 >= 0.000001 ) { intersection* h1 = new intersection(); intersection& hit( *h1 ); mathvec< double >& nn( n1 ); double tt = t1; double normalFactor = 1.0; #line 202 "nws/cylinder.nw" mathvec< double > spot = rp + ( rd * tt ); if ( nn.size() == 0 ) { nn = spot * this->sphereMask * normalFactor; nn.normalize(); } hit.setObjectPosition( spot ); hit.setObjectNormal( nn ); hit.setObjectDirection( rd ); hit.setPosition( spot ); hit.setNormal( nn ); hit.setDirection( rd ); hit.reorient( this->scale, this->orientation, this->center ); hit.setDistance( ( hit.getPosition() - start ).magnitude() ); hit.setObjectColor( &this->chroma ); #line 264 "nws/cylinder.nw" hit.setOutside(); hits.insert( hits.end(), h1 ); } if ( t2 >= 0.000001 ) { intersection* h2 = new intersection(); intersection& hit( *h2 ); mathvec< double >& nn( n2 ); double tt = t2; double normalFactor = -1.0; #line 202 "nws/cylinder.nw" mathvec< double > spot = rp + ( rd * tt ); if ( nn.size() == 0 ) { nn = spot * this->sphereMask * normalFactor; nn.normalize(); } hit.setObjectPosition( spot ); hit.setObjectNormal( nn ); hit.setObjectDirection( rd ); hit.setPosition( spot ); hit.setNormal( nn ); hit.setDirection( rd ); hit.reorient( this->scale, this->orientation, this->center ); hit.setDistance( ( hit.getPosition() - start ).magnitude() ); hit.setObjectColor( &this->chroma ); #line 275 "nws/cylinder.nw" hit.setInside(); hits.insert( hits.end(), h2 ); } return hits.size() > 0; } #line 293 "nws/cylinder.nw" bool cylinder::sphereIntersect( const mathvec< double >& direction, const mathvec< double >& start, double* t1, double* t2 ) const { if ( this->roundDimensions == 0 ) { return true; } mathvec< double > rds = direction * this->sphereMask; mathvec< double > rps = start * this->sphereMask; double aa = rds ^ rds; double cc = ( rps ^ rps ) - 1.0; if ( aa < 0.000001 ) { return ( cc < 0.000001 ); } double bb = 2.0 * ( rds ^ rps ); double discriminant = bb * bb - 4.0 * aa * cc; if ( discriminant < 0.000001 ) { return false; } double root = ::sqrt( discriminant ); if ( aa > 0 ) { *t1 = ( -bb - root ) / ( 2.0 * aa ); *t2 = ( -bb + root ) / ( 2.0 * aa ); } else { *t1 = ( -bb + root ) / ( 2.0 * aa ); *t2 = ( -bb - root ) / ( 2.0 * aa ); } if ( *t2 < 0.000001 ) { return false; } return true; } #line 351 "nws/cylinder.nw" bool cylinder::cubeIntersect( const mathvec< double >& direction, const mathvec< double >& start, double* t1, double* t2, mathvec< double >& n1, mathvec< double >& n2 ) const { unsigned int dims = this->center.size(); if ( this->roundDimensions == dims ) { return true; } unsigned int n1dim = dims; double n1mag = 1.0; unsigned int n2dim = dims; double n2mag = 1.0; for ( unsigned int ii=this->roundDimensions; ii < dims; ++ii ) { double t1c; double t2c; double nn = direction[ ii ]; double ss = start[ ii ]; if ( ::fabs( nn ) < 0.000001 ) { if ( ss < -1.0 || ss > 1.0 ) { return false; } else { continue; } } t1c = ( -ss + 1.0 ) / nn; t2c = ( -ss - 1.0 ) / nn; if ( t1c < 0.000001 && t2c < 0.000001 ) { return false; } double mag = 1.0; if ( t1c > t2c ) { double tmp = t1c; t1c = t2c; t2c = tmp; mag = -1.0; } if ( t2c < *t1 || t1c > *t2 ) { return false; } if ( t1c > *t1 ) { *t1 = t1c; n1dim = ii; n1mag = mag; } if ( t2c < *t2 ) { *t2 = t2c; n2dim = ii; n2mag = mag; } } if ( n1dim < dims ) { n1.resize( dims, 0.0 ); n1[ n1dim ] = n1mag; } if ( n2dim < dims ) { n2.resize( dims, 0.0 ); n2[ n2dim ] = n2mag; } return true; } #line 436 "nws/cylinder.nw" bool cylinder::inside( const mathvec< double >& start ) const { mathvec< double > rp = start - this->center; rp.antirotate( this->orientation ); rp /= this->scale; return this->_inside( rp ); } bool cylinder::_inside( const mathvec< double >& rp ) const { unsigned int dims = this->center.size(); for ( unsigned int ii=this->roundDimensions; ii < dims; ++ii ) { if ( ::fabs( rp[ ii ] ) > 1.0 ) { return false; } } double sum = 0.0; for ( unsigned int ii=0; ii < this->roundDimensions; ++ii ) { sum += rp[ ii ] * rp[ ii ]; } return sum <= 1.0; } #line 473 "nws/cylinder.nw" std::istream& operator >> ( std::istream& stream, cylinder& cc ) { input in( stream ); cc.roundDimensions = 0; while ( in.check() ) { char token[ input::MAX_TOKEN_LEN ]; if ( in.get( token, sizeof(token) ) == 0 ) { return stream; } std::string tok( token ); char semicolon; if ( tok == "roundDimensions" ) { stream >> cc.roundDimensions >> semicolon; } else if ( tok == "base" ) { stream >> (object&)cc >> semicolon; } else { in.ignore( "CYLINDER", tok.c_str() ); } } return stream; } ./rt2.7.2007.05.17/Code/cylinder.h0100644000077300007650000000334510600166055014133 0ustar patpat#line 534 "nws/cylinder.nw" #ifndef _NKLEIN_CYLINDER_H_ #define _NKLEIN_CYLINDER_H_ 1 #include #include #include #include "object.h" #line 509 "nws/cylinder.nw" class cylinder : public object { protected: #line 48 "nws/cylinder.nw" unsigned int roundDimensions; #line 54 "nws/cylinder.nw" mathvec< double > sphereMask; #line 512 "nws/cylinder.nw" #line 285 "nws/cylinder.nw" bool sphereIntersect( const mathvec< double >& direction, const mathvec< double >& start, double* t1, double* t2 ) const; #line 342 "nws/cylinder.nw" bool cubeIntersect( const mathvec< double >& direction, const mathvec< double >& start, double* t1, double* t2, mathvec< double >& n1, mathvec< double >& n2 ) const; #line 513 "nws/cylinder.nw" public: #line 61 "nws/cylinder.nw" cylinder( const scene* ss ); #line 73 "nws/cylinder.nw" cylinder( double radius, const scene* ss ); #line 88 "nws/cylinder.nw" virtual ~cylinder( void ); #line 101 "nws/cylinder.nw" virtual void setDimensions( unsigned int dd ); #line 136 "nws/cylinder.nw" virtual bool intersect( const mathvec< double >& direction, const mathvec< double >& start, intersection& hit ) const; #line 228 "nws/cylinder.nw" virtual bool intersect( const mathvec< double >& direction, const mathvec< double >& start, std::vector< intersection* >& hits ) const; #line 431 "nws/cylinder.nw" virtual bool inside( const mathvec< double >& start ) const; virtual bool _inside( const mathvec< double >& rp ) const; #line 469 "nws/cylinder.nw" friend std::istream& operator >> ( std::istream& in, cylinder& cc ); #line 515 "nws/cylinder.nw" public: static const char* id; }; #line 544 "nws/cylinder.nw" #endif /*_NKLEIN_CYLINDER_H_*/ ./rt2.7.2007.05.17/Code/expr.cc0100644000077300007650000004636510600166060013443 0ustar patpat#line 411 "nws/expr.nw" #include #include #include #include "input.h" #include "expr.h" #include "portal.h" const char* expr::id = "NKVERSION: expr( 2.1.2007.03.21 )"; #line 258 "nws/expr-binary.nw" class exprBinary : public expr { public: #line 39 "nws/expr-binary.nw" exprBinary( double (*_func)( double, double ) ) : func( _func ), left( 0 ), right( 0 ) { }; #line 48 "nws/expr-binary.nw" ~exprBinary( void ) { delete this->right; delete this->left; }; #line 60 "nws/expr-binary.nw" virtual bool isConstant( void ) const { return this->left->isConstant() && this->right->isConstant(); }; #line 66 "nws/expr-binary.nw" virtual bool usesPosition( void ) const { return this->left->usesPosition() || this->right->usesPosition(); }; #line 72 "nws/expr-binary.nw" virtual bool usesNormal( void ) const { return this->left->usesNormal() || this->right->usesNormal(); }; #line 78 "nws/expr-binary.nw" virtual bool usesDirection( void ) const { return this->left->usesDirection() || this->right->usesDirection(); }; #line 90 "nws/expr-binary.nw" virtual double evaluate( const mathvec& pos, const mathvec& norm, const mathvec& dir ) { return (*this->func)( this->left->evaluate( pos, norm, dir ), this->right->evaluate( pos, norm, dir ) ); } #line 107 "nws/expr-binary.nw" virtual std::istream& get( std::istream& in, const std::map< std::string, class portal* >& portals ) { delete this->left; this->left = expr::read( in, portals ); delete this->right; this->right = expr::read( in, portals ); return in; }; #line 261 "nws/expr-binary.nw" protected: #line 30 "nws/expr-binary.nw" double (*func)( double, double ); expr* left; expr* right; #line 263 "nws/expr-binary.nw" public: static const char* id; }; const char* exprBinary::id = "NKVERSION: exprBinary( 2.1.2007.03.21 )"; #line 216 "nws/expr-unary.nw" class exprUnary : public expr { public: #line 52 "nws/expr-unary.nw" exprUnary( double (*_func)( double ) ) : func( _func ), operand( 0 ) { }; #line 61 "nws/expr-unary.nw" ~exprUnary( void ) { delete this->operand; }; #line 71 "nws/expr-unary.nw" virtual bool isConstant( void ) const { return this->operand->isConstant(); }; #line 77 "nws/expr-unary.nw" virtual bool usesPosition( void ) const { return this->operand->usesPosition(); }; #line 83 "nws/expr-unary.nw" virtual bool usesNormal( void ) const { return this->operand->usesNormal(); }; #line 89 "nws/expr-unary.nw" virtual bool usesDirection( void ) const { return this->operand->usesDirection(); }; #line 100 "nws/expr-unary.nw" virtual double evaluate( const mathvec& pos, const mathvec& norm, const mathvec& dir ) { return (*this->func)( this->operand->evaluate( pos, norm, dir ) ); } #line 114 "nws/expr-unary.nw" virtual std::istream& get( std::istream& in, const std::map< std::string, class portal* >& portals ) { delete this->operand; this->operand = expr::read( in, portals ); return in; }; #line 219 "nws/expr-unary.nw" protected: #line 45 "nws/expr-unary.nw" double (*func)( double ); expr* operand; #line 221 "nws/expr-unary.nw" public: static const char* id; }; const char* exprUnary::id = "NKVERSION: exprUnary( 2.1.2007.03.21 )"; #line 143 "nws/expr-const.nw" class exprConst : public expr { public: #line 25 "nws/expr-const.nw" exprConst( double _value ) : value( _value ) {}; #line 32 "nws/expr-const.nw" virtual bool isConstant( void ) const { return true; }; #line 38 "nws/expr-const.nw" virtual bool usesPosition( void ) const { return false; }; #line 44 "nws/expr-const.nw" virtual bool usesNormal( void ) const { return false; }; #line 50 "nws/expr-const.nw" virtual bool usesDirection( void ) const { return false; }; #line 60 "nws/expr-const.nw" virtual double evaluate( const mathvec& /*position*/, const mathvec& /*normal*/, const mathvec& /*direction*/ ) { return this->value; } #line 76 "nws/expr-const.nw" virtual std::istream& get( std::istream& in, const std::map< std::string, class portal* >& /*portals*/ ) { return in; }; #line 146 "nws/expr-const.nw" protected: #line 18 "nws/expr-const.nw" double value; #line 148 "nws/expr-const.nw" public: static const char* id; }; const char* exprConst::id = "NKVERSION: exprConst( 2.1.2007.03.21 )"; #line 108 "nws/expr-pos.nw" class exprPosition : public expr { public: #line 25 "nws/expr-pos.nw" exprPosition( void ) : operand( 0 ) { }; #line 34 "nws/expr-pos.nw" ~exprPosition( void ) { delete this->operand; }; #line 45 "nws/expr-pos.nw" virtual bool isConstant( void ) const { return false; }; #line 51 "nws/expr-pos.nw" virtual bool usesPosition( void ) const { return true; }; #line 57 "nws/expr-pos.nw" virtual bool usesNormal( void ) const { return this->operand->usesNormal(); }; #line 63 "nws/expr-pos.nw" virtual bool usesDirection( void ) const { return this->operand->usesDirection(); }; #line 75 "nws/expr-pos.nw" virtual double evaluate( const mathvec& pos, const mathvec& norm, const mathvec& dir ) { double op = this->operand->evaluate( pos, norm, dir ); unsigned int index = (unsigned int)( op + 0.5 ); return pos[ index ]; } #line 91 "nws/expr-pos.nw" virtual std::istream& get( std::istream& in, const std::map< std::string, class portal* >& portals ) { delete this->operand; this->operand = expr::read( in, portals ); return in; }; #line 111 "nws/expr-pos.nw" protected: #line 19 "nws/expr-pos.nw" expr* operand; #line 113 "nws/expr-pos.nw" public: static const char* id; }; const char* exprPosition::id = "NKVERSION: exprPosition( 2.1.2007.03.21 )"; #line 112 "nws/expr-dir.nw" class exprDirection : public expr { public: #line 29 "nws/expr-dir.nw" exprDirection( void ) : operand( 0 ) { }; #line 38 "nws/expr-dir.nw" ~exprDirection( void ) { delete this->operand; }; #line 49 "nws/expr-dir.nw" virtual bool isConstant( void ) const { return false; }; #line 55 "nws/expr-dir.nw" virtual bool usesPosition( void ) const { return this->operand->usesPosition(); }; #line 61 "nws/expr-dir.nw" virtual bool usesNormal( void ) const { return this->operand->usesNormal(); }; #line 67 "nws/expr-dir.nw" virtual bool usesDirection( void ) const { return true; }; #line 79 "nws/expr-dir.nw" virtual double evaluate( const mathvec& pos, const mathvec& norm, const mathvec& dir ) { double op = this->operand->evaluate( pos, norm, dir ); unsigned int index = (unsigned int)( op + 0.5 ); return dir[ index ]; } #line 95 "nws/expr-dir.nw" virtual std::istream& get( std::istream& in, const std::map< std::string, class portal* >& portals ) { delete this->operand; this->operand = expr::read( in, portals ); return in; }; #line 115 "nws/expr-dir.nw" protected: #line 23 "nws/expr-dir.nw" expr* operand; #line 117 "nws/expr-dir.nw" public: static const char* id; }; const char* exprDirection::id = "NKVERSION: exprDirection( 2.1.2007.03.21 )"; #line 111 "nws/expr-norm.nw" class exprNormal : public expr { public: #line 28 "nws/expr-norm.nw" exprNormal( void ) : operand( 0 ) { }; #line 37 "nws/expr-norm.nw" ~exprNormal( void ) { delete this->operand; }; #line 48 "nws/expr-norm.nw" virtual bool isConstant( void ) const { return false; }; #line 54 "nws/expr-norm.nw" virtual bool usesPosition( void ) const { return this->operand->usesPosition(); }; #line 60 "nws/expr-norm.nw" virtual bool usesNormal( void ) const { return true; }; #line 66 "nws/expr-norm.nw" virtual bool usesDirection( void ) const { return this->operand->usesDirection(); }; #line 78 "nws/expr-norm.nw" virtual double evaluate( const mathvec& pos, const mathvec& norm, const mathvec& dir ) { double op = this->operand->evaluate( pos, norm, dir ); unsigned int index = (unsigned int)( op + 0.5 ); return norm[ index ]; } #line 94 "nws/expr-norm.nw" virtual std::istream& get( std::istream& in, const std::map< std::string, class portal* >& portals ) { delete this->operand; this->operand = expr::read( in, portals ); return in; }; #line 114 "nws/expr-norm.nw" protected: #line 22 "nws/expr-norm.nw" expr* operand; #line 116 "nws/expr-norm.nw" public: static const char* id; }; const char* exprNormal::id = "NKVERSION: exprNormal( 2.1.2007.03.21 )"; #line 118 "nws/expr-ref.nw" class exprReference : public expr { public: #line 34 "nws/expr-ref.nw" exprReference( const mathvec< double >& pp ) : pixel( pp ), operand( 0 ) { }; #line 44 "nws/expr-ref.nw" ~exprReference( void ) { delete this->operand; }; #line 55 "nws/expr-ref.nw" virtual bool isConstant( void ) const { return false; }; #line 61 "nws/expr-ref.nw" virtual bool usesPosition( void ) const { return true; }; #line 67 "nws/expr-ref.nw" virtual bool usesNormal( void ) const { return true; }; #line 73 "nws/expr-ref.nw" virtual bool usesDirection( void ) const { return true; }; #line 85 "nws/expr-ref.nw" virtual double evaluate( const mathvec& pos, const mathvec& norm, const mathvec& dir ) { double op = this->operand->evaluate( pos, norm, dir ); unsigned int index = (unsigned int)( op + 0.5 ); return this->pixel[ index ]; } #line 101 "nws/expr-ref.nw" virtual std::istream& get( std::istream& in, const std::map< std::string, class portal* >& portals ) { delete this->operand; this->operand = expr::read( in, portals ); return in; }; #line 121 "nws/expr-ref.nw" protected: #line 26 "nws/expr-ref.nw" const mathvec< double >& pixel; expr* operand; #line 123 "nws/expr-ref.nw" public: static const char* id; }; const char* exprReference::id = "NKVERSION: exprReference( 2.1.2007.03.21 )"; #line 125 "nws/expr-binary.nw" class BinaryExpressionTable { protected: typedef double (*FunctionType)( double, double ); typedef std::map< std::string, FunctionType > TableType; typedef TableType::const_iterator const_iterator; TableType table; public: BinaryExpressionTable( void ); exprBinary* operator [] ( const std::string& name ) const; static double add( double aa, double bb ); static double sub( double aa, double bb ); static double mul( double aa, double bb ); static double div( double aa, double bb ); static double mod( double aa, double bb ); static double idiv( double aa, double bb ); static double min( double aa, double bb ); static double max( double aa, double bb ); public: static const char* id; }; const char* BinaryExpressionTable::id = "NKVERSION: BinaryExpressionTable( 2.1.2007.03.21 )"; #line 155 "nws/expr-binary.nw" BinaryExpressionTable::BinaryExpressionTable( void ) { this->table[ "+" ] = BinaryExpressionTable::add; this->table[ "-" ] = BinaryExpressionTable::sub; this->table[ "*" ] = BinaryExpressionTable::mul; this->table[ "/" ] = BinaryExpressionTable::div; this->table[ "%" ] = BinaryExpressionTable::mod; this->table[ "div" ] = BinaryExpressionTable::idiv; this->table[ "atan2" ] = (double (*)( double, double ))::atan2; this->table[ "^" ] = (double (*)( double, double ))::pow; this->table[ "min" ] = BinaryExpressionTable::min; this->table[ "max" ] = BinaryExpressionTable::max; } #line 174 "nws/expr-binary.nw" exprBinary* BinaryExpressionTable::operator [] ( const std::string& name ) const { const_iterator it = this->table.find( name ); if ( it != this->table.end() ) { return new exprBinary( it->second ); } else { return 0; } } #line 189 "nws/expr-binary.nw" double BinaryExpressionTable::add( double aa, double bb ) { return aa + bb; } double BinaryExpressionTable::sub( double aa, double bb ) { return aa - bb; } double BinaryExpressionTable::mul( double aa, double bb ) { return aa * bb; } double BinaryExpressionTable::div( double aa, double bb ) { return aa / bb; } #line 213 "nws/expr-binary.nw" double BinaryExpressionTable::mod( double aa, double bb ) { double ii; double rr = ::modf( aa / bb, &ii ); return rr * bb; } #line 224 "nws/expr-binary.nw" double BinaryExpressionTable::idiv( double aa, double bb ) { double ii; (void) ::modf( aa / bb, &ii ); return ii * bb; } #line 234 "nws/expr-binary.nw" double BinaryExpressionTable::min( double aa, double bb ) { if ( aa < bb ) { return aa; } else { return bb; } } double BinaryExpressionTable::max( double aa, double bb ) { if ( aa < bb ) { return bb; } else { return aa; } } #line 130 "nws/expr-unary.nw" class UnaryExpressionTable { protected: typedef double (*FunctionType)( double ); typedef std::map< std::string, FunctionType > TableType; typedef TableType::const_iterator const_iterator; TableType table; public: UnaryExpressionTable( void ); exprUnary* operator [] ( const std::string& name ) const; static double sign( double ); public: static const char* id; }; const char* UnaryExpressionTable::id = "NKVERSION: UnaryExpressionTable( 2.1.2007.03.21 )"; #line 153 "nws/expr-unary.nw" UnaryExpressionTable::UnaryExpressionTable( void ) { this->table[ "sin" ] = (double (*)( double ))::sin; this->table[ "cos" ] = (double (*)( double ))::cos; this->table[ "tan" ] = (double (*)( double ))::tan; this->table[ "atan" ] = (double (*)( double ))::atan; this->table[ "sinh" ] = (double (*)( double ))::sinh; this->table[ "cosh" ] = (double (*)( double ))::cosh; this->table[ "tanh" ] = (double (*)( double ))::tanh; this->table[ "sqrt" ] = (double (*)( double ))::sqrt; this->table[ "cbrt" ] = (double (*)( double ))::cbrt; this->table[ "exp" ] = (double (*)( double ))::exp; this->table[ "log" ] = (double (*)( double ))::log; this->table[ "log10" ] = (double (*)( double ))::log10; this->table[ "fabs" ] = (double (*)( double ))::fabs; this->table[ "floor" ] = (double (*)( double ))::floor; this->table[ "ceil" ] = (double (*)( double ))::ceil; this->table[ "rint" ] = (double (*)( double ))::rint; this->table[ "round" ] = (double (*)( double ))::rint; this->table[ "sign" ] = UnaryExpressionTable::sign; this->table[ "gamma" ] = (double (*)( double ))::gamma; this->table[ "lgamma" ] = (double (*)( double ))::lgamma; this->table[ "erf" ] = (double (*)( double ))::erf; } #line 182 "nws/expr-unary.nw" double UnaryExpressionTable::sign( double vv ) { if ( vv > 0.000001 ) { return 1.0; } else if ( vv < -0.000001 ) { return -1.0; } else { return 0.0; } } #line 197 "nws/expr-unary.nw" exprUnary* UnaryExpressionTable::operator [] ( const std::string& name ) const { const_iterator it = this->table.find( name ); if ( it != this->table.end() ) { return new exprUnary( it->second ); } else { return 0; } } #line 90 "nws/expr-const.nw" class ConstantExpressionTable { protected: typedef std::map< std::string, double > TableType; typedef TableType::const_iterator const_iterator; TableType table; public: ConstantExpressionTable( void ); exprConst* operator [] ( const std::string& name ) const; public: static const char* id; }; const char* ConstantExpressionTable::id = "NKVERSION: ConstantExpressionTable( 2.1.2007.03.21 )"; #line 110 "nws/expr-const.nw" ConstantExpressionTable::ConstantExpressionTable( void ) { this->table[ "pi" ] = M_PI; this->table[ "2pi" ] = 2.0 * M_PI; this->table[ "e" ] = M_E; this->table[ "sqrt2" ] = M_SQRT2; } #line 123 "nws/expr-const.nw" exprConst* ConstantExpressionTable::operator [] ( const std::string& name ) const { const_iterator it = this->table.find( name ); if ( it != this->table.end() ) { return new exprConst( it->second ); } else { return 0; } } #line 334 "nws/expr.nw" class TableInitializer { public: TableInitializer( void ); public: static const char* id; }; const char* TableInitializer::id = "NKVERSION: TableInitializer( 2.1.2007.03.21 )"; #line 346 "nws/expr.nw" TableInitializer::TableInitializer( void ) { std::map portals; expr* ee = expr::read( "+ sin pi 1", portals ); if ( ee != 0 ) { delete ee; } }; #line 359 "nws/expr.nw" static TableInitializer __tableInitializer; #line 52 "nws/expr.nw" expr::~expr( void ) {} #line 106 "nws/expr.nw" expr* expr::read( std::istream& stream, const std::map& portals ) { input in( stream ); if ( in.check() ) { char token[ input::MAX_TOKEN_LEN ]; if ( in.get( token, sizeof(token) ) == 0 ) { return 0; } std::string tok( token ); if ( tok == "pos" ) { expr* nn = new exprPosition(); nn->get( stream, portals ); return nn; } else if ( tok == "dir" ) { expr* nn = new exprDirection(); nn->get( stream, portals ); return nn; } else if ( tok == "norm" ) { expr* nn = new exprNormal(); nn->get( stream, portals ); return nn; } else if ( tok == "@" ) { #line 152 "nws/expr.nw" if ( in.get( token, sizeof(token) ) == 0 ) { return 0; } std::string name( token ); std::map< std::string, class portal* >::const_iterator pp = portals.find( name ); if ( pp == portals.end() ) { return 0; } exprReference* rret = new exprReference( pp->second->getPixel() ); rret->get( stream, portals ); return rret; #line 136 "nws/expr.nw" } #line 174 "nws/expr.nw" static const BinaryExpressionTable binaries; exprBinary* bret = binaries[ tok ]; if ( bret != 0 ) { bret->get( stream, portals ); if ( bret->isConstant() ) { mathvec< double > dd; exprConst* cret = new exprConst( bret->evaluate( dd, dd, dd ) ); delete bret; return cret; } else { return bret; } } #line 139 "nws/expr.nw" #line 195 "nws/expr.nw" static const UnaryExpressionTable unaries; exprUnary* uret = unaries[ tok ]; if ( uret != 0 ) { uret->get( stream, portals ); if ( uret->isConstant() ) { mathvec< double > dd; exprConst* cret = new exprConst( uret->evaluate( dd, dd, dd ) ); delete uret; return cret; } else { return uret; } } #line 140 "nws/expr.nw" #line 216 "nws/expr.nw" static const ConstantExpressionTable constants; exprConst* cret = constants[ tok ]; if ( cret != 0 ) { cret->get( stream, portals ); return cret; } #line 229 "nws/expr.nw" double value; std::istringstream str( token ); str >> value; if ( ! str.fail() ) { return new exprConst( value ); } #line 141 "nws/expr.nw" } return 0; } #line 243 "nws/expr.nw" expr* expr::read( const char* str, const std::map& portals ) { std::istringstream in( str ); return read( in, portals ); } #line 281 "nws/expr.nw" void expr::read( std::istream& in, basevec< expr* >& exprs, const std::map& portals ) { char bogus; unsigned int len; in.setf( std::ios::skipws ); in >> bogus; // "[" in >> len; in >> bogus >> bogus; // "]<" exprs.resize( len, (expr*)0 ); for (unsigned ii=0; ii < len; ++ii) { exprs[ ii ] = expr::read( in, portals ); if (ii < len-1) { in >> bogus; // "," } } while (bogus != '>' && in.good() ) { in >> bogus; // ">" } } #line 314 "nws/expr.nw" void expr::read( const char* str, basevec< expr* >& exprs, const std::map& portals ) { std::istringstream in( str ); expr::read( in, exprs, portals ); } ./rt2.7.2007.05.17/Code/expr.h0100644000077300007650000000254010600166046013274 0ustar patpat#line 390 "nws/expr.nw" #ifndef _NKLEIN_EXPR_H_ #define _NKLEIN_EXPR_H_ 1 #include #include #include #include "mathvec.h" class scene; #line 368 "nws/expr.nw" class expr { public: #line 48 "nws/expr.nw" virtual ~expr( void ); #line 61 "nws/expr.nw" virtual bool isConstant( void ) const = 0; virtual bool usesPosition( void ) const = 0; virtual bool usesNormal( void ) const = 0; virtual bool usesDirection( void ) const = 0; #line 72 "nws/expr.nw" virtual double evaluate( const mathvec& position, const mathvec& normal, const mathvec& direction ) = 0; #line 85 "nws/expr.nw" virtual std::istream& get( std::istream& in, const std::map< std::string, class portal* >& portals ) = 0; #line 94 "nws/expr.nw" static expr* read( std::istream& in, const std::map& portals ); static expr* read( const char* str, const std::map& portals ); #line 261 "nws/expr.nw" static void read( std::istream& in, basevec< expr* >& exprs, const std::map< std::string, class portal* >& portals ); static void read( const char* str, basevec< expr* >& exprs, const std::map< std::string, class portal* >& portals ); #line 371 "nws/expr.nw" public: static const char* id; }; #line 402 "nws/expr.nw" #endif /*_NKLEIN_EXPR_H_*/ ./rt2.7.2007.05.17/Code/extrusion.cc0100644000077300007650000001311310600166054014511 0ustar patpat#line 349 "nws/extrusion.nw" #include #include #include #ifndef MAXFLOAT #include #endif #include "input.h" #include "extrusion.h" const char* extrusion::id = "NKVERSION: extrusion( 2.1.2007.03.21 )"; #line 50 "nws/extrusion.nw" extrusion::extrusion( const scene* ss ) : object( ss ) #line 39 "nws/extrusion.nw" , subDimensions( 0 ), obj( 0 ) #line 52 "nws/extrusion.nw" { } #line 64 "nws/extrusion.nw" extrusion::~extrusion( void ) { delete this->obj; }; #line 78 "nws/extrusion.nw" void extrusion::setDimensions( unsigned int dd ) { if ( this->subDimensions == 0 || this->subDimensions > dd ) { this->subDimensions = dd; } if ( this->obj != 0 ) { this->obj->setDimensions( this->subDimensions ); } this->object::setDimensions( dd ); } #line 105 "nws/extrusion.nw" bool extrusion::intersect( const mathvec< double >& direction, const mathvec< double >& start, intersection& hit ) const { if ( this->obj == 0 ) { return false; } #line 127 "nws/extrusion.nw" mathvec< double > rd = direction; rd.antirotate( this->orientation ); rd /= this->scale; mathvec< double > fullrd = rd; rd.resize( this->subDimensions, 0.0 ); fullrd.normalize(); rd.normalize(); mathvec< double > rp = start - this->center; rp.antirotate( this->orientation ); rp /= this->scale; mathvec< double > fullrp = rp; rp.resize( this->subDimensions, 0.0 ); #line 115 "nws/extrusion.nw" bool ret = false; if ( ( rd ^ rd ) > 0.000001 ) { ret = this->obj->intersect( rd, rp, hit ); if ( ret ) { #line 146 "nws/extrusion.nw" mathvec< double > hitPosition; if ( hit.getDistance() < MAXFLOAT / 2.0 ) { hitPosition = fullrd; rd.resize( fullrd.size(), 0.0 ); hitPosition *= hit.getDistance(); double distFactor = ( rd ^ fullrd ); if ( distFactor > 0.000001 ) { hitPosition /= distFactor; } hitPosition += fullrp; hit.setPosition( hitPosition ); } else { hitPosition = hit.getPosition(); hitPosition.resize( this->center.size(), 0.0 ); hit.setPosition( hitPosition ); } hit.setDirection( fullrd ); mathvec< double > hitNormal = hit.getNormal(); hitNormal.resize( this->center.size(), 0.0 ); hit.setNormal( hitNormal ); hit.reorient( this->scale, this->orientation, this->center ); hit.setDistance( ( hitPosition - start ).magnitude() ); if ( this->gotColor ) { hit.recolor( this->chroma ); } #line 120 "nws/extrusion.nw" } } return ret; } #line 190 "nws/extrusion.nw" bool extrusion::intersect( const mathvec< double >& direction, const mathvec< double >& start, std::vector< intersection* >& hits ) const { if ( this->obj == 0 ) { return false; } #line 127 "nws/extrusion.nw" mathvec< double > rd = direction; rd.antirotate( this->orientation ); rd /= this->scale; mathvec< double > fullrd = rd; rd.resize( this->subDimensions, 0.0 ); fullrd.normalize(); rd.normalize(); mathvec< double > rp = start - this->center; rp.antirotate( this->orientation ); rp /= this->scale; mathvec< double > fullrp = rp; rp.resize( this->subDimensions, 0.0 ); #line 200 "nws/extrusion.nw" hits.clear(); bool ret; if ( ( rd ^ rd ) > 0.000001 ) { ret = this->obj->intersect( rd, rp, hits ); if ( ret ) { for ( unsigned int ii=0; ii < hits.size(); ++ii ) { intersection& hit( *hits[ ii ] ); #line 146 "nws/extrusion.nw" mathvec< double > hitPosition; if ( hit.getDistance() < MAXFLOAT / 2.0 ) { hitPosition = fullrd; rd.resize( fullrd.size(), 0.0 ); hitPosition *= hit.getDistance(); double distFactor = ( rd ^ fullrd ); if ( distFactor > 0.000001 ) { hitPosition /= distFactor; } hitPosition += fullrp; hit.setPosition( hitPosition ); } else { hitPosition = hit.getPosition(); hitPosition.resize( this->center.size(), 0.0 ); hit.setPosition( hitPosition ); } hit.setDirection( fullrd ); mathvec< double > hitNormal = hit.getNormal(); hitNormal.resize( this->center.size(), 0.0 ); hit.setNormal( hitNormal ); hit.reorient( this->scale, this->orientation, this->center ); hit.setDistance( ( hitPosition - start ).magnitude() ); if ( this->gotColor ) { hit.recolor( this->chroma ); } #line 209 "nws/extrusion.nw" } } } else { ret = this->obj->inside( rp ); if ( ret ) { intersection* nn = new intersection(); this->forgeHit( direction, start, *nn ); hits.insert( hits.end(), nn ); } } return ret; } #line 232 "nws/extrusion.nw" bool extrusion::inside( const mathvec< double >& start ) const { if ( this->obj == 0 ) { return false; } mathvec< double > rp = start - this->center; rp.antirotate( this->orientation ); rp /= this->scale; rp.resize( this->subDimensions, 0.0 ); return this->_inside( rp ); } bool extrusion::_inside( const mathvec< double >& rp ) const { if ( this->obj == 0 ) { return false; } return this->obj->inside( rp ); } #line 265 "nws/extrusion.nw" std::istream& operator >> ( std::istream& stream, extrusion& ee ) { input in( stream ); while ( in.check() ) { char token[ input::MAX_TOKEN_LEN ]; if ( in.get( token, sizeof(token) ) == 0 ) { return stream; } std::string tok( token ); char semicolon; if ( tok == "dimensions" ) { stream >> ee.subDimensions >> semicolon; } else if ( tok == "object" ) { object* nn = object::read( stream, ee.myScene ); if ( nn != 0 ) { delete ee.obj; ee.obj = nn; } else { std::cerr << "EXTRUSION failed to get an object!" << std::endl; } } else if ( tok == "base" ) { stream >> (object&)ee >> semicolon; } else { in.ignore( "EXTRUSION", tok.c_str() ); } } return stream; } ./rt2.7.2007.05.17/Code/extrusion.h0100644000077300007650000000235510600166054014361 0ustar patpat#line 331 "nws/extrusion.nw" #ifndef _NKLEIN_EXTRUSION_H_ #define _NKLEIN_EXTRUSION_H_ 1 #include #include #include #include "object.h" #line 307 "nws/extrusion.nw" class extrusion : public object { protected: #line 35 "nws/extrusion.nw" unsigned int subDimensions; object* obj; #line 310 "nws/extrusion.nw" public: #line 46 "nws/extrusion.nw" extrusion( const scene* ss ); #line 60 "nws/extrusion.nw" virtual ~extrusion( void ); #line 74 "nws/extrusion.nw" virtual void setDimensions( unsigned int dd ); #line 97 "nws/extrusion.nw" virtual bool intersect( const mathvec< double >& direction, const mathvec< double >& start, intersection& hit ) const; #line 182 "nws/extrusion.nw" virtual bool intersect( const mathvec< double >& direction, const mathvec< double >& start, std::vector< intersection* >& hits ) const; #line 227 "nws/extrusion.nw" virtual bool inside( const mathvec< double >& start ) const; virtual bool _inside( const mathvec< double >& rp ) const; #line 261 "nws/extrusion.nw" friend std::istream& operator >> ( std::istream& in, extrusion& cc ); #line 312 "nws/extrusion.nw" public: static const char* id; }; #line 341 "nws/extrusion.nw" #endif /*_NKLEIN_EXTRUSION_H_*/ ./rt2.7.2007.05.17/Code/halfspace.cc0100644000077300007650000001135310600166056014405 0ustar patpat#line 356 "nws/halfspace.nw" #include #include #include #include "input.h" #include "halfspace.h" const char* halfspace::id = "NKVERSION: halfspace( 2.1.2007.03.21 )"; #line 39 "nws/halfspace.nw" halfspace::halfspace( const scene* ss ) : object( ss ) { } #line 51 "nws/halfspace.nw" halfspace::halfspace( const mathvec& cc ) : object( 0 ) { this->center = cc; this->orientation.resize( 1 ); this->orientation[ 0 ] = cc; this->orientation[ 0 ].normalize(); } #line 67 "nws/halfspace.nw" halfspace::halfspace( const mathvec& cc, const mathvec& nn ) : object( 0 ) { this->center = cc; this->orientation.resize( 1 ); this->orientation[ 0 ] = nn; this->orientation[ 0 ].normalize(); } #line 87 "nws/halfspace.nw" halfspace::~halfspace( void ) { }; #line 99 "nws/halfspace.nw" void halfspace::setDimensions( unsigned int dd ) { this->object::setDimensions( dd ); } #line 120 "nws/halfspace.nw" bool halfspace::intersect( const mathvec< double >& direction, const mathvec< double >& start, intersection& hit ) const { #line 139 "nws/halfspace.nw" unsigned int len = this->center.size(); mathvec< double > rd = direction; rd.antirotate( this->orientation ); rd /= this->scale; rd.normalize(); mathvec< double > rp = start - this->center; rp.antirotate( this->orientation ); rp /= this->scale; mathvec< double > nn( 0.0, len ); if ( rp[ 0 ] > 0.0 ) { nn[ 0 ] = 1.0; } else { nn[ 0 ] = -1.0; } double tt; double dd = rd[ 0 ]; if ( ::fabs( dd ) > 0.000001 ) { tt = - rp[ 0 ] / dd; } else { tt = - 1.0; } #line 128 "nws/halfspace.nw" if ( tt > 0.000001 ) { #line 168 "nws/halfspace.nw" mathvec< double > spot = rp + ( rd * tt ); if ( rp[ 0 ] > 0.0 ) { hit.setOutside(); } else { hit.setInside(); } hit.setObjectPosition( spot ); hit.setObjectNormal( nn ); hit.setObjectDirection( rd.normalize() ); hit.setPosition( spot ); hit.setNormal( nn ); hit.setDirection( rd ); hit.reorient( this->scale, this->orientation, this->center ); hit.setDistance( ( hit.getPosition() - start ).magnitude() ); hit.setObjectColor( &this->chroma ); #line 130 "nws/halfspace.nw" } else { return false; } return true; } #line 203 "nws/halfspace.nw" bool halfspace::intersect( const mathvec< double >& direction, const mathvec< double >& start, std::vector< intersection* >& hits ) const { #line 139 "nws/halfspace.nw" unsigned int len = this->center.size(); mathvec< double > rd = direction; rd.antirotate( this->orientation ); rd /= this->scale; rd.normalize(); mathvec< double > rp = start - this->center; rp.antirotate( this->orientation ); rp /= this->scale; mathvec< double > nn( 0.0, len ); if ( rp[ 0 ] > 0.0 ) { nn[ 0 ] = 1.0; } else { nn[ 0 ] = -1.0; } double tt; double dd = rd[ 0 ]; if ( ::fabs( dd ) > 0.000001 ) { tt = - rp[ 0 ] / dd; } else { tt = - 1.0; } #line 211 "nws/halfspace.nw" hits.clear(); if ( tt > 0.000001 ) { intersection* hh = new intersection(); intersection& hit( *hh ); #line 168 "nws/halfspace.nw" mathvec< double > spot = rp + ( rd * tt ); if ( rp[ 0 ] > 0.0 ) { hit.setOutside(); } else { hit.setInside(); } hit.setObjectPosition( spot ); hit.setObjectNormal( nn ); hit.setObjectDirection( rd.normalize() ); hit.setPosition( spot ); hit.setNormal( nn ); hit.setDirection( rd ); hit.reorient( this->scale, this->orientation, this->center ); hit.setDistance( ( hit.getPosition() - start ).magnitude() ); hit.setObjectColor( &this->chroma ); #line 217 "nws/halfspace.nw" hits.insert( hits.end(), hh ); } else if ( rp[ 0 ] <= 0.0 ) { intersection* hh = new intersection(); this->forgeHit( direction, start, *hh ); hits.insert( hits.end(), hh ); } return hits.size() > 0; } #line 237 "nws/halfspace.nw" double halfspace::distance( const mathvec< double >& start ) const { mathvec< double > rp = start - this->center; rp.antirotate( this->orientation ); rp /= this->scale; return rp[ 0 ]; } #line 256 "nws/halfspace.nw" bool halfspace::inside( const mathvec< double >& start ) const { mathvec< double > rp = start - this->center; rp.antirotate( this->orientation ); rp /= this->scale; return this->_inside( rp ); } bool halfspace::_inside( const mathvec< double >& rp ) const { return rp[ 0 ] <= 0.0; } #line 282 "nws/halfspace.nw" std::istream& operator >> ( std::istream& stream, halfspace& hh ) { input in( stream ); while ( in.check() ) { char token[ input::MAX_TOKEN_LEN ]; if ( in.get( token, sizeof(token) ) == 0 ) { return stream; } std::string tok( token ); char semicolon; if ( tok == "base" ) { stream >> (object&)hh >> semicolon; } else { in.ignore( "HALFSPACE", tok.c_str() ); } } return stream; } ./rt2.7.2007.05.17/Code/halfspace.h0100644000077300007650000000257710600166055014256 0ustar patpat#line 337 "nws/halfspace.nw" #ifndef _NKLEIN_HALFSPACE_H_ #define _NKLEIN_HALFSPACE_H_ 1 #include #include #include #include "object.h" #line 315 "nws/halfspace.nw" class halfspace : public object { public: #line 35 "nws/halfspace.nw" halfspace( const scene* ss ); #line 47 "nws/halfspace.nw" halfspace( const mathvec< double >& cc ); #line 63 "nws/halfspace.nw" halfspace( const mathvec< double >& cc, const mathvec< double >& nn ); #line 83 "nws/halfspace.nw" virtual ~halfspace( void ); #line 95 "nws/halfspace.nw" virtual void setDimensions( unsigned int dd ); #line 112 "nws/halfspace.nw" virtual bool intersect( const mathvec< double >& direction, const mathvec< double >& start, intersection& hit ) const; #line 195 "nws/halfspace.nw" virtual bool intersect( const mathvec< double >& direction, const mathvec< double >& start, std::vector< intersection* >& hits ) const; #line 231 "nws/halfspace.nw" double distance( const mathvec< double >& start ) const; #line 251 "nws/halfspace.nw" virtual bool inside( const mathvec< double >& start ) const; virtual bool _inside( const mathvec< double >& rp ) const; #line 278 "nws/halfspace.nw" friend std::istream& operator >> ( std::istream& in, halfspace& cc ); #line 318 "nws/halfspace.nw" public: static const char* id; }; #line 347 "nws/halfspace.nw" #endif /*_NKLEIN_HALFSPACE_H_*/ ./rt2.7.2007.05.17/Code/image.cc0100644000077300007650000004123510600166057013544 0ustar patpat#line 282 "nws/image.nw" #include #include #include #include #include #include "input.h" #include "image.h" const char* image::id = "NKVERSION: image( 2.1.2007.03.21 )"; #line 216 "nws/image-ppm.nw" #ifdef USE_PPM class imagePPM : public image { public: #line 40 "nws/image-ppm.nw" imagePPM( void ) : out( 0 ), borderRow( 0 ) { }; #line 49 "nws/image-ppm.nw" virtual ~imagePPM( void ) { delete this->out; delete[] this->borderRow; }; #line 62 "nws/image-ppm.nw" virtual void setSize( unsigned int ww, unsigned int hh, unsigned int dd, unsigned int cc ) { if ( cc > 3 ) { cc = 3; } else if ( cc < 3 ) { cc = 1; } this->image::setSize( ww, hh, dd, cc ); unsigned int len = this->width * this->channelCount; delete[] this->borderRow; this->borderRow = new unsigned char[ len ]; for ( unsigned int ii=0; ii < len; ++ii ) { this->borderRow[ ii ] = (unsigned char)0xFF; } this->pixelCount = 0; }; #line 97 "nws/image-ppm.nw" virtual void add( const mathvec< double >& pixel ) { this->checkOutput(); if ( pixel.size() <= this->channelCount ) { unsigned char lastVal = 0; for ( unsigned int ii=0; ii < pixel.size(); ++ii ) { int val = (int)( pixel[ ii ] * 255.0 + 0.5 ); lastVal = (unsigned char)( val<0 ) ? 0 : ( val>255 ) ? 255 : val ; this->out->put( lastVal ); } for ( unsigned int ii=pixel.size(); ii < this->channelCount; ++ii ) { this->out->put( lastVal ); } } else { int total = 0; for ( unsigned int ii=0; ii < pixel.size(); ++ii ) { int val = (int)( pixel[ ii ] * 255.0 + 0.5 ); total += ( val < 0 ) ? 0 : ( val > 255 ) ? 255 : val ; } unsigned char val = (unsigned char)( total / pixel.size() ); for ( unsigned int ii=0; ii < this->channelCount; ++ii ) { this->out->put( val ); } } }; #line 126 "nws/image-ppm.nw" virtual void addBorderPixel( void ) { this->checkOutput(); this->out->write( (const char*)borderRow, this->channelCount ); }; #line 135 "nws/image-ppm.nw" virtual void addBorderRow( void ) { this->checkOutput( this->width ); this->out->write( (const char*)borderRow, this->width*this->channelCount ); }; #line 183 "nws/image-ppm.nw" virtual std::istream& get( std::istream& stream ) { input in( stream ); while ( in.check() ) { char token[ input::MAX_TOKEN_LEN ]; if ( in.get( token, sizeof(token) ) == 0 ) { return stream; } std::string tok( token ); char semicolon; if ( tok == "common" ) { this->image::get( stream ); stream >> semicolon; } else { in.ignore( "PPM", tok.c_str() ); } } return stream; }; #line 220 "nws/image-ppm.nw" protected: #line 144 "nws/image-ppm.nw" void checkOutput( unsigned int count = 1 ) { if ( this->pixelCount < count ) { delete this->out; this->out = 0; this->pixelCount = this->width * this->height - count; } else { this->pixelCount -= count; } if ( this->out == 0 ) { std::string fname = this->getNumberedBasename() + ".ppm"; this->out = new std::ofstream( fname.c_str() ); if ( this->channelCount == 1 ) { *this->out << "P5" << std::endl; } else { *this->out << "P6" << std::endl; } *this->out << this->width << " " << this->height << std::endl; *this->out << "255" << std::endl; } }; #line 222 "nws/image-ppm.nw" #line 20 "nws/image-ppm.nw" std::ostream* out; #line 26 "nws/image-ppm.nw" unsigned char* borderRow; #line 32 "nws/image-ppm.nw" unsigned int pixelCount; #line 223 "nws/image-ppm.nw" public: static const char* id; }; const char* imagePPM::id = "NKVERSION: imagePPM( 2.1.2007.03.21 )"; #endif #line 301 "nws/image-png.nw" #ifdef USE_PNG #include class imagePNG : public image { public: #line 51 "nws/image-png.nw" imagePNG( void ) : out( 0 ), borderRow( 0 ), tmpBuffer( 0 ), pixelBuffer( 0 ), pngPtr( 0 ), infoPtr( 0 ) { }; #line 62 "nws/image-png.nw" virtual ~imagePNG( void ) { if ( this->pngPtr != 0 ) { ::png_write_end( this->pngPtr, this->infoPtr ); ::png_destroy_write_struct( &this->pngPtr, &this->infoPtr ); } delete this->out; delete[] this->pixelBuffer; delete[] this->borderRow; delete[] this->tmpBuffer; }; #line 81 "nws/image-png.nw" virtual void setSize( unsigned int ww, unsigned int hh, unsigned int dd, unsigned int cc ) { if ( cc > 4 ) { cc = 4; } this->image::setSize( ww, hh, dd, cc ); unsigned int len = this->width * this->channelCount; delete[] this->borderRow; this->borderRow = new unsigned char[ len ]; delete[] this->tmpBuffer; this->tmpBuffer = new unsigned char[ len ]; delete[] this->pixelBuffer; this->pixelBuffer = new png_byte[ len ]; for ( unsigned int ii=0; ii < len; ++ii ) { this->borderRow[ ii ] = (unsigned char)0xFF; } this->pixelCount = 0; }; #line 120 "nws/image-png.nw" virtual void add( const mathvec< double >& pixel ) { unsigned int curSample = 0; if ( pixel.size() <= this->channelCount ) { unsigned char lastVal = 0; for ( unsigned int ii=0; ii < pixel.size(); ++ii ) { int val = (int)( pixel[ ii ] * 255.0 + 0.5 ); lastVal = (unsigned char)( val<0 ) ? 0 : ( val>255 ) ? 255 : val ; this->tmpBuffer[ curSample++ ] = lastVal; } for ( unsigned int ii=pixel.size(); ii < this->channelCount; ++ii ) { this->tmpBuffer[ curSample++ ] = lastVal; } } else { int total = 0; for ( unsigned int ii=0; ii < pixel.size(); ++ii ) { int val = (int)( pixel[ ii ] * 255.0 + 0.5 ); total += ( val < 0 ) ? 0 : ( val > 255 ) ? 255 : val ; } unsigned char val = (unsigned char)( total / pixel.size() ); for ( unsigned int ii=0; ii < this->channelCount; ++ii ) { this->tmpBuffer[ curSample++ ] = val; } } this->write( this->tmpBuffer, 1 ); }; #line 150 "nws/image-png.nw" virtual void addBorderPixel( void ) { this->write( this->borderRow, 1 ); }; #line 158 "nws/image-png.nw" virtual void addBorderRow( void ) { this->write( this->borderRow, this->width ); }; #line 268 "nws/image-png.nw" virtual std::istream& get( std::istream& stream ) { input in( stream ); while ( in.check() ) { char token[ input::MAX_TOKEN_LEN ]; if ( in.get( token, sizeof(token) ) == 0 ) { return stream; } std::string tok( token ); char semicolon; if ( tok == "common" ) { this->image::get( stream ); stream >> semicolon; } else { in.ignore( "PNG", tok.c_str() ); } } return stream; }; #line 307 "nws/image-png.nw" protected: #line 166 "nws/image-png.nw" void write( const unsigned char* buffer, unsigned int count ) { if ( this->pixelCount < count ) { if ( this->pngPtr != 0 ) { ::png_write_end( this->pngPtr, this->infoPtr ); ::png_destroy_write_struct( &this->pngPtr, &this->infoPtr ); } delete this->out; this->out = 0; this->pixelCount = this->width * this->height - count; } else { this->pixelCount -= count; } if ( this->out == 0 ) { std::string fname = this->getNumberedBasename() + ".png"; this->out = new std::ofstream( fname.c_str() ); this->pngPtr = ::png_create_write_struct( PNG_LIBPNG_VER_STRING, 0, 0, 0 ); if ( this->pngPtr == 0 ) { std::cerr << "Unable to create png write structure" << std::endl; return; } this->infoPtr = ::png_create_info_struct( this->pngPtr ); if ( this->infoPtr == 0 ) { std::cerr << "Unable to create png info structure" << std::endl; ::png_destroy_write_struct( &this->pngPtr, 0 ); return; } if ( ::setjmp( this->pngPtr->jmpbuf ) ) { std::cerr << "Something wrong during write png" << std::endl; ::png_destroy_write_struct( &this->pngPtr, &this->infoPtr ); } ::png_set_write_fn( this->pngPtr, this->out, imagePNG::writeData, imagePNG::flushData ); ::png_set_compression_level( this->pngPtr, Z_BEST_COMPRESSION ); static int colorTypes[] = { 0, PNG_COLOR_TYPE_GRAY, PNG_COLOR_TYPE_GRAY_ALPHA, PNG_COLOR_TYPE_RGB, PNG_COLOR_TYPE_RGB_ALPHA }; ::png_set_IHDR( this->pngPtr, this->infoPtr, this->width, this->height, 8, colorTypes[ this->channelCount ], PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT ); ::png_write_info( this->pngPtr, this->infoPtr ); this->rowSpot = 0; } count *= this->channelCount; for ( unsigned int ii=0; ii < count; ++ii ) { this->pixelBuffer[ rowSpot++ ] = buffer[ ii ]; } if ( rowSpot >= this->width * this->channelCount ) { ::png_write_row( this->pngPtr, this->pixelBuffer ); this->rowSpot = 0; } }; #line 239 "nws/image-png.nw" static void writeData( png_structp ctx, png_bytep buffer, png_size_t size ) { std::ofstream* dst = (std::ofstream*)::png_get_io_ptr( ctx ); dst->write( (const char*)buffer, size ); } static void flushData( png_structp ctx ) { std::ofstream* dst = (std::ofstream*)::png_get_io_ptr( ctx ); dst->flush(); } #line 309 "nws/image-png.nw" #line 20 "nws/image-png.nw" std::ostream* out; #line 28 "nws/image-png.nw" unsigned char* borderRow; unsigned char* tmpBuffer; png_bytep pixelBuffer; unsigned int rowSpot; #line 36 "nws/image-png.nw" png_structp pngPtr; png_infop infoPtr; #line 43 "nws/image-png.nw" unsigned int pixelCount; #line 310 "nws/image-png.nw" public: static const char* id; }; const char* imagePNG::id = "NKVERSION: imagePNG( 2.1.2007.03.21 )"; #endif #line 292 "nws/image-accum.nw" class imageAccum : public image { protected: #line 34 "nws/image-accum.nw" typedef enum { MINIMUM, MAXIMUM, AVERAGE, FIRST } MethodType; #line 295 "nws/image-accum.nw" public: #line 57 "nws/image-accum.nw" imageAccum( void ) : sub( 0 ), accumulator( 0 ) { }; #line 66 "nws/image-accum.nw" virtual ~imageAccum( void ) { delete this->sub; delete[] this->accumulator; }; #line 79 "nws/image-accum.nw" virtual void setSize( unsigned int ww, unsigned int hh, unsigned int dd, unsigned int cc ) { this->image::setSize( ww, hh, dd, cc ); this->sub->setSize( ww, hh, 1, cc ); this->pixelsRemaining = ww * hh * dd; unsigned int len = ww * hh * cc; this->accumulator = new double[ len ]; this->curIndex = 0; double initialValue = 0.0; if ( this->method == MINIMUM ) { initialValue = 1.0; } for ( unsigned int ii=0; ii < len; ++ii ) { this->accumulator[ ii ] = initialValue; } this->curPixel.resize( cc, 0.0 ); this->allOnes.resize( cc, 1.0 ); }; #line 116 "nws/image-accum.nw" virtual void add( const mathvec< double >& pixel ) { if ( pixel.size() <= this->channelCount ) { double lastVal = 0.0; for ( unsigned int ii=0; ii < pixel.size(); ++ii ) { lastVal = pixel[ ii ]; this->curPixel[ ii ] = lastVal; } for ( unsigned int ii=pixel.size(); ii < this->channelCount; ++ii ) { this->curPixel[ ii ] = lastVal; } } else { double total = 0.0; for ( unsigned int ii=0; ii < pixel.size(); ++ii ) { total += pixel[ ii ]; } double val = ( total / (double)pixel.size() ); for ( unsigned int ii=0; ii < this->channelCount; ++ii ) { this->curPixel[ ii ] = val; } } this->add(); }; #line 143 "nws/image-accum.nw" virtual void addBorderPixel( void ) { this->curPixel = this->allOnes; this->add(); }; #line 152 "nws/image-accum.nw" virtual void addBorderRow( void ) { this->curPixel = this->allOnes; for ( unsigned int ii=0; ii < this->width; ++ii ) { this->add(); } }; #line 244 "nws/image-accum.nw" virtual std::istream& get( std::istream& stream ) { input in( stream ); this->method = AVERAGE; while ( in.check() ) { char token[ input::MAX_TOKEN_LEN ]; if ( in.get( token, sizeof(token) ) == 0 ) { return stream; } std::string tok( token ); char semicolon; if ( tok == "method" ) { if ( in.get( token, sizeof(token) ) == 0 ) { return stream; } std::string meth( token ); if ( meth == "minimum" || meth == "min" ) { this->method = MINIMUM; } else if ( meth == "maximum" || meth == "max" ) { this->method = MAXIMUM; } else if ( meth == "average" || meth == "avg" ) { this->method = AVERAGE; } else if ( meth == "first" ) { this->method = FIRST; } } else if ( tok == "image" ) { this->sub = this->image::read( stream ); stream >> semicolon; } else { in.ignore( "ACCUM", tok.c_str() ); } } return stream; }; #line 297 "nws/image-accum.nw" protected: #line 162 "nws/image-accum.nw" virtual void add( void ) { double* spot = &this->accumulator[ this->curIndex ]; this->curIndex += this->channelCount; switch ( this->method ) { case MINIMUM: { double curTotal = ( this->curPixel ^ this->allOnes ); double spotTotal = 0.0; #line 219 "nws/image-accum.nw" for ( unsigned int ii=0; ii < this->channelCount; ++ii ) { spotTotal += spot[ ii ]; } #line 172 "nws/image-accum.nw" if ( curTotal < spotTotal ) { #line 224 "nws/image-accum.nw" for ( unsigned int ii=0; ii < this->channelCount; ++ii ) { spot[ ii ] = this->curPixel[ ii ]; } #line 174 "nws/image-accum.nw" } } break; case MAXIMUM: { double curTotal = ( this->curPixel ^ this->allOnes ); double spotTotal = 0.0; #line 219 "nws/image-accum.nw" for ( unsigned int ii=0; ii < this->channelCount; ++ii ) { spotTotal += spot[ ii ]; } #line 181 "nws/image-accum.nw" if ( curTotal > spotTotal ) { #line 224 "nws/image-accum.nw" for ( unsigned int ii=0; ii < this->channelCount; ++ii ) { spot[ ii ] = this->curPixel[ ii ]; } #line 183 "nws/image-accum.nw" } } break; case AVERAGE: { for ( unsigned int ii=0; ii < this->channelCount; ++ii ) { spot[ ii ] += this->curPixel[ ii ] / (double)this->depth; } } break; case FIRST: { double spotTotal = 0.0; #line 219 "nws/image-accum.nw" for ( unsigned int ii=0; ii < this->channelCount; ++ii ) { spotTotal += spot[ ii ]; } #line 194 "nws/image-accum.nw" if ( spotTotal < 0.000001 ) { #line 224 "nws/image-accum.nw" for ( unsigned int ii=0; ii < this->channelCount; ++ii ) { spot[ ii ] = this->curPixel[ ii ]; } #line 196 "nws/image-accum.nw" } } break; }; unsigned int len = this->width * this->height * this->channelCount; if ( this->curIndex >= len ) { this->curIndex = 0; } if ( --this->pixelsRemaining == 0 ) { mathvec< double > pixel( this->channelCount ); for ( unsigned int ii=0; ii < len; /*done*/ ) { for ( unsigned int kk=0; kk < this->channelCount; ++kk ) { pixel[ kk ] = this->accumulator[ ii++ ]; } this->sub->add( pixel ); } } }; #line 299 "nws/image-accum.nw" #line 43 "nws/image-accum.nw" image* sub; double* accumulator; unsigned int curIndex; unsigned int pixelsRemaining; MethodType method; mathvec< double > curPixel; mathvec< double > allOnes; #line 300 "nws/image-accum.nw" public: static const char* id; }; const char* imageAccum::id = "NKVERSION: imageAccum( 2.1.2007.03.21 )"; #line 71 "nws/image.nw" image::image( void ) : currentImage( 0 ) { } #line 86 "nws/image.nw" image::~image( void ) { } #line 108 "nws/image.nw" void image::setSize( unsigned int ww, unsigned int hh, unsigned int dd, unsigned int cc ) { this->width = ww; this->height = hh; this->depth = dd; this->channelCount = cc; } #line 123 "nws/image.nw" void image::setBasename( const std::string& bb ) { this->basename = bb; } #line 141 "nws/image.nw" std::string image::getNumberedBasename( void ) { std::ostringstream fname; fname << this->basename; if ( this->depth > 1 || this->currentImage > 1 ) { unsigned int digits = (unsigned int)( ::log10( (double)this->depth ) + 1.0000001 ); fname << std::setw( digits ) << std::setfill( '0' ); fname << this->currentImage++; } return fname.str(); } #line 176 "nws/image.nw" image* image::read( std::istream& stream ) { input in( stream ); if ( in.check() ) { char token[ input::MAX_TOKEN_LEN ]; if ( in.get( token, sizeof(token) ) == 0 ) { return 0; } std::string tok( token ); #line 171 "nws/image-ppm.nw" #ifdef USE_PPM if ( tok == "ppm" ) { image* nn = new imagePPM(); nn->get( stream ); return nn; } else #endif #line 256 "nws/image-png.nw" #ifdef USE_PNG if ( tok == "png" ) { image* nn = new imagePNG(); nn->get( stream ); return nn; } else #endif #line 234 "nws/image-accum.nw" if ( tok == "accumulator" || tok == "accum" ) { image* nn = new imageAccum(); nn->get( stream ); return nn; } else #line 191 "nws/image.nw" { in.ignore( "IMAGE FACTORY", tok.c_str() ); } } return 0; } #line 207 "nws/image.nw" std::istream& image::get( std::istream& stream ) { input in( stream ); while ( in.check() ) { char token[ input::MAX_TOKEN_LEN ]; if ( in.get( token, sizeof(token) ) == 0 ) { return stream; } std::string tok( token ); if ( tok == "basename" || tok == "filename" ) { in.get( token, sizeof(token) ); this->basename = token; } else { in.ignore( "IMAGE", tok.c_str() ); } } return stream; } ./rt2.7.2007.05.17/Code/image.h0100644000077300007650000000232210600166051013372 0ustar patpat#line 264 "nws/image.nw" #ifndef _NKLEIN_IMAGE_H_ #define _NKLEIN_IMAGE_H_ 1 #include #include #include "mathvec.h" #line 239 "nws/image.nw" class image { protected: #line 43 "nws/image.nw" unsigned int width; unsigned int height; unsigned int depth; unsigned int channelCount; #line 52 "nws/image.nw" std::string basename; #line 59 "nws/image.nw" unsigned int currentImage; #line 242 "nws/image.nw" #line 203 "nws/image.nw" virtual std::istream& get( std::istream& stream ); #line 243 "nws/image.nw" public: #line 67 "nws/image.nw" image( void ); #line 82 "nws/image.nw" virtual ~image( void ); #line 99 "nws/image.nw" virtual void setSize( unsigned int ww, unsigned int hh, unsigned int dd, unsigned int cc ); virtual void setBasename( const std::string& bb ); #line 135 "nws/image.nw" virtual std::string getNumberedBasename( void ); #line 161 "nws/image.nw" virtual void add( const mathvec< double >& pixel ) = 0; virtual void addBorderPixel( void ) = 0; virtual void addBorderRow( void ) = 0; #line 171 "nws/image.nw" static image* read( std::istream& in ); #line 245 "nws/image.nw" public: static const char* id; }; #line 273 "nws/image.nw" #endif /*_NKLEIN_IMAGE_H_*/ ./rt2.7.2007.05.17/Code/input.cc0100644000077300007650000000373710600166363013626 0ustar patpat#line 187 "nws/input.nw" #include "input.h" const char* input::id = "NKVERSION: input( 2.1.2007.03.21 )"; #line 20 "nws/input.nw" input::input( std::istream& _in ) : in( _in ), braceLevel( 0 ) { } #line 40 "nws/input.nw" bool input::check( bool _ignoreEverything ) { unsigned int startBraceLevel = this->braceLevel; for (;;) { int ch = in.peek(); if ( ch < 0 ) { break; } else if ( ch == '{' ) { this->in.get(); ++this->braceLevel; } else if ( ch == '}' ) { this->in.get(); --this->braceLevel; } else if ( ch == ';' ) { if ( this->braceLevel == 0 || ( _ignoreEverything && this->braceLevel == startBraceLevel ) ) { break; } else { this->in.get(); } } else if ( ch == ',' ) { if ( this->braceLevel == 0 ) { break; } else { this->in.get(); } } else if ( ch == '#' ) { while ( ch >= 0 && ch != '\n' ) { ch = this->in.get(); } } else if ( isspace( ch ) ) { this->in.get(); } else if ( ! _ignoreEverything ) { return true; } else { this->in.get(); } } return false; } #line 94 "nws/input.nw" void input::ignore( const char* prefix, const char* token ) { char ch; std::cerr << prefix << ": Ignoring " << token; while ( this->check( true ) ) { ch = this->in.get(); #ifndef NDEBUG std::cerr << ch; #endif }; ch = this->in.get(); #ifndef NDEBUG std::cerr << ch; #endif std::cerr << std::endl; } #line 125 "nws/input.nw" unsigned int input::get( char token[], unsigned int tokenLen ) { if ( ! this->check() ) { return 0; } unsigned int len = 0; int ch = this->in.peek(); while ( this->in.good() && !isspace( ch ) && ch != ',' && ch != ';' && ch != '>' && len < tokenLen-1 ) { ch = this->in.get(); *token++ = ch; ++len; ch = this->in.peek(); } *token = '\0'; while ( this->in.good() && !isspace( ch ) && ch != ',' && ch != ';' && ch != '>' ) { ch = this->in.get(); ch = this->in.peek(); } return len; } ./rt2.7.2007.05.17/Code/input.h0100644000077300007650000000117410600166047013460 0ustar patpat#line 167 "nws/input.nw" #ifndef _NKLEIN_INPUT_H_ #define _NKLEIN_INPUT_H_ 1 #include class input { protected: #line 7 "nws/input.nw" std::istream& in; unsigned int braceLevel; #line 174 "nws/input.nw" public: #line 16 "nws/input.nw" input( std::istream& _in ); #line 33 "nws/input.nw" bool check( bool _ignoreEverything = false ); #line 88 "nws/input.nw" void ignore( const char* prefix, const char* token ); #line 120 "nws/input.nw" enum { MAX_TOKEN_LEN = 64 }; unsigned int get( char token[], unsigned int tokenLen ); #line 176 "nws/input.nw" public: static const char* id; }; #endif /* _NKLEIN_INPUT_H_ */ ./rt2.7.2007.05.17/Code/inter.cc0100644000077300007650000001566710600166052013610 0ustar patpat#line 463 "nws/csg-inter.nw" #include #include #include #ifndef MAXFLOAT #include #endif #include "input.h" #include "inter.h" const char* csginter::id = "NKVERSION: csginter( 2.1.2007.03.21 )"; #line 44 "nws/csg-inter.nw" csginter::csginter( const scene* ss ) : object( ss ) { } #line 57 "nws/csg-inter.nw" csginter::~csginter( void ) { std::vector< object* >::iterator it; for ( it=this->objs.begin(); it != this->objs.end(); ++it ) { delete *it; } }; #line 74 "nws/csg-inter.nw" void csginter::setDimensions( unsigned int dd ) { std::vector< object* >::iterator it; for ( it=this->objs.begin(); it != this->objs.end(); ++it ) { (*it)->setDimensions( dd ); } this->object::setDimensions( dd ); } #line 99 "nws/csg-inter.nw" bool csginter::intersect( const mathvec< double >& direction, const mathvec< double >& start, intersection& hit ) const { std::vector< intersection* > hits; bool ret = this->intersect( direction, start, hits ); if ( ret ) { hit = *hits[ 0 ]; std::vector< intersection* >::iterator it; for ( it = hits.begin(); it != hits.end(); ++it ) { delete *it; } } return ret; } #line 135 "nws/csg-inter.nw" bool csginter::intersect( const mathvec< double >& direction, const mathvec< double >& start, std::vector< intersection* >& hits ) const { hits.clear(); #line 153 "nws/csg-inter.nw" mathvec< double > rd = direction; rd.antirotate( this->orientation ); rd /= this->scale; rd.normalize(); mathvec< double > rp = start - this->center; rp.antirotate( this->orientation ); rp /= this->scale; #line 143 "nws/csg-inter.nw" #line 164 "nws/csg-inter.nw" unsigned int len = this->objs.size(); std::vector< std::vector< intersection* > > hitLists( len ); std::vector< unsigned int > hitStarts( len ); bool allHit = true; bool amOutside = false; for ( unsigned int ii=0; allHit && ii < len; ++ii ) { std::vector< intersection* >& curHits( hitLists[ ii ] ); object* obj = this->objs[ ii ]; if ( obj->intersect( rd, rp, curHits ) ) { if ( ! amOutside ) { amOutside = curHits[ 0 ]->isOutside(); } } else { allHit = false; } hitStarts[ ii ] = 0; } #line 144 "nws/csg-inter.nw" if ( allHit ) { #line 188 "nws/csg-inter.nw" intersection* bestHit; unsigned int bestII = 0; unsigned int bestJJ = 0; do { bestHit = 0; if ( amOutside ) { #line 207 "nws/csg-inter.nw" bool done = false; while ( !done ) { #line 215 "nws/csg-inter.nw" bool notSet = true; double dist = MAXFLOAT; for ( unsigned int ii=0; ii < len; ++ii ) { std::vector< intersection* >& curHits( hitLists[ ii ] ); unsigned int hStart = hitStarts[ ii ]; unsigned int hLen = curHits.size(); if ( hStart < hLen ) { intersection* hit = curHits[ hStart ]; if ( hit->isOutside() ) { double curDist = hit->getDistance(); if ( notSet || curDist < dist ) { bestII = ii; bestJJ = hStart; bestHit = hit; dist = curDist - 0.000001; notSet = false; } } } } if ( bestHit == 0 ) { break; } else { hitStarts[ bestII ] = bestJJ + 1; } #line 210 "nws/csg-inter.nw" #line 244 "nws/csg-inter.nw" bool insideAll = true; for ( unsigned int ii=0; insideAll && ii < len; ++ii ) { if ( ii == bestII ) { continue; } std::vector< intersection* >& curHits( hitLists[ ii ] ); unsigned int hLen = curHits.size(); for ( unsigned int jj=hitStarts[ ii ]; jj < hLen; ++jj ) { intersection* hit = curHits[ jj ]; double curDist = hit->getDistance(); if ( curDist <= dist ) { ++hitStarts[ ii ]; } else if ( hit->isOutside() ) { insideAll = false; break; } else { break; } } if ( hitStarts[ ii ] == hLen && hLen > 0 && curHits[ hLen-1 ] != 0 && curHits[ hLen-1 ]->isInside() ) { insideAll = false; } } if ( !insideAll ) { bestHit = 0; } else { done = true; } #line 211 "nws/csg-inter.nw" } #line 195 "nws/csg-inter.nw" } else { #line 277 "nws/csg-inter.nw" bool notSet = true; double dist = MAXFLOAT; for ( unsigned int ii=0; ii < len; ++ii ) { std::vector< intersection* >& curHits( hitLists[ ii ] ); unsigned int hStart = hitStarts[ ii ]; unsigned int hLen = curHits.size(); if ( hStart < hLen ) { intersection* hit = curHits[ hStart ]; if ( hit->isInside() ) { double curDist = hit->getDistance(); if ( notSet || curDist < dist ) { bestII = ii; bestJJ = hStart; bestHit = hit; dist = curDist - 0.000001; notSet = false; } } } } #line 197 "nws/csg-inter.nw" #line 300 "nws/csg-inter.nw" if ( bestHit != 0 ) { for ( unsigned int ii=0; ii < len; ++ii ) { if ( ii == bestII ) { continue; } std::vector< intersection* >& curHits( hitLists[ ii ] ); unsigned int hLen = curHits.size(); for ( unsigned int jj=hitStarts[ ii ]; jj < hLen; ++jj ) { intersection* hit = curHits[ jj ]; double curDist = hit->getDistance(); if ( curDist <= dist ) { ++hitStarts[ ii ]; } } } } #line 198 "nws/csg-inter.nw" } if ( bestHit != 0 ) { #line 320 "nws/csg-inter.nw" std::vector< intersection* >& curHits( hitLists[ bestII ] ); curHits[ bestJJ ] = 0; hitStarts[ bestII ] = bestJJ+1; bestHit->reorient( this->scale, this->orientation, this->center ); bestHit->setDistance( ( bestHit->getPosition() - start ).magnitude() ); if ( this->gotColor ) { bestHit->recolor( this->chroma ); } hits.insert( hits.end(), bestHit ); #line 201 "nws/csg-inter.nw" } amOutside = !amOutside; } while ( bestHit != 0 ); #line 146 "nws/csg-inter.nw" } #line 332 "nws/csg-inter.nw" for ( unsigned int ii=0; ii < len; ++ii ) { std::vector< intersection* >& curHits( hitLists[ ii ] ); unsigned int hLen = curHits.size(); for ( unsigned int jj=0; jj < hLen; ++jj ) { delete curHits[ jj ]; } curHits.clear(); } #line 148 "nws/csg-inter.nw" return hits.size() > 0; } #line 350 "nws/csg-inter.nw" bool csginter::inside( const mathvec< double >& start ) const { mathvec< double > rp = start - this->center; rp.antirotate( this->orientation ); rp /= this->scale; return this->_inside( rp ); } bool csginter::_inside( const mathvec< double >& rp ) const { unsigned int len = this->objs.size(); bool in = len > 0; for ( unsigned int ii=0; in && ii < len; ++ii ) { in = this->objs[ ii ]->inside( rp ); } return in; } #line 382 "nws/csg-inter.nw" std::istream& operator >> ( std::istream& stream, csginter& cc ) { input in( stream ); while ( in.check() ) { char token[ input::MAX_TOKEN_LEN ]; if ( in.get( token, sizeof(token) ) == 0 ) { return stream; } std::string tok( token ); char semicolon; if ( tok == "object" ) { object* nn = object::read( stream, cc.myScene ); if ( nn != 0 ) { cc.objs.insert( cc.objs.end(), nn ); } else { std::cerr << "INTER failed to get an object!" << std::endl; } } else if ( tok == "base" ) { stream >> (object&)cc >> semicolon; } else { in.ignore( "INTER", tok.c_str() ); } } return stream; } ./rt2.7.2007.05.17/Code/inter.h0100644000077300007650000000232110600166052013431 0ustar patpat#line 445 "nws/csg-inter.nw" #ifndef _NKLEIN_INTER_H_ #define _NKLEIN_INTER_H_ 1 #include #include #include #include "object.h" #line 421 "nws/csg-inter.nw" class csginter : public object { protected: #line 33 "nws/csg-inter.nw" std::vector< object* > objs; #line 424 "nws/csg-inter.nw" public: #line 40 "nws/csg-inter.nw" csginter( const scene* ss ); #line 53 "nws/csg-inter.nw" virtual ~csginter( void ); #line 70 "nws/csg-inter.nw" virtual void setDimensions( unsigned int dd ); #line 91 "nws/csg-inter.nw" virtual bool intersect( const mathvec< double >& direction, const mathvec< double >& start, intersection& hit ) const; #line 123 "nws/csg-inter.nw" virtual bool intersect( const mathvec< double >& direction, const mathvec< double >& start, std::vector< intersection* >& hits ) const; #line 345 "nws/csg-inter.nw" virtual bool inside( const mathvec< double >& start ) const; virtual bool _inside( const mathvec< double >& rp ) const; #line 378 "nws/csg-inter.nw" friend std::istream& operator >> ( std::istream& in, csginter& cc ); #line 426 "nws/csg-inter.nw" public: static const char* id; }; #line 455 "nws/csg-inter.nw" #endif /*_NKLEIN_INTER_H_*/ ./rt2.7.2007.05.17/Code/intersection.cc0100644000077300007650000000264610600166057015173 0ustar patpat#line 261 "nws/intersection.nw" #include #include #include #include "input.h" #include "intersection.h" const char* intersection::id = "NKVERSION: intersection( 2.1.2007.03.21 )"; #line 47 "nws/intersection.nw" intersection::intersection( void ) : objectColor( 0 ) { } #line 142 "nws/intersection.nw" void intersection::reorient( const mathvec< double >& scale, const basevec< mathvec< double > >& orientation, const mathvec< double >& center ) { this->position *= scale; this->position.rotate( orientation ); this->position += center; this->direction *= scale; this->direction.rotate( orientation ); this->direction.normalize(); this->normal /= scale; this->normal.rotate( orientation ); this->normal.normalize(); } #line 174 "nws/intersection.nw" void intersection::recolor( const color& cc ) { this->setObjectColor( &cc ); this->setObjectPosition( this->getPosition() ); this->setObjectNormal( this->getNormal() ); this->setObjectDirection( this->getDirection() ); } #line 197 "nws/intersection.nw" void intersection::evaluate( double contribution, unsigned int height, mathvec< double >& pp ) const { if ( this->pixel.size() == 0 ) { this->objectColor->evaluate( this->objectPosition, this->objectNormal, this->objectDirection, contribution, height, *(mathvec< double >*)&this->pixel ); } pp = this->pixel; } ./rt2.7.2007.05.17/Code/intersection.h0100644000077300007650000000520610600166047015027 0ustar patpat#line 242 "nws/intersection.nw" #ifndef _NKLEIN_INTERSECTION_H_ #define _NKLEIN_INTERSECTION_H_ 1 #include #include #include #include "color.h" #line 218 "nws/intersection.nw" class intersection { protected: #line 10 "nws/intersection.nw" mathvec< double > position; mathvec< double > normal; mathvec< double > direction; bool inside; #line 21 "nws/intersection.nw" mathvec< double > objectPosition; mathvec< double > objectNormal; mathvec< double > objectDirection; #line 29 "nws/intersection.nw" const color* objectColor; double distance; #line 36 "nws/intersection.nw" mathvec< double > pixel; #line 221 "nws/intersection.nw" public: #line 43 "nws/intersection.nw" intersection( void ); #line 58 "nws/intersection.nw" inline void setPosition( const mathvec< double >& pp ) { this->position = pp; }; inline void setNormal( const mathvec< double >& nn ) { this->normal = nn; }; inline void setDirection( const mathvec< double >& dd ) { this->direction = dd; }; inline void setInside( void ) { this->inside = true; }; inline void setOutside( void ) { this->inside = false; }; inline void setDistance( double dd ) { this->distance = dd; }; #line 84 "nws/intersection.nw" inline const mathvec< double >& getPosition( void ) const { return this->position; }; inline const mathvec< double >& getNormal( void ) const { return this->normal; }; inline const mathvec< double >& getDirection( void ) const { return this->direction; }; inline bool isInside( void ) const { return this->inside; } inline bool isOutside( void ) const { return ! this->inside; } inline const color* getColor( void ) const { return this->objectColor; } inline double getDistance( void ) const { return this->distance; } #line 113 "nws/intersection.nw" inline void setObjectPosition( const mathvec< double >& pp ) { this->objectPosition = pp; }; inline void setObjectNormal( const mathvec< double >& nn ) { this->objectNormal = nn; }; inline void setObjectDirection( const mathvec< double >& dd ) { this->objectDirection = dd; }; inline void setObjectColor( const color* cc ) { this->objectColor = cc; }; #line 134 "nws/intersection.nw" void reorient( const mathvec< double >& scale, const basevec< mathvec< double > >& orientation, const mathvec< double >& center ); #line 168 "nws/intersection.nw" void recolor( const color& cc ); #line 190 "nws/intersection.nw" void evaluate( double contribution, unsigned int height, mathvec< double >& pp ) const; #line 223 "nws/intersection.nw" public: static const char* id; }; #line 252 "nws/intersection.nw" #endif /*_NKLEIN_INTERSECTION_H_*/ ./rt2.7.2007.05.17/Code/light.cc0100644000077300007650000000433410600166057013570 0ustar patpat#line 278 "nws/light.nw" #include #include #include "input.h" #include "light.h" const char* light::id = "NKVERSION: light( 2.1.2007.03.21 )"; #line 63 "nws/light.nw" light::light( const scene* ss ) : myScene( ss ), chroma( ss ), falloff( 0.0 ), outerCosine(-2.0), cosineRange(-1.0) { } #line 81 "nws/light.nw" void light::setDimensions( unsigned int dd ) { this->position.resize( dd, 0.0 ); this->chroma.setDimensions( dd ); this->direction.resize( dd, 0.0 ); double dmag = this->direction.magnitude(); if ( dmag >= 0.000001 ) { this->direction /= dmag; } } #line 134 "nws/light.nw" void light::evaluate( const mathvec< double >& pos, const mathvec< double >& norm, const mathvec< double >& dir, double contribution, unsigned int height, mathvec< double >& pixel ) const { this->chroma.evaluate( pos, norm, dir, contribution, height, pixel ); if ( this->outerCosine > -1.5 ) { double cc = - ( dir ^ this->direction ); double diff = cc - this->outerCosine; if ( diff < 0.000001 ) { pixel *= 0.0; } else if ( diff < this->cosineRange ) { pixel *= diff / this->cosineRange; } } } #line 173 "nws/light.nw" std::istream& operator >> ( std::istream& stream, light& ll ) { input in( stream ); while ( in.check() ) { char token[ input::MAX_TOKEN_LEN ]; if ( in.get( token, sizeof(token) ) == 0 ) { return stream; } std::string tok( token ); char semicolon; if ( tok == "position" || tok == "center" ) { stream >> ll.position >> semicolon; } else if ( tok == "direction" ) { stream >> ll.direction >> semicolon; } else if ( tok == "falloff" ) { stream >> ll.falloff >> semicolon; } else if ( tok == "angles" ) { #line 211 "nws/light.nw" double inner; char comma; double outer; stream >> inner >> comma >> outer >> semicolon; inner = ::cos( inner * M_PI / 180.0 ); outer = ::cos( outer * M_PI / 180.0 ); if ( inner < outer ) { double tmp = inner; inner = outer; outer = tmp; } ll.outerCosine = outer; ll.cosineRange = inner - outer; #line 196 "nws/light.nw" } else if ( tok == "color" ) { stream >> ll.chroma >> semicolon; } else { in.ignore( "LIGHT", tok.c_str() ); } } return stream; } ./rt2.7.2007.05.17/Code/light.h0100644000077300007650000000230110600166047013421 0ustar patpat#line 259 "nws/light.nw" #ifndef _NKLEIN_LIGHT_H_ #define _NKLEIN_LIGHT_H_ 1 #include #include #include #include "color.h" #line 235 "nws/light.nw" class light { protected: #line 37 "nws/light.nw" const scene* myScene; #line 44 "nws/light.nw" mathvec< double > position; color chroma; double falloff; mathvec< double > direction; double outerCosine; double cosineRange; #line 238 "nws/light.nw" public: #line 59 "nws/light.nw" light( const scene* ss ); #line 77 "nws/light.nw" void setDimensions( unsigned int dd ); #line 101 "nws/light.nw" inline const mathvec< double >& getPosition( void ) const { return this->position; }; #line 110 "nws/light.nw" inline double getFallOff( void ) const { return this->falloff; }; #line 121 "nws/light.nw" void evaluate( const mathvec< double >& position, const mathvec< double >& normal, const mathvec< double >& direction, double contribution, unsigned int height, mathvec< double >& pixel ) const; #line 162 "nws/light.nw" friend std::istream& operator >> ( std::istream& in, light& cc ); #line 240 "nws/light.nw" public: static const char* id; }; #line 269 "nws/light.nw" #endif /*_NKLEIN_LIGHT_H_*/ ./rt2.7.2007.05.17/Code/main.cc0100644000077300007650000000254110600166046013401 0ustar patpat#line 115 "nws/main.nw" #include #include #include #include "scene.h" #include "nkthread.h" #line 10 "nws/main.nw" int main( int argc, const char* const argv[] ) { int ii; #line 34 "nws/main.nw" for ( ii=1; ii < argc; ++ii ) { std::string arg( argv[ ii ] ); if ( arg[0] != '-' ) { break; } else if ( arg == "-t" ) { #line 53 "nws/main.nw" std::istringstream str( argv[++ii] ); unsigned int count = 0; str >> count; if ( count > 100 ) { count = 100; } thread::instance()->setWorkerCount( count ); #line 41 "nws/main.nw" } else { std::cerr << "Unknown argument: " << arg << std::endl; #line 65 "nws/main.nw" std::cerr << "USAGE: " << argv[0]; std::cerr << " [-t threadCount]"; std::cerr << " file1 file2 ..." << std::endl; #line 44 "nws/main.nw" return __LINE__; } } #line 17 "nws/main.nw" if ( ii < argc ) { #line 76 "nws/main.nw" while ( ii < argc ) { std::ifstream stream( argv[ii++] ); if ( stream.good() ) { scene ss; stream >> ss; ss.render(); } else { std::cerr << "Couldn't open: " << argv[ii-1] << std::endl; } } #line 19 "nws/main.nw" } else { #line 92 "nws/main.nw" if ( std::cin.good() ) { scene ss; std::cin >> ss; ss.render(); } else { std::cerr << "Couldn't read standard input" << std::endl; } #line 21 "nws/main.nw" } return 0; } ./rt2.7.2007.05.17/Code/mathvec.cc0100644000077300007650000000106410623061160014077 0ustar patpat#line 894 "nws/mathvec.nw" #include "mathvec.h" template< typename TT > const char* mathvec::id = "NKVERSION: mathvec<>( 2.1.2007.05.17 )"; #line 62 "nws/mathvec.nw" template class mathvec< double >; template class mathvec< unsigned int >; template class basevec< mathvec< double > >; template class basevec< mathvec< unsigned int > >; #line 71 "nws/mathvec.nw" template bool orthogonalize( basevec< mathvec< double > >& matrix, unsigned int dims ); #line 79 "nws/mathvec.nw" template void transpose( basevec< mathvec< double > >& matrix ); ./rt2.7.2007.05.17/Code/mathvec.h0100644000077300007650000003136310623061332013747 0ustar patpat#line 869 "nws/mathvec.nw" #ifndef _NKLEIN_MATHVEC_H_ #define _NKLEIN_MATHVEC_H_ 1 #include #include #include #include "basevec.h" #line 842 "nws/mathvec.nw" template < typename TT > class mathvec; #line 878 "nws/mathvec.nw" #line 246 "nws/mathvec.nw" template < typename TT > const mathvec< TT > operator * ( const TT& alpha, const mathvec< TT >& vv ); #line 880 "nws/mathvec.nw" #line 845 "nws/mathvec.nw" template < typename TT > class mathvec : public basevec< TT > { public: #line 90 "nws/mathvec.nw" mathvec(); #line 101 "nws/mathvec.nw" mathvec( unsigned int len ); #line 114 "nws/mathvec.nw" mathvec( const TT value, unsigned int len ); #line 126 "nws/mathvec.nw" mathvec( const TT array[], unsigned int len ); #line 139 "nws/mathvec.nw" mathvec( const mathvec< TT >& other ); #line 153 "nws/mathvec.nw" mathvec( const char* str ); #line 172 "nws/mathvec.nw" bool operator != ( const mathvec< TT >& other ) const; bool operator == ( const mathvec< TT >& other ) const; #line 220 "nws/mathvec.nw" const mathvec< TT >& operator *= ( const TT& alpha ); #line 251 "nws/mathvec.nw" friend const mathvec< TT > operator * ( const TT& alpha, const mathvec< TT >& vv ); const mathvec< TT > operator * ( const TT& alpha ) const; #line 282 "nws/mathvec.nw" const mathvec< TT >& operator /= ( const TT& other ); #line 311 "nws/mathvec.nw" const mathvec< TT > operator / ( const TT& alpha ); #line 330 "nws/mathvec.nw" const mathvec< TT >& operator += ( const mathvec< TT >& other ); #line 352 "nws/mathvec.nw" const mathvec< TT > operator + ( const mathvec< TT >& other ) const; #line 371 "nws/mathvec.nw" const mathvec< TT >& operator -= ( const mathvec< TT >& other ); #line 394 "nws/mathvec.nw" const mathvec< TT > operator - ( const mathvec< TT >& other ) const; #line 413 "nws/mathvec.nw" const mathvec< TT >& operator *= ( const mathvec< TT >& other ); #line 436 "nws/mathvec.nw" const mathvec< TT > operator * ( const mathvec< TT >& other ) const; #line 455 "nws/mathvec.nw" const mathvec< TT >& operator /= ( const mathvec< TT >& other ); #line 484 "nws/mathvec.nw" const mathvec< TT > operator / ( const mathvec< TT >& other ) const; #line 504 "nws/mathvec.nw" const TT operator ^ ( const mathvec< TT >& other ) const; #line 532 "nws/mathvec.nw" TT magnitude( void ) const; mathvec< TT >& normalize( void ); #line 687 "nws/mathvec.nw" mathvec< TT >& rotate( const basevec< mathvec< TT > >& matrix ); #line 713 "nws/mathvec.nw" mathvec< TT >& antirotate( const basevec< mathvec< TT > >& matrix ); #line 743 "nws/mathvec.nw" mathvec< TT > solve( const basevec< mathvec< TT > >& _AA ); #line 849 "nws/mathvec.nw" public: static const char* id; }; #line 881 "nws/mathvec.nw" #line 93 "nws/mathvec.nw" template < typename TT > mathvec< TT >::mathvec() : basevec< TT >() { } #line 104 "nws/mathvec.nw" template < typename TT > mathvec< TT >::mathvec( unsigned int len ) : basevec< TT >() { TT zero( 0U ); this->resize( len, zero ); } #line 117 "nws/mathvec.nw" template < typename TT > mathvec< TT >::mathvec( const TT value, unsigned int len ) : basevec< TT >( value, len ) { } #line 129 "nws/mathvec.nw" template < typename TT > mathvec< TT >::mathvec( const TT array[], unsigned int len ) : basevec< TT >( array, len ) { } #line 142 "nws/mathvec.nw" template < typename TT > mathvec< TT >::mathvec( const mathvec< TT >& other ) : basevec< TT >( other ) { } #line 156 "nws/mathvec.nw" template < typename TT > mathvec< TT >::mathvec( const char* str ) : basevec< TT >( str ) { } #line 181 "nws/mathvec.nw" template < typename TT > bool mathvec< TT >::operator != ( const mathvec< TT >& other ) const { if ( this->size() != other.size() ) { return true; } unsigned int len( this->size() ); for ( unsigned int ii=0; ii < len; ++ii ) { if ( (*this)[ ii ] != other[ ii ] ) { return true; } } return false; } #line 203 "nws/mathvec.nw" template < typename TT > bool mathvec< TT >::operator == ( const mathvec< TT >& other ) const { return ! ( (*this) != other ); } #line 226 "nws/mathvec.nw" template < typename TT > const mathvec< TT >& mathvec< TT >::operator *= ( const TT& alpha ) { unsigned int len( this->size() ); for ( unsigned int ii=0; ii < len; ++ii ) { (*this)[ ii ] *= alpha; } return *this; } #line 257 "nws/mathvec.nw" template < typename TT > const mathvec< TT > operator * ( const TT& alpha, const mathvec< TT >& vv ) { mathvec< TT > result( vv ); result *= alpha; return result; } #line 268 "nws/mathvec.nw" template < typename TT > const mathvec< TT > mathvec< TT >::operator * ( const TT& alpha ) const { mathvec< TT > result( *this ); result *= alpha; return result; } #line 288 "nws/mathvec.nw" template < typename TT > const mathvec< TT >& mathvec< TT >::operator /= ( const TT& alpha ) { unsigned int len( this->size() ); TT zero( 0U ); if ( alpha != zero ) { for ( unsigned int ii=0; ii < len; ++ii ) { (*this)[ ii ] /= alpha; } } else { for ( unsigned int ii=0; ii < len; ++ii ) { (*this)[ ii ] = zero; } } return *this; } #line 314 "nws/mathvec.nw" template < typename TT > const mathvec< TT > mathvec< TT >::operator / ( const TT& alpha ) { mathvec< TT > result( *this ); result /= alpha; return result; } #line 337 "nws/mathvec.nw" template < typename TT > const mathvec< TT >& mathvec< TT >::operator += ( const mathvec< TT >& other ) { unsigned int len( this->size() ); for ( unsigned int ii=0; ii < len; ++ii ) { (*this)[ ii ] += other[ ii ]; } return *this; } #line 355 "nws/mathvec.nw" template < typename TT > const mathvec< TT > mathvec< TT >::operator + ( const mathvec< TT >& other ) const { mathvec< TT > result( *this ); result += other; return result; } #line 379 "nws/mathvec.nw" template < typename TT > const mathvec< TT >& mathvec< TT >::operator -= ( const mathvec< TT >& other ) { unsigned int len( this->size() ); for ( unsigned int ii=0; ii < len; ++ii ) { (*this)[ ii ] -= other[ ii ]; } return *this; } #line 397 "nws/mathvec.nw" template < typename TT > const mathvec< TT > mathvec< TT >::operator - ( const mathvec< TT >& other ) const { mathvec< TT > result( *this ); result -= other; return result; } #line 421 "nws/mathvec.nw" template < typename TT > const mathvec< TT >& mathvec< TT >::operator *= ( const mathvec< TT >& other ) { unsigned int len( this->size() ); for ( unsigned int ii=0; ii < len; ++ii ) { (*this)[ ii ] *= other[ ii ]; } return *this; } #line 439 "nws/mathvec.nw" template < typename TT > const mathvec< TT > mathvec< TT >::operator * ( const mathvec< TT >& other ) const { mathvec< TT > result( *this ); result *= other; return result; } #line 464 "nws/mathvec.nw" template < typename TT > const mathvec< TT >& mathvec< TT >::operator /= ( const mathvec< TT >& other ) { TT zero( 0U ); unsigned int len( this->size() ); for ( unsigned int ii=0; ii < len; ++ii ) { if ( other[ ii ] != zero ) { (*this)[ ii ] /= other[ ii ]; } else { (*this)[ ii ] = zero; } } return *this; } #line 487 "nws/mathvec.nw" template < typename TT > const mathvec< TT > mathvec< TT >::operator / ( const mathvec< TT >& other ) const { mathvec< TT > result( *this ); result /= other; return result; } #line 510 "nws/mathvec.nw" template < typename TT > const TT mathvec< TT >::operator ^ ( const mathvec< TT >& other ) const { unsigned int len( this->size() ); TT result( 0U ); for ( unsigned int ii=0; ii < len; ++ii ) { result += (*this)[ ii ] * other[ ii ]; } return result; } #line 539 "nws/mathvec.nw" template < typename TT > TT mathvec< TT >::magnitude( void ) const { return (TT)std::sqrt( (double)( (*this) ^ (*this) ) ); } #line 551 "nws/mathvec.nw" template < typename TT > mathvec< TT >& mathvec< TT >::normalize( void ) { *this /= this->magnitude(); return *this; } #line 690 "nws/mathvec.nw" template < typename TT > mathvec< TT >& mathvec< TT >::rotate( const basevec< mathvec< TT > >& matrix ) { mathvec< TT >& res( *this ); mathvec< TT > orig( *this ); for ( unsigned int ii=0; ii < this->size(); ++ii ) { TT value = 0; for ( unsigned int jj=0; jj < this->size(); ++jj ) { value += orig[ jj ] * matrix[ jj ][ ii ]; } res[ ii ] = value; } return res; } #line 716 "nws/mathvec.nw" template < typename TT > mathvec< TT >& mathvec< TT >::antirotate( const basevec< mathvec< TT > >& matrix ) { mathvec< TT >& res( *this ); mathvec< TT > orig( *this ); for ( unsigned int ii=0; ii < this->size(); ++ii ) { const mathvec< TT >& col( matrix[ ii ] ); TT value = 0; for ( unsigned int jj=0; jj < this->size(); ++jj ) { value += orig[ jj ] * col[ jj ]; } res[ ii ] = value; } return res; } #line 746 "nws/mathvec.nw" template < typename TT > mathvec< TT > mathvec< TT >::solve( const basevec< mathvec< TT > >& _AA ) { unsigned int nn = this->size(); mathvec< TT > xx( nn ); #line 767 "nws/mathvec.nw" mathvec< unsigned int > perm( nn ); for ( unsigned int ii=0; ii < nn; ++ii ) { perm[ ii ] = ii; } basevec< mathvec< TT > > AA( _AA ); mathvec< TT > bb( *this ); static const TT zero = (TT)0; static const TT minusOne = (TT)-1; #line 755 "nws/mathvec.nw" for ( unsigned int jj=0; jj < nn-1; ++jj ) { #line 780 "nws/mathvec.nw" TT pivot = AA[ perm[ jj ] ][ jj ]; if ( pivot < zero ) { pivot *= minusOne; } unsigned int piv = jj; unsigned int ptmp = perm[ jj ]; for ( unsigned int ii=jj+1; ii < nn; ++ii ) { TT cur = AA[ perm[ ii ] ][ jj ]; if ( cur < zero ) { cur *= minusOne; } if ( cur > pivot ) { pivot = cur; piv = ii; } } perm[ jj ] = perm[ piv ]; perm[ piv ] = ptmp; if ( (double)pivot < 0.000001 ) { return xx; } #line 757 "nws/mathvec.nw" #line 806 "nws/mathvec.nw" unsigned int pj = perm[ jj ]; const mathvec< TT >& baseRow( AA[ pj ] ); for ( unsigned int ii=jj+1; ii < nn; ++ii ) { unsigned int pi = perm[ ii ]; mathvec< TT >& curRow( AA[ pi ] ); TT mm = curRow[ jj ] / baseRow[ jj ]; curRow[ jj ] = zero; bb[ pi ] -= mm * bb[ pj ]; for ( unsigned int kk=jj+1; kk < nn; ++kk ) { curRow[ kk ] -= mm * baseRow[ kk ]; } } #line 758 "nws/mathvec.nw" } #line 821 "nws/mathvec.nw" for ( unsigned int kk=0; kk < nn; ++kk ) { unsigned int ii = ( nn - 1 ) - kk; unsigned int pi = perm[ ii ]; const mathvec< TT >& curRow( AA[ pi ] ); xx[ ii ] = bb[ pi ]; for ( unsigned int jj=ii+1; jj < nn; ++jj ) { xx[ ii ] -= curRow[ jj ] * xx[ jj ]; } xx[ ii ] /= curRow[ ii ]; } #line 762 "nws/mathvec.nw" return xx; } #line 883 "nws/mathvec.nw" #line 593 "nws/mathvec.nw" template < typename TT > bool orthogonalize( basevec< mathvec< TT > >& matrix, unsigned int dims ); #line 662 "nws/mathvec.nw" template < typename TT > void transpose( basevec< mathvec< TT > >& matrix ); #line 884 "nws/mathvec.nw" #line 600 "nws/mathvec.nw" template < typename TT > bool orthogonalize( basevec< mathvec< TT > >& matrix, unsigned int dims ) { unsigned int originalSize = matrix.size(); #line 614 "nws/mathvec.nw" for ( unsigned int ii=0; ii < originalSize; ++ii ) { matrix[ ii ].resize( dims, 0.0 ); #line 625 "nws/mathvec.nw" mathvec< double > vv( matrix[ ii ] ); for ( unsigned int jj=0; jj < ii; ++jj ) { matrix[ ii ] -= ( vv ^ matrix[ jj ] ) * matrix[ jj ]; } #line 617 "nws/mathvec.nw" #line 632 "nws/mathvec.nw" double mag = matrix[ ii ].magnitude(); bool zero = ( mag < 0.000001 ); if ( ! zero ) { matrix[ ii ] /= mag; } #line 618 "nws/mathvec.nw" if ( zero ) { return false; } } #line 608 "nws/mathvec.nw" #line 640 "nws/mathvec.nw" matrix.resize( dims ); unsigned int currentGuessColumn = 0; for ( unsigned int ii=originalSize; ii < dims; ++ii ) { matrix[ ii ].resize( dims, 0.0 ); #line 654 "nws/mathvec.nw" matrix[ ii ] *= 0.0; matrix[ ii ][ currentGuessColumn++ ] = 1.0; #line 645 "nws/mathvec.nw" #line 625 "nws/mathvec.nw" mathvec< double > vv( matrix[ ii ] ); for ( unsigned int jj=0; jj < ii; ++jj ) { matrix[ ii ] -= ( vv ^ matrix[ jj ] ) * matrix[ jj ]; } #line 646 "nws/mathvec.nw" #line 632 "nws/mathvec.nw" double mag = matrix[ ii ].magnitude(); bool zero = ( mag < 0.000001 ); if ( ! zero ) { matrix[ ii ] /= mag; } #line 647 "nws/mathvec.nw" if ( zero ) { --ii; } } #line 609 "nws/mathvec.nw" return true; } #line 668 "nws/mathvec.nw" template < typename TT > void transpose( basevec< mathvec< TT > >& matrix ) { unsigned int originalSize = matrix.size(); for ( unsigned int ii=0; ii < originalSize-1; ++ii ) { for ( unsigned int jj=ii+1; jj < originalSize; ++jj ) { TT tt = matrix[ ii ][ jj ]; matrix[ ii ][ jj ] = matrix[ jj ][ ii ]; matrix[ jj ][ ii ] = tt; } } } #line 886 "nws/mathvec.nw" #endif /*_NKLEIN_MATHVEC_H_*/ ./rt2.7.2007.05.17/Code/nkthread.cc0100644000077300007650000001216410605630517014263 0ustar patpat#line 280 "nws/nkthread.nw" #include #include #include "nkthread.h" #line 130 "nws/thread-worker.nw" extern "C" void* ThreadWorkerLoopStarter( void* arg ); #line 25 "nws/thread-work.nw" thread::work::work( void ) : done( true ) { #ifdef USE_PTHREADS ::pthread_mutex_init( &this->mutex, 0 ); ::pthread_cond_init( &this->condition, 0 ); #endif } #line 42 "nws/thread-work.nw" thread::work::~work( void ) { #ifdef USE_PTHREADS ::pthread_cond_destroy( &this->condition ); ::pthread_mutex_destroy( &this->mutex ); #endif } #line 64 "nws/thread-work.nw" void thread::work::start( void ) { this->done = false; thread* mgr = thread::instance(); mgr->start( this ); } #line 79 "nws/thread-work.nw" void thread::work::wait( void ) { #ifdef USE_PTHREADS ::pthread_mutex_lock( &this->mutex ); while ( !this->done ) { ::pthread_cond_wait( &this->condition, &this->mutex ); } ::pthread_mutex_unlock( &this->mutex ); #endif } #line 99 "nws/thread-work.nw" void thread::work::finish( void ) { #ifdef USE_PTHREADS ::pthread_mutex_lock( &this->mutex ); #endif this->done = true; #ifdef USE_PTHREADS ::pthread_cond_broadcast( &this->condition ); ::pthread_mutex_unlock( &this->mutex ); #endif } #line 31 "nws/thread-worker.nw" thread::worker::worker( void ) : todo( 0 ), done( false ) { #ifdef USE_PTHREADS ::pthread_mutex_init( &this->mutex, 0 ); ::pthread_cond_init( &this->condition, 0 ); ::pthread_create( &this->myThread, 0, ThreadWorkerLoopStarter, this ); #endif } #line 50 "nws/thread-worker.nw" thread::worker::~worker( void ) { this->lock(); this->done = true; this->wakeup(); this->unlock(); #ifdef USE_PTHREADS ::pthread_join( this->myThread, 0 ); ::pthread_cond_destroy( &this->condition ); ::pthread_mutex_destroy( &this->mutex ); #endif } #line 82 "nws/thread-worker.nw" void thread::worker::wakeup( void ) { #ifdef USE_PTHREADS ::pthread_cond_signal( &this->condition ); #endif } #line 97 "nws/thread-worker.nw" void thread::worker::lock( void ) { #ifdef USE_PTHREADS ::pthread_mutex_lock( &this->mutex ); #endif } #line 107 "nws/thread-worker.nw" void thread::worker::wait( void ) { #ifdef USE_PTHREADS ::pthread_cond_wait( &this->condition, &this->mutex ); #endif } #line 116 "nws/thread-worker.nw" void thread::worker::unlock( void ) { #ifdef USE_PTHREADS ::pthread_mutex_unlock( &this->mutex ); #endif } #line 134 "nws/thread-worker.nw" void* ThreadWorkerLoopStarter( void* arg ) { thread::worker* me = (thread::worker*)arg; return me->loop(); } #line 147 "nws/thread-worker.nw" void* thread::worker::loop( void ) { #ifdef USE_PTHREADS thread* mgr = thread::instance(); for (;;) { this->todo = 0; mgr->makeWorkerAvailable( this ); this->lock(); do { if ( this->done ) { this->unlock(); return 0; } this->wait(); } while ( this->todo == 0 ); this->unlock(); this->todo->perform(); this->todo->finish(); } #endif return 0; } #line 288 "nws/nkthread.nw" const char* thread::id = "NKVERSION: thread( 2.1.2007.04.07 )"; const char* thread::work::id = "NKVERSION: thread::work( 2.1.2007.04.07 )"; const char* thread::worker::id = "NKVERSION: thread::worker( 2.1.2007.04.07 )"; #line 40 "nws/nkthread.nw" thread* thread::instance( void ) { static thread mgr; return &mgr; }; #line 55 "nws/nkthread.nw" thread::thread( void ) { #ifdef USE_PTHREADS ::pthread_mutex_init( &this->mutex, 0 ); #endif } #line 71 "nws/nkthread.nw" thread::~thread( void ) { this->setWorkerCount( 0 ); #ifdef USE_PTHREADS ::pthread_mutex_destroy( &this->mutex ); #endif } #line 92 "nws/nkthread.nw" void thread::setWorkerCount( unsigned int nn ) { std::vector< worker* > tmp; this->lock(); unsigned int original = this->workers.size(); if ( original < nn ) { for ( unsigned int ii=original; ii < nn; ++ii ) { new worker(); } } else if ( original > nn ) { tmp.resize( original - nn ); for ( unsigned int ii=nn; ii < original; ++ii ) { tmp[ ii - nn ] = this->workers.front(); this->workers.pop_front(); } } #ifdef USE_PTHREADS ::pthread_setconcurrency( nn+1 ); #endif this->unlock(); for ( unsigned int ii=0; ii < tmp.size(); ++ii ) { delete tmp[ ii ]; } } #line 132 "nws/nkthread.nw" void thread::makeWorkerAvailable( worker* ww ) { this->lock(); this->workers.push_back( ww ); this->unlock(); } #line 152 "nws/nkthread.nw" void thread::start( thread::work* ww ) { worker* wr = 0; this->lock(); if ( this->workers.size() > 0 ) { wr = this->workers.front(); this->workers.pop_front(); } this->unlock(); if ( wr == 0 ) { ww->perform(); ww->finish(); } else { wr->lock(); wr->setWork( ww ); wr->wakeup(); wr->unlock(); } } #line 186 "nws/nkthread.nw" void thread::lock( void ) { #ifdef USE_PTHREADS ::pthread_mutex_lock( &this->mutex ); #endif } #line 196 "nws/nkthread.nw" void thread::unlock( void ) { #ifdef USE_PTHREADS ::pthread_mutex_unlock( &this->mutex ); #endif } #line 215 "nws/nkthread.nw" void thread::wait( void* cond ) { #ifdef USE_PTHREADS ::pthread_cond_wait( (pthread_cond_t*)cond, &this->mutex ); #endif } ./rt2.7.2007.05.17/Code/nkthread.h0100644000077300007650000000455710605627525014141 0ustar patpat#line 260 "nws/nkthread.nw" #ifndef _NKLEIN_THREAD_H_ #define _NKLEIN_THREAD_H_ 1 #include #ifdef USE_PTHREADS # include #endif #line 230 "nws/nkthread.nw" class thread { public: #line 119 "nws/thread-work.nw" class work { protected: #line 10 "nws/thread-work.nw" #ifdef USE_PTHREADS pthread_mutex_t mutex; pthread_cond_t condition; #endif bool done; #line 122 "nws/thread-work.nw" public: #line 21 "nws/thread-work.nw" work( void ); #line 38 "nws/thread-work.nw" virtual ~work( void ); #line 56 "nws/thread-work.nw" virtual void perform( void ) = 0; #line 61 "nws/thread-work.nw" void start( void ); #line 76 "nws/thread-work.nw" void wait( void ); #line 96 "nws/thread-work.nw" void finish( void ); #line 124 "nws/thread-work.nw" public: static const char* id; }; #line 181 "nws/thread-worker.nw" class worker { protected: #line 9 "nws/thread-worker.nw" #ifdef USE_PTHREADS pthread_mutex_t mutex; pthread_cond_t condition; pthread_t myThread; #endif #line 18 "nws/thread-worker.nw" thread::work* todo; bool done; #line 184 "nws/thread-worker.nw" public: #line 27 "nws/thread-worker.nw" worker( void ); #line 46 "nws/thread-worker.nw" virtual ~worker( void ); #line 69 "nws/thread-worker.nw" void setWork( thread::work* ww ) { this->todo = ww; }; #line 78 "nws/thread-worker.nw" void wakeup( void ); #line 92 "nws/thread-worker.nw" void lock( void ); void wait( void ); void unlock( void ); #line 143 "nws/thread-worker.nw" void* loop( void ); #line 186 "nws/thread-worker.nw" public: static const char* id; }; #line 234 "nws/nkthread.nw" protected: #line 28 "nws/nkthread.nw" #ifdef USE_PTHREADS pthread_mutex_t mutex; #endif std::deque< worker* > workers; #line 236 "nws/nkthread.nw" public: #line 37 "nws/nkthread.nw" static thread* instance( void ); #line 51 "nws/nkthread.nw" thread( void ); #line 67 "nws/nkthread.nw" ~thread( void ); #line 88 "nws/nkthread.nw" void setWorkerCount( unsigned int nn ); #line 148 "nws/nkthread.nw" void start( thread::work* ww ); #line 181 "nws/nkthread.nw" void lock( void ); void unlock( void ); #line 211 "nws/nkthread.nw" void wait( void* cond ); #line 238 "nws/nkthread.nw" friend class thread::worker; protected: #line 128 "nws/nkthread.nw" void makeWorkerAvailable( worker* ww ); #line 241 "nws/nkthread.nw" public: static const char* id; }; #line 271 "nws/nkthread.nw" #endif /*_NKLEIN_THREAD_H_*/ ./rt2.7.2007.05.17/Code/object.cc0100644000077300007650000001224510623062056013726 0ustar patpat#line 398 "nws/object.nw" #include #include #include #ifndef MAXFLOAT #include #endif #include "input.h" #include "object.h" #line 18 "nws/halfspace.nw" #include "halfspace.h" #line 25 "nws/cylinder.nw" #include "cylinder.h" #line 25 "nws/quadratic.nw" #include "quadratic.h" #line 36 "nws/convex.nw" #include "inter.h" #include "convex.h" #line 34 "nws/coxeter.nw" #include "inter.h" #include "convex.h" #include "coxeter.h" #line 20 "nws/complement.nw" #include "complement.h" #line 20 "nws/csg-union.nw" #include "union.h" #line 20 "nws/csg-set.nw" #include "set.h" #line 20 "nws/csg-inter.nw" #include "inter.h" #line 21 "nws/extrusion.nw" #include "extrusion.h" #line 409 "nws/object.nw" const char* object::id = "NKVERSION: object( 2.1.2007.05.17 )"; #line 56 "nws/object.nw" color object::fakeColor( "channels [3]< 0 , 0 , 0 >;\n" "reflectiveness 0.0;\n" "specularness 0.0;\n" "transparency 1.0;\n" ); #line 72 "nws/object.nw" object::object( const scene* ss ) : myScene( ss ), defaultScale( 1.0 ), chroma( ss ), gotColor(false) { }; #line 87 "nws/object.nw" object::~object( void ) { }; #line 101 "nws/object.nw" void object::setDimensions( unsigned int dd ) { this->scale.resize( dd, this->defaultScale ); ::orthogonalize( this->orientation, dd ); this->center.resize( dd, 0.0 ); this->chroma.setDimensions( dd ); } #line 203 "nws/object.nw" void object::evaluate( const mathvec< double >& position, const mathvec< double >& normal, const mathvec< double >& direction, double contribution, unsigned int height, mathvec< double >& pixel ) const { this->chroma.evaluate( position, normal, direction, contribution, height, pixel ); } #line 234 "nws/object.nw" void object::forgeHit( const mathvec< double >& direction, const mathvec< double >& start, intersection& hit ) const { mathvec< double > pos = direction; pos *= MAXFLOAT; pos += start; mathvec< double > norm = direction; norm *= -1.0; hit.setPosition( pos ); hit.setNormal( norm ); hit.setDirection( direction ); hit.setObjectPosition( pos ); hit.setObjectNormal( norm ); hit.setObjectDirection( direction ); hit.setInside(); hit.setDistance( MAXFLOAT ); hit.setObjectColor( &object::fakeColor ); } #line 270 "nws/object.nw" std::istream& operator >> ( std::istream& stream, object& ll ) { input in( stream ); ll.gotColor = false; while ( in.check() ) { char token[ input::MAX_TOKEN_LEN ]; if ( in.get( token, sizeof(token) ) == 0 ) { return stream; } std::string tok( token ); char semicolon; if ( tok == "scale" ) { stream >> ll.scale >> semicolon; } else if ( tok == "orientation" ) { stream >> ll.orientation >> semicolon; } else if ( tok == "antiorientation" ) { stream >> ll.orientation >> semicolon; ::orthogonalize( ll.orientation, ll.orientation[0].size() ); ::transpose( ll.orientation ); } else if ( tok == "center" ) { stream >> ll.center >> semicolon; } else if ( tok == "color" ) { stream >> ll.chroma >> semicolon; ll.gotColor = true; } else { in.ignore( "OBJECT", tok.c_str() ); } } return stream; } #line 320 "nws/object.nw" object* object::read( std::istream& stream, const scene* ss ) { input in( stream ); while ( in.check() ) { char token[ input::MAX_TOKEN_LEN ]; if ( in.get( token, sizeof(token) ) == 0 ) { return 0; } std::string objectType( token ); char semicolon; #line 21 "nws/halfspace.nw" if ( objectType == "halfspace" ) { halfspace* obj = new halfspace( ss ); stream >> *obj >> semicolon; return obj; } else #line 28 "nws/cylinder.nw" if ( objectType == "cylinder" ) { cylinder* obj = new cylinder( ss ); stream >> *obj >> semicolon; return obj; } else #line 28 "nws/quadratic.nw" if ( objectType == "quadratic" ) { quadratic* obj = new quadratic( ss ); stream >> *obj >> semicolon; return obj; } else #line 40 "nws/convex.nw" if ( objectType == "convex" ) { convex* obj = new convex( ss ); stream >> *obj >> semicolon; return obj; } else #line 39 "nws/coxeter.nw" if ( objectType == "coxeter" ) { coxeter* obj = new coxeter( ss ); stream >> *obj >> semicolon; return obj; } else #line 23 "nws/complement.nw" if ( objectType == "complement" ) { complement* obj = new complement( ss ); stream >> *obj >> semicolon; return obj; } else #line 23 "nws/csg-union.nw" if ( objectType == "union" ) { csgunion* obj = new csgunion( ss ); stream >> *obj >> semicolon; return obj; } else #line 23 "nws/csg-set.nw" if ( objectType == "set" ) { csgset* obj = new csgset( ss ); stream >> *obj >> semicolon; return obj; } else #line 23 "nws/csg-inter.nw" if ( objectType == "intersection" || objectType == "inter" ) { csginter* obj = new csginter( ss ); stream >> *obj >> semicolon; return obj; } else #line 24 "nws/extrusion.nw" if ( objectType == "extrusion" ) { extrusion* obj = new extrusion( ss ); stream >> *obj >> semicolon; return obj; } else #line 335 "nws/object.nw" { in.ignore( "OBJECT READER", objectType.c_str() ); } } return 0; } ./rt2.7.2007.05.17/Code/object.h0100644000077300007650000000513510602474461013574 0ustar patpat#line 376 "nws/object.nw" #ifndef _NKLEIN_OBJECT_H_ #define _NKLEIN_OBJECT_H_ 1 #include #include #include #include "intersection.h" #line 350 "nws/object.nw" class object { protected: #line 33 "nws/object.nw" const scene* myScene; #line 40 "nws/object.nw" double defaultScale; mathvec< double > scale; basevec< mathvec< double > > orientation; mathvec< double > center; color chroma; bool gotColor; #line 52 "nws/object.nw" static color fakeColor; #line 353 "nws/object.nw" protected: #line 226 "nws/object.nw" void forgeHit( const mathvec< double >& direction, const mathvec< double >& start, intersection& hit ) const; #line 355 "nws/object.nw" public: #line 68 "nws/object.nw" object( const scene* ss ); #line 83 "nws/object.nw" virtual ~object( void ); #line 97 "nws/object.nw" virtual void setDimensions( unsigned int dd ); #line 115 "nws/object.nw" inline const mathvec< double >& getScale( void ) const { return this->scale; }; inline const basevec< mathvec< double > >& getOrientation( void ) const { return this->orientation; }; inline const mathvec< double >& getCenter( void ) const { return this->center; }; inline const color& getColor( void ) const { return this->chroma; }; inline color* getColorPtr( void ) { return &this->chroma; }; #line 136 "nws/object.nw" inline void setScale( const mathvec< double >& ss ) { this->scale = ss; }; inline void setOrientation( const basevec< mathvec< double > >& oo ) { this->orientation = oo; }; inline void setCenter( const mathvec< double >& cc ) { this->center = cc; }; #line 154 "nws/object.nw" virtual bool intersect( const mathvec< double >& direction, const mathvec< double >& start, intersection& hit ) const = 0; #line 167 "nws/object.nw" virtual bool intersect( const mathvec< double >& direction, const mathvec< double >& start, std::vector< intersection* >& hits ) const = 0; #line 182 "nws/object.nw" virtual bool inside( const mathvec< double >& start ) const = 0; virtual bool _inside( const mathvec< double >& start ) const = 0; #line 192 "nws/object.nw" void evaluate( const mathvec< double >& position, const mathvec< double >& normal, const mathvec< double >& direction, double contribution, unsigned int height, mathvec< double >& pixel ) const; #line 266 "nws/object.nw" friend std::istream& operator >> ( std::istream& in, object& cc ); #line 313 "nws/object.nw" static object* read( std::istream& in, const scene* ss ); #line 357 "nws/object.nw" public: static const char* id; }; #line 386 "nws/object.nw" #endif /*_NKLEIN_OBJECT_H_*/ ./rt2.7.2007.05.17/Code/portal.cc0100644000077300007650000000460210600166052013753 0ustar patpat#line 306 "nws/portal.nw" #include #include #include "input.h" #include "universe.h" #include "scene.h" #include "portal.h" const char* portal::id = "NKVERSION: portal( 2.1.2007.03.21 )"; #line 67 "nws/portal.nw" portal::portal( const scene* ss ) : myScene( ss ), univ( 0 ) { } #line 80 "nws/portal.nw" portal::~portal( void ) { } #line 114 "nws/portal.nw" void portal::setDimensions( unsigned int dd ) { this->scale.resize( dd, 1.0 ); ::orthogonalize( this->orientation, dd ); this->center.resize( dd, 0.0 ); } #line 140 "nws/portal.nw" bool portal::evaluate( const mathvec< double >& position, const mathvec< double >& direction, double contribution, unsigned int height, unsigned int channelCount ) { #line 161 "nws/portal.nw" if ( this->univ == 0 && this->universeName != "" ) { this->univ = this->myScene->getUniverse( this->universeName ); } if ( this->univ == 0 ) { return false; } #line 147 "nws/portal.nw" #line 173 "nws/portal.nw" mathvec< double > rd = direction; rd.rotate( this->orientation ); rd /= this->scale; rd.normalize(); mathvec< double > rp = position; rp.rotate( this->orientation ); rp /= this->scale; rp += this->center; #line 148 "nws/portal.nw" #line 190 "nws/portal.nw" unsigned int dims = this->univ->getDimensions(); if ( rp.size() != dims ) { rp.resize( dims, 0.0 ); rd.resize( dims, 0.0 ); double magdir = rd.magnitude(); if ( magdir >= 0.000001 ) { rd /= magdir; } else { this->pixel *= 0.0; return false; } } #line 150 "nws/portal.nw" this->pixel.resize( channelCount, 0.0 ); return this->univ->evaluate( rp, rd, contribution, height-1, this->pixel ); } #line 216 "nws/portal.nw" std::istream& operator >> ( std::istream& stream, portal& pp ) { input in( stream ); while ( in.check() ) { char token[ input::MAX_TOKEN_LEN ]; if ( in.get( token, sizeof(token) ) == 0 ) { return stream; } std::string tok( token ); char semicolon; if ( tok == "scale" ) { stream >> pp.scale >> semicolon; } else if ( tok == "orientation" ) { stream >> pp.orientation >> semicolon; } else if ( tok == "center" ) { stream >> pp.center >> semicolon; } else if ( tok == "universe" ) { if ( in.get( token, sizeof(token) ) == 0 ) { return stream; } pp.universeName = token; } else { in.ignore( "PORTAL", tok.c_str() ); } } return stream; } ./rt2.7.2007.05.17/Code/portal.h0100644000077300007650000000231610600166052013615 0ustar patpat#line 282 "nws/portal.nw" #ifndef _NKLEIN_PORTAL_H_ #define _NKLEIN_PORTAL_H_ 1 #include #include #include "mathvec.h" class scene; class universe; #line 257 "nws/portal.nw" class portal { protected: #line 34 "nws/portal.nw" const scene* myScene; #line 41 "nws/portal.nw" const universe* univ; std::string universeName; #line 47 "nws/portal.nw" mathvec< double > pixel; #line 53 "nws/portal.nw" mathvec< double > scale; basevec< mathvec< double > > orientation; mathvec< double > center; #line 260 "nws/portal.nw" public: #line 63 "nws/portal.nw" portal( const scene* ss ); #line 76 "nws/portal.nw" ~portal( void ); #line 91 "nws/portal.nw" const mathvec< double >& getPixel( void ) const { return this->pixel; }; #line 107 "nws/portal.nw" void setDimensions( unsigned int dd ); #line 128 "nws/portal.nw" bool evaluate( const mathvec< double >& position, const mathvec< double >& direction, double contribution, unsigned int height, unsigned int channelCount ); #line 209 "nws/portal.nw" friend std::istream& operator >> ( std::istream& in, portal& pp ); #line 262 "nws/portal.nw" public: static const char* id; }; #line 294 "nws/portal.nw" #endif /*_NKLEIN_PORTAL_H_*/ ./rt2.7.2007.05.17/Code/quadratic.cc0100644000077300007650000002170010600166056014431 0ustar patpat#line 414 "nws/quadratic.nw" #include #include #include #include "input.h" #include "quadratic.h" const char* quadratic::id = "NKVERSION: quadratic( 2.1.2007.03.21 )"; #line 49 "nws/quadratic.nw" quadratic::quadratic( const scene* ss ) : object( ss ) { } #line 62 "nws/quadratic.nw" quadratic::~quadratic( void ) { } #line 75 "nws/quadratic.nw" void quadratic::setDimensions( unsigned int dd ) { this->squares.resize( dd ); for ( unsigned int ii=0; ii < dd; ++ii ) { this->squares[ ii ].resize( dd, 0.0 ); } this->linears.resize( dd ); this->object::setDimensions( dd ); } #line 102 "nws/quadratic.nw" bool quadratic::intersect( const mathvec< double >& direction, const mathvec< double >& start, intersection& hit ) const { #line 135 "nws/quadratic.nw" mathvec< double > rd = direction; rd.antirotate( this->orientation ); rd /= this->scale; rd.normalize(); mathvec< double > rp = start - this->center; rp.antirotate( this->orientation ); rp /= this->scale; double t1 = -1.0; double t2 = -1.0; double AA = 0.0; double BB = 0.0; double CC = this->scalar; unsigned int len = this->squares.size(); for ( unsigned int ii=0; ii < len; ++ii ) { for ( unsigned int jj=0; jj < len; ++jj ) { double ss = this->squares[ ii ][ jj ]; AA += ss * rd[ ii ] * rd[ jj ]; BB += ss * rd[ ii ] * rp[ jj ]; BB += ss * rp[ ii ] * rd[ jj ]; CC += ss * rp[ ii ] * rp[ jj ]; } double ll = this->linears[ ii ]; BB += ll * rd[ ii ]; CC += ll * rp[ ii ]; } bool hitQuadratic = false; if ( ::fabs( AA ) > 0.000001 ) { double DD = BB * BB - 4.0 * AA * CC; if ( DD > 0.000001 ) { double dd = ::sqrt( DD ); t1 = ( - BB - dd ) / ( 2.0 * AA ); t2 = ( - BB + dd ) / ( 2.0 * AA ); if ( t2 < t1 ) { double tmp = t1; t1 = t2; t2 = tmp; } hitQuadratic = t2 >= 0.000001; } } else if ( ::fabs( BB ) > 0.000001 ) { t1 = -CC / BB; hitQuadratic = t1 >= 0.000001; } #line 110 "nws/quadratic.nw" if ( ! hitQuadratic ) { if ( this->_inside( rp ) ) { this->forgeHit( direction, start, hit ); return true; } return false; } if ( t1 >= 0.000001 ) { mathvec< double > nn; double tt = t1; #line 189 "nws/quadratic.nw" mathvec< double > spot = rp + ( rd * tt ); nn.resize( len ); for ( unsigned int ii=0; ii < len; ++ii ) { double vv = this->linears[ ii ]; for ( unsigned int jj=0; jj < len; ++jj ) { double ff = ( this->squares[ ii ][ jj ] + this->squares[ jj ][ ii ] ); vv += ff * spot[ jj ]; } nn[ ii ] = vv; } if ( this->_inside( rp ) ) { nn *= -1.0; hit.setInside(); } else { hit.setOutside(); } nn.normalize(); hit.setObjectPosition( spot ); hit.setObjectNormal( nn ); hit.setObjectDirection( rd ); hit.setPosition( spot ); hit.setNormal( nn ); hit.setDirection( rd ); hit.reorient( this->scale, this->orientation, this->center ); hit.setDistance( ( hit.getPosition() - start ).magnitude() ); hit.setObjectColor( &this->chroma ); #line 122 "nws/quadratic.nw" } else if ( t2 >= 0.000001 ) { mathvec< double > nn; double tt = t2; #line 189 "nws/quadratic.nw" mathvec< double > spot = rp + ( rd * tt ); nn.resize( len ); for ( unsigned int ii=0; ii < len; ++ii ) { double vv = this->linears[ ii ]; for ( unsigned int jj=0; jj < len; ++jj ) { double ff = ( this->squares[ ii ][ jj ] + this->squares[ jj ][ ii ] ); vv += ff * spot[ jj ]; } nn[ ii ] = vv; } if ( this->_inside( rp ) ) { nn *= -1.0; hit.setInside(); } else { hit.setOutside(); } nn.normalize(); hit.setObjectPosition( spot ); hit.setObjectNormal( nn ); hit.setObjectDirection( rd ); hit.setPosition( spot ); hit.setNormal( nn ); hit.setDirection( rd ); hit.reorient( this->scale, this->orientation, this->center ); hit.setDistance( ( hit.getPosition() - start ).magnitude() ); hit.setObjectColor( &this->chroma ); #line 126 "nws/quadratic.nw" } else { return false; } return true; } #line 238 "nws/quadratic.nw" bool quadratic::intersect( const mathvec< double >& direction, const mathvec< double >& start, std::vector< intersection* >& hits ) const { #line 135 "nws/quadratic.nw" mathvec< double > rd = direction; rd.antirotate( this->orientation ); rd /= this->scale; rd.normalize(); mathvec< double > rp = start - this->center; rp.antirotate( this->orientation ); rp /= this->scale; double t1 = -1.0; double t2 = -1.0; double AA = 0.0; double BB = 0.0; double CC = this->scalar; unsigned int len = this->squares.size(); for ( unsigned int ii=0; ii < len; ++ii ) { for ( unsigned int jj=0; jj < len; ++jj ) { double ss = this->squares[ ii ][ jj ]; AA += ss * rd[ ii ] * rd[ jj ]; BB += ss * rd[ ii ] * rp[ jj ]; BB += ss * rp[ ii ] * rd[ jj ]; CC += ss * rp[ ii ] * rp[ jj ]; } double ll = this->linears[ ii ]; BB += ll * rd[ ii ]; CC += ll * rp[ ii ]; } bool hitQuadratic = false; if ( ::fabs( AA ) > 0.000001 ) { double DD = BB * BB - 4.0 * AA * CC; if ( DD > 0.000001 ) { double dd = ::sqrt( DD ); t1 = ( - BB - dd ) / ( 2.0 * AA ); t2 = ( - BB + dd ) / ( 2.0 * AA ); if ( t2 < t1 ) { double tmp = t1; t1 = t2; t2 = tmp; } hitQuadratic = t2 >= 0.000001; } } else if ( ::fabs( BB ) > 0.000001 ) { t1 = -CC / BB; hitQuadratic = t1 >= 0.000001; } #line 246 "nws/quadratic.nw" hits.clear(); if ( !hitQuadratic ) { if ( this->_inside( rp ) ) { intersection* hh = new intersection(); hits.insert( hits.end(), hh ); this->forgeHit( direction, start, *hh ); } } else { if ( t1 >= 0.000001 ) { intersection* h1 = new intersection(); hits.insert( hits.end(), h1 ); intersection& hit( *h1 ); mathvec< double > nn; double tt = t1; #line 189 "nws/quadratic.nw" mathvec< double > spot = rp + ( rd * tt ); nn.resize( len ); for ( unsigned int ii=0; ii < len; ++ii ) { double vv = this->linears[ ii ]; for ( unsigned int jj=0; jj < len; ++jj ) { double ff = ( this->squares[ ii ][ jj ] + this->squares[ jj ][ ii ] ); vv += ff * spot[ jj ]; } nn[ ii ] = vv; } if ( this->_inside( rp ) ) { nn *= -1.0; hit.setInside(); } else { hit.setOutside(); } nn.normalize(); hit.setObjectPosition( spot ); hit.setObjectNormal( nn ); hit.setObjectDirection( rd ); hit.setPosition( spot ); hit.setNormal( nn ); hit.setDirection( rd ); hit.reorient( this->scale, this->orientation, this->center ); hit.setDistance( ( hit.getPosition() - start ).magnitude() ); hit.setObjectColor( &this->chroma ); #line 263 "nws/quadratic.nw" hit.setOutside(); } if ( t2 >= 0.000001 ) { intersection* h2 = new intersection(); hits.insert( hits.end(), h2 ); intersection& hit( *h2 ); mathvec< double > nn; double tt = t2; #line 189 "nws/quadratic.nw" mathvec< double > spot = rp + ( rd * tt ); nn.resize( len ); for ( unsigned int ii=0; ii < len; ++ii ) { double vv = this->linears[ ii ]; for ( unsigned int jj=0; jj < len; ++jj ) { double ff = ( this->squares[ ii ][ jj ] + this->squares[ jj ][ ii ] ); vv += ff * spot[ jj ]; } nn[ ii ] = vv; } if ( this->_inside( rp ) ) { nn *= -1.0; hit.setInside(); } else { hit.setOutside(); } nn.normalize(); hit.setObjectPosition( spot ); hit.setObjectNormal( nn ); hit.setObjectDirection( rd ); hit.setPosition( spot ); hit.setNormal( nn ); hit.setDirection( rd ); hit.reorient( this->scale, this->orientation, this->center ); hit.setDistance( ( hit.getPosition() - start ).magnitude() ); hit.setObjectColor( &this->chroma ); #line 274 "nws/quadratic.nw" hit.setInside(); } } return hits.size() > 0; } #line 290 "nws/quadratic.nw" bool quadratic::inside( const mathvec< double >& start ) const { mathvec< double > rp = start - this->center; rp.antirotate( this->orientation ); rp /= this->scale; return this->_inside( rp ); } bool quadratic::_inside( const mathvec< double >& rp ) const { unsigned int len = this->center.size(); double sum = this->scalar; for ( unsigned int ii=0; ii < len; ++ii ) { double vv = this->linears[ ii ]; for ( unsigned int jj=0; jj < len; ++jj ) { vv += this->squares[ ii ][ jj ] * rp[ jj ]; } sum += vv * rp[ ii ]; } return sum <= 0.0; } #line 326 "nws/quadratic.nw" std::istream& operator >> ( std::istream& stream, quadratic& qq ) { input in( stream ); qq.scalar = 0.0; while ( in.check() ) { char token[ input::MAX_TOKEN_LEN ]; if ( in.get( token, sizeof(token) ) == 0 ) { return stream; } std::string tok( token ); char semicolon; if ( tok == "squares" ) { stream >> qq.squares >> semicolon; } else if ( tok == "linears" ) { stream >> qq.linears >> semicolon; } else if ( tok == "scalar" ) { stream >> qq.scalar >> semicolon; } else if ( tok == "base" ) { stream >> (object&)qq >> semicolon; } else { in.ignore( "QUADRATIC", tok.c_str() ); } } qq.linears.resize( qq.squares.size(), 0.0 ); for ( unsigned int ii=0; ii < qq.squares.size(); ++ii ) { qq.squares[ ii ].resize( qq.squares.size(), 0.0 ); } return stream; } ./rt2.7.2007.05.17/Code/quadratic.h0100644000077300007650000000242410600166057014276 0ustar patpat#line 395 "nws/quadratic.nw" #ifndef _NKLEIN_QUADRATIC_H_ #define _NKLEIN_QUADRATIC_H_ 1 #include #include #include #include "object.h" #line 371 "nws/quadratic.nw" class quadratic : public object { protected: #line 36 "nws/quadratic.nw" basevec< mathvec< double > > squares; mathvec< double > linears; double scalar; #line 374 "nws/quadratic.nw" public: #line 45 "nws/quadratic.nw" quadratic( const scene* ss ); #line 58 "nws/quadratic.nw" virtual ~quadratic( void ); #line 71 "nws/quadratic.nw" virtual void setDimensions( unsigned int dd ); #line 94 "nws/quadratic.nw" virtual bool intersect( const mathvec< double >& direction, const mathvec< double >& start, intersection& hit ) const; #line 230 "nws/quadratic.nw" virtual bool intersect( const mathvec< double >& direction, const mathvec< double >& start, std::vector< intersection* >& hits ) const; #line 285 "nws/quadratic.nw" virtual bool inside( const mathvec< double >& start ) const; virtual bool _inside( const mathvec< double >& rp ) const; #line 322 "nws/quadratic.nw" friend std::istream& operator >> ( std::istream& in, quadratic& cc ); #line 376 "nws/quadratic.nw" public: static const char* id; }; #line 405 "nws/quadratic.nw" #endif /*_NKLEIN_QUADRATIC_H_*/ ./rt2.7.2007.05.17/Code/scene.cc0100644000077300007650000000275110600166051013551 0ustar patpat#line 235 "nws/scene.nw" #include "input.h" #include "scene.h" const char* scene::id = "NKVERSION: scene( 2.1.2007.03.21 )"; #line 52 "nws/scene.nw" scene::scene( void ) { } #line 69 "nws/scene.nw" scene::~scene( void ) { UniverseMap::iterator uu; for ( uu=this->universes.begin(); uu != this->universes.end(); ++uu ) { delete uu->second; } ViewList::iterator vv; for ( vv=this->views.begin(); vv != this->views.end(); ++vv ) { delete *vv; } } #line 107 "nws/scene.nw" void scene::render( void ) const { ViewList::const_iterator vv; for ( vv=this->views.begin(); vv != this->views.end(); ++vv ) { (*vv)->render(); } } #line 134 "nws/scene.nw" std::istream& operator >> ( std::istream& stream, scene& ss ) { input in( stream ); while ( in.check() ) { char token[ input::MAX_TOKEN_LEN ]; if ( in.get( token, sizeof(token) ) == 0 ) { return stream; } std::string tok( token ); char semicolon; if ( tok == "view" ) { #line 166 "nws/scene.nw" view* vv = new view( (const scene*)&ss ); stream >> *vv >> semicolon; ss.views.insert( ss.views.end(), vv ); #line 151 "nws/scene.nw" } else if ( tok == "universe" ) { #line 176 "nws/scene.nw" if ( in.get( token, sizeof(token) ) == 0 ) { return stream; } std::string name( token ); universe* uu = new universe( (const scene*)&ss ); stream >> *uu >> semicolon; ss.universes[ name ] = uu; #line 153 "nws/scene.nw" } else { in.ignore( "SCENE", tok.c_str() ); } } return stream; } ./rt2.7.2007.05.17/Code/scene.h0100644000077300007650000000200310600166051013401 0ustar patpat#line 215 "nws/scene.nw" #ifndef _NKLEIN_SCENE_H_ #define _NKLEIN_SCENE_H_ 1 #include #include #include #include "view.h" #include "universe.h" #line 191 "nws/scene.nw" class scene { protected: #line 38 "nws/scene.nw" typedef std::vector< const view* > ViewList; ViewList views; typedef std::map< std::string, const universe* > UniverseMap; UniverseMap universes; #line 194 "nws/scene.nw" public: #line 48 "nws/scene.nw" scene( void ); #line 61 "nws/scene.nw" ~scene( void ); #line 87 "nws/scene.nw" const universe* getUniverse( const std::string& name ) const { UniverseMap::const_iterator uu = this->universes.find( name ); if ( uu != this->universes.end() ) { return uu->second; } else { return 0; } }; #line 101 "nws/scene.nw" void render( void ) const; #line 128 "nws/scene.nw" friend std::istream& operator >> ( std::istream& in, scene& ss ); #line 196 "nws/scene.nw" public: static const char* id; }; #line 226 "nws/scene.nw" #endif /*_NKLEIN_SCENE_H_*/ ./rt2.7.2007.05.17/Code/set.cc0100644000077300007650000001056210600166053013250 0ustar patpat#line 343 "nws/csg-set.nw" #include #include #include #ifndef MAXFLOAT #include #endif #include "input.h" #include "set.h" const char* csgset::id = "NKVERSION: csgset( 2.1.2007.03.21 )"; #line 44 "nws/csg-set.nw" csgset::csgset( const scene* ss ) : object( ss ) { } #line 57 "nws/csg-set.nw" csgset::~csgset( void ) { std::vector< object* >::iterator it; for ( it=this->objs.begin(); it != this->objs.end(); ++it ) { delete *it; } }; #line 74 "nws/csg-set.nw" void csgset::setDimensions( unsigned int dd ) { std::vector< object* >::iterator it; for ( it=this->objs.begin(); it != this->objs.end(); ++it ) { (*it)->setDimensions( dd ); } this->object::setDimensions( dd ); } #line 99 "nws/csg-set.nw" bool csgset::intersect( const mathvec< double >& direction, const mathvec< double >& start, intersection& hit ) const { std::vector< intersection* > hits; bool ret = this->intersect( direction, start, hits ); if ( ret ) { hit = *hits[ 0 ]; std::vector< intersection* >::iterator it; for ( it = hits.begin(); it != hits.end(); ++it ) { delete *it; } } return ret; } #line 131 "nws/csg-set.nw" bool csgset::intersect( const mathvec< double >& direction, const mathvec< double >& start, std::vector< intersection* >& hits ) const { #line 147 "nws/csg-set.nw" mathvec< double > rd = direction; rd.antirotate( this->orientation ); rd /= this->scale; rd.normalize(); mathvec< double > rp = start - this->center; rp.antirotate( this->orientation ); rp /= this->scale; #line 138 "nws/csg-set.nw" #line 158 "nws/csg-set.nw" unsigned int len = this->objs.size(); std::vector< std::vector< intersection* > > hitLists( len ); std::vector< unsigned int > hitStarts( len ); bool gotHit = false; for ( unsigned int ii=0; ii < len; ++ii ) { std::vector< intersection* >& curHits( hitLists[ ii ] ); object* obj = this->objs[ ii ]; if ( obj->intersect( rd, rp, curHits ) ) { gotHit = true; } hitStarts[ ii ] = 0; } #line 139 "nws/csg-set.nw" if ( gotHit ) { #line 177 "nws/csg-set.nw" unsigned int bestII = 0; unsigned int bestJJ = 0; intersection* bestHit; do { bestHit = 0; #line 190 "nws/csg-set.nw" bool notSet = true; double dist = MAXFLOAT; for ( unsigned int ii=0; ii < len; ++ii ) { std::vector< intersection* >& curHits( hitLists[ ii ] ); unsigned int hStart = hitStarts[ ii ]; unsigned int hLen = curHits.size(); if ( hStart < hLen ) { intersection* hit = curHits[ hStart ]; double curDist = hit->getDistance(); if ( notSet || curDist < dist ) { bestII = ii; bestJJ = hStart; bestHit = hit; dist = curDist; notSet = false; } } } #line 183 "nws/csg-set.nw" if ( bestHit != 0 ) { #line 211 "nws/csg-set.nw" std::vector< intersection* >& curHits( hitLists[ bestII ] ); curHits[ bestJJ ] = 0; hitStarts[ bestII ] = bestJJ+1; bestHit->reorient( this->scale, this->orientation, this->center ); bestHit->setDistance( ( bestHit->getPosition() - start ).magnitude() ); if ( this->gotColor ) { bestHit->recolor( this->chroma ); } hits.insert( hits.end(), bestHit ); #line 185 "nws/csg-set.nw" } } while ( bestHit != 0 ); #line 141 "nws/csg-set.nw" } return gotHit; } #line 230 "nws/csg-set.nw" bool csgset::inside( const mathvec< double >& start ) const { mathvec< double > rp = start - this->center; rp.antirotate( this->orientation ); rp /= this->scale; return this->_inside( rp ); } bool csgset::_inside( const mathvec< double >& rp ) const { unsigned int len = this->objs.size(); bool outside = true; for ( unsigned int ii=0; outside && ii < len; ++ii ) { outside = ! this->objs[ ii ]->inside( rp ); } return ! outside; } #line 262 "nws/csg-set.nw" std::istream& operator >> ( std::istream& stream, csgset& cc ) { input in( stream ); while ( in.check() ) { char token[ input::MAX_TOKEN_LEN ]; if ( in.get( token, sizeof(token) ) == 0 ) { return stream; } std::string tok( token ); char semicolon; if ( tok == "object" ) { object* nn = object::read( stream, cc.myScene ); if ( nn != 0 ) { cc.objs.insert( cc.objs.end(), nn ); } else { std::cerr << "SET failed to get an object!" << std::endl; } } else if ( tok == "base" ) { stream >> (object&)cc >> semicolon; } else { in.ignore( "SET", tok.c_str() ); } } return stream; } ./rt2.7.2007.05.17/Code/set.h0100644000077300007650000000225110600166053013106 0ustar patpat#line 325 "nws/csg-set.nw" #ifndef _NKLEIN_SET_H_ #define _NKLEIN_SET_H_ 1 #include #include #include #include "object.h" #line 301 "nws/csg-set.nw" class csgset : public object { protected: #line 33 "nws/csg-set.nw" std::vector< object* > objs; #line 304 "nws/csg-set.nw" public: #line 40 "nws/csg-set.nw" csgset( const scene* ss ); #line 53 "nws/csg-set.nw" virtual ~csgset( void ); #line 70 "nws/csg-set.nw" virtual void setDimensions( unsigned int dd ); #line 91 "nws/csg-set.nw" virtual bool intersect( const mathvec< double >& direction, const mathvec< double >& start, intersection& hit ) const; #line 123 "nws/csg-set.nw" virtual bool intersect( const mathvec< double >& direction, const mathvec< double >& start, std::vector< intersection* >& hits ) const; #line 225 "nws/csg-set.nw" virtual bool inside( const mathvec< double >& start ) const; virtual bool _inside( const mathvec< double >& rp ) const; #line 258 "nws/csg-set.nw" friend std::istream& operator >> ( std::istream& in, csgset& cc ); #line 306 "nws/csg-set.nw" public: static const char* id; }; #line 335 "nws/csg-set.nw" #endif /*_NKLEIN_SET_H_*/ ./rt2.7.2007.05.17/Code/union.cc0100644000077300007650000001610110600166053013600 0ustar patpat#line 463 "nws/csg-union.nw" #include #include #include #ifndef MAXFLOAT #include #endif #include "input.h" #include "union.h" const char* csgunion::id = "NKVERSION: csgunion( 2.1.2007.03.21 )"; #line 44 "nws/csg-union.nw" csgunion::csgunion( const scene* ss ) : object( ss ) { } #line 57 "nws/csg-union.nw" csgunion::~csgunion( void ) { std::vector< object* >::iterator it; for ( it=this->objs.begin(); it != this->objs.end(); ++it ) { delete *it; } }; #line 74 "nws/csg-union.nw" void csgunion::setDimensions( unsigned int dd ) { std::vector< object* >::iterator it; for ( it=this->objs.begin(); it != this->objs.end(); ++it ) { (*it)->setDimensions( dd ); } this->object::setDimensions( dd ); } #line 99 "nws/csg-union.nw" bool csgunion::intersect( const mathvec< double >& direction, const mathvec< double >& start, intersection& hit ) const { std::vector< intersection* > hits; bool ret = this->intersect( direction, start, hits ); if ( ret ) { hit = *hits[ 0 ]; std::vector< intersection* >::iterator it; for ( it = hits.begin(); it != hits.end(); ++it ) { delete *it; } } return ret; } #line 131 "nws/csg-union.nw" bool csgunion::intersect( const mathvec< double >& direction, const mathvec< double >& start, std::vector< intersection* >& hits ) const { hits.clear(); #line 154 "nws/csg-union.nw" mathvec< double > rd = direction; rd.antirotate( this->orientation ); rd /= this->scale; rd.normalize(); mathvec< double > rp = start - this->center; rp.antirotate( this->orientation ); rp /= this->scale; #line 139 "nws/csg-union.nw" #line 165 "nws/csg-union.nw" unsigned int len = this->objs.size(); std::vector< std::vector< intersection* > > hitLists( len ); std::vector< unsigned int > hitStarts( len ); bool gotHit = false; bool amInside = false; for ( unsigned int ii=0; ii < len; ++ii ) { std::vector< intersection* >& curHits( hitLists[ ii ] ); object* obj = this->objs[ ii ]; if ( obj->intersect( rd, rp, curHits ) ) { gotHit = true; if ( ! amInside ) { amInside = curHits[ 0 ]->isInside(); } } hitStarts[ ii ] = 0; } #line 140 "nws/csg-union.nw" if ( gotHit ) { #line 188 "nws/csg-union.nw" intersection* bestHit; unsigned int bestII = 0; unsigned int bestJJ = 0; do { bestHit = 0; if ( amInside ) { #line 207 "nws/csg-union.nw" bool done = false; while ( !done ) { #line 215 "nws/csg-union.nw" bool notSet = true; double dist = MAXFLOAT; for ( unsigned int ii=0; ii < len; ++ii ) { std::vector< intersection* >& curHits( hitLists[ ii ] ); unsigned int hStart = hitStarts[ ii ]; unsigned int hLen = curHits.size(); if ( hStart < hLen ) { intersection* hit = curHits[ hStart ]; if ( hit->isInside() ) { double curDist = hit->getDistance(); if ( notSet || curDist < dist ) { bestII = ii; bestJJ = hStart; bestHit = hit; dist = curDist - 0.000001; notSet = false; } } } } if ( bestHit == 0 ) { break; } else { hitStarts[ bestII ] = bestJJ + 1; } #line 210 "nws/csg-union.nw" #line 244 "nws/csg-union.nw" bool outsideAll = true; for ( unsigned int ii=0; outsideAll && ii < len; ++ii ) { if ( ii == bestII ) { continue; } std::vector< intersection* >& curHits( hitLists[ ii ] ); unsigned int hLen = curHits.size(); for ( unsigned int jj=hitStarts[ ii ]; jj < hLen; ++jj ) { intersection* hit = curHits[ jj ]; double curDist = hit->getDistance(); if ( curDist < dist ) { ++hitStarts[ ii ]; } else if ( hit->isInside() ) { outsideAll = false; break; } else { break; } } if ( hitStarts[ ii ] == hLen && hLen > 0 && curHits[ hLen-1 ] != 0 && curHits[ hLen-1 ]->isOutside() ) { outsideAll = false; } } if ( !outsideAll ) { bestHit = 0; } else { done = true; } #line 211 "nws/csg-union.nw" } #line 195 "nws/csg-union.nw" } else { #line 277 "nws/csg-union.nw" bool notSet = true; double dist = MAXFLOAT; for ( unsigned int ii=0; ii < len; ++ii ) { std::vector< intersection* >& curHits( hitLists[ ii ] ); unsigned int hStart = hitStarts[ ii ]; unsigned int hLen = curHits.size(); if ( hStart < hLen ) { intersection* hit = curHits[ hStart ]; if ( hit->isOutside() ) { double curDist = hit->getDistance(); if ( notSet || curDist < dist ) { bestII = ii; bestJJ = hStart; bestHit = hit; dist = curDist - 0.000001; notSet = false; } } } } #line 197 "nws/csg-union.nw" #line 300 "nws/csg-union.nw" if ( bestHit != 0 ) { for ( unsigned int ii=0; ii < len; ++ii ) { if ( ii == bestII ) { continue; } std::vector< intersection* >& curHits( hitLists[ ii ] ); unsigned int hLen = curHits.size(); for ( unsigned int jj=hitStarts[ ii ]; jj < hLen; ++jj ) { intersection* hit = curHits[ jj ]; double curDist = hit->getDistance(); if ( curDist < dist ) { ++hitStarts[ ii ]; } } } } #line 198 "nws/csg-union.nw" } if ( bestHit != 0 ) { #line 320 "nws/csg-union.nw" std::vector< intersection* >& curHits( hitLists[ bestII ] ); curHits[ bestJJ ] = 0; hitStarts[ bestII ] = bestJJ+1; bestHit->reorient( this->scale, this->orientation, this->center ); bestHit->setDistance( ( bestHit->getPosition() - start ).magnitude() ); if ( this->gotColor ) { bestHit->recolor( this->chroma ); } hits.insert( hits.end(), bestHit ); #line 201 "nws/csg-union.nw" } amInside = !amInside; } while ( bestHit != 0 ); #line 142 "nws/csg-union.nw" #line 332 "nws/csg-union.nw" for ( unsigned int ii=0; ii < len; ++ii ) { std::vector< intersection* >& curHits( hitLists[ ii ] ); unsigned int hLen = curHits.size(); for ( unsigned int jj=0; jj < hLen; ++jj ) { delete curHits[ jj ]; } curHits.clear(); } #line 143 "nws/csg-union.nw" if ( hits.size() == 0 ) { intersection* nn = new intersection(); this->forgeHit( direction, start, *nn ); hits.insert( hits.end(), nn ); } } return gotHit; } #line 350 "nws/csg-union.nw" bool csgunion::inside( const mathvec< double >& start ) const { mathvec< double > rp = start - this->center; rp.antirotate( this->orientation ); rp /= this->scale; return this->_inside( rp ); } bool csgunion::_inside( const mathvec< double >& rp ) const { unsigned int len = this->objs.size(); bool outside = true; for ( unsigned int ii=0; outside && ii < len; ++ii ) { outside = ! this->objs[ ii ]->inside( rp ); } return ! outside; } #line 382 "nws/csg-union.nw" std::istream& operator >> ( std::istream& stream, csgunion& cc ) { input in( stream ); while ( in.check() ) { char token[ input::MAX_TOKEN_LEN ]; if ( in.get( token, sizeof(token) ) == 0 ) { return stream; } std::string tok( token ); char semicolon; if ( tok == "object" ) { object* nn = object::read( stream, cc.myScene ); if ( nn != 0 ) { cc.objs.insert( cc.objs.end(), nn ); } else { std::cerr << "UNION failed loading an object!" << std::endl; } } else if ( tok == "base" ) { stream >> (object&)cc >> semicolon; } else { in.ignore( "UNION", tok.c_str() ); } } return stream; } ./rt2.7.2007.05.17/Code/union.h0100644000077300007650000000232110600166052013440 0ustar patpat#line 445 "nws/csg-union.nw" #ifndef _NKLEIN_UNION_H_ #define _NKLEIN_UNION_H_ 1 #include #include #include #include "object.h" #line 421 "nws/csg-union.nw" class csgunion : public object { protected: #line 33 "nws/csg-union.nw" std::vector< object* > objs; #line 424 "nws/csg-union.nw" public: #line 40 "nws/csg-union.nw" csgunion( const scene* ss ); #line 53 "nws/csg-union.nw" virtual ~csgunion( void ); #line 70 "nws/csg-union.nw" virtual void setDimensions( unsigned int dd ); #line 91 "nws/csg-union.nw" virtual bool intersect( const mathvec< double >& direction, const mathvec< double >& start, intersection& hit ) const; #line 123 "nws/csg-union.nw" virtual bool intersect( const mathvec< double >& direction, const mathvec< double >& start, std::vector< intersection* >& hits ) const; #line 345 "nws/csg-union.nw" virtual bool inside( const mathvec< double >& start ) const; virtual bool _inside( const mathvec< double >& rp ) const; #line 378 "nws/csg-union.nw" friend std::istream& operator >> ( std::istream& in, csgunion& cc ); #line 426 "nws/csg-union.nw" public: static const char* id; }; #line 455 "nws/csg-union.nw" #endif /*_NKLEIN_UNION_H_*/ ./rt2.7.2007.05.17/Code/universe.cc0100644000077300007650000003637710600166051014327 0ustar patpat#line 567 "nws/universe.nw" #include #ifndef MAXFLOAT #include #endif #include "input.h" #include "nkthread.h" #include "universe.h" const char* universe::id = "NKVERSION: universe( 2.1.2007.03.21 )"; #line 112 "nws/universe-inter.nw" class intersectionWork : public thread::work { protected: #line 15 "nws/universe-inter.nw" const mathvec< double >* position; const mathvec< double >* direction; const object* obj; intersection hit; bool gotHit; #line 115 "nws/universe-inter.nw" public: #line 26 "nws/universe-inter.nw" intersectionWork( void ) { }; #line 34 "nws/universe-inter.nw" virtual ~intersectionWork( void ) { this->wait(); }; #line 45 "nws/universe-inter.nw" void set( const mathvec< double >& pp, const mathvec< double >& dd, const object* oo ) { this->position = &pp; this->direction = ⅆ this->obj = oo; this->gotHit = false; this->start(); }; #line 63 "nws/universe-inter.nw" virtual void perform( void ) { this->gotHit = this->obj->intersect( *this->direction, *this->position, this->hit ); if ( this->gotHit && this->hit.getDistance() > MAXFLOAT / 2.0 ) { this->gotHit = false; } }; #line 79 "nws/universe-inter.nw" bool wasHit( void ) { this->wait(); return this->gotHit; }; #line 89 "nws/universe-inter.nw" double getDistance( void ) { this->wait(); return this->hit.getDistance(); }; #line 99 "nws/universe-inter.nw" const intersection& getIntersection( void ) { this->wait(); return this->hit; }; #line 117 "nws/universe-inter.nw" public: static const char* id; }; const char* intersectionWork::id = "NKVERSION: intersectionWork( 2.1.2007.03.21 )"; #line 110 "nws/universe-refl.nw" class reflectionWork : public thread::work { protected: #line 17 "nws/universe-refl.nw" const mathvec< double >& reflectedDirection; const intersection& hit; unsigned int height; double contribution; const universe* univ; double amount; mathvec< double > pixel; #line 113 "nws/universe-refl.nw" public: #line 36 "nws/universe-refl.nw" reflectionWork( const mathvec< double >& rr, const intersection& hh, double cn, unsigned int hg, const universe* uu ) : reflectedDirection( rr ), hit( hh ), height( hg ), contribution( cn ), univ( uu ) { const color* cc = hit.getColor(); this->amount = cc->getReflectiveness(); if ( this->contribution * this->amount > 0.000001 ) { this->start(); } else { this->amount = 0.0; this->finish(); } }; #line 58 "nws/universe-refl.nw" virtual ~reflectionWork( void ) { this->wait(); }; #line 68 "nws/universe-refl.nw" virtual void perform( void ) { mathvec< double > pos = this->hit.getPosition(); pos += this->reflectedDirection * 0.000001; if ( this->univ->evaluate( pos, this->reflectedDirection, this->contribution, this->height-1, this->pixel ) == false ) { this->amount = 0.0; } }; #line 88 "nws/universe-refl.nw" inline double getAmount( void ) { this->wait(); return this->amount; }; #line 98 "nws/universe-refl.nw" const mathvec< double >& getPixel( void ) { this->wait(); return this->pixel; }; #line 115 "nws/universe-refl.nw" public: static const char* id; }; const char* reflectionWork::id = "NKVERSION: reflectionWork( 2.1.2007.03.21 )"; #line 204 "nws/universe-refr.nw" class refractionWork : public thread::work { protected: #line 17 "nws/universe-refr.nw" const intersection& hit; unsigned int height; double contribution; double indexOfRefraction; const universe* univ; double amount; mathvec< double > pixel; #line 207 "nws/universe-refr.nw" public: #line 36 "nws/universe-refr.nw" refractionWork( const intersection& hh, double cn, unsigned int hg, double ior, const universe* uu ) : hit( hh ), height( hg ), contribution( cn ), indexOfRefraction( ior ), univ( uu ) { const color* cc = hit.getColor(); this->amount = cc->getTransparency(); if ( this->contribution * this->amount > 0.000001 ) { this->start(); } else { this->amount = 0.0; this->finish(); } }; #line 57 "nws/universe-refr.nw" virtual ~refractionWork( void ) { this->wait(); }; #line 129 "nws/universe-refr.nw" virtual void perform( void ) { mathvec< double > pos = this->hit.getPosition(); mathvec< double > dir = this->hit.getDirection(); const color* cc = this->hit.getColor(); double hitIOR = cc->getIndexOfRefraction(); double ior1; double ior2; if ( this->hit.isOutside() ) { ior1 = this->indexOfRefraction; ior2 = hitIOR; } else { ior1 = hitIOR; ior2 = 1.0; } if ( ::fabs( ior1 - ior2 ) > 0.000001 ) { mathvec< double > norm = this->hit.getNormal(); norm *= -1.0; double rn = ( dir ^ norm ); if ( rn >= -0.000001 ) { double alpha = ior1 / ior2; double beta = - alpha * rn + ::sqrt( 1.0 + alpha * alpha * ( rn * rn - 1.0 ) ); dir *= alpha; norm *= beta; dir += norm; } else { this->amount = 0.0; } } pos += dir * 0.000001; if ( this->univ->evaluate( pos, dir, ior2, this->contribution, this->height-1, this->pixel ) == false ) { this->amount = 0.0; } }; #line 182 "nws/universe-refr.nw" inline double getAmount( void ) { this->wait(); return this->amount; }; #line 192 "nws/universe-refr.nw" const mathvec< double >& getPixel( void ) { this->wait(); return this->pixel; }; #line 209 "nws/universe-refr.nw" public: static const char* id; }; const char* refractionWork::id = "NKVERSION: refractionWork( 2.1.2007.03.21 )"; #line 204 "nws/universe-shad.nw" class shadowWork : public thread::work { protected: #line 20 "nws/universe-shad.nw" const mathvec< double >* reflectedDirection; const intersection* hit; const light* lamp; double contribution; unsigned int height; const universe* univ; mathvec< double > diffusePixel; mathvec< double > specularPixel; double amount; mathvec< double > pixel; #line 207 "nws/universe-shad.nw" public: #line 42 "nws/universe-shad.nw" shadowWork( void ) { } #line 52 "nws/universe-shad.nw" virtual ~shadowWork( void ) { this->wait(); }; #line 62 "nws/universe-shad.nw" void set( const mathvec< double >* rr, const intersection* hh, const light* ll, double cn, unsigned int hg, const universe* uu ) { this->reflectedDirection = rr; this->hit = hh; this->lamp = ll; this->contribution = cn; this->height = hg; this->univ = uu; this->start(); }; #line 88 "nws/universe-shad.nw" virtual void perform( void ) { #line 117 "nws/universe-shad.nw" mathvec< double > pos = this->hit->getPosition(); mathvec< double > dir = this->lamp->getPosition(); dir -= pos; double lampDist = dir.magnitude(); dir /= lampDist; pos += dir * 0.000001; #line 91 "nws/universe-shad.nw" mathvec< double > norm = this->hit->getNormal(); this->amount = norm ^ dir; double distFact = ( lampDist * this->lamp->getFallOff() ); if ( ::fabs( distFact ) > 0.0000001 ) { this->amount /= distFact * distFact; } const color* cc = this->hit->getColor(); if ( this->amount > 0.0 || cc->getTransparency() > 0.000001 ) { this->diffusePixel.resize( cc->getChannelCount(), 0.0 ); #line 131 "nws/universe-shad.nw" this->univ->checkShadow( pos, dir, lampDist, this->contribution, this->height, this->amount, this->diffusePixel ); #line 104 "nws/universe-shad.nw" } if ( this->amount > 0.0 ) { #line 141 "nws/universe-shad.nw" this->lamp->evaluate( pos, norm, dir, this->contribution, this->height, this->diffusePixel ); #line 108 "nws/universe-shad.nw" #line 150 "nws/universe-shad.nw" this->specularPixel = this->diffusePixel; double specularness = cc->getSpecularness(); if ( specularness > 0.000001 ) { double phong = cc->getPhong(); double cosAngle = ( *this->reflectedDirection ^ dir ); double factor = ::pow(cosAngle,phong) * specularness; this->specularPixel *= factor; } else { this->specularPixel *= 0.0; } #line 109 "nws/universe-shad.nw" #line 167 "nws/universe-shad.nw" mathvec< double > objPixel; this->hit->evaluate( this->contribution, this->height, objPixel ); this->diffusePixel *= objPixel; #line 110 "nws/universe-shad.nw" } }; #line 178 "nws/universe-shad.nw" inline double getAmount( void ) { this->wait(); return this->amount; }; #line 189 "nws/universe-shad.nw" const mathvec< double >& getPixel( double diffuseAmount ) { this->wait(); this->pixel = this->diffusePixel; this->pixel *= diffuseAmount; this->pixel += this->specularPixel; return this->pixel; }; #line 209 "nws/universe-shad.nw" public: static const char* id; }; const char* shadowWork::id = "NKVERSION: shadowWork( 2.1.2007.03.21 )"; #line 75 "nws/universe.nw" universe::universe( const scene* ss ) : myScene( ss ), ambientLight( ss ), gotAmbient( false ), skyColor( ss ), quickRender( false ) { } #line 90 "nws/universe.nw" universe::~universe( void ) { for ( unsigned int ii=0; ii < this->objects.size(); ++ii ) { delete objects[ ii ]; } for ( unsigned int ii=0; ii < this->lights.size(); ++ii ) { delete lights[ ii ]; } } #line 122 "nws/universe.nw" void universe::setDimensions( unsigned int dims ) { this->dimensions = dims; for ( unsigned int ii=0; ii < this->lights.size(); ++ii ) { this->lights[ ii ]->setDimensions( this->dimensions ); } for ( unsigned int ii=0; ii < this->objects.size(); ++ii ) { this->objects[ ii ]->setDimensions( this->dimensions ); } this->ambientLight.setDimensions( dims ); this->skyColor.setDimensions( dims ); } #line 156 "nws/universe.nw" bool universe::evaluate( const mathvec< double >& position, const mathvec< double >& direction, double contribution, unsigned int height, mathvec< double >& pixel ) const { return this->evaluate( position, direction, 1.0, contribution, height, pixel ); } #line 192 "nws/universe.nw" bool universe::evaluate( const mathvec< double >& position, const mathvec< double >& direction, double indexOfRefraction, double contribution, unsigned int height, mathvec< double >& pixel ) const { if ( height == 0 || contribution < 0.000001 ) { return false; } else { #line 223 "nws/universe.nw" pixel *= 0.0; #line 265 "nws/universe.nw" std::vector< intersectionWork > intersections( this->objects.size() ); for ( unsigned int ii=0; ii < this->objects.size(); ++ii ) { intersections[ ii ].set( position, direction, this->objects[ ii ] ); } #line 227 "nws/universe.nw" intersectionWork* closest = 0; double closestDistance = MAXFLOAT; for ( unsigned int ii=0; ii < this->objects.size(); ++ii ) { if ( intersections[ ii ].wasHit() && intersections[ ii ].getDistance() < closestDistance ) { closest = &intersections[ ii ]; closestDistance = closest->getDistance(); } } #line 242 "nws/universe.nw" if ( closest == 0 ) { mathvec< double > normal = direction * -1.0; this->skyColor.evaluate( position, normal, direction, contribution, height, pixel ); pixel *= contribution; return true; } #line 255 "nws/universe.nw" intersection hit = closest->getIntersection(); intersections.resize(0); #line 204 "nws/universe.nw" if ( this->quickRender ) { #line 276 "nws/universe.nw" mathvec< double > ndir = hit.getNormal(); double dot = -( ndir ^ direction ); dot = 1.0 - 0.75 * ( 1.0 - dot ); if ( dot < 0.25 ) { dot = 0.25; } hit.evaluate( contribution, height, pixel ); pixel *= dot; #line 206 "nws/universe.nw" } else { #line 294 "nws/universe.nw" mathvec< double > ndir = hit.getNormal(); mathvec< double > rdir = hit.getDirection(); // reflected ray ndir *= -2.0 * ( rdir ^ ndir ); rdir += ndir; reflectionWork reflected( rdir, hit, contribution, height, this ); refractionWork refracted( hit, contribution, height, indexOfRefraction, this ); #line 314 "nws/universe.nw" std::vector< shadowWork > shadows( this->lights.size() ); for ( unsigned int ii=0; ii < shadows.size(); ++ii ) { shadows[ ii ].set( &rdir, &hit, this->lights[ ii ], contribution, height, this ); } #line 325 "nws/universe.nw" if ( pixel.size() < hit.getColor()->getChannelCount() ) { pixel.resize( hit.getColor()->getChannelCount() ); } if ( this->gotAmbient ) { mathvec< double > normal = direction * -1.0; hit.evaluate( contribution, height, pixel ); mathvec< double > ambientPixel; this->ambientLight.evaluate( position, normal, direction, contribution, height, ambientPixel ); pixel *= ambientPixel; } else { pixel *= 0.0; } #line 348 "nws/universe.nw" double reflectedAmount = reflected.getAmount(); if ( reflectedAmount > 0.000001 ) { pixel += reflectedAmount * reflected.getPixel(); } double refractedAmount = refracted.getAmount(); if ( refractedAmount > 0.000001 ) { pixel += refractedAmount * refracted.getPixel(); } for ( unsigned int ii=0; ii < shadows.size(); ++ii ) { double amount = shadows[ ii ].getAmount(); if ( amount > 0.000001 ) { double diffuseness = 1.0 - reflectedAmount - refractedAmount; pixel += amount * shadows[ ii ].getPixel( diffuseness ); } } pixel *= contribution; #line 208 "nws/universe.nw" } return true; } } #line 395 "nws/universe.nw" void universe::checkShadow( const mathvec< double >& position, const mathvec< double >& direction, double lampDistance, double contribution, unsigned int height, double& amount, mathvec< double >& pixel ) const { #line 265 "nws/universe.nw" std::vector< intersectionWork > intersections( this->objects.size() ); for ( unsigned int ii=0; ii < this->objects.size(); ++ii ) { intersections[ ii ].set( position, direction, this->objects[ ii ] ); } #line 407 "nws/universe.nw" #line 416 "nws/universe.nw" for ( unsigned int ii=0; ii < this->objects.size(); ++ii ) { if ( intersections[ ii ].wasHit() && intersections[ ii ].getDistance() < lampDistance ) { const color* cc = intersections[ ii ].getIntersection().getColor(); double tt = cc->getTransparency(); if ( tt < 0.000001 ) { amount = 0.0; break; } else { mathvec< double > objPixel; if ( tt < 0.999999 ) { intersections[ ii ].getIntersection().evaluate( contribution * tt, height, objPixel ); objPixel *= ( 1.0 - tt ); objPixel *= pixel; pixel *= tt; pixel += objPixel; } else { pixel *= tt; } amount *= tt; } } } #line 408 "nws/universe.nw" } #line 464 "nws/universe.nw" std::istream& operator >> ( std::istream& stream, universe& uu ) { input in( stream ); unsigned int dims = 2; uu.gotAmbient = false; while ( in.check() ) { char token[ input::MAX_TOKEN_LEN ]; if ( in.get( token, sizeof(token) ) == 0 ) { return stream; } std::string tok( token ); char semicolon; if ( tok == "dimensions" || tok == "dims" ) { stream >> dims >> semicolon; } else if ( tok == "ambientLight" || tok == "ambient" ) { stream >> uu.ambientLight >> semicolon; uu.gotAmbient = true; } else if ( tok == "skyColor" || tok == "sky" ) { stream >> uu.skyColor >> semicolon; } else if ( tok == "quickRender" ) { stream >> semicolon; uu.quickRender = true; } else if ( tok == "light" ) { light* nn = new light( uu.myScene ); stream >> *nn >> semicolon; uu.lights.insert( uu.lights.end(), nn ); } else if ( tok == "object" ) { object* nn = object::read( stream, uu.myScene ); if ( nn != 0 ) { uu.objects.insert( uu.objects.end(), nn ); } } else { in.ignore( "UNIVERSE", tok.c_str() ); } } uu.setDimensions( dims ); return stream; } ./rt2.7.2007.05.17/Code/universe.h0100644000077300007650000000327110600166050014153 0ustar patpat#line 542 "nws/universe.nw" #ifndef _NKLEIN_UNIVERSE_H_ #define _NKLEIN_UNIVERSE_H_ 1 #include #include #include #include "light.h" #include "object.h" #line 518 "nws/universe.nw" class universe { protected: #line 48 "nws/universe.nw" const scene* myScene; #line 55 "nws/universe.nw" unsigned int dimensions; std::vector< light* > lights; std::vector< object* > objects; color ambientLight; bool gotAmbient; color skyColor; bool quickRender; #line 521 "nws/universe.nw" public: #line 71 "nws/universe.nw" universe( const scene* ss ); #line 86 "nws/universe.nw" ~universe( void ); #line 109 "nws/universe.nw" inline unsigned int getDimensions( void ) const { return this->dimensions; }; #line 119 "nws/universe.nw" void setDimensions( unsigned int dims ); #line 144 "nws/universe.nw" bool evaluate( const mathvec< double >& position, const mathvec< double >& direction, double contribution, unsigned int height, mathvec< double >& pixel ) const; #line 174 "nws/universe.nw" bool evaluate( const mathvec< double >& position, const mathvec< double >& direction, double indexOfRefraction, double contribution, unsigned int height, mathvec< double >& pixel ) const; #line 379 "nws/universe.nw" void checkShadow( const mathvec< double >& position, const mathvec< double >& direction, double lampDistance, double contribution, unsigned int height, double& amount, mathvec< double >& pixel ) const; #line 447 "nws/universe.nw" friend std::istream& operator >> ( std::istream& in, universe& cc ); #line 523 "nws/universe.nw" public: static const char* id; }; #line 553 "nws/universe.nw" #endif /*_NKLEIN_UNIVERSE_H_*/ ./rt2.7.2007.05.17/Code/view.cc0100644000077300007650000002040110600166057013424 0ustar patpat#line 791 "nws/view.nw" #include #include "input.h" #include "view.h" const char* view::id = "NKVERSION: view( 2.1.2007.03.21 )"; #line 230 "nws/view.nw" view::view( const scene* ss ) : myScene( ss ), viewport( ss ), #line 221 "nws/view.nw" wrap( false ), gamma( 1.0 ), border( 1 ), composite( 0 ), traceDepth( 12 ) #line 232 "nws/view.nw" { } #line 245 "nws/view.nw" view::~view( void ) { for ( unsigned int ii=0; ii < this->images.size(); ++ii ) { delete this->images[ ii ]; } } #line 268 "nws/view.nw" void view::render( void ) const { #line 302 "nws/view.nw" mathvec< unsigned int > coordinates( 0U, this->size.size() ); #line 272 "nws/view.nw" #line 312 "nws/view.nw" unsigned int width = 1; unsigned int height = 1; unsigned int wdirs = 0; unsigned int hdirs = 0; for ( unsigned int ii=0; ii < this->composite; ++ii ) { bool bb = this->contributesToWidth[ ii ]; if ( bb ) { width = width * this->size[ ii ]; ++wdirs; } else { height = height * this->size[ ii ]; ++hdirs; } } if ( wdirs < 1 ) { width += 2 * this->border; } if ( hdirs < 1 ) { height += 2 * this->border; } #line 273 "nws/view.nw" #line 337 "nws/view.nw" unsigned int depth=1; for ( unsigned int ii=this->composite; ii < this->size.size(); ++ii ) { depth *= this->size[ ii ]; } #line 274 "nws/view.nw" #line 347 "nws/view.nw" for ( unsigned int ii=0; ii < this->images.size(); ++ii ) { this->images[ ii ]->setSize( width, height, depth, this->viewport.getChannelCount() ); } #line 276 "nws/view.nw" mathvec< double > position( 0.0, this->size.size() + 1 ); mathvec< double > direction( this->size.size() + 1 ); mathvec< double > normal; mathvec< double > pixel; for ( unsigned int kk=0; kk < depth; ++kk ) { for ( unsigned int jj=0; jj < height; ++jj ) { for ( unsigned int ii=0; ii < width; ++ii ) { if ( this->calculateDirection( coordinates, direction ) ) { #line 358 "nws/view.nw" normal = direction * -1.0; #line 286 "nws/view.nw" #line 364 "nws/view.nw" this->viewport.evaluate( position, normal, direction, 1.0, this->traceDepth, pixel ); unsigned int len = pixel.size(); for ( unsigned int ii=0; ii < len; ++ii ) { double val = pixel[ ii ]; if ( val > 0.0 ) { pixel[ ii ] = ::pow( val, this->gamma ); } } #line 287 "nws/view.nw" #line 382 "nws/view.nw" for ( unsigned int ll=0; ll < this->images.size(); ++ll ) { this->images[ ll ]->add( pixel ); } #line 288 "nws/view.nw" } else { #line 390 "nws/view.nw" for ( unsigned int ll=0; ll < this->images.size(); ++ll ) { this->images[ ll ]->addBorderPixel(); } #line 290 "nws/view.nw" } this->incrementDirection( coordinates ); } } } } #line 418 "nws/view.nw" bool view::calculateDirection( const mathvec< unsigned int >& coordinates, mathvec< double >& direction ) const { unsigned int dims = coordinates.size(); direction[ 0 ] = 0.0; #line 438 "nws/view.nw" for ( unsigned int ii=0; ii < dims; ++ii ) { unsigned int index = this->permutation[ ii ] + 1; unsigned int bb = 0; if ( this->needsBorders[ ii ] ) { bb = this->border; } double is = (double)( this->size[ ii ] - 2*bb ); double ss = is / 2.0 - 0.5; if ( ss < 0.000001 ) { direction[ index ] = 0.0; } else { unsigned int cc = coordinates[ ii ]; double tt = (double)( cc - bb ) - ss; if ( cc < bb || cc + bb >= this->size[ ii ] ) { return false; } direction[ index ] = this->angularExtents[ ii ] * tt / ss; } } #line 428 "nws/view.nw" #line 473 "nws/view.nw" double mag = direction.magnitude(); if ( this->wrap == false && mag > M_PI ) { return false; } else { if ( mag < 0.000001 ) { direction *= 0.0; direction[ 0 ] = 1.0; } else { direction *= -::sin( mag ) / mag; direction[ 0 ] = ::cos( mag ); } return true; } #line 429 "nws/view.nw" } #line 506 "nws/view.nw" void view::incrementDirection( mathvec< unsigned int >& coordinates ) const { unsigned int dims = coordinates.size(); for ( unsigned int ii=0; ii < dims; ++ii ) { if ( ++coordinates[ ii ] < this->size[ ii ] ) { break; } else { coordinates[ ii ] = 0; } } } #line 550 "nws/view.nw" std::istream& operator >> ( std::istream& stream, view& vv ) { mathvec< double > units; mathvec< double > dpu; mathvec< double > fishEye; double viewDepth = 12.0; vv.vertical = false; input in( stream ); while ( in.check() ) { char token[ input::MAX_TOKEN_LEN ]; if ( in.get( token, sizeof(token) ) == 0 ) { return stream; } std::string tok( token ); char semicolon; if ( tok == "unitsPerDimension" || tok == "units" ) { stream >> units >> semicolon; } else if ( tok == "dotsPerUnit" || tok == "dpu" || tok == "dpi" ) { stream >> dpu >> semicolon; } else if ( tok == "viewDepth" || tok == "depth" ) { stream >> viewDepth >> semicolon; } else if ( tok == "fishEye" ) { stream >> fishEye >> semicolon; } else if ( tok == "wrapAround" || tok == "wrap" ) { vv.wrap = true; stream >> semicolon; } else if ( tok == "gamma" ) { stream >> vv.gamma >> semicolon; } else if ( tok == "border" ) { stream >> vv.border >> semicolon; } else if ( tok == "composite" ) { stream >> vv.composite >> semicolon; } else if ( tok == "vertical" ) { vv.vertical = true; stream >> semicolon; } else if ( tok == "traceDepth" || tok == "maxDepth" ) { stream >> vv.traceDepth >> semicolon; } else if ( tok == "viewport" || tok == "color" ) { stream >> vv.viewport >> semicolon; } else if ( tok == "image" ) { image* nn = image::read( stream ); vv.images.insert( vv.images.end(), nn ); stream >> semicolon; } else { in.ignore( "VIEW", tok.c_str() ); } } #line 620 "nws/view.nw" unsigned int dims = units.size(); if ( dims == 0 ) { std::cerr << "View: length dimensions are zero" << std::endl; return stream; } dpu.resize( dims, 1.0 ); if ( vv.composite == 0 || vv.composite > dims ) { vv.composite = dims; } unsigned int ii; fishEye.resize( dims, 0.0 ); #line 606 "nws/view.nw" #line 645 "nws/view.nw" vv.permutation.resize( dims ); vv.contributesToWidth.resize( vv.composite ); vv.needsBorders.resize( dims, false ); unsigned int evenDims = vv.composite / 2; unsigned int oddDims = vv.composite - evenDims; for (ii = 0; ii < oddDims; ++ii) { vv.permutation[ii] = ii * 2; vv.contributesToWidth[ ii ] = true; } for (ii = oddDims; ii < vv.composite; ++ii) { vv.permutation[ii] = ( ii - oddDims ) * 2 + 1; vv.contributesToWidth[ ii ] = false; } for (ii = vv.composite; ii < dims; ++ii) { vv.permutation[ii] = ii; } if ( vv.vertical && oddDims > 0 && evenDims > 0 ) { #line 696 "nws/view.nw" if ( ( vv.composite & 1 ) == 1 ) { unsigned int tt = vv.permutation[ oddDims - 1 ]; for ( ii=oddDims; ii < vv.composite; ++ii ) { vv.permutation[ ii - 1 ] = vv.permutation[ ii ]; } vv.permutation[ vv.composite-1 ] = tt; vv.contributesToWidth[ oddDims - 1 ] = false; --oddDims; ++evenDims; } for ( ii=1; ii < oddDims; ++ii ) { unsigned int tt = vv.permutation[ ii ]; vv.permutation[ ii ] = vv.permutation[ ii + oddDims ]; vv.permutation[ ii + oddDims ] = tt; } #line 668 "nws/view.nw" } unsigned int wdims = 0; unsigned int hdims = 0; for ( ii = 0; ii < vv.composite; ++ii ) { if ( vv.contributesToWidth[ ii ] ) { ++wdims; } else { ++hdims; } } for ( ii = 0; ii < vv.composite; ++ii ) { if ( vv.contributesToWidth[ ii ] ) { vv.needsBorders[ ii ] = ( --wdims > 0 ); } else { vv.needsBorders[ ii ] = ( --hdims > 0 ); } } for ( ii = vv.composite; ii < dims; ++ii ) { vv.needsBorders[ ii ] = false; } #line 607 "nws/view.nw" #line 721 "nws/view.nw" vv.size.resize( dims ); vv.angularExtents.resize( dims ); for (ii = 0; ii < dims; ++ii) { unsigned int permuted = vv.permutation[ii]; double un = units[permuted]; double len = dpu[permuted] * un; double baseAngle; vv.size[ ii ] = (unsigned int)(::fabs( len ) + 0.5); if ( permuted+1 != vv.composite && permuted+2 != vv.composite ) { vv.size[ ii ] += 2 * vv.border; } baseAngle = atan2( un, 2.0 * viewDepth ); vv.angularExtents[ ii ] = baseAngle * ( 1.0 + fishEye[permuted]); } #line 609 "nws/view.nw" vv.viewport.setDimensions( dims+1 ); return stream; } ./rt2.7.2007.05.17/Code/view.h0100644000077300007650000000251110600166050013261 0ustar patpat#line 770 "nws/view.nw" #ifndef _NKLEIN_VIEW_H_ #define _NKLEIN_VIEW_H_ 1 #include #include #include #include "color.h" #include "image.h" #line 746 "nws/view.nw" class view { protected: #line 167 "nws/view.nw" const scene* myScene; #line 175 "nws/view.nw" color viewport; #line 184 "nws/view.nw" mathvec< unsigned int > size; mathvec< double > angularExtents; bool wrap; double gamma; unsigned int border; #line 194 "nws/view.nw" unsigned int composite; #line 199 "nws/view.nw" unsigned int traceDepth; #line 206 "nws/view.nw" mathvec permutation; std::vector contributesToWidth; std::vector needsBorders; bool vertical; #line 214 "nws/view.nw" std::vector< image* > images; #line 749 "nws/view.nw" public: #line 226 "nws/view.nw" view( const scene* ss ); #line 241 "nws/view.nw" ~view( void ); #line 257 "nws/view.nw" void render( void ) const; #line 403 "nws/view.nw" bool calculateDirection( const mathvec< unsigned int >& coordinates, mathvec< double >& direction ) const; #line 497 "nws/view.nw" void incrementDirection( mathvec< unsigned int >& coordinates ) const; #line 525 "nws/view.nw" friend std::istream& operator >> ( std::istream& in, view& cc ); #line 751 "nws/view.nw" public: static const char* id; }; #line 781 "nws/view.nw" #endif /*_NKLEIN_VIEW_H_*/ ./rt2.7.2007.05.17/GNUmakefile0100644000077300007650000004204010623057660013352 0ustar patpat ARCH := $(shell uname -s)-$(shell uname -p) PREFIX := $(HOME) ifdef BEAUTIFY TANGLE_LINES := BEAUTIFIER := bcpp else TANGLE_LINES := -L BEAUTIFIER := cat endif USE_PNG := 1 ifeq ($(USE_PNG),1) PNGBASE := $(shell \ for spot in /usr /usr/local /sw /cis /opt/local ; do \ if [ -f $${spot}/include/png.h ]; then \ echo $$spot; \ exit 0; \ fi; \ done \ ) endif ifeq ($(ARCH),SunOS-sparc) CXX := CC OPTFLG := -O5 CXXFLAGS := $(OPTFLG) -instances=extern -mt LIBS := -lpthread TOJPEG := cjpeg else CXX := g++ OPTFLG := -O3 -funroll-loops CXXFLAGS := $(OPTFLG) -Wall LIBS := -lpthread # /sw/lib/libefence.a TOJPEG := pnmtojpeg endif ifeq ($(ARCH),Linux-unknown) CXXFLAGS += -pthread endif ifeq ($(ARCH),Darwin-powerpc) CXXFLAGS += -fstack-check endif #ASSERTFLG := -DDEBUG=1 ASSERTFLG := -DNDEBUG=1 VERS := 2.1.$(shell date +'%Y.%m.%d') PROG := rt ifdef HAS_NOWEB PDF := $(PROG).pdf endif BUILD := Build-$(ARCH) CODE := Code SCENE := Scene DOC := Doc IMG := Image NWS := \ nws/start.nw \ nws/scene.nw \ nws/view.nw \ nws/universe.nw \ nws/universe-inter.nw \ nws/universe-refl.nw \ nws/universe-refr.nw \ nws/universe-shad.nw \ nws/light.nw \ nws/object.nw \ nws/halfspace.nw \ nws/cylinder.nw \ nws/quadratic.nw \ nws/convex.nw \ nws/coxeter.nw \ nws/complement.nw \ nws/csg-union.nw \ nws/csg-set.nw \ nws/csg-inter.nw \ nws/extrusion.nw \ nws/image.nw \ nws/image-ppm.nw \ nws/image-png.nw \ nws/image-accum.nw \ nws/portal.nw \ nws/color.nw \ nws/expr.nw \ nws/expr-binary.nw \ nws/expr-unary.nw \ nws/expr-const.nw \ nws/expr-pos.nw \ nws/expr-dir.nw \ nws/expr-norm.nw \ nws/expr-ref.nw \ nws/mathvec.nw \ nws/basevec.nw \ nws/intersection.nw \ nws/nkthread.nw \ nws/thread-work.nw \ nws/thread-worker.nw \ nws/input.nw \ nws/main.nw \ nws/samples.nw \ nws/sample-justColor.nw \ nws/sample-spot.nw \ nws/sample-space.nw \ nws/sample-cylinders.nw \ nws/sample-quadratic.nw \ nws/sample-compl.nw \ nws/sample-union.nw \ nws/sample-inter.nw \ nws/sample-extrusion.nw \ nws/sample-coxeter.nw \ nws/sample-inside.nw \ nws/end.nw HDRS := \ $(CODE)/scene.h \ $(CODE)/portal.h \ $(CODE)/universe.h \ $(CODE)/inter.h \ $(CODE)/union.h \ $(CODE)/set.h \ $(CODE)/complement.h \ $(CODE)/extrusion.h \ $(CODE)/coxeter.h \ $(CODE)/convex.h \ $(CODE)/halfspace.h \ $(CODE)/cylinder.h \ $(CODE)/quadratic.h \ $(CODE)/object.h \ $(CODE)/intersection.h \ $(CODE)/light.h \ $(CODE)/view.h \ $(CODE)/image.h \ $(CODE)/color.h \ $(CODE)/expr.h \ $(CODE)/mathvec.h \ $(CODE)/basevec.h \ $(CODE)/nkthread.h \ $(CODE)/input.h OBJS := \ $(BUILD)/main.o \ $(BUILD)/scene.o \ $(BUILD)/portal.o \ $(BUILD)/universe.o \ $(BUILD)/inter.o \ $(BUILD)/union.o \ $(BUILD)/set.o \ $(BUILD)/complement.o \ $(BUILD)/extrusion.o \ $(BUILD)/coxeter.o \ $(BUILD)/convex.o \ $(BUILD)/halfspace.o \ $(BUILD)/cylinder.o \ $(BUILD)/quadratic.o \ $(BUILD)/object.o \ $(BUILD)/intersection.o \ $(BUILD)/light.o \ $(BUILD)/view.o \ $(BUILD)/image.o \ $(BUILD)/color.o \ $(BUILD)/expr.o \ $(BUILD)/mathvec.o \ $(BUILD)/basevec.o \ $(BUILD)/nkthread.o \ $(BUILD)/input.o IMAGES := \ $(IMG)/justColor.jpg \ $(IMG)/space.jpg \ $(IMG)/spot.jpg \ $(IMG)/cylinders.jpg \ $(IMG)/quadratic.jpg \ $(IMG)/compl.jpg \ $(IMG)/union.jpg \ $(IMG)/inter.jpg \ $(IMG)/extrusion.jpg \ $(IMG)/coxeter.jpg \ $(IMG)/inside.jpg IMG_INPUTS := $(patsubst $(IMG)/%.jpg,$(SCENE)/%.rt,$(IMAGES)) SRCS := $(patsubst $(BUILD)/%.o,$(CODE)/%.cc,$(OBJS)) ######################################### MKDIR_CMD = test -d $(@D) || mkdir -p $(@D) #CPPFLAGS := -I$(CODE) $(ASSERTFLG) -DUSE_PPM=1 CPPFLAGS := -I$(CODE) $(ASSERTFLG) -DUSE_PPM=1 -DUSE_PTHREADS=1 ifneq ($(PNGBASE),) CPPFLAGS += -I$(PNGBASE)/include -DUSE_PNG=1 ifeq ($(ARCH),SunOS-sparc) LIBS += -R$(PNGBASE)/lib endif LIBS += -L$(PNGBASE)/lib -lpng -lz endif ######################################### all: $(PROG) install: $(PREFIX)/bin/$(PROG) doc: $(PDF) images: $(IMAGES) tidy: rm -rf $(BUILD) rm -rf $(DOC) clean: tidy rm -f $(PROG) $(PDF) rm -rf $(IMG) ifdef HAS_NOWEB rm -rf $(CODE) rm -rf $(SCENE) endif ######################################### $(PREFIX)/bin/%: % -@$(MKDIR_CMD) cp $< $@ $(OBJS): $(BUILD)/%.o: $(CODE)/%.cc -@$(MKDIR_CMD) @echo $(CXX) -c $( $@ ; rm -f $*.ppm ifdef HAS_NOWEB $(IMG_INPUTS): $(SCENE)/%.rt: nws/sample-%.nw -@$(MKDIR_CMD) @echo tangle $(@F) @notangle -R$(@F) $(NWS) | sed -e 's/RT_VERSION/$(VERS)/g' | cpif $@ $(SRCS): $(CODE)/%.cc: -@$(MKDIR_CMD) @echo tangle $(@F) @notangle -R$(@F) $(TANGLE_LINES) $(NWS) \ | sed -e 's/RT_VERSION/$(VERS)/g' | $(BEAUTIFIER) | cpif $@ $(HDRS): $(CODE)/%.h: -@$(MKDIR_CMD) @echo tangle $(@F) @notangle -R$(@F) $(TANGLE_LINES) $(NWS) \ | sed -e 's/RT_VERSION/$(VERS)/g' | $(BEAUTIFIER) | cpif $@ endif ######################################### $(BUILD)/input.o: $(CODE)/input.h $(BUILD)/nkthread.o: $(CODE)/nkthread.h $(BUILD)/basevec.o: $(CODE)/basevec.h $(CODE)/basevec.cc $(BUILD)/mathvec.o: $(CODE)/basevec.h $(CODE)/basevec.cc $(BUILD)/mathvec.o: $(CODE)/mathvec.h $(CODE)/mathvec.cc $(BUILD)/expr.o: $(CODE)/basevec.h $(CODE)/basevec.cc $(BUILD)/expr.o: $(CODE)/mathvec.h $(CODE)/mathvec.cc $(BUILD)/expr.o: $(CODE)/expr.h $(BUILD)/expr.o: $(CODE)/input.h $(BUILD)/expr.o: $(CODE)/portal.h $(BUILD)/color.o: $(CODE)/basevec.h $(CODE)/basevec.cc $(BUILD)/color.o: $(CODE)/mathvec.h $(CODE)/mathvec.cc $(BUILD)/color.o: $(CODE)/expr.h $(BUILD)/color.o: $(CODE)/input.h $(BUILD)/color.o: $(CODE)/portal.h $(BUILD)/color.o: $(CODE)/color.h $(BUILD)/image.o: $(CODE)/basevec.h $(CODE)/basevec.cc $(BUILD)/image.o: $(CODE)/mathvec.h $(CODE)/mathvec.cc $(BUILD)/image.o: $(CODE)/expr.h $(BUILD)/image.o: $(CODE)/input.h $(BUILD)/image.o: $(CODE)/color.h $(BUILD)/image.o: $(CODE)/image.h $(BUILD)/view.o: $(CODE)/basevec.h $(CODE)/basevec.cc $(BUILD)/view.o: $(CODE)/mathvec.h $(CODE)/mathvec.cc $(BUILD)/view.o: $(CODE)/expr.h $(BUILD)/view.o: $(CODE)/input.h $(BUILD)/view.o: $(CODE)/color.h $(BUILD)/view.o: $(CODE)/image.h $(BUILD)/view.o: $(CODE)/view.h $(BUILD)/light.o: $(CODE)/basevec.h $(CODE)/basevec.cc $(BUILD)/light.o: $(CODE)/mathvec.h $(CODE)/mathvec.cc $(BUILD)/light.o: $(CODE)/expr.h $(BUILD)/light.o: $(CODE)/input.h $(BUILD)/light.o: $(CODE)/color.h $(BUILD)/light.o: $(CODE)/light.h $(BUILD)/intersection.o: $(CODE)/basevec.h $(CODE)/basevec.cc $(BUILD)/intersection.o: $(CODE)/mathvec.h $(CODE)/mathvec.cc $(BUILD)/intersection.o: $(CODE)/expr.h $(BUILD)/intersection.o: $(CODE)/input.h $(BUILD)/intersection.o: $(CODE)/color.h $(BUILD)/intersection.o: $(CODE)/intersection.h $(BUILD)/object.o: $(CODE)/basevec.h $(CODE)/basevec.cc $(BUILD)/object.o: $(CODE)/mathvec.h $(CODE)/mathvec.cc $(BUILD)/object.o: $(CODE)/expr.h $(BUILD)/object.o: $(CODE)/input.h $(BUILD)/object.o: $(CODE)/color.h $(BUILD)/object.o: $(CODE)/intersection.h $(BUILD)/object.o: $(CODE)/object.h $(BUILD)/object.o: $(CODE)/coxeter.h $(BUILD)/object.o: $(CODE)/convex.h $(BUILD)/object.o: $(CODE)/halfspace.h $(BUILD)/object.o: $(CODE)/cylinder.h $(BUILD)/object.o: $(CODE)/quadratic.h $(BUILD)/object.o: $(CODE)/complement.h $(BUILD)/object.o: $(CODE)/extrusion.h $(BUILD)/object.o: $(CODE)/union.h $(BUILD)/object.o: $(CODE)/set.h $(BUILD)/object.o: $(CODE)/inter.h $(BUILD)/cylinder.o: $(CODE)/basevec.h $(CODE)/basevec.cc $(BUILD)/cylinder.o: $(CODE)/mathvec.h $(CODE)/mathvec.cc $(BUILD)/cylinder.o: $(CODE)/expr.h $(BUILD)/cylinder.o: $(CODE)/input.h $(BUILD)/cylinder.o: $(CODE)/color.h $(BUILD)/cylinder.o: $(CODE)/intersection.h $(BUILD)/cylinder.o: $(CODE)/object.h $(BUILD)/cylinder.o: $(CODE)/cylinder.h $(BUILD)/coxeter.o: $(CODE)/basevec.h $(CODE)/basevec.cc $(BUILD)/coxeter.o: $(CODE)/mathvec.h $(CODE)/mathvec.cc $(BUILD)/coxeter.o: $(CODE)/expr.h $(BUILD)/coxeter.o: $(CODE)/input.h $(BUILD)/coxeter.o: $(CODE)/color.h $(BUILD)/coxeter.o: $(CODE)/intersection.h $(BUILD)/coxeter.o: $(CODE)/object.h $(BUILD)/coxeter.o: $(CODE)/halfspace.h $(BUILD)/coxeter.o: $(CODE)/inter.h $(BUILD)/coxeter.o: $(CODE)/convex.h $(BUILD)/coxeter.o: $(CODE)/coxeter.h $(BUILD)/convex.o: $(CODE)/basevec.h $(CODE)/basevec.cc $(BUILD)/convex.o: $(CODE)/mathvec.h $(CODE)/mathvec.cc $(BUILD)/convex.o: $(CODE)/expr.h $(BUILD)/convex.o: $(CODE)/input.h $(BUILD)/convex.o: $(CODE)/color.h $(BUILD)/convex.o: $(CODE)/intersection.h $(BUILD)/convex.o: $(CODE)/object.h $(BUILD)/convex.o: $(CODE)/halfspace.h $(BUILD)/convex.o: $(CODE)/inter.h $(BUILD)/convex.o: $(CODE)/cylinder.h $(BUILD)/convex.o: $(CODE)/convex.h $(BUILD)/halfspace.o: $(CODE)/basevec.h $(CODE)/basevec.cc $(BUILD)/halfspace.o: $(CODE)/mathvec.h $(CODE)/mathvec.cc $(BUILD)/halfspace.o: $(CODE)/expr.h $(BUILD)/halfspace.o: $(CODE)/input.h $(BUILD)/halfspace.o: $(CODE)/color.h $(BUILD)/halfspace.o: $(CODE)/intersection.h $(BUILD)/halfspace.o: $(CODE)/object.h $(BUILD)/halfspace.o: $(CODE)/halfspace.h $(BUILD)/quadratic.o: $(CODE)/basevec.h $(CODE)/basevec.cc $(BUILD)/quadratic.o: $(CODE)/mathvec.h $(CODE)/mathvec.cc $(BUILD)/quadratic.o: $(CODE)/expr.h $(BUILD)/quadratic.o: $(CODE)/input.h $(BUILD)/quadratic.o: $(CODE)/color.h $(BUILD)/quadratic.o: $(CODE)/intersection.h $(BUILD)/quadratic.o: $(CODE)/object.h $(BUILD)/quadratic.o: $(CODE)/quadratic.h $(BUILD)/complement.o: $(CODE)/basevec.h $(CODE)/basevec.cc $(BUILD)/complement.o: $(CODE)/mathvec.h $(CODE)/mathvec.cc $(BUILD)/complement.o: $(CODE)/expr.h $(BUILD)/complement.o: $(CODE)/input.h $(BUILD)/complement.o: $(CODE)/color.h $(BUILD)/complement.o: $(CODE)/intersection.h $(BUILD)/complement.o: $(CODE)/object.h $(BUILD)/complement.o: $(CODE)/complement.h $(BUILD)/extrusion.o: $(CODE)/basevec.h $(CODE)/basevec.cc $(BUILD)/extrusion.o: $(CODE)/mathvec.h $(CODE)/mathvec.cc $(BUILD)/extrusion.o: $(CODE)/expr.h $(BUILD)/extrusion.o: $(CODE)/input.h $(BUILD)/extrusion.o: $(CODE)/color.h $(BUILD)/extrusion.o: $(CODE)/intersection.h $(BUILD)/extrusion.o: $(CODE)/object.h $(BUILD)/extrusion.o: $(CODE)/extrusion.h $(BUILD)/union.o: $(CODE)/basevec.h $(CODE)/basevec.cc $(BUILD)/union.o: $(CODE)/mathvec.h $(CODE)/mathvec.cc $(BUILD)/union.o: $(CODE)/expr.h $(BUILD)/union.o: $(CODE)/input.h $(BUILD)/union.o: $(CODE)/color.h $(BUILD)/union.o: $(CODE)/intersection.h $(BUILD)/union.o: $(CODE)/object.h $(BUILD)/union.o: $(CODE)/union.h $(BUILD)/set.o: $(CODE)/basevec.h $(CODE)/basevec.cc $(BUILD)/set.o: $(CODE)/mathvec.h $(CODE)/mathvec.cc $(BUILD)/set.o: $(CODE)/expr.h $(BUILD)/set.o: $(CODE)/input.h $(BUILD)/set.o: $(CODE)/color.h $(BUILD)/set.o: $(CODE)/intersection.h $(BUILD)/set.o: $(CODE)/object.h $(BUILD)/set.o: $(CODE)/set.h $(BUILD)/inter.o: $(CODE)/basevec.h $(CODE)/basevec.cc $(BUILD)/inter.o: $(CODE)/mathvec.h $(CODE)/mathvec.cc $(BUILD)/inter.o: $(CODE)/expr.h $(BUILD)/inter.o: $(CODE)/input.h $(BUILD)/inter.o: $(CODE)/color.h $(BUILD)/inter.o: $(CODE)/intersection.h $(BUILD)/inter.o: $(CODE)/object.h $(BUILD)/inter.o: $(CODE)/inter.h $(BUILD)/universe.o: $(CODE)/basevec.h $(CODE)/basevec.cc $(BUILD)/universe.o: $(CODE)/mathvec.h $(CODE)/mathvec.cc $(BUILD)/universe.o: $(CODE)/expr.h $(BUILD)/universe.o: $(CODE)/input.h $(BUILD)/universe.o: $(CODE)/color.h $(BUILD)/universe.o: $(CODE)/intersection.h $(BUILD)/universe.o: $(CODE)/object.h $(BUILD)/universe.o: $(CODE)/light.h $(BUILD)/universe.o: $(CODE)/nkthread.h $(BUILD)/universe.o: $(CODE)/universe.h $(BUILD)/portal.o: $(CODE)/basevec.h $(CODE)/basevec.cc $(BUILD)/portal.o: $(CODE)/mathvec.h $(CODE)/mathvec.cc $(BUILD)/portal.o: $(CODE)/expr.h $(BUILD)/portal.o: $(CODE)/input.h $(BUILD)/portal.o: $(CODE)/color.h $(BUILD)/portal.o: $(CODE)/intersection.h $(BUILD)/portal.o: $(CODE)/object.h $(BUILD)/portal.o: $(CODE)/light.h $(BUILD)/portal.o: $(CODE)/nkthread.h $(BUILD)/portal.o: $(CODE)/universe.h $(BUILD)/portal.o: $(CODE)/portal.h $(BUILD)/portal.o: $(CODE)/scene.h $(BUILD)/scene.o: $(CODE)/basevec.h $(CODE)/basevec.cc $(BUILD)/scene.o: $(CODE)/mathvec.h $(CODE)/mathvec.cc $(BUILD)/scene.o: $(CODE)/expr.h $(BUILD)/scene.o: $(CODE)/input.h $(BUILD)/scene.o: $(CODE)/color.h $(BUILD)/scene.o: $(CODE)/intersection.h $(BUILD)/scene.o: $(CODE)/object.h $(BUILD)/scene.o: $(CODE)/light.h $(BUILD)/scene.o: $(CODE)/universe.h $(BUILD)/scene.o: $(CODE)/view.h $(BUILD)/scene.o: $(CODE)/image.h $(BUILD)/scene.o: $(CODE)/scene.h $(BUILD)/main.o: $(CODE)/basevec.h $(CODE)/basevec.cc $(BUILD)/main.o: $(CODE)/mathvec.h $(CODE)/mathvec.cc $(BUILD)/main.o: $(CODE)/expr.h $(BUILD)/main.o: $(CODE)/input.h $(BUILD)/main.o: $(CODE)/color.h $(BUILD)/main.o: $(CODE)/intersection.h $(BUILD)/main.o: $(CODE)/object.h $(BUILD)/main.o: $(CODE)/light.h $(BUILD)/main.o: $(CODE)/nkthread.h $(BUILD)/main.o: $(CODE)/universe.h $(BUILD)/main.o: $(CODE)/view.h $(BUILD)/main.o: $(CODE)/image.h $(BUILD)/main.o: $(CODE)/scene.h ifdef HAS_NOWEB $(CODE)/input.h: nws/input.nw $(CODE)/input.cc: nws/input.nw $(CODE)/basevec.h: nws/basevec.nw $(CODE)/basevec.cc: nws/basevec.nw $(CODE)/mathvec.h: nws/basevec.nw $(CODE)/mathvec.h: nws/mathvec.nw $(CODE)/mathvec.cc: nws/basevec.nw $(CODE)/mathvec.cc: nws/mathvec.nw $(CODE)/expr.h: nws/expr.nw $(CODE)/expr.h: nws/expr-binary.nw $(CODE)/expr.h: nws/expr-unary.nw $(CODE)/expr.h: nws/expr-const.nw $(CODE)/expr.h: nws/expr-pos.nw $(CODE)/expr.h: nws/expr-dir.nw $(CODE)/expr.h: nws/expr-norm.nw $(CODE)/expr.h: nws/expr-ref.nw $(CODE)/expr.cc: nws/expr.nw $(CODE)/expr.cc: nws/expr-binary.nw $(CODE)/expr.cc: nws/expr-unary.nw $(CODE)/expr.cc: nws/expr-const.nw $(CODE)/expr.cc: nws/expr-pos.nw $(CODE)/expr.cc: nws/expr-dir.nw $(CODE)/expr.cc: nws/expr-norm.nw $(CODE)/expr.cc: nws/expr-ref.nw $(CODE)/color.h: nws/color.nw $(CODE)/color.cc: nws/color.nw $(CODE)/image.h: nws/image.nw $(CODE)/image.h: nws/image-accum.nw $(CODE)/image.h: nws/image-ppm.nw $(CODE)/image.h: nws/image-png.nw $(CODE)/image.cc: nws/image.nw $(CODE)/image.cc: nws/image-accum.nw $(CODE)/image.cc: nws/image-ppm.nw $(CODE)/image.cc: nws/image-png.nw $(CODE)/light.h: nws/light.nw $(CODE)/light.cc: nws/light.nw $(CODE)/intersection.h: nws/intersection.nw $(CODE)/intersection.cc: nws/intersection.nw $(CODE)/object.h: nws/object.nw $(CODE)/object.cc: nws/object.nw $(CODE)/object.cc: nws/coxeter.nw $(CODE)/object.cc: nws/convex.nw $(CODE)/object.cc: nws/halfspace.nw $(CODE)/object.cc: nws/quadratic.nw $(CODE)/object.cc: nws/complement.nw $(CODE)/object.cc: nws/extrusion.nw $(CODE)/object.cc: nws/csg-union.nw $(CODE)/object.cc: nws/csg-set.nw $(CODE)/object.cc: nws/csg-inter.nw $(CODE)/object.cc: nws/cylinder.nw $(CODE)/coxeter.h: nws/coxeter.nw $(CODE)/coxeter.cc: nws/coxeter.nw $(CODE)/coxeter.cc: nws/convex.nw $(CODE)/convex.h: nws/convex.nw $(CODE)/convex.cc: nws/convex.nw $(CODE)/halfspace.h: nws/halfspace.nw $(CODE)/halfspace.cc: nws/halfspace.nw $(CODE)/cylinder.h: nws/cylinder.nw $(CODE)/cylinder.cc: nws/cylinder.nw $(CODE)/quadratic.h: nws/quadratic.nw $(CODE)/quadratic.cc: nws/quadratic.nw $(CODE)/complement.h: nws/complement.nw $(CODE)/complement.cc: nws/complement.nw $(CODE)/extrusion.h: nws/extrusion.nw $(CODE)/extrusion.cc: nws/extrusion.nw $(CODE)/union.h: nws/csg-union.nw $(CODE)/union.cc: nws/csg-union.nw $(CODE)/set.h: nws/csg-set.nw $(CODE)/set.cc: nws/csg-set.nw $(CODE)/inter.h: nws/csg-inter.nw $(CODE)/inter.cc: nws/csg-inter.nw $(CODE)/nkthread.h: nws/nkthread.nw $(CODE)/nkthread.h: nws/thread-work.nw $(CODE)/nkthread.h: nws/thread-worker.nw $(CODE)/nkthread.cc: nws/nkthread.nw $(CODE)/nkthread.cc: nws/thread-work.nw $(CODE)/nkthread.cc: nws/thread-worker.nw $(CODE)/universe.h: nws/universe.nw $(CODE)/universe.cc: nws/universe.nw $(CODE)/universe.cc: nws/universe-inter.nw $(CODE)/universe.cc: nws/universe-refl.nw $(CODE)/universe.cc: nws/universe-refr.nw $(CODE)/universe.cc: nws/universe-shad.nw $(CODE)/portal.h: nws/portal.nw $(CODE)/portal.cc: nws/portal.nw $(CODE)/scene.h: nws/scene.nw $(CODE)/scene.cc: nws/scene.nw $(CODE)/view.h: nws/view.nw $(CODE)/view.cc: nws/view.nw $(CODE)/main.cc: nws/main.nw endif ######################################### .PHONY: all .PHONY: clean .PHONY: doc .PHONY: images .PHONY: install .PHONY: tidy .SECONDARY: $(OBJS) .SECONDARY: $(SRCS) .SECONDARY: $(HDRS) ./rt2.7.2007.05.17/img/0040755000077300007650000000000010640535342012054 5ustar patpat./rt2.7.2007.05.17/img/Expr_Class_Hierarchy.graffle0100644000077300007650000010176310031151223017434 0ustar patpat CanvasColor w 1 ColumnAlign 1 ColumnSpacing 36 GraphDocumentVersion 3 GraphicsList Class LineGraphic Head ID 13 ID 29 Labels Label Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica-Bold;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\b\fs24 \cf0 1} LabelVisible YES Offset 9.5238113403320312 Position 0.9523809552192688 Points {144, 72.75} {279, 72} {279, 162} Style stroke HeadArrow 0 TailArrow 0 Tail ID 15 Class LineGraphic Head ID 13 ID 28 Labels Label Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica-Bold;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\b\fs24 \cf0 2} LabelVisible YES Offset 10.793652534484863 Position 0.9365079402923584 Points {144, 306.75} {279, 306} {279, 216} Style stroke HeadArrow 0 TailArrow 0 Tail ID 16 Class LineGraphic Head ID 13 ID 27 Points {415.552, 101} {320.897, 162} Style stroke HeadArrow UMLInheritance LineType 1 TailArrow 0 Tail ID 20 Class LineGraphic Head ID 13 ID 26 Points {414, 160.5} {324, 179.5} Style stroke HeadArrow UMLInheritance LineType 1 TailArrow 0 Tail ID 19 Class LineGraphic Head ID 13 ID 25 Points {414, 219} {324, 199} Style stroke HeadArrow UMLInheritance LineType 1 TailArrow 0 Tail ID 18 Class LineGraphic Head ID 13 ID 24 Points {416.288, 279} {320.186, 216} Style stroke HeadArrow UMLInheritance LineType 1 TailArrow 0 Tail ID 17 Class LineGraphic Head ID 13 ID 23 Points {144, 189.75} {234, 189.25} Style stroke HeadArrow UMLInheritance LineType 1 TailArrow 0 Tail ID 14 Class LineGraphic Head ID 13 ID 22 Points {141.712, 279} {237.814, 216} Style stroke HeadArrow UMLInheritance LineType 1 TailArrow 0 Tail ID 16 Class LineGraphic Head ID 13 ID 21 Points {142.448, 101} {237.103, 162} Style stroke HeadArrow UMLInheritance LineType 1 TailArrow 0 Tail ID 15 Bounds {{414, 45}, {90, 56}} Class MultiTextGraphic FitText Vertical ID 20 ListOrientation Vertical Style fill GradientAngle 304 GradientCenter {-0.294118, -0.264706} TextList Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica-Bold;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\qc \f0\b\fs24 \cf0 ExprRef} Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\fs24 \cf0 index} Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\fs24 \cf0 evaluate()\ isConst()} TextPlacement 0 Bounds {{414, 123}, {90, 56}} Class MultiTextGraphic FitText Vertical ID 19 ListOrientation Vertical Style fill GradientAngle 304 GradientCenter {-0.294118, -0.264706} TextList Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica-Bold;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\qc \f0\b\fs24 \cf0 ExprNorm} Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\fs24 \cf0 index} Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\fs24 \cf0 evaluate()\ isConst()} TextPlacement 0 Bounds {{414, 201}, {90, 56}} Class MultiTextGraphic FitText Vertical ID 18 ListOrientation Vertical Style fill GradientAngle 304 GradientCenter {-0.294118, -0.264706} TextList Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica-Bold;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\qc \f0\b\fs24 \cf0 ExprDir} Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\fs24 \cf0 index} Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\fs24 \cf0 evaluate()\ isConst()} TextPlacement 0 Bounds {{414, 279}, {90, 56}} Class MultiTextGraphic FitText Vertical ID 17 ListOrientation Vertical Style fill GradientAngle 304 GradientCenter {-0.294118, -0.264706} TextList Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica-Bold;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\qc \f0\b\fs24 \cf0 ExprPos} Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\fs24 \cf0 index} Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\fs24 \cf0 evaluate()\ isConst()} TextPlacement 0 Bounds {{54, 279}, {90, 56}} Class MultiTextGraphic FitText Vertical ID 16 ListOrientation Vertical Style fill GradientAngle 304 GradientCenter {-0.294118, -0.264706} TextList Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica-Bold;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\qc \f0\b\fs24 \cf0 ExprBinary} Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\fs24 \cf0 func} Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\fs24 \cf0 evaluate()\ isConst()} TextPlacement 0 Bounds {{54, 45}, {90, 56}} Class MultiTextGraphic FitText Vertical ID 15 ListOrientation Vertical Style fill GradientAngle 304 GradientCenter {-0.294118, -0.264706} TextList Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica-Bold;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\qc \f0\b\fs24 \cf0 ExprUnary} Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\fs24 \cf0 func} Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\fs24 \cf0 evaluate()\ isConst()} TextPlacement 0 Bounds {{54, 162}, {90, 56}} Class MultiTextGraphic FitText Vertical ID 14 ListOrientation Vertical Style fill GradientAngle 304 GradientCenter {-0.294118, -0.264706} TextList Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica-Bold;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\qc \f0\b\fs24 \cf0 ExprConst} Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\fs24 \cf0 value} Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\fs24 \cf0 evaluate()\ isConst()} TextPlacement 0 Bounds {{234, 162}, {90, 54}} Class MultiTextGraphic FitText Vertical ID 13 ListOrientation Vertical Style fill GradientAngle 304 GradientCenter {-0.294118, -0.264706} TextList Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica-Bold;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\qc \f0\b\fs24 \cf0 Expr} Align 0 Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\fs24 \cf0 evaluate()\ isConst()} TextPlacement 0 GridInfo ShowsGrid YES SnapsToGrid YES GuidesVisible YES HPages 1 ImageCounter 1 IsPalette NO Layers Lock NO Name Layer 1 Print YES View YES LayoutInfo AutoAdjust YES ChildOrdering 2 MagneticFieldCenter {0, 0} LinksVisible NO MagnetsVisible NO Orientation 2 PageBreaks YES PageSetup BAt0eXBlZHN0cmVhbYED6IQBQISEhAtOU1ByaW50SW5mbwGEhAhOU09iamVjdACFkoSE hBNOU011dGFibGVEaWN0aW9uYXJ5AISEDE5TRGljdGlvbmFyeQCUhAFpFJKEhIQITlNT dHJpbmcBlIQBKxBOU0pvYkRpc3Bvc2l0aW9uhpKEmZkPTlNQcmludFNwb29sSm9ihpKE mZkOTlNCb3R0b21NYXJnaW6GkoSEhAhOU051bWJlcgCEhAdOU1ZhbHVlAJSEASqEhAFm nQCGkoSZmQhOU0NvcGllc4aShJ2chJeXAYaShJmZD05TUHJpbnRBbGxQYWdlc4aShJ2c opcAhpKEmZkNTlNSaWdodE1hcmdpboaShJ2cn50AhpKEmZkUTlNWZXJ0aWNhbGx5Q2Vu dGVyZWSGkoSdnKKXAYaShJmZCU5TUHJpbnRlcoaShISECU5TUHJpbnRlcgCUkoSZmQ9I UCBMYXNlckpldCBJSUmGhpKEmZkLTlNQYXBlck5hbWWGkoSZmQZMZXR0ZXKGkoSZmQtO U0ZpcnN0UGFnZYaShJ2copcBhpKEmZkUTlNWZXJ0aWNhbFBhZ2luYXRpb26GkoSdnKKX AIaShJmZD05TU2NhbGluZ0ZhY3RvcoaShJ2cn50BhpKEmZkWTlNIb3Jpem9udGFsbHlD ZW50ZXJlZIaSqJKEmZkMTlNMZWZ0TWFyZ2luhpKEnZyfnQCGkoSZmQ5OU1BNUGFnZUZv cm1hdIaShISEBk5TRGF0YQCUl4EdrYQHWzc1OTdjXTw/eG1sIHZlcnNpb249IjEuMCIg ZW5jb2Rpbmc9IlVURi04Ij8+CjwhRE9DVFlQRSBwbGlzdCBQVUJMSUMgIi0vL0FwcGxl IENvbXB1dGVyLy9EVEQgUExJU1QgMS4wLy9FTiIgImh0dHA6Ly93d3cuYXBwbGUuY29t L0RURHMvUHJvcGVydHlMaXN0LTEuMC5kdGQiPgo8cGxpc3QgdmVyc2lvbj0iMS4wIj4K PGRpY3Q+Cgk8a2V5PmNvbS5hcHBsZS5wcmludC5QYWdlRm9ybWF0LlBNSG9yaXpvbnRh bFJlczwva2V5PgoJPGRpY3Q+CgkJPGtleT5jb20uYXBwbGUucHJpbnQudGlja2V0LmNy ZWF0b3I8L2tleT4KCQk8c3RyaW5nPmNvbS5hcHBsZS5wcmludGluZ21hbmFnZXI8L3N0 cmluZz4KCQk8a2V5PmNvbS5hcHBsZS5wcmludC50aWNrZXQuaXRlbUFycmF5PC9rZXk+ CgkJPGFycmF5PgoJCQk8ZGljdD4KCQkJCTxrZXk+Y29tLmFwcGxlLnByaW50LlBhZ2VG b3JtYXQuUE1Ib3Jpem9udGFsUmVzPC9rZXk+CgkJCQk8cmVhbD43MjwvcmVhbD4KCQkJ CTxrZXk+Y29tLmFwcGxlLnByaW50LnRpY2tldC5jbGllbnQ8L2tleT4KCQkJCTxzdHJp bmc+Y29tLmFwcGxlLnByaW50aW5nbWFuYWdlcjwvc3RyaW5nPgoJCQkJPGtleT5jb20u YXBwbGUucHJpbnQudGlja2V0Lm1vZERhdGU8L2tleT4KCQkJCTxkYXRlPjIwMDMtMDEt MjRUMTY6Mjg6NTRaPC9kYXRlPgoJCQkJPGtleT5jb20uYXBwbGUucHJpbnQudGlja2V0 LnN0YXRlRmxhZzwva2V5PgoJCQkJPGludGVnZXI+MDwvaW50ZWdlcj4KCQkJPC9kaWN0 PgoJCTwvYXJyYXk+Cgk8L2RpY3Q+Cgk8a2V5PmNvbS5hcHBsZS5wcmludC5QYWdlRm9y bWF0LlBNT3JpZW50YXRpb248L2tleT4KCTxkaWN0PgoJCTxrZXk+Y29tLmFwcGxlLnBy aW50LnRpY2tldC5jcmVhdG9yPC9rZXk+CgkJPHN0cmluZz5jb20uYXBwbGUucHJpbnRp bmdtYW5hZ2VyPC9zdHJpbmc+CgkJPGtleT5jb20uYXBwbGUucHJpbnQudGlja2V0Lml0 ZW1BcnJheTwva2V5PgoJCTxhcnJheT4KCQkJPGRpY3Q+CgkJCQk8a2V5PmNvbS5hcHBs ZS5wcmludC5QYWdlRm9ybWF0LlBNT3JpZW50YXRpb248L2tleT4KCQkJCTxpbnRlZ2Vy PjE8L2ludGVnZXI+CgkJCQk8a2V5PmNvbS5hcHBsZS5wcmludC50aWNrZXQuY2xpZW50 PC9rZXk+CgkJCQk8c3RyaW5nPmNvbS5hcHBsZS5wcmludGluZ21hbmFnZXI8L3N0cmlu Zz4KCQkJCTxrZXk+Y29tLmFwcGxlLnByaW50LnRpY2tldC5tb2REYXRlPC9rZXk+CgkJ CQk8ZGF0ZT4yMDAzLTAxLTI0VDE2OjI4OjU0WjwvZGF0ZT4KCQkJCTxrZXk+Y29tLmFw cGxlLnByaW50LnRpY2tldC5zdGF0ZUZsYWc8L2tleT4KCQkJCTxpbnRlZ2VyPjA8L2lu dGVnZXI+CgkJCTwvZGljdD4KCQk8L2FycmF5PgoJPC9kaWN0PgoJPGtleT5jb20uYXBw bGUucHJpbnQuUGFnZUZvcm1hdC5QTVNjYWxpbmc8L2tleT4KCTxkaWN0PgoJCTxrZXk+ Y29tLmFwcGxlLnByaW50LnRpY2tldC5jcmVhdG9yPC9rZXk+CgkJPHN0cmluZz5jb20u YXBwbGUucHJpbnRpbmdtYW5hZ2VyPC9zdHJpbmc+CgkJPGtleT5jb20uYXBwbGUucHJp bnQudGlja2V0Lml0ZW1BcnJheTwva2V5PgoJCTxhcnJheT4KCQkJPGRpY3Q+CgkJCQk8 a2V5PmNvbS5hcHBsZS5wcmludC5QYWdlRm9ybWF0LlBNU2NhbGluZzwva2V5PgoJCQkJ PHJlYWw+MTwvcmVhbD4KCQkJCTxrZXk+Y29tLmFwcGxlLnByaW50LnRpY2tldC5jbGll bnQ8L2tleT4KCQkJCTxzdHJpbmc+Y29tLmFwcGxlLnByaW50aW5nbWFuYWdlcjwvc3Ry aW5nPgoJCQkJPGtleT5jb20uYXBwbGUucHJpbnQudGlja2V0Lm1vZERhdGU8L2tleT4K CQkJCTxkYXRlPjIwMDMtMDEtMjRUMTY6Mjg6NTRaPC9kYXRlPgoJCQkJPGtleT5jb20u YXBwbGUucHJpbnQudGlja2V0LnN0YXRlRmxhZzwva2V5PgoJCQkJPGludGVnZXI+MDwv aW50ZWdlcj4KCQkJPC9kaWN0PgoJCTwvYXJyYXk+Cgk8L2RpY3Q+Cgk8a2V5PmNvbS5h cHBsZS5wcmludC5QYWdlRm9ybWF0LlBNVmVydGljYWxSZXM8L2tleT4KCTxkaWN0PgoJ CTxrZXk+Y29tLmFwcGxlLnByaW50LnRpY2tldC5jcmVhdG9yPC9rZXk+CgkJPHN0cmlu Zz5jb20uYXBwbGUucHJpbnRpbmdtYW5hZ2VyPC9zdHJpbmc+CgkJPGtleT5jb20uYXBw bGUucHJpbnQudGlja2V0Lml0ZW1BcnJheTwva2V5PgoJCTxhcnJheT4KCQkJPGRpY3Q+ CgkJCQk8a2V5PmNvbS5hcHBsZS5wcmludC5QYWdlRm9ybWF0LlBNVmVydGljYWxSZXM8 L2tleT4KCQkJCTxyZWFsPjcyPC9yZWFsPgoJCQkJPGtleT5jb20uYXBwbGUucHJpbnQu dGlja2V0LmNsaWVudDwva2V5PgoJCQkJPHN0cmluZz5jb20uYXBwbGUucHJpbnRpbmdt YW5hZ2VyPC9zdHJpbmc+CgkJCQk8a2V5PmNvbS5hcHBsZS5wcmludC50aWNrZXQubW9k RGF0ZTwva2V5PgoJCQkJPGRhdGU+MjAwMy0wMS0yNFQxNjoyODo1NFo8L2RhdGU+CgkJ CQk8a2V5PmNvbS5hcHBsZS5wcmludC50aWNrZXQuc3RhdGVGbGFnPC9rZXk+CgkJCQk8 aW50ZWdlcj4wPC9pbnRlZ2VyPgoJCQk8L2RpY3Q+CgkJPC9hcnJheT4KCTwvZGljdD4K CTxrZXk+Y29tLmFwcGxlLnByaW50LlBhZ2VGb3JtYXQuUE1WZXJ0aWNhbFNjYWxpbmc8 L2tleT4KCTxkaWN0PgoJCTxrZXk+Y29tLmFwcGxlLnByaW50LnRpY2tldC5jcmVhdG9y PC9rZXk+CgkJPHN0cmluZz5jb20uYXBwbGUucHJpbnRpbmdtYW5hZ2VyPC9zdHJpbmc+ CgkJPGtleT5jb20uYXBwbGUucHJpbnQudGlja2V0Lml0ZW1BcnJheTwva2V5PgoJCTxh cnJheT4KCQkJPGRpY3Q+CgkJCQk8a2V5PmNvbS5hcHBsZS5wcmludC5QYWdlRm9ybWF0 LlBNVmVydGljYWxTY2FsaW5nPC9rZXk+CgkJCQk8cmVhbD4xPC9yZWFsPgoJCQkJPGtl eT5jb20uYXBwbGUucHJpbnQudGlja2V0LmNsaWVudDwva2V5PgoJCQkJPHN0cmluZz5j b20uYXBwbGUucHJpbnRpbmdtYW5hZ2VyPC9zdHJpbmc+CgkJCQk8a2V5PmNvbS5hcHBs ZS5wcmludC50aWNrZXQubW9kRGF0ZTwva2V5PgoJCQkJPGRhdGU+MjAwMy0wMS0yNFQx NjoyODo1NFo8L2RhdGU+CgkJCQk8a2V5PmNvbS5hcHBsZS5wcmludC50aWNrZXQuc3Rh dGVGbGFnPC9rZXk+CgkJCQk8aW50ZWdlcj4wPC9pbnRlZ2VyPgoJCQk8L2RpY3Q+CgkJ PC9hcnJheT4KCTwvZGljdD4KCTxrZXk+Y29tLmFwcGxlLnByaW50LnN1YlRpY2tldC5w YXBlcl9pbmZvX3RpY2tldDwva2V5PgoJPGRpY3Q+CgkJPGtleT5jb20uYXBwbGUucHJp bnQuUGFnZUZvcm1hdC5QTUFkanVzdGVkUGFnZVJlY3Q8L2tleT4KCQk8ZGljdD4KCQkJ PGtleT5jb20uYXBwbGUucHJpbnQudGlja2V0LmNyZWF0b3I8L2tleT4KCQkJPHN0cmlu Zz5jb20uYXBwbGUucHJpbnRpbmdtYW5hZ2VyPC9zdHJpbmc+CgkJCTxrZXk+Y29tLmFw cGxlLnByaW50LnRpY2tldC5pdGVtQXJyYXk8L2tleT4KCQkJPGFycmF5PgoJCQkJPGRp Y3Q+CgkJCQkJPGtleT5jb20uYXBwbGUucHJpbnQuUGFnZUZvcm1hdC5QTUFkanVzdGVk UGFnZVJlY3Q8L2tleT4KCQkJCQk8YXJyYXk+CgkJCQkJCTxyZWFsPjAuMDwvcmVhbD4K CQkJCQkJPHJlYWw+MC4wPC9yZWFsPgoJCQkJCQk8cmVhbD43MzQ8L3JlYWw+CgkJCQkJ CTxyZWFsPjU3NjwvcmVhbD4KCQkJCQk8L2FycmF5PgoJCQkJCTxrZXk+Y29tLmFwcGxl LnByaW50LnRpY2tldC5jbGllbnQ8L2tleT4KCQkJCQk8c3RyaW5nPmNvbS5hcHBsZS5w cmludGluZ21hbmFnZXI8L3N0cmluZz4KCQkJCQk8a2V5PmNvbS5hcHBsZS5wcmludC50 aWNrZXQubW9kRGF0ZTwva2V5PgoJCQkJCTxkYXRlPjIwMDMtMTAtMjJUMjA6MTE6NTBa PC9kYXRlPgoJCQkJCTxrZXk+Y29tLmFwcGxlLnByaW50LnRpY2tldC5zdGF0ZUZsYWc8 L2tleT4KCQkJCQk8aW50ZWdlcj4wPC9pbnRlZ2VyPgoJCQkJPC9kaWN0PgoJCQk8L2Fy cmF5PgoJCTwvZGljdD4KCQk8a2V5PmNvbS5hcHBsZS5wcmludC5QYWdlRm9ybWF0LlBN QWRqdXN0ZWRQYXBlclJlY3Q8L2tleT4KCQk8ZGljdD4KCQkJPGtleT5jb20uYXBwbGUu cHJpbnQudGlja2V0LmNyZWF0b3I8L2tleT4KCQkJPHN0cmluZz5jb20uYXBwbGUucHJp bnRpbmdtYW5hZ2VyPC9zdHJpbmc+CgkJCTxrZXk+Y29tLmFwcGxlLnByaW50LnRpY2tl dC5pdGVtQXJyYXk8L2tleT4KCQkJPGFycmF5PgoJCQkJPGRpY3Q+CgkJCQkJPGtleT5j b20uYXBwbGUucHJpbnQuUGFnZUZvcm1hdC5QTUFkanVzdGVkUGFwZXJSZWN0PC9rZXk+ CgkJCQkJPGFycmF5PgoJCQkJCQk8cmVhbD4tMTg8L3JlYWw+CgkJCQkJCTxyZWFsPi0x ODwvcmVhbD4KCQkJCQkJPHJlYWw+Nzc0PC9yZWFsPgoJCQkJCQk8cmVhbD41OTQ8L3Jl YWw+CgkJCQkJPC9hcnJheT4KCQkJCQk8a2V5PmNvbS5hcHBsZS5wcmludC50aWNrZXQu Y2xpZW50PC9rZXk+CgkJCQkJPHN0cmluZz5jb20uYXBwbGUucHJpbnRpbmdtYW5hZ2Vy PC9zdHJpbmc+CgkJCQkJPGtleT5jb20uYXBwbGUucHJpbnQudGlja2V0Lm1vZERhdGU8 L2tleT4KCQkJCQk8ZGF0ZT4yMDAzLTEwLTIyVDIwOjExOjUwWjwvZGF0ZT4KCQkJCQk8 a2V5PmNvbS5hcHBsZS5wcmludC50aWNrZXQuc3RhdGVGbGFnPC9rZXk+CgkJCQkJPGlu dGVnZXI+MDwvaW50ZWdlcj4KCQkJCTwvZGljdD4KCQkJPC9hcnJheT4KCQk8L2RpY3Q+ CgkJPGtleT5jb20uYXBwbGUucHJpbnQuUGFwZXJJbmZvLlBNUGFwZXJOYW1lPC9rZXk+ CgkJPGRpY3Q+CgkJCTxrZXk+Y29tLmFwcGxlLnByaW50LnRpY2tldC5jcmVhdG9yPC9r ZXk+CgkJCTxzdHJpbmc+Y29tLmFwcGxlLnByaW50LnBtLlBvc3RTY3JpcHQ8L3N0cmlu Zz4KCQkJPGtleT5jb20uYXBwbGUucHJpbnQudGlja2V0Lml0ZW1BcnJheTwva2V5PgoJ CQk8YXJyYXk+CgkJCQk8ZGljdD4KCQkJCQk8a2V5PmNvbS5hcHBsZS5wcmludC5QYXBl ckluZm8uUE1QYXBlck5hbWU8L2tleT4KCQkJCQk8c3RyaW5nPm5hLWxldHRlcjwvc3Ry aW5nPgoJCQkJCTxrZXk+Y29tLmFwcGxlLnByaW50LnRpY2tldC5jbGllbnQ8L2tleT4K CQkJCQk8c3RyaW5nPmNvbS5hcHBsZS5wcmludC5wbS5Qb3N0U2NyaXB0PC9zdHJpbmc+ CgkJCQkJPGtleT5jb20uYXBwbGUucHJpbnQudGlja2V0Lm1vZERhdGU8L2tleT4KCQkJ CQk8ZGF0ZT4yMDAwLTA3LTI4VDIyOjU3OjA0WjwvZGF0ZT4KCQkJCQk8a2V5PmNvbS5h cHBsZS5wcmludC50aWNrZXQuc3RhdGVGbGFnPC9rZXk+CgkJCQkJPGludGVnZXI+MTwv aW50ZWdlcj4KCQkJCTwvZGljdD4KCQkJPC9hcnJheT4KCQk8L2RpY3Q+CgkJPGtleT5j b20uYXBwbGUucHJpbnQuUGFwZXJJbmZvLlBNVW5hZGp1c3RlZFBhZ2VSZWN0PC9rZXk+ CgkJPGRpY3Q+CgkJCTxrZXk+Y29tLmFwcGxlLnByaW50LnRpY2tldC5jcmVhdG9yPC9r ZXk+CgkJCTxzdHJpbmc+Y29tLmFwcGxlLnByaW50LnBtLlBvc3RTY3JpcHQ8L3N0cmlu Zz4KCQkJPGtleT5jb20uYXBwbGUucHJpbnQudGlja2V0Lml0ZW1BcnJheTwva2V5PgoJ CQk8YXJyYXk+CgkJCQk8ZGljdD4KCQkJCQk8a2V5PmNvbS5hcHBsZS5wcmludC5QYXBl ckluZm8uUE1VbmFkanVzdGVkUGFnZVJlY3Q8L2tleT4KCQkJCQk8YXJyYXk+CgkJCQkJ CTxyZWFsPjAuMDwvcmVhbD4KCQkJCQkJPHJlYWw+MC4wPC9yZWFsPgoJCQkJCQk8cmVh bD43MzQ8L3JlYWw+CgkJCQkJCTxyZWFsPjU3NjwvcmVhbD4KCQkJCQk8L2FycmF5PgoJ CQkJCTxrZXk+Y29tLmFwcGxlLnByaW50LnRpY2tldC5jbGllbnQ8L2tleT4KCQkJCQk8 c3RyaW5nPmNvbS5hcHBsZS5wcmludGluZ21hbmFnZXI8L3N0cmluZz4KCQkJCQk8a2V5 PmNvbS5hcHBsZS5wcmludC50aWNrZXQubW9kRGF0ZTwva2V5PgoJCQkJCTxkYXRlPjIw MDMtMDEtMjRUMTY6Mjg6NTRaPC9kYXRlPgoJCQkJCTxrZXk+Y29tLmFwcGxlLnByaW50 LnRpY2tldC5zdGF0ZUZsYWc8L2tleT4KCQkJCQk8aW50ZWdlcj4wPC9pbnRlZ2VyPgoJ CQkJPC9kaWN0PgoJCQk8L2FycmF5PgoJCTwvZGljdD4KCQk8a2V5PmNvbS5hcHBsZS5w cmludC5QYXBlckluZm8uUE1VbmFkanVzdGVkUGFwZXJSZWN0PC9rZXk+CgkJPGRpY3Q+ CgkJCTxrZXk+Y29tLmFwcGxlLnByaW50LnRpY2tldC5jcmVhdG9yPC9rZXk+CgkJCTxz dHJpbmc+Y29tLmFwcGxlLnByaW50LnBtLlBvc3RTY3JpcHQ8L3N0cmluZz4KCQkJPGtl eT5jb20uYXBwbGUucHJpbnQudGlja2V0Lml0ZW1BcnJheTwva2V5PgoJCQk8YXJyYXk+ CgkJCQk8ZGljdD4KCQkJCQk8a2V5PmNvbS5hcHBsZS5wcmludC5QYXBlckluZm8uUE1V bmFkanVzdGVkUGFwZXJSZWN0PC9rZXk+CgkJCQkJPGFycmF5PgoJCQkJCQk8cmVhbD4t MTg8L3JlYWw+CgkJCQkJCTxyZWFsPi0xODwvcmVhbD4KCQkJCQkJPHJlYWw+Nzc0PC9y ZWFsPgoJCQkJCQk8cmVhbD41OTQ8L3JlYWw+CgkJCQkJPC9hcnJheT4KCQkJCQk8a2V5 PmNvbS5hcHBsZS5wcmludC50aWNrZXQuY2xpZW50PC9rZXk+CgkJCQkJPHN0cmluZz5j b20uYXBwbGUucHJpbnRpbmdtYW5hZ2VyPC9zdHJpbmc+CgkJCQkJPGtleT5jb20uYXBw bGUucHJpbnQudGlja2V0Lm1vZERhdGU8L2tleT4KCQkJCQk8ZGF0ZT4yMDAzLTAxLTI0 VDE2OjI4OjU0WjwvZGF0ZT4KCQkJCQk8a2V5PmNvbS5hcHBsZS5wcmludC50aWNrZXQu c3RhdGVGbGFnPC9rZXk+CgkJCQkJPGludGVnZXI+MDwvaW50ZWdlcj4KCQkJCTwvZGlj dD4KCQkJPC9hcnJheT4KCQk8L2RpY3Q+CgkJPGtleT5jb20uYXBwbGUucHJpbnQuUGFw ZXJJbmZvLnBwZC5QTVBhcGVyTmFtZTwva2V5PgoJCTxkaWN0PgoJCQk8a2V5PmNvbS5h cHBsZS5wcmludC50aWNrZXQuY3JlYXRvcjwva2V5PgoJCQk8c3RyaW5nPmNvbS5hcHBs ZS5wcmludC5wbS5Qb3N0U2NyaXB0PC9zdHJpbmc+CgkJCTxrZXk+Y29tLmFwcGxlLnBy aW50LnRpY2tldC5pdGVtQXJyYXk8L2tleT4KCQkJPGFycmF5PgoJCQkJPGRpY3Q+CgkJ CQkJPGtleT5jb20uYXBwbGUucHJpbnQuUGFwZXJJbmZvLnBwZC5QTVBhcGVyTmFtZTwv a2V5PgoJCQkJCTxzdHJpbmc+TGV0dGVyPC9zdHJpbmc+CgkJCQkJPGtleT5jb20uYXBw bGUucHJpbnQudGlja2V0LmNsaWVudDwva2V5PgoJCQkJCTxzdHJpbmc+Y29tLmFwcGxl LnByaW50LnBtLlBvc3RTY3JpcHQ8L3N0cmluZz4KCQkJCQk8a2V5PmNvbS5hcHBsZS5w cmludC50aWNrZXQubW9kRGF0ZTwva2V5PgoJCQkJCTxkYXRlPjIwMDAtMDctMjhUMjI6 NTc6MDRaPC9kYXRlPgoJCQkJCTxrZXk+Y29tLmFwcGxlLnByaW50LnRpY2tldC5zdGF0 ZUZsYWc8L2tleT4KCQkJCQk8aW50ZWdlcj4xPC9pbnRlZ2VyPgoJCQkJPC9kaWN0PgoJ CQk8L2FycmF5PgoJCTwvZGljdD4KCQk8a2V5PmNvbS5hcHBsZS5wcmludC50aWNrZXQu QVBJVmVyc2lvbjwva2V5PgoJCTxzdHJpbmc+MDAuMjA8L3N0cmluZz4KCQk8a2V5PmNv bS5hcHBsZS5wcmludC50aWNrZXQucHJpdmF0ZUxvY2s8L2tleT4KCQk8ZmFsc2UvPgoJ CTxrZXk+Y29tLmFwcGxlLnByaW50LnRpY2tldC50eXBlPC9rZXk+CgkJPHN0cmluZz5j b20uYXBwbGUucHJpbnQuUGFwZXJJbmZvVGlja2V0PC9zdHJpbmc+Cgk8L2RpY3Q+Cgk8 a2V5PmNvbS5hcHBsZS5wcmludC50aWNrZXQuQVBJVmVyc2lvbjwva2V5PgoJPHN0cmlu Zz4wMC4yMDwvc3RyaW5nPgoJPGtleT5jb20uYXBwbGUucHJpbnQudGlja2V0LnByaXZh dGVMb2NrPC9rZXk+Cgk8ZmFsc2UvPgoJPGtleT5jb20uYXBwbGUucHJpbnQudGlja2V0 LnR5cGU8L2tleT4KCTxzdHJpbmc+Y29tLmFwcGxlLnByaW50LlBhZ2VGb3JtYXRUaWNr ZXQ8L3N0cmluZz4KPC9kaWN0Pgo8L3BsaXN0PgqGkoSZmQ1OU09yaWVudGF0aW9uhpKE nZyilwCGkoSZmRlOU1ByaW50UmV2ZXJzZU9yaWVudGF0aW9uhpKkkoSZmQpOU0xhc3RQ YWdlhpKEnZyil4J/////hpKEmZkLTlNUb3BNYXJnaW6GkoSdnJ+dAIaShJmZC05TUGFw ZXJTaXplhpKEnpyEhAx7X05TU2l6ZT1mZn2hgQJkgQMYhpKEmZkVTlNIb3Jpem9uYWxQ YWdpbmF0aW9uhpKEnZyilwCGhoY= ReadOnly NO RowAlign 2 RowSpacing 36 SheetTitle Canvas 1 SmartAlignmentGuidesActive YES SmartDistanceGuidesActive YES UseEntirePage VPages 1 WindowInfo CurrentSheet 0 Frame {{114, 0}, {591, 746}} ShowRuler ShowStatusBar VisibleRegion {{0, 0}, {576, 648}} Zoom 1 ./rt2.7.2007.05.17/img/Scene_Class_Hierarchy.graffle0100644000077300007650000015660510031151223017560 0ustar patpat CanvasColor w 1 ColumnAlign 1 ColumnSpacing 36 GraphDocumentVersion 3 GraphicsList Class LineGraphic Head ID 4 ID 34 Labels Filled NO FixedWidth 12.600067138671875 Label Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\fs24 \cf0 *} LabelVisible YES Offset 6.9841289520263672 Position 0.1587301641702652 Points {396, 268.75} {450, 231.25} Style stroke HeadArrow 0 LineType 1 TailArrow 0 Tail ID 33 Bounds {{306, 258}, {90, 84}} Class MultiTextGraphic FitText Vertical ID 33 ListOrientation Vertical Style fill GradientAngle 304 GradientCenter {-0.294118, -0.264706} TextList Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica-Bold;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\qc \f0\b\fs24 \cf0 Portal} Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\fs24 \cf0 universe\ scale\ center\ orientation} Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\fs24 \cf0 evaluate()} TextPlacement 0 Class LineGraphic Head ID 31 ID 32 Labels Filled NO FixedWidth 12.600067138671875 Label Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\fs24 \cf0 *} LabelVisible YES Offset 6.9841289520263672 Position 0.1587301641702652 Points {450, 515.522} {333, 545.478} Style stroke HeadArrow 0 LineType 1 TailArrow 0 Tail ID 7 Bounds {{243, 523}, {90, 68}} Class MultiTextGraphic FitText Vertical ID 31 ListOrientation Vertical Style fill GradientAngle 304 GradientCenter {-0.294118, -0.264706} TextList Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica-Bold;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\qc \f0\b\fs24 \cf0 PPM} Align 0 Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\fs24 \cf0 addPixel()\ addClearPixl()\ setSize()} TextPlacement 0 Class LineGraphic Head ID 29 ID 30 Labels Filled NO FixedWidth 12.600067138671875 Label Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\fs24 \cf0 *} LabelVisible YES Offset 6.9841289520263672 Position 0.1587301641702652 Points {450, 551.083} {419.496, 583} Style stroke HeadArrow 0 LineType 1 TailArrow 0 Tail ID 7 Bounds {{342, 583}, {90, 68}} Class MultiTextGraphic FitText Vertical ID 29 ListOrientation Vertical Style fill GradientAngle 304 GradientCenter {-0.294118, -0.264706} TextList Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica-Bold;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\qc \f0\b\fs24 \cf0 PNG} Align 0 Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\fs24 \cf0 addPixel()\ addClearPixl()\ setSize()} TextPlacement 0 Class LineGraphic Head ID 26 ID 28 Labels Filled NO FixedWidth 12.600067138671875 Label Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\fs24 \cf0 *} LabelVisible YES Offset 6.9841289520263672 Position 0.1587301641702652 Points {450, 494.161} {261, 452.839} Style stroke HeadArrow 0 LineType 1 TailArrow 0 Tail ID 7 Class LineGraphic Head ID 26 ID 27 Labels Filled NO FixedWidth 12.600067138671875 Label Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\fs24 \cf0 *} LabelVisible YES Offset 6.9841289520263672 Position 0.1587301641702652 Points {216, 354} {216, 415} Style stroke HeadArrow 0 LineType 1 TailArrow 0 Tail ID 6 Bounds {{171, 415}, {90, 56}} Class MultiTextGraphic FitText Vertical ID 26 ListOrientation Vertical Style fill GradientAngle 304 GradientCenter {-0.294118, -0.264706} TextList Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica-Bold;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\qc \f0\b\fs24 \cf0 Scene} Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\fs24 \cf0 universeList\ imageList} Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\fs24 \cf0 render()} TextPlacement 0 Class LineGraphic Head ID 4 ID 25 Labels Filled NO FixedWidth 12.600067138671875 Label Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica-Bold;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\b\fs24 \cf0 c} LabelVisible YES Offset 6.9841289520263672 Position 0.1587301641702652 Points {495, 106} {495, 151} Style stroke HeadArrow 0 LineType 1 TailArrow 0 Tail ID 3 Class LineGraphic Head ID 6 ID 24 Labels Filled NO FixedWidth 12.600067138671875 Label Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\fs24 \cf0 *} LabelVisible YES Offset 6.9841289520263672 Position 0.1587301641702652 Points {216, 190} {216, 270} Style stroke HeadArrow 0 LineType 1 TailArrow 0 Tail ID 11 Class LineGraphic Head ID 6 ID 23 Labels Filled NO FixedWidth 12.600067138671875 Label Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\fs24 \cf0 *} LabelVisible YES Offset 6.9841289520263672 Position 0.1587301641702652 Points {318.322, 191} {251.517, 270} Style stroke HeadArrow 0 LineType 1 TailArrow 0 Tail ID 10 Class LineGraphic Head ID 11 ID 22 Points {144, 174.846} {171, 162.154} Style stroke HeadArrow UMLInheritance LineType 1 TailArrow 0 Tail ID 18 Class LineGraphic Head ID 11 ID 21 Points {144, 128.077} {171, 132.923} Style stroke HeadArrow UMLInheritance LineType 1 TailArrow 0 Tail ID 19 Class LineGraphic Head ID 11 ID 20 Points {132.773, 72} {171, 103.692} Style stroke HeadArrow UMLInheritance LineType 1 TailArrow 0 Tail ID 17 Bounds {{54, 92}, {90, 56}} Class MultiTextGraphic FitText Vertical ID 19 ListOrientation Vertical Style fill GradientAngle 304 GradientCenter {-0.294118, -0.264706} TextList Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica-Bold;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\qc \f0\b\fs24 \cf0 Complement} Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\fs24 \cf0 obj} Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\fs24 \cf0 evaluate()\ intersect()} TextPlacement 0 Bounds {{54, 168}, {90, 56}} Class MultiTextGraphic FitText Vertical ID 18 ListOrientation Vertical Style fill GradientAngle 304 GradientCenter {-0.294118, -0.264706} TextList Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica-Bold;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\qc \f0\b\fs24 \cf0 Union} Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\fs24 \cf0 objList} Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\fs24 \cf0 evaluate()\ intersect()} TextPlacement 0 Bounds {{54, 16}, {90, 56}} Class MultiTextGraphic FitText Vertical ID 17 ListOrientation Vertical Style fill GradientAngle 304 GradientCenter {-0.294118, -0.264706} TextList Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica-Bold;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\qc \f0\b\fs24 \cf0 Intersection} Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\fs24 \cf0 objList} Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\fs24 \cf0 evaluate()\ intersect()} TextPlacement 0 Class LineGraphic Head ID 11 ID 16 Points {288, 85.6154} {261, 106.385} Style stroke HeadArrow UMLInheritance LineType 1 TailArrow 0 Tail ID 15 Bounds {{288, 16}, {90, 70}} Class MultiTextGraphic FitText Vertical ID 15 ListOrientation Vertical Style fill GradientAngle 304 GradientCenter {-0.294118, -0.264706} TextList Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica-Bold;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\qc \f0\b\fs24 \cf0 QuadSurf} Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\fs24 \cf0 squareCoef\ linearCoef\ total} Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\fs24 \cf0 intersect()} TextPlacement 0 Class LineGraphic Head ID 11 ID 14 Points {216, 58} {216, 92} Style stroke HeadArrow UMLInheritance LineType 1 TailArrow 0 Tail ID 13 Bounds {{171, 16}, {90, 42}} Class MultiTextGraphic FitText Vertical ID 13 ListOrientation Vertical Style fill GradientAngle 304 GradientCenter {-0.294118, -0.264706} TextList Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica-Bold;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\qc \f0\b\fs24 \cf0 Cylinder} Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\fs24 \cf0 roundDims} Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\fs24 \cf0 intersect()} TextPlacement 0 Bounds {{54, 295}, {90, 68}} Class MultiTextGraphic FitText Vertical ID 12 ListOrientation Vertical Style fill GradientAngle 304 GradientCenter {-0.294118, -0.264706} TextList Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica-Bold;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\qc \f0\b\fs24 \cf0 Intersection} Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\fs24 \cf0 normal\ distance\ outside} Align 0 TextPlacement 0 Bounds {{171, 92}, {90, 98}} Class MultiTextGraphic FitText Vertical ID 11 ListOrientation Vertical Style fill GradientAngle 304 GradientCenter {-0.294118, -0.264706} TextList Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica-Bold;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\qc \f0\b\fs24 \cf0 Object} Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\fs24 \cf0 scale\ center\ orientation\ dimensions} Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\fs24 \cf0 evaluate()\ intersect()} TextPlacement 0 Bounds {{297, 135}, {90, 56}} Class MultiTextGraphic FitText Vertical ID 10 ListOrientation Vertical Style fill GradientAngle 304 GradientCenter {-0.294118, -0.264706} TextList Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica-Bold;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\qc \f0\b\fs24 \cf0 Light} Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\fs24 \cf0 center\ value} Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\fs24 \cf0 evaluate()} TextPlacement 0 Class LineGraphic Head ID 4 ID 9 Points {495, 304} {495, 249} Style stroke HeadArrow UMLInheritance LineType 1 TailArrow 0 Tail ID 5 Class LineGraphic Head ID 5 ID 8 Points {495, 448} {495, 402} Style stroke HeadArrow UMLInheritance LineType 1 TailArrow 0 Tail ID 7 Bounds {{450, 448}, {90, 112}} Class MultiTextGraphic FitText Vertical ID 7 ListOrientation Vertical Style fill GradientAngle 304 GradientCenter {-0.294118, -0.264706} TextList Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica-Bold;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\qc \f0\b\fs24 \cf0 Image} Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\fs24 \cf0 colorDims\ nameFormat\ outStream} Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\fs24 \cf0 addPixel()\ addClearPixl()\ setSize()\ prepareOut()} TextPlacement 0 Bounds {{171, 270}, {90, 84}} Class MultiTextGraphic FitText Vertical ID 6 ListOrientation Vertical Style fill GradientAngle 304 GradientCenter {-0.294118, -0.264706} TextList Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica-Bold;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\qc \f0\b\fs24 \cf0 Universe} Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\fs24 \cf0 name\ dimensions\ skyColor\ ambientLight} Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\fs24 \cf0 evaluate()} TextPlacement 0 Bounds {{450, 304}, {90, 98}} Class MultiTextGraphic FitText Vertical ID 5 ListOrientation Vertical Style fill GradientAngle 304 GradientCenter {-0.294118, -0.264706} TextList Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica-Bold;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\qc \f0\b\fs24 \cf0 View} Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\fs24 \cf0 wrapAround\ viewAngle\ gamma\ maxDepth\ permutation} Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\fs24 \cf0 evaluate()} TextPlacement 0 Bounds {{450, 151}, {90, 98}} Class MultiTextGraphic FitText Vertical ID 4 ListOrientation Vertical Style fill GradientAngle 304 GradientCenter {-0.294118, -0.264706} TextList Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica-Bold;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\qc \f0\b\fs24 \cf0 Color} Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\fs24 \cf0 diffuseness\ reflectivity\ transparency\ phong\ ior} Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\fs24 \cf0 evaluate()} TextPlacement 0 Bounds {{450, 52}, {90, 54}} Class MultiTextGraphic FitText Vertical ID 3 ListOrientation Vertical Style fill GradientAngle 304 GradientCenter {-0.294118, -0.264706} TextList Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica-Bold;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\qc \f0\b\fs24 \cf0 Expr} Align 0 Align 0 Text {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\ql\qnatural \f0\fs24 \cf0 evaluate()\ isConst()} TextPlacement 0 GridInfo ShowsGrid YES SnapsToGrid YES GuidesVisible YES HPages 1 ImageCounter 1 IsPalette NO Layers Lock NO Name Layer 1 Print YES View YES LayoutInfo AutoAdjust YES ChildOrdering 2 MagneticFieldCenter {0, 0} LinksVisible NO MagnetsVisible NO Orientation 2 PageBreaks YES PageSetup BAt0eXBlZHN0cmVhbYED6IQBQISEhAtOU1ByaW50SW5mbwGEhAhOU09iamVjdACFkoSE hBNOU011dGFibGVEaWN0aW9uYXJ5AISEDE5TRGljdGlvbmFyeQCUhAFpFJKEhIQITlNT dHJpbmcBlIQBKxBOU0pvYkRpc3Bvc2l0aW9uhpKEmZkPTlNQcmludFNwb29sSm9ihpKE mZkOTlNCb3R0b21NYXJnaW6GkoSEhAhOU051bWJlcgCEhAdOU1ZhbHVlAJSEASqEhAFm nQCGkoSZmRROU1ZlcnRpY2FsbHlDZW50ZXJlZIaShJ2chJeXAYaShJmZD05TUHJpbnRB bGxQYWdlc4aShJ2copcAhpKEmZkNTlNSaWdodE1hcmdpboaShJ2cn50AhpKEmZkITlND b3BpZXOGkoSdnKKXAYaShJmZCU5TUHJpbnRlcoaShISECU5TUHJpbnRlcgCUkoSZmQ9I UCBMYXNlckpldCBJSUmGhpKEmZkLTlNQYXBlck5hbWWGkoSZmQZMZXR0ZXKGkoSZmQtO U0ZpcnN0UGFnZYaShJ2copcBhpKEmZkZTlNQcmludFJldmVyc2VPcmllbnRhdGlvboaS pJKEmZkPTlNTY2FsaW5nRmFjdG9yhpKEnZyfnQGGkoSZmQpOU0xhc3RQYWdlhpKEnZyi l4J/////hpKEmZkMTlNMZWZ0TWFyZ2luhpKEnZyfnQCGkoSZmQ5OU1BNUGFnZUZvcm1h dIaShISEBk5TRGF0YQCUl4EdrYQHWzc1OTdjXTw/eG1sIHZlcnNpb249IjEuMCIgZW5j b2Rpbmc9IlVURi04Ij8+CjwhRE9DVFlQRSBwbGlzdCBQVUJMSUMgIi0vL0FwcGxlIENv bXB1dGVyLy9EVEQgUExJU1QgMS4wLy9FTiIgImh0dHA6Ly93d3cuYXBwbGUuY29tL0RU RHMvUHJvcGVydHlMaXN0LTEuMC5kdGQiPgo8cGxpc3QgdmVyc2lvbj0iMS4wIj4KPGRp Y3Q+Cgk8a2V5PmNvbS5hcHBsZS5wcmludC5QYWdlRm9ybWF0LlBNSG9yaXpvbnRhbFJl czwva2V5PgoJPGRpY3Q+CgkJPGtleT5jb20uYXBwbGUucHJpbnQudGlja2V0LmNyZWF0 b3I8L2tleT4KCQk8c3RyaW5nPmNvbS5hcHBsZS5wcmludGluZ21hbmFnZXI8L3N0cmlu Zz4KCQk8a2V5PmNvbS5hcHBsZS5wcmludC50aWNrZXQuaXRlbUFycmF5PC9rZXk+CgkJ PGFycmF5PgoJCQk8ZGljdD4KCQkJCTxrZXk+Y29tLmFwcGxlLnByaW50LlBhZ2VGb3Jt YXQuUE1Ib3Jpem9udGFsUmVzPC9rZXk+CgkJCQk8cmVhbD43MjwvcmVhbD4KCQkJCTxr ZXk+Y29tLmFwcGxlLnByaW50LnRpY2tldC5jbGllbnQ8L2tleT4KCQkJCTxzdHJpbmc+ Y29tLmFwcGxlLnByaW50aW5nbWFuYWdlcjwvc3RyaW5nPgoJCQkJPGtleT5jb20uYXBw bGUucHJpbnQudGlja2V0Lm1vZERhdGU8L2tleT4KCQkJCTxkYXRlPjIwMDMtMDEtMjRU MTY6Mjg6NTRaPC9kYXRlPgoJCQkJPGtleT5jb20uYXBwbGUucHJpbnQudGlja2V0LnN0 YXRlRmxhZzwva2V5PgoJCQkJPGludGVnZXI+MDwvaW50ZWdlcj4KCQkJPC9kaWN0PgoJ CTwvYXJyYXk+Cgk8L2RpY3Q+Cgk8a2V5PmNvbS5hcHBsZS5wcmludC5QYWdlRm9ybWF0 LlBNT3JpZW50YXRpb248L2tleT4KCTxkaWN0PgoJCTxrZXk+Y29tLmFwcGxlLnByaW50 LnRpY2tldC5jcmVhdG9yPC9rZXk+CgkJPHN0cmluZz5jb20uYXBwbGUucHJpbnRpbmdt YW5hZ2VyPC9zdHJpbmc+CgkJPGtleT5jb20uYXBwbGUucHJpbnQudGlja2V0Lml0ZW1B cnJheTwva2V5PgoJCTxhcnJheT4KCQkJPGRpY3Q+CgkJCQk8a2V5PmNvbS5hcHBsZS5w cmludC5QYWdlRm9ybWF0LlBNT3JpZW50YXRpb248L2tleT4KCQkJCTxpbnRlZ2VyPjE8 L2ludGVnZXI+CgkJCQk8a2V5PmNvbS5hcHBsZS5wcmludC50aWNrZXQuY2xpZW50PC9r ZXk+CgkJCQk8c3RyaW5nPmNvbS5hcHBsZS5wcmludGluZ21hbmFnZXI8L3N0cmluZz4K CQkJCTxrZXk+Y29tLmFwcGxlLnByaW50LnRpY2tldC5tb2REYXRlPC9rZXk+CgkJCQk8 ZGF0ZT4yMDAzLTAxLTI0VDE2OjI4OjU0WjwvZGF0ZT4KCQkJCTxrZXk+Y29tLmFwcGxl LnByaW50LnRpY2tldC5zdGF0ZUZsYWc8L2tleT4KCQkJCTxpbnRlZ2VyPjA8L2ludGVn ZXI+CgkJCTwvZGljdD4KCQk8L2FycmF5PgoJPC9kaWN0PgoJPGtleT5jb20uYXBwbGUu cHJpbnQuUGFnZUZvcm1hdC5QTVNjYWxpbmc8L2tleT4KCTxkaWN0PgoJCTxrZXk+Y29t LmFwcGxlLnByaW50LnRpY2tldC5jcmVhdG9yPC9rZXk+CgkJPHN0cmluZz5jb20uYXBw bGUucHJpbnRpbmdtYW5hZ2VyPC9zdHJpbmc+CgkJPGtleT5jb20uYXBwbGUucHJpbnQu dGlja2V0Lml0ZW1BcnJheTwva2V5PgoJCTxhcnJheT4KCQkJPGRpY3Q+CgkJCQk8a2V5 PmNvbS5hcHBsZS5wcmludC5QYWdlRm9ybWF0LlBNU2NhbGluZzwva2V5PgoJCQkJPHJl YWw+MTwvcmVhbD4KCQkJCTxrZXk+Y29tLmFwcGxlLnByaW50LnRpY2tldC5jbGllbnQ8 L2tleT4KCQkJCTxzdHJpbmc+Y29tLmFwcGxlLnByaW50aW5nbWFuYWdlcjwvc3RyaW5n PgoJCQkJPGtleT5jb20uYXBwbGUucHJpbnQudGlja2V0Lm1vZERhdGU8L2tleT4KCQkJ CTxkYXRlPjIwMDMtMDEtMjRUMTY6Mjg6NTRaPC9kYXRlPgoJCQkJPGtleT5jb20uYXBw bGUucHJpbnQudGlja2V0LnN0YXRlRmxhZzwva2V5PgoJCQkJPGludGVnZXI+MDwvaW50 ZWdlcj4KCQkJPC9kaWN0PgoJCTwvYXJyYXk+Cgk8L2RpY3Q+Cgk8a2V5PmNvbS5hcHBs ZS5wcmludC5QYWdlRm9ybWF0LlBNVmVydGljYWxSZXM8L2tleT4KCTxkaWN0PgoJCTxr ZXk+Y29tLmFwcGxlLnByaW50LnRpY2tldC5jcmVhdG9yPC9rZXk+CgkJPHN0cmluZz5j b20uYXBwbGUucHJpbnRpbmdtYW5hZ2VyPC9zdHJpbmc+CgkJPGtleT5jb20uYXBwbGUu cHJpbnQudGlja2V0Lml0ZW1BcnJheTwva2V5PgoJCTxhcnJheT4KCQkJPGRpY3Q+CgkJ CQk8a2V5PmNvbS5hcHBsZS5wcmludC5QYWdlRm9ybWF0LlBNVmVydGljYWxSZXM8L2tl eT4KCQkJCTxyZWFsPjcyPC9yZWFsPgoJCQkJPGtleT5jb20uYXBwbGUucHJpbnQudGlj a2V0LmNsaWVudDwva2V5PgoJCQkJPHN0cmluZz5jb20uYXBwbGUucHJpbnRpbmdtYW5h Z2VyPC9zdHJpbmc+CgkJCQk8a2V5PmNvbS5hcHBsZS5wcmludC50aWNrZXQubW9kRGF0 ZTwva2V5PgoJCQkJPGRhdGU+MjAwMy0wMS0yNFQxNjoyODo1NFo8L2RhdGU+CgkJCQk8 a2V5PmNvbS5hcHBsZS5wcmludC50aWNrZXQuc3RhdGVGbGFnPC9rZXk+CgkJCQk8aW50 ZWdlcj4wPC9pbnRlZ2VyPgoJCQk8L2RpY3Q+CgkJPC9hcnJheT4KCTwvZGljdD4KCTxr ZXk+Y29tLmFwcGxlLnByaW50LlBhZ2VGb3JtYXQuUE1WZXJ0aWNhbFNjYWxpbmc8L2tl eT4KCTxkaWN0PgoJCTxrZXk+Y29tLmFwcGxlLnByaW50LnRpY2tldC5jcmVhdG9yPC9r ZXk+CgkJPHN0cmluZz5jb20uYXBwbGUucHJpbnRpbmdtYW5hZ2VyPC9zdHJpbmc+CgkJ PGtleT5jb20uYXBwbGUucHJpbnQudGlja2V0Lml0ZW1BcnJheTwva2V5PgoJCTxhcnJh eT4KCQkJPGRpY3Q+CgkJCQk8a2V5PmNvbS5hcHBsZS5wcmludC5QYWdlRm9ybWF0LlBN VmVydGljYWxTY2FsaW5nPC9rZXk+CgkJCQk8cmVhbD4xPC9yZWFsPgoJCQkJPGtleT5j b20uYXBwbGUucHJpbnQudGlja2V0LmNsaWVudDwva2V5PgoJCQkJPHN0cmluZz5jb20u YXBwbGUucHJpbnRpbmdtYW5hZ2VyPC9zdHJpbmc+CgkJCQk8a2V5PmNvbS5hcHBsZS5w cmludC50aWNrZXQubW9kRGF0ZTwva2V5PgoJCQkJPGRhdGU+MjAwMy0wMS0yNFQxNjoy ODo1NFo8L2RhdGU+CgkJCQk8a2V5PmNvbS5hcHBsZS5wcmludC50aWNrZXQuc3RhdGVG bGFnPC9rZXk+CgkJCQk8aW50ZWdlcj4wPC9pbnRlZ2VyPgoJCQk8L2RpY3Q+CgkJPC9h cnJheT4KCTwvZGljdD4KCTxrZXk+Y29tLmFwcGxlLnByaW50LnN1YlRpY2tldC5wYXBl cl9pbmZvX3RpY2tldDwva2V5PgoJPGRpY3Q+CgkJPGtleT5jb20uYXBwbGUucHJpbnQu UGFnZUZvcm1hdC5QTUFkanVzdGVkUGFnZVJlY3Q8L2tleT4KCQk8ZGljdD4KCQkJPGtl eT5jb20uYXBwbGUucHJpbnQudGlja2V0LmNyZWF0b3I8L2tleT4KCQkJPHN0cmluZz5j b20uYXBwbGUucHJpbnRpbmdtYW5hZ2VyPC9zdHJpbmc+CgkJCTxrZXk+Y29tLmFwcGxl LnByaW50LnRpY2tldC5pdGVtQXJyYXk8L2tleT4KCQkJPGFycmF5PgoJCQkJPGRpY3Q+ CgkJCQkJPGtleT5jb20uYXBwbGUucHJpbnQuUGFnZUZvcm1hdC5QTUFkanVzdGVkUGFn ZVJlY3Q8L2tleT4KCQkJCQk8YXJyYXk+CgkJCQkJCTxyZWFsPjAuMDwvcmVhbD4KCQkJ CQkJPHJlYWw+MC4wPC9yZWFsPgoJCQkJCQk8cmVhbD43MzQ8L3JlYWw+CgkJCQkJCTxy ZWFsPjU3NjwvcmVhbD4KCQkJCQk8L2FycmF5PgoJCQkJCTxrZXk+Y29tLmFwcGxlLnBy aW50LnRpY2tldC5jbGllbnQ8L2tleT4KCQkJCQk8c3RyaW5nPmNvbS5hcHBsZS5wcmlu dGluZ21hbmFnZXI8L3N0cmluZz4KCQkJCQk8a2V5PmNvbS5hcHBsZS5wcmludC50aWNr ZXQubW9kRGF0ZTwva2V5PgoJCQkJCTxkYXRlPjIwMDMtMTAtMjJUMjE6MzY6MzJaPC9k YXRlPgoJCQkJCTxrZXk+Y29tLmFwcGxlLnByaW50LnRpY2tldC5zdGF0ZUZsYWc8L2tl eT4KCQkJCQk8aW50ZWdlcj4wPC9pbnRlZ2VyPgoJCQkJPC9kaWN0PgoJCQk8L2FycmF5 PgoJCTwvZGljdD4KCQk8a2V5PmNvbS5hcHBsZS5wcmludC5QYWdlRm9ybWF0LlBNQWRq dXN0ZWRQYXBlclJlY3Q8L2tleT4KCQk8ZGljdD4KCQkJPGtleT5jb20uYXBwbGUucHJp bnQudGlja2V0LmNyZWF0b3I8L2tleT4KCQkJPHN0cmluZz5jb20uYXBwbGUucHJpbnRp bmdtYW5hZ2VyPC9zdHJpbmc+CgkJCTxrZXk+Y29tLmFwcGxlLnByaW50LnRpY2tldC5p dGVtQXJyYXk8L2tleT4KCQkJPGFycmF5PgoJCQkJPGRpY3Q+CgkJCQkJPGtleT5jb20u YXBwbGUucHJpbnQuUGFnZUZvcm1hdC5QTUFkanVzdGVkUGFwZXJSZWN0PC9rZXk+CgkJ CQkJPGFycmF5PgoJCQkJCQk8cmVhbD4tMTg8L3JlYWw+CgkJCQkJCTxyZWFsPi0xODwv cmVhbD4KCQkJCQkJPHJlYWw+Nzc0PC9yZWFsPgoJCQkJCQk8cmVhbD41OTQ8L3JlYWw+ CgkJCQkJPC9hcnJheT4KCQkJCQk8a2V5PmNvbS5hcHBsZS5wcmludC50aWNrZXQuY2xp ZW50PC9rZXk+CgkJCQkJPHN0cmluZz5jb20uYXBwbGUucHJpbnRpbmdtYW5hZ2VyPC9z dHJpbmc+CgkJCQkJPGtleT5jb20uYXBwbGUucHJpbnQudGlja2V0Lm1vZERhdGU8L2tl eT4KCQkJCQk8ZGF0ZT4yMDAzLTEwLTIyVDIxOjM2OjMyWjwvZGF0ZT4KCQkJCQk8a2V5 PmNvbS5hcHBsZS5wcmludC50aWNrZXQuc3RhdGVGbGFnPC9rZXk+CgkJCQkJPGludGVn ZXI+MDwvaW50ZWdlcj4KCQkJCTwvZGljdD4KCQkJPC9hcnJheT4KCQk8L2RpY3Q+CgkJ PGtleT5jb20uYXBwbGUucHJpbnQuUGFwZXJJbmZvLlBNUGFwZXJOYW1lPC9rZXk+CgkJ PGRpY3Q+CgkJCTxrZXk+Y29tLmFwcGxlLnByaW50LnRpY2tldC5jcmVhdG9yPC9rZXk+ CgkJCTxzdHJpbmc+Y29tLmFwcGxlLnByaW50LnBtLlBvc3RTY3JpcHQ8L3N0cmluZz4K CQkJPGtleT5jb20uYXBwbGUucHJpbnQudGlja2V0Lml0ZW1BcnJheTwva2V5PgoJCQk8 YXJyYXk+CgkJCQk8ZGljdD4KCQkJCQk8a2V5PmNvbS5hcHBsZS5wcmludC5QYXBlcklu Zm8uUE1QYXBlck5hbWU8L2tleT4KCQkJCQk8c3RyaW5nPm5hLWxldHRlcjwvc3RyaW5n PgoJCQkJCTxrZXk+Y29tLmFwcGxlLnByaW50LnRpY2tldC5jbGllbnQ8L2tleT4KCQkJ CQk8c3RyaW5nPmNvbS5hcHBsZS5wcmludC5wbS5Qb3N0U2NyaXB0PC9zdHJpbmc+CgkJ CQkJPGtleT5jb20uYXBwbGUucHJpbnQudGlja2V0Lm1vZERhdGU8L2tleT4KCQkJCQk8 ZGF0ZT4yMDAwLTA3LTI4VDIyOjU3OjA0WjwvZGF0ZT4KCQkJCQk8a2V5PmNvbS5hcHBs ZS5wcmludC50aWNrZXQuc3RhdGVGbGFnPC9rZXk+CgkJCQkJPGludGVnZXI+MTwvaW50 ZWdlcj4KCQkJCTwvZGljdD4KCQkJPC9hcnJheT4KCQk8L2RpY3Q+CgkJPGtleT5jb20u YXBwbGUucHJpbnQuUGFwZXJJbmZvLlBNVW5hZGp1c3RlZFBhZ2VSZWN0PC9rZXk+CgkJ PGRpY3Q+CgkJCTxrZXk+Y29tLmFwcGxlLnByaW50LnRpY2tldC5jcmVhdG9yPC9rZXk+ CgkJCTxzdHJpbmc+Y29tLmFwcGxlLnByaW50LnBtLlBvc3RTY3JpcHQ8L3N0cmluZz4K CQkJPGtleT5jb20uYXBwbGUucHJpbnQudGlja2V0Lml0ZW1BcnJheTwva2V5PgoJCQk8 YXJyYXk+CgkJCQk8ZGljdD4KCQkJCQk8a2V5PmNvbS5hcHBsZS5wcmludC5QYXBlcklu Zm8uUE1VbmFkanVzdGVkUGFnZVJlY3Q8L2tleT4KCQkJCQk8YXJyYXk+CgkJCQkJCTxy ZWFsPjAuMDwvcmVhbD4KCQkJCQkJPHJlYWw+MC4wPC9yZWFsPgoJCQkJCQk8cmVhbD43 MzQ8L3JlYWw+CgkJCQkJCTxyZWFsPjU3NjwvcmVhbD4KCQkJCQk8L2FycmF5PgoJCQkJ CTxrZXk+Y29tLmFwcGxlLnByaW50LnRpY2tldC5jbGllbnQ8L2tleT4KCQkJCQk8c3Ry aW5nPmNvbS5hcHBsZS5wcmludGluZ21hbmFnZXI8L3N0cmluZz4KCQkJCQk8a2V5PmNv bS5hcHBsZS5wcmludC50aWNrZXQubW9kRGF0ZTwva2V5PgoJCQkJCTxkYXRlPjIwMDMt MDEtMjRUMTY6Mjg6NTRaPC9kYXRlPgoJCQkJCTxrZXk+Y29tLmFwcGxlLnByaW50LnRp Y2tldC5zdGF0ZUZsYWc8L2tleT4KCQkJCQk8aW50ZWdlcj4wPC9pbnRlZ2VyPgoJCQkJ PC9kaWN0PgoJCQk8L2FycmF5PgoJCTwvZGljdD4KCQk8a2V5PmNvbS5hcHBsZS5wcmlu dC5QYXBlckluZm8uUE1VbmFkanVzdGVkUGFwZXJSZWN0PC9rZXk+CgkJPGRpY3Q+CgkJ CTxrZXk+Y29tLmFwcGxlLnByaW50LnRpY2tldC5jcmVhdG9yPC9rZXk+CgkJCTxzdHJp bmc+Y29tLmFwcGxlLnByaW50LnBtLlBvc3RTY3JpcHQ8L3N0cmluZz4KCQkJPGtleT5j b20uYXBwbGUucHJpbnQudGlja2V0Lml0ZW1BcnJheTwva2V5PgoJCQk8YXJyYXk+CgkJ CQk8ZGljdD4KCQkJCQk8a2V5PmNvbS5hcHBsZS5wcmludC5QYXBlckluZm8uUE1VbmFk anVzdGVkUGFwZXJSZWN0PC9rZXk+CgkJCQkJPGFycmF5PgoJCQkJCQk8cmVhbD4tMTg8 L3JlYWw+CgkJCQkJCTxyZWFsPi0xODwvcmVhbD4KCQkJCQkJPHJlYWw+Nzc0PC9yZWFs PgoJCQkJCQk8cmVhbD41OTQ8L3JlYWw+CgkJCQkJPC9hcnJheT4KCQkJCQk8a2V5PmNv bS5hcHBsZS5wcmludC50aWNrZXQuY2xpZW50PC9rZXk+CgkJCQkJPHN0cmluZz5jb20u YXBwbGUucHJpbnRpbmdtYW5hZ2VyPC9zdHJpbmc+CgkJCQkJPGtleT5jb20uYXBwbGUu cHJpbnQudGlja2V0Lm1vZERhdGU8L2tleT4KCQkJCQk8ZGF0ZT4yMDAzLTAxLTI0VDE2 OjI4OjU0WjwvZGF0ZT4KCQkJCQk8a2V5PmNvbS5hcHBsZS5wcmludC50aWNrZXQuc3Rh dGVGbGFnPC9rZXk+CgkJCQkJPGludGVnZXI+MDwvaW50ZWdlcj4KCQkJCTwvZGljdD4K CQkJPC9hcnJheT4KCQk8L2RpY3Q+CgkJPGtleT5jb20uYXBwbGUucHJpbnQuUGFwZXJJ bmZvLnBwZC5QTVBhcGVyTmFtZTwva2V5PgoJCTxkaWN0PgoJCQk8a2V5PmNvbS5hcHBs ZS5wcmludC50aWNrZXQuY3JlYXRvcjwva2V5PgoJCQk8c3RyaW5nPmNvbS5hcHBsZS5w cmludC5wbS5Qb3N0U2NyaXB0PC9zdHJpbmc+CgkJCTxrZXk+Y29tLmFwcGxlLnByaW50 LnRpY2tldC5pdGVtQXJyYXk8L2tleT4KCQkJPGFycmF5PgoJCQkJPGRpY3Q+CgkJCQkJ PGtleT5jb20uYXBwbGUucHJpbnQuUGFwZXJJbmZvLnBwZC5QTVBhcGVyTmFtZTwva2V5 PgoJCQkJCTxzdHJpbmc+TGV0dGVyPC9zdHJpbmc+CgkJCQkJPGtleT5jb20uYXBwbGUu cHJpbnQudGlja2V0LmNsaWVudDwva2V5PgoJCQkJCTxzdHJpbmc+Y29tLmFwcGxlLnBy aW50LnBtLlBvc3RTY3JpcHQ8L3N0cmluZz4KCQkJCQk8a2V5PmNvbS5hcHBsZS5wcmlu dC50aWNrZXQubW9kRGF0ZTwva2V5PgoJCQkJCTxkYXRlPjIwMDAtMDctMjhUMjI6NTc6 MDRaPC9kYXRlPgoJCQkJCTxrZXk+Y29tLmFwcGxlLnByaW50LnRpY2tldC5zdGF0ZUZs YWc8L2tleT4KCQkJCQk8aW50ZWdlcj4xPC9pbnRlZ2VyPgoJCQkJPC9kaWN0PgoJCQk8 L2FycmF5PgoJCTwvZGljdD4KCQk8a2V5PmNvbS5hcHBsZS5wcmludC50aWNrZXQuQVBJ VmVyc2lvbjwva2V5PgoJCTxzdHJpbmc+MDAuMjA8L3N0cmluZz4KCQk8a2V5PmNvbS5h cHBsZS5wcmludC50aWNrZXQucHJpdmF0ZUxvY2s8L2tleT4KCQk8ZmFsc2UvPgoJCTxr ZXk+Y29tLmFwcGxlLnByaW50LnRpY2tldC50eXBlPC9rZXk+CgkJPHN0cmluZz5jb20u YXBwbGUucHJpbnQuUGFwZXJJbmZvVGlja2V0PC9zdHJpbmc+Cgk8L2RpY3Q+Cgk8a2V5 PmNvbS5hcHBsZS5wcmludC50aWNrZXQuQVBJVmVyc2lvbjwva2V5PgoJPHN0cmluZz4w MC4yMDwvc3RyaW5nPgoJPGtleT5jb20uYXBwbGUucHJpbnQudGlja2V0LnByaXZhdGVM b2NrPC9rZXk+Cgk8ZmFsc2UvPgoJPGtleT5jb20uYXBwbGUucHJpbnQudGlja2V0LnR5 cGU8L2tleT4KCTxzdHJpbmc+Y29tLmFwcGxlLnByaW50LlBhZ2VGb3JtYXRUaWNrZXQ8 L3N0cmluZz4KPC9kaWN0Pgo8L3BsaXN0PgqGkoSZmQ1OU09yaWVudGF0aW9uhpKEnZyi lwCGkoSZmRROU1ZlcnRpY2FsUGFnaW5hdGlvboaShJ2copcAhpKEmZkWTlNIb3Jpem9u dGFsbHlDZW50ZXJlZIaSoZKEmZkLTlNUb3BNYXJnaW6GkoSdnJ+dAIaShJmZC05TUGFw ZXJTaXplhpKEnpyEhAx7X05TU2l6ZT1mZn2hgQJkgQMYhpKEmZkVTlNIb3Jpem9uYWxQ YWdpbmF0aW9uhpKEnZyilwCGhoY= ReadOnly NO RowAlign 0 RowSpacing 36 SheetTitle Canvas 1 SmartAlignmentGuidesActive YES SmartDistanceGuidesActive YES UseEntirePage VPages 1 WindowInfo CurrentSheet 0 Frame {{30, -1}, {591, 746}} ShowRuler ShowStatusBar VisibleRegion {{0, 0}, {576, 648}} Zoom 1 ./rt2.7.2007.05.17/Jamfile0100644000077300007650000000366210053435654012601 0ustar patpatSubDir TOP ; SEARCH_NWS = $(SEARCH_SOURCE) nws ; LOCATE_SOURCE = Code ; LOCATE_TARGET = Build-$(OS) ; LINK = $(C++) ; SRCS = main scene portal universe inter union set complement ; SRCS += extrusion coxeter convex halfspace cylinder quadratic ; SRCS += object intersection light view image color expr ; SRCS += mathvec basevec nkthread input ; Main rt : $(SRCS).cc ; Clean clean : $(LOCATE_SOURCE) $(LOCATE_TARGET) ; EXPR_DEPENDS = binary unary const pos dir norm ref ; IMAGE_DEPENDS = accum ppm png ; OBJECT_DEPENDS = coxeter convex halfspace quadratic complement extrusion ; OBJECT_DEPENDS += csg-union csg-set csg-inter cylinder ; THREAD_DEPENDS = work worker ; UNIVERSE_DEPENDS = inter refl refr shad ; Tangle input.h input.cc : input.nw ; Tangle basevec.h basevec.cc : basevec.nw ; Tangle mathvec.h mathvec.cc : mathvec.nw ; Tangle expr.h : expr.nw ; Tangle expr.cc : expr.nw expr-$(EXPR_DEPENDS).nw ; Tangle color.h color.cc : color.nw ; Tangle image.h : image.nw ; Tangle image.cc : image.nw image-$(IMAGE_DEPENDS).nw ; Tangle light.h light.cc : light.nw ; Tangle intersection.h intersection.cc : intersection.nw ; Tangle object.h : object.nw ; Tangle object.cc : object.nw $(OBJECT_DEPENDS).nw ; Tangle coxeter.h coxeter.cc : coxeter.nw ; Tangle convex.h convex.cc : convex.nw ; Tangle halfspace.h halfspace.cc : halfspace.nw ; Tangle cylinder.h cylinder.cc : cylinder.nw ; Tangle quadratic.h quadratic.cc : quadratic.nw ; Tangle complement.h complement.cc : complement.nw ; Tangle extrusion.h extrusion.cc : extrusion.nw ; Tangle union.h union.cc : csg-union.nw ; Tangle set.h set.cc : csg-set.nw ; Tangle inter.h inter.cc : csg-inter.nw ; Tangle nkthread.h nkthread.cc : nkthread.nw thread-$(THREAD_DEPENDS).nw ; Tangle universe.h : universe.nw ; Tangle universe.cc : universe.nw universe-$(UNIVERSE_DEPENDS).nw ; Tangle portal.h portal.cc : portal.nw ; Tangle scene.h scene.cc : scene.nw ; Tangle view.h view.cc : view.nw ; Tangle main.cc : main.nw ; ./rt2.7.2007.05.17/Jamrules0100644000077300007650000000171410053435661013006 0ustar patpatTANGLE = notangle ; RM = rm -rf ; rule Tangle { local t = [ FGristFiles $(1) ] ; local nw = [ FGristFiles $(2) ] ; MakeLocate $(t) : $(LOCATE_SOURCE) ; SEARCH on $(nw) = $(SEARCH_NWS) ; Depends first : $(t) ; Depends $(t) : $(nw) ; Clean clean : $(t) ; local file ; for file in $(t) { TangleFile $(file) : $(nw) ; CHUNKNAME on $(file) = $(file:BSG=) ; HDRRULE on $(file) = HdrRule ; HDRSCAN on $(file) = $(HDRPATTERN) ; HDRSEARCH on $(file) = $(SEARCH_SOURCE:E) $(SUBDIRHDRS) $(HDRS) $(STDHDRS) ; HDRGRIST on $(file) = $(HDRGRIST) ; } } rule TangleFile { switch $(1) { case *.h : TangleFlags $(1) : $(TANGLEFLAGS) -L ; case *.cc : TangleFlags $(1) : $(TANGLEFLAGS) -L ; case * : TangleFlags $(1) : $(TANGLEFLAGS) ; } Notangle $(1) : $(2) ; } rule TangleFlags { TANGLEFLAGS on [ FGristFiles $(1) ] += $(2) ; } actions Notangle { $(TANGLE) $(TANGLEFLAGS) -R$(CHUNKNAME) $(2) > $(1) } ./rt2.7.2007.05.17/nws/0040755000077300007650000000000010640535342012107 5ustar patpat./rt2.7.2007.05.17/nws/basevec.nw0100644000077300007650000001575210623061636014075 0ustar patpat@ \chapter{Basic Vectors} \label{sec:basevec} This template class extends the [[vector<>]] class from the standard template library to include the small amount of code needed to read and write the vector format used in this raytracer. This class is extended by the [[mathvec<>]] class. The code in this raytracer uses a variety of types of these vectors. They will be instantiated in the places where the element classes are defined. <>= template class basevec< double >; template class basevec< unsigned int >; @ \section{Creating Vectors} There are several ways to create vectors. The most basice way is using the default constructor which simply initializes a zero-length vector. <>= basevec(); @ <>= template < typename TT > basevec< TT >::basevec() : std::vector< TT >() { } @ One could initialize a vector from a given array and given length. <>= basevec( const TT array[], unsigned int len ); @ <>= template < typename TT > basevec< TT >::basevec( const TT array[], unsigned int len ) : std::vector< TT >( len ) { for ( unsigned int ii=0; ii < len; ++ii ) { (*this)[ ii ] = array[ ii ]; } } @ One could initialize a vector from a given value and given length. <>= basevec( const TT value, unsigned int len ); @ <>= template < typename TT > basevec< TT >::basevec( const TT value, unsigned int len ) : std::vector< TT >( len ) { for ( unsigned int ii=0; ii < len; ++ii ) { (*this)[ ii ] = value; } } @ One could copy an existing vector. This method makes use of the assignment operator defined next. <>= basevec( const basevec< TT >& other ); @ <>= template < typename TT > basevec< TT >::basevec( const basevec< TT >& other ) : std::vector< TT >() { *this = other; } @ One could also assign a vector from a given vector. <>= const basevec< TT >& operator = ( const basevec< TT >& other ); @ <>= template < typename TT > const basevec< TT >& basevec< TT >::operator = ( const basevec< TT >& other ) { unsigned int len( other.size() ); this->resize( len ); for ( unsigned int ii=0; ii < len; ++ii ) { (*this)[ ii ] = other[ ii ]; } return *this; } @ One can also, craftily enough, assign a vector from a string representation of the vector. For example, one might assign a unit 3-vector using the string [["[3]< 1, 0, 0 >"]] <>= basevec( const char* str ); @ <>= template < typename TT > basevec< TT >::basevec( const char* str ) : std::vector< TT >() { std::istringstream in( str ); in >> (*this); if ( ! in.good() ) { this->resize( 0 ); } } @ \section{Input and Output of Vectors} \label{sec:basevec-input} \label{sec:basevec-output} As seen above, this raytracer presents vectors as a comma-separated list of the component values surrounded by greater-than and less-than symbols and preceded by the length of the vector in square brackets. The following routines read and write them. <>= template < typename TT > std::istream& operator >> ( std::istream&, basevec< TT >& ); template < typename TT > std::ostream& operator << ( std::ostream&, const basevec< TT >& ); @ <>= friend std::istream& operator >> ( std::istream&, basevec< TT >& ); friend std::ostream& operator << ( std::ostream&, const basevec< TT >& ); @ The input routine sets the input stream to skip white space. Then, it plucks off the opening bracket, the vector length, the closing bracket, and the greater-than sign. It initializes a zero vector of the given size. Then, it proceeds to read through the components being careful to pluck out the commas. Then, it continues plucking off any bogus characters until it comes to the less-than sign. <>= template < typename TT > std::istream& operator >> ( std::istream& in, basevec< TT >& vv ) { char bogus; unsigned int len; in.setf( std::ios::skipws ); in >> bogus; // "[" in >> len; in >> bogus >> bogus; // "]" "<" TT zero( 0U ); vv.resize( len, zero ); for (unsigned ii=0; ii < len; ++ii) { in >> vv[ii]; if (ii < len-1) { in >> bogus; // "," } } while (bogus != '>' && in.good() ) { in >> bogus; // ">" } return in; } @ The output routine emits the opening bracket, the length of the vector, the closing bracket, the greater-than sign, and a bit of white space. Then, it emits each component value being careful to add a comma and some whitespace between components. Then, it emits the less-than sign. <>= template < typename TT > std::ostream& operator << ( std::ostream& out, const basevec< TT >& vv ) { unsigned int len = vv.size(); out.put( '[' ); out << len; out.put( ']' ).put( '<' ).put( ' ' ); for (unsigned int ii=0; ii < len; ++ii) { out << vv[ii]; if (ii < len-1) { out.put( ',' ).put( ' ' ); } } out.put( ' ' ).put( '>' ); return out; } @ \section{The Class Definition} \label{sec:basevec-class} This class inherits directly from the [[vector<>]] template class in the standard template library. It includes all of the methods declared above. And, it includes some version identification information. <>= template < typename TT > class basevec; @ <>= template < typename TT > class basevec : public std::vector< TT > { public: <> public: static const char* id; }; @ \section{Source Files} The following sections assemble the source files for the [[basevec]] template class from the chunks above. \subsection{[[basevec.h]]} The header file the [[basevec]] template class includes the [[iostream]] and [[vector]] headers from the standard C++ libraries and then incorporates the template defined in \ref{sec:basevec-class} above. In order to make templates work out alright, this file also includes the implementations of the template methods. All of this is wrapped in syntactic sugar to avoid problems should this file be included more than once. <>= #ifndef _NKLEIN_BASEVEC_H_ #define _NKLEIN_BASEVEC_H_ 1 #include #include #include <> <> <> <> #endif /*_NKLEIN_BASEVEC_H_*/ @ \subsection{[[basevec.cc]]} Herein, the instantiations of the [[basevec]] class are included. The implementation requires the definition of the class itself. <>= #include "basevec.h" template< typename TT > const char* basevec::id = "NKVERSION: basevec<>( RT_VERSION )"; <> @ ./rt2.7.2007.05.17/nws/color.nw0100644000077300007650000003116010030761333013563 0ustar patpat@ \chapter{Color} \label{sec:color} Most views will contain a viewport. That viewport is an instance of this color class. Additionally, all objects and all lights must specify a color. Technically, when one considers objects which contain other objects, this statement is not entirely precise. More precise would be that if one modeled the top-level object as a tree, there must be some color specified along every path to a leaf. The color contains zero or more portal specifications. It contains an expression vector specifying the values of the pixel channels. It contains parameters defining the specularness, the reflectiveness, and the transparency of the object. It contains a parameter specifying the Phong shading attribute and a parameter defining the index of refraction of the object. It contains vectors to rescale and recenter the color coordinates and a matrix to reorient them. <>= color_parameters ::= color_parameters color_param | color_param ; color_param ::= 'portal' portal_name '{' portal_parameters '}' ';' | color_channels | 'specularness' real ';' | 'transparency' real ';' | 'reflectiveness' real ';' | 'phong' real ';' | color_ior | 'scale' real_vector ';' | 'orientation' real_matrix ';' | 'center' real_vector ';' ; portal_name ::= string ; color_channels ::= 'channels' expr_vector ';' | 'color' expr_vector ';' color_ior ::= 'indexOfRefraction' real ';' | 'ior' real ';' ; @ Portal parameters are described in \S\ref{sec:portal}. To be useful, each portal instance contained within this color class should have a name that is unique within this color instance. Expression vectors are described in \S\ref{sec:expr-vector}. The color, if it is to be useful, must specify the channels vector. If the specularness is omitted, it is assumed to be [[0.1]]. If the transparency is omitted, it is assumed to be zero. If the reflectiveness is omitted, it is assumed to be zero. If the Phong factor is omitted, it is assumed to be [[15.0]]. If the index of refraction is omitted, it is assumed to be one. The color instance keeps a pointer to the scene to which it belongs so that it can help any portals contained within the color to track down the universes they wish to use. <>= const scene* myScene; @ The [[color]] class defines all aspects of the color of an object. This class tracks the color channel values. <>= basevec< expr* > channels; @ The channels above may need to reference portals. The following map tracks the portals for this color. <>= typedef std::map< std::string, class portal* > PortalMap; PortalMap portals; @ In addition, this class tracks the specularness, transparency, reflectiveness, Phong factor, and index of refraction. <>= double specularness; double transparency; double reflectiveness; double phong; double indexOfRefraction; @ Note: It may be nice to allow these to be full-blown expressions at some point. The color may vary with the position and normal at the point of the color and the direction from which the color is viewed. If any of those are true, the appropriate boolean is set here. If they are not true, then the color does not bother to reorient the unneeded vectors. <>= bool usesPosition; bool usesNormal; bool usesDirection; @ In order to allow flexibility in the position and orientation of the color field, the color keeps its own scale, orientation, and center. <>= mathvec< double > scale; basevec< mathvec< double > > orientation; mathvec< double > center; @ \section{Constructor} The color constructor sets up default values for the color. <>= specularness( 0.1 ), transparency( 0.0 ), reflectiveness( 0.0 ), phong( 15.0 ), indexOfRefraction( 1.0 ), usesPosition( false ), usesNormal( false ), usesDirection( false ) @ The default constructor does nothing more than prepare the defaults. <>= color( const scene* ss ); @ <>= color::color( const scene* ss ) : myScene( ss ), <> { } @ This constructor allows other objects to initialize a color from its string representation. <>= color( const char* str, const scene* ss = 0 ); @ <>= color::color( const char* str, const scene* ss ) : myScene( ss ), <> { std::istringstream in( str ); in >> *this; } @ \section{Setting Up The Number Of Dimensions} When the number of dimensions are set on the object which contains this color, that information is passed along to the color class so that it can resize the appropriate vectors and inform its child portals. <>= void setDimensions( unsigned int dd ); @ <>= void color::setDimensions( unsigned int dd ) { this->scale.resize( dd, 1.0 ); ::orthogonalize( this->orientation, dd ); this->center.resize( dd, 0.0 ); PortalMap::iterator it; for ( it = this->portals.begin(); it != this->portals.end(); ++it ) { it->second->setDimensions( dd ); } } @ \section{Evaluating The Color} This method allows one to query the number of channels this color provides. <>= inline unsigned int getChannelCount( void ) const { return this->channels.size(); }; @ The following methods allow one to query basic properties of the color. <>= inline double getReflectiveness( void ) const { return this->reflectiveness; }; inline double getTransparency( void ) const { return this->transparency; }; inline double getIndexOfRefraction( void ) const { return this->indexOfRefraction; }; inline double getSpecularness( void ) const { return this->specularness; }; inline double getPhong( void ) const { return this->phong; }; @ The following method allows one to query the color at a given position, with a given normal, and from a given direction. <>= void evaluate( const mathvec< double >& position, const mathvec< double >& normal, const mathvec< double >& direction, double contribution, unsigned int height, mathvec< double >& pixel ) const; @ <>= void color::evaluate( const mathvec< double >& position, const mathvec< double >& normal, const mathvec< double >& direction, double contribution, unsigned int height, mathvec< double >& pixel ) const { <> <> <> <> } @ If the pixel vector is smaller than the channels vector, the pixel vector is resized. <>= if ( pixel.size() < this->channels.size() ) { pixel.resize( this->channels.size() ); } @ If the rendering has already reached its maximum depth (the bottom of its height) or if the contribution of this pixel is too small or if this pixel has no pixel expressions, this method stops early. <>= if ( height == 0 || contribution < 0.0001 || this->channels.size() == 0 ) { pixel *= 0.0; return; } @ If the position, normal, or direction are used, they will have to be rotated, translated, and scaled into this color's space. <>= mathvec pos; mathvec norm; mathvec dir; @ The position has to be scaled, rotated, and translated. <>= if ( this->usesPosition ) { pos = position * this->scale; pos.rotate( this->orientation ); pos += this->center; } @ The normal has to be scaled, rotated, and renormalized. It has to be scaled and renormalized because the scaling factor may be different in different directions. <>= if ( this->usesNormal ) { norm = normal * this->scale; norm.rotate( this->orientation ); norm.normalize(); } @ <>= if ( this->usesDirection ) { dir = direction * this->scale; dir.rotate( this->orientation ); dir.normalize(); } @ <>= PortalMap& pps( *(PortalMap*)&this->portals ); PortalMap::iterator it; for ( it = pps.begin(); it != pps.end(); ++it ) { it->second->evaluate( pos, dir, contribution, height, this->channels.size() ); } @ To assign the pixel, this method loops through and evaluates each expression in the channels vector scaling it by the contribution. It also tracks the last stored value so that it can replicate it to the rest of the channels in the pixel. <>= double lastVal = 0.0; for ( unsigned int ii=0; ii < this->channels.size(); ++ii ) { pixel[ii] = this->channels[ii]->evaluate( pos, norm, dir ) * contribution; lastVal = pixel[ ii ]; } for ( unsigned int ii=this->channels.size(); ii < pixel.size(); ++ii ) { pixel[ii] = lastVal; } @ \section{Loading A Color} The following method allows one to read in a color from a stream. <>= friend std::istream& operator >> ( std::istream& in, color& cc ); @ <>= std::istream& operator >> ( std::istream& stream, color& cc ) { input in( stream ); while ( in.check() ) { char token[ input::MAX_TOKEN_LEN ]; if ( in.get( token, sizeof(token) ) == 0 ) { return stream; } std::string tok( token ); char semicolon; if ( tok == "portal" ) { <> } else if ( tok == "channels" || tok == "color" ) { expr::read( stream, cc.channels, cc.portals ); <> stream >> semicolon; } else if ( tok == "specularness" ) { stream >> cc.specularness >> semicolon; } else if ( tok == "transparency" ) { stream >> cc.transparency >> semicolon; } else if ( tok == "reflectiveness" ) { stream >> cc.reflectiveness >> semicolon; } else if ( tok == "phong" ) { stream >> cc.phong >> semicolon; } else if ( tok == "indexOfRefraction" || tok == "ior" ) { stream >> cc.indexOfRefraction >> semicolon; } else if ( tok == "scale" ) { stream >> cc.scale >> semicolon; } else if ( tok == "orientation" ) { stream >> cc.orientation >> semicolon; } else if ( tok == "center" ) { stream >> cc.center >> semicolon; } else { in.ignore( "COLOR", tok.c_str() ); } } return stream; } @ To read in a portal, this code gets the name of the portal. Then, it allocates a new portal, reads it in, and puts it in the portal map. <>= if ( in.get( token, sizeof(token) ) == 0 ) { break; } std::string name( token ); portal* pp = new portal( cc.myScene ); stream >> *pp >> semicolon; cc.portals[ name ] = pp; @ This section of code updates the top-level booleans that indicate whether or not this color uses the position, normal, and direction vectors that are passed into the color for evaluation. <>= cc.usesPosition = false; cc.usesNormal = false; cc.usesDirection = false; for ( unsigned int ii=0; ii < cc.channels.size(); ++ii ) { cc.usesPosition = cc.usesPosition || cc.channels[ ii ]->usesPosition(); cc.usesNormal = cc.usesNormal || cc.channels[ ii ]->usesNormal(); cc.usesDirection = cc.usesDirection || cc.channels[ ii ]->usesDirection(); } @ \section{The Class Definition} \label{sec:color-class} This class includes all of the methods declared above. And, it includes some version identification information. <>= class color { protected: <> public: <> public: static const char* id; }; @ \section{Source Files} The following sections assemble the source files for the [[color]] class from the chunks above. \subsection{[[color.h]]} The header file the [[color]] class includes the [[iostream]] and [[string]] headers from the standard C++ libraries and the header file for the [[mathvec<>]] class and then incorporates the class defined in \ref{sec:color-class} above. All of this is wrapped in syntactic sugar to avoid problems should this file be included more than once. <>= #ifndef _NKLEIN_COLOR_H_ #define _NKLEIN_COLOR_H_ 1 #include #include #include #include "expr.h" <> #endif /*_NKLEIN_COLOR_H_*/ @ \subsection{[[color.cc]]} Herein, the implementations of the methods of the [[color]] class are included as well as the the declarations and implementations of the derived classes. <>= #include #include #include #include "input.h" #include "color.h" #include "portal.h" const char* color::id = "NKVERSION: color( RT_VERSION )"; <> @ ./rt2.7.2007.05.17/nws/complement.nw0100644000077300007650000001650010032074773014620 0ustar patpat@ \chapter{Complement} \label{sec:complement} The complement is a CSG (Constructive Solid Geometry) primitive. Intersections with it are simply intersections with the object it contains with all of the inside hits turned to outside hits (and vice-versa). The complement contains a sub-object. And, it can specify parameters from the base object class. <>= complement_params ::= 'object' object_type_and_params ';' | 'base' '{' object_parameters '}' ';' ; @ The complement class can only contain one sub-object. The following snippets are used so that the object's factory method can create instance of this class. <>= #include "complement.h" @ <>= if ( objectType == "complement" ) { complement* obj = new complement( ss ); stream >> *obj >> semicolon; return obj; } else @ The [[complement]] class is a subclass of the [[object]] class from \ref{sec:object}. It contains a sub-object. It simply flips the inside/outside-ness of the object it contains. <>= object* obj; @ <>= , obj( 0 ) @ \section{Constructor} The default constructor does nothing. <>= complement( const scene* ss ); @ <>= complement::complement( const scene* ss ) : object( ss ) <> { } @ \section{Destructor} This destructor has to delete the sub-object. <>= virtual ~complement( void ); @ <>= complement::~complement( void ) { delete this->obj; }; @ \section{Setting The Number of Dimensions} Even though this method is virtual, there is an implementation that derived classes should invoke. <>= virtual void setDimensions( unsigned int dd ); @ <>= void complement::setDimensions( unsigned int dd ) { if ( this->obj != 0 ) { this->obj->setDimensions( dd ); } this->object::setDimensions( dd ); } @ \section{Intersection A Ray And A Complement} This first intersection method retrieves only the closest intersection to the ray's origin. The ray is specified by its direction and start. <>= virtual bool intersect( const mathvec< double >& direction, const mathvec< double >& start, intersection& hit ) const; @ <>= bool complement::intersect( const mathvec< double >& direction, const mathvec< double >& start, intersection& hit ) const { if ( this->obj == 0 ) { return false; } <> bool ret = this->obj->intersect( rd, rp, hit ); if ( ret ) { <> } return ret; } @ <>= mathvec< double > rd = direction; rd.antirotate( this->orientation ); rd /= this->scale; rd.normalize(); mathvec< double > rp = start - this->center; rp.antirotate( this->orientation ); rp /= this->scale; @ <>= hit.reorient( this->scale, this->orientation, this->center ); hit.setDistance( ( hit.getPosition() - start ).magnitude() ); if ( this->gotColor ) { hit.recolor( this->chroma ); } if ( hit.isInside() ) { hit.setOutside(); } else { hit.setInside(); } @ This second intersection method retrieves all intersections between this complement and the ray. The ray is specified by its direction and start. The array of hits is sorted in order of increasing distance from the start of the ray. <>= virtual bool intersect( const mathvec< double >& direction, const mathvec< double >& start, std::vector< intersection* >& hits ) const; @ <>= bool complement::intersect( const mathvec< double >& direction, const mathvec< double >& start, std::vector< intersection* >& hits ) const { if ( this->obj == 0 ) { return false; } <> bool ret = this->obj->intersect( rd, rp, hits ); if ( ret ) { for ( unsigned int ii=0; ii < hits.size(); ++ii ) { intersection& hit( *hits[ ii ] ); <> } } else { intersection* nn = new intersection(); this->forgeHit( direction, start, *nn ); hits.insert( hits.end(), nn ); } return true; } @ \section{Checking If A Point Is Inside A Complement} <>= virtual bool inside( const mathvec< double >& start ) const; virtual bool _inside( const mathvec< double >& rp ) const; @ <>= bool complement::inside( const mathvec< double >& start ) const { if ( this->obj == 0 ) { return false; } mathvec< double > rp = start - this->center; rp.antirotate( this->orientation ); rp /= this->scale; return this->_inside( rp ); } bool complement::_inside( const mathvec< double >& rp ) const { if ( this->obj == 0 ) { return false; } return ! this->obj->inside( rp ); } @ \section{Loading A Complement} The following method allows one to read in an complement from a stream. <>= friend std::istream& operator >> ( std::istream& in, complement& cc ); @ <>= std::istream& operator >> ( std::istream& stream, complement& cc ) { input in( stream ); while ( in.check() ) { char token[ input::MAX_TOKEN_LEN ]; if ( in.get( token, sizeof(token) ) == 0 ) { return stream; } std::string tok( token ); char semicolon; if ( tok == "object" ) { object* nn = object::read( stream, cc.myScene ); if ( nn != 0 ) { delete cc.obj; cc.obj = nn; } else { std::cerr << "COMPLEMENT got no object!" << std::endl; } } else if ( tok == "base" ) { stream >> (object&)cc >> semicolon; } else { in.ignore( "COMPLEMENT", tok.c_str() ); } } return stream; } @ \section{The Class Definition} \label{sec:complement-class} This class includes all of the methods declared above. And, it includes some version identification information. <>= class complement : public object { protected: <> public: <> public: static const char* id; }; @ \section{Source Files} The following sections assemble the source files for the [[complement]] class from the chunks above. \subsection{[[complement.h]]} The header file the [[complement]] class includes the [[iostream]], [[string]], and [[map]] headers from the standard C++ libraries and the header file for the [[object]] base class and then incorporates the class defined in \ref{sec:complement-class} above. All of this is wrapped in syntactic sugar to avoid problems should this file be included more than once. <>= #ifndef _NKLEIN_COMPLEMENT_H_ #define _NKLEIN_COMPLEMENT_H_ 1 #include #include #include #include "object.h" <> #endif /*_NKLEIN_COMPLEMENT_H_*/ @ \subsection{[[complement.cc]]} Herein, the implementations of the methods of the [[complement]] class are included as well as the the declarations and implementations of the derived classes. <>= #include #include #include #ifndef MAXFLOAT #include #endif #include "input.h" #include "complement.h" const char* complement::id = "NKVERSION: complement( RT_VERSION )"; <> @ ./rt2.7.2007.05.17/nws/convex.nw0100644000077300007650000003621310603300026013745 0ustar patpat@ \chapter{Convex} \label{sec:convex} Before scaling, orienting, and position, the convex object represents the convex hull (along with the interior) of a given set of points. \textit{Note:} if the points are $n$-dimensional, but there are not $n$ linearly independent vectors from one point to another in the set of points, the result will be a hyperplane which contains all of the points. One can specify a matrix of points or a point at a time. The list is never cleared, so one could accumulate points with multiple point vectors and/or multiple point matrixes. One can also specify parameters for the object base class. <>= convex_params ::= 'points' real_matrix ';' | 'point' real_vector ';' | 'colorDistance' real ';' | 'specialColor' integer '{' color_parameters '}' ';' | 'base' '{' object_parameters '}' ';' ; @ The [[colorDistance]] parameter is used in conjunction with the [[specialColor]] parameters to give different coloring to edges, vertexes, and the like. The [[specialColor]] has an integer parameter and color information. See \S\ref{sec:object} for information about the [[color_parameters]]. The integer parameter tells the dimension of the subfacet to color. For example, zero colors the vertexes, 1 colors the edges, 2 colors the planar faces, etc. The intersection is colored with this color if the point is within [[colorDistance]] of the right number of planes for this subfacet. The following snippets are used so that the object's factory method can create instance of this class. <>= #include "inter.h" #include "convex.h" @ <>= if ( objectType == "convex" ) { convex* obj = new convex( ss ); stream >> *obj >> semicolon; return obj; } else @ <>= std::vector< mathvec< double > > pts; @ <>= double colorDistance; std::vector< color* > specialColors; @ \section{Constructor} The default constructor does nothing. <>= convex( const scene* ss ); @ <>= convex::convex( const scene* ss ) : csginter( ss ), colorDistance( 0.0 ) { } @ \section{Destructor} The destructor has nothing to do. <>= virtual ~convex( void ); @ <>= convex::~convex( void ) { }; @ \section{Adding A Point} <>= void addPoint( const mathvec< double >& point ); @ <>= void convex::addPoint( const mathvec< double >& point ) { this->pts.insert( this->pts.end(), point ); }; @ \section{Calculating The Bounding Planes} This class uses the inherited CSG intersection methods from \S\ref{sec:inter} and then does some simple post-processing on the results. As such, here we adds the bounding hyperplanes to the CSG intersection's list of objects. This method calculates the bounding hyperplanes. <>= void calculateBoundingPlanes( bool dbg = false ); @ This method could stand a major algorithmic upgrade if there are better methods available. For an object with 240 vertexes with $E8$ symmetry, this code has spent more than a month trying to calculate the bounding planes and shows no sign of nearing completion yet. <>= class PlaneInfo { public: PlaneInfo( const mathvec< double >& nn, const mathvec< double >& pp, double oo, std::vector< mathvec< double > >& pts ) : normal( nn ), point( pp ), offset( oo ) { this->mask.resize( pts.size() ); for ( unsigned int ii=0; ii < pts.size(); ++ii ) { double vv = ( this->normal ^ pts[ ii ] ) - this->offset; this->mask[ ii ] = ( ::fabs( vv ) < 0.000001 ); } }; public: mathvec< double > normal; mathvec< double > point; double offset; std::vector< bool > mask; bool exceeded; }; void convex::calculateBoundingPlanes( bool dbg ) { std::list< PlaneInfo > planes; <> <> <> <> <> if ( planes.size() > 0 ) { for ( unsigned int kk=rr; kk < nn; ++kk ) { const mathvec< double >& cur( this->pts[ kk ] ); <> if ( pool.size() >= rr-1 ) { <> } } <> } if ( dbg ) { std::cerr << "(" << planes.size() << ") faces" << std::endl; std::list< PlaneInfo >::const_iterator it = planes.begin(); while ( it != planes.end() ) { std::cerr << " " << it->normal << std::endl; ++it; } } } @ <>= unsigned int nn = this->pts.size(); if ( nn == 0 ) { return; } unsigned int rr = this->pts[ 0 ].size(); for ( unsigned int ii=1; ii < nn; ++ii ) { unsigned int len = this->pts[ ii ].size(); if ( len > rr ) { rr = len; } } if ( rr > nn ) { std::cerr << "CONVEX: Not enough points to form a plane" << std::endl; return; } for ( unsigned int ii=0; ii < nn; ++ii ) { this->pts[ ii ].resize( rr, 0.0 ); } @ <>= mathvec< unsigned int > choice; choice.resize( rr ); for ( unsigned int ii=0; ii < rr; ++ii ) { unsigned int jj = rr - ii - 1; choice[ ii ] = jj; } @ <>= double radius2 = 0.0; for ( unsigned int kk=0; kk < nn; ++kk ) { const mathvec< double >& cur( this->pts[ kk ] ); double r2 = cur ^ cur; if ( r2 > radius2 ) { radius2 = r2; } } @ <>= cylinder* sphere = new cylinder( ::sqrt( radius2 )+0.01, this->myScene ); this->objs.insert( this->objs.begin(), sphere ); @ <>= do { <> if ( plane ) { <> <> } } while ( planes.size() == 0 && this->incrementChoice( choice, nn ) ); @ <>= basevec< mathvec< double > > matrix; matrix.resize( rr-1 ); mathvec< double >& first( this->pts[ choice[ 0 ] ] ); for ( unsigned int ii=1; ii < rr; ++ii ) { mathvec< double >& cur( this->pts[ choice[ ii ] ] ); matrix[ ii-1 ] = cur - first; } bool plane = ::orthogonalize( matrix, rr ); @ <>= mathvec< double > norm( matrix[ rr-1 ] ); double dd = ( norm ^ first ); @ <>= <> norm *= -1.0; dd = ( norm ^ first ); <> @ <>= { bool unique = true; std::list< PlaneInfo >::iterator pit = planes.begin(); while ( unique && pit != planes.end() ) { if ( ::fabs( pit->offset - dd ) < 0.000001 ) { if ( ( pit->normal - norm ).magnitude() < 0.000001 ) { unique = false; } } ++pit; } if ( unique ) { planes.insert( planes.end(), PlaneInfo( norm, first, dd, this->pts ) ); } } @ <>= std::vector< mathvec< double > > pool; std::vector< bool > pointMask( kk, false ); std::list< PlaneInfo >::iterator pit = planes.begin(); while ( pit != planes.end() ) { double diff = ( pit->normal ^ cur ) - pit->offset; pit->exceeded = ( diff > 0.000001 ); if ( pit->exceeded ) { for ( unsigned int ii=0; ii < kk; ++ii ) { if ( pit->mask[ ii ] == true && pointMask[ ii ] == false ) { pool.insert( pool.end(), this->pts[ ii ] ); pointMask[ ii ] = true; } } } std::list< PlaneInfo >::iterator last = pit++; if ( last->exceeded ) { planes.erase( last ); } } @ <>= <> do { <> if ( plane ) { <> <> if ( bounding ) { <> } } } while ( this->incrementChoice( choice, pool.size() ) ); @ <>= mathvec< unsigned int > choice; choice.resize( rr-1 ); for ( unsigned int ii=0; ii < rr-1; ++ii ) { unsigned int jj = rr - ii - 2; choice[ ii ] = jj; } @ <>= basevec< mathvec< double > > matrix; matrix.resize( rr-1 ); mathvec< double >& first( this->pts[ kk ] ); for ( unsigned int ii=0; ii < rr-1; ++ii ) { mathvec< double >& cur( pool[ choice[ ii ] ] ); matrix[ ii ] = cur - first; } bool plane = ::orthogonalize( matrix, rr ); @ <>= bool bounding = true; unsigned int above = 0; unsigned int below = 0; unsigned int ps = pool.size(); for ( unsigned int ii=0; bounding && ii < ps; ++ii ) { double vv = ( norm ^ pool[ ii ] ) - dd; if ( vv > 0.000001 ) { ++above; } else if ( vv < -0.000001 ) { ++below; } bounding = ( above == 0 || below == 0 ); } if ( bounding && above > 0 ) { norm *= -1.0; dd = ( norm ^ first ); } @ <>= std::list< PlaneInfo >::iterator pit = planes.begin(); while ( pit != planes.end() ) { halfspace* hh = new halfspace( pit->point, pit->normal ); this->objs.insert( this->objs.end(), hh ); ++pit; } @ \section{Incrementing A Choice} <>= bool incrementChoice( mathvec< unsigned int >& choice, unsigned int nn ); @ <>= bool convex::incrementChoice( mathvec< unsigned int >& choice, unsigned int nn ) { unsigned int dims = choice.size(); bool ret = false; for ( unsigned int ii=0; !ret && ii < dims; ++ii ) { if ( ++choice[ ii ] < nn - ii ) { for ( unsigned int jj=0; jj < ii; ++jj ) { unsigned int kk = ii - jj - 1; choice[ kk ] = choice[ ii ] + jj + 1; } ret = true; } } return ret; } @ \section{Intersection A Ray And A Convex Hull} This first intersection method retrieves only the closest intersection to the ray's origin. The ray is specified by its direction and start. <>= virtual bool intersect( const mathvec< double >& direction, const mathvec< double >& start, intersection& hit ) const; @ <>= bool convex::intersect( const mathvec< double >& direction, const mathvec< double >& start, intersection& hit ) const { bool ret = this->csginter::intersect( direction, start, hit ); if ( ret && this->colorDistance > 0.000001 ) { <> } return ret; } @ To recolor the hit, we run through and count the number of hyperplanes that this hit is near. Then, we use the appropriate color to try <>= const mathvec< double >& loc = hit.getPosition(); mathvec< double > rp = loc - this->center; rp.antirotate( this->orientation ); rp /= this->scale; unsigned int clen = this->center.size(); unsigned int cmax = clen; for ( unsigned int kk=0; kk < clen; ++kk ) { if ( this->specialColors[ kk ] != 0 ) { cmax = clen - kk; break; } } unsigned int len = this->specialColors.size(); unsigned int hitCount = 0; unsigned int cindex = 0; std::vector< object* >::const_iterator jj = this->objs.begin(); for ( ++jj; hitCount < cmax && jj != this->objs.end(); ++jj ) { halfspace* hh = (halfspace*)*jj; double dd = ::fabs( hh->distance( rp ) ); if ( dd <= this->colorDistance ) { cindex = clen - ++hitCount; } } if ( cindex < len ) { color* cc = this->specialColors[ cindex ]; if ( cc != 0 ) { hit.recolor( *cc ); } } @ This second intersection method retrieves all intersections between this convex hull and the ray. The ray is specified by its direction and start. The array of hits is sorted in order of increasing distance from the start of the ray. <>= virtual bool intersect( const mathvec< double >& direction, const mathvec< double >& start, std::vector< intersection* >& hits ) const; @ The intersection of a set of objects is the complement of the union of the complements. Thus, this logic follows that of the union with inside-ness and outside-ness reversed. <>= bool convex::intersect( const mathvec< double >& direction, const mathvec< double >& start, std::vector< intersection* >& hits ) const { bool ret = this->csginter::intersect( direction, start, hits ); if ( ret && this->colorDistance > 0.000001 ) { std::vector< intersection* >::iterator it; for ( it = hits.begin(); it != hits.end(); ++it ) { intersection& hit( *(*it) ); <> } } return ret; } @ \section{Loading A Convex} The following method allows one to read in an convex from a stream. <>= friend std::istream& operator >> ( std::istream& in, convex& cc ); @ <>= std::istream& operator >> ( std::istream& stream, convex& hh ) { input in( stream ); while ( in.check() ) { char token[ input::MAX_TOKEN_LEN ]; if ( in.get( token, sizeof(token) ) == 0 ) { return stream; } std::string tok( token ); char semicolon; <> else if ( tok == "points" ) { basevec< mathvec< double > > pts; stream >> pts >> semicolon; for ( unsigned int ii=0; ii < pts.size(); ++ii ) { hh.addPoint( pts[ii] ); } } else if ( tok == "point" ) { mathvec< double > point; stream >> point >> semicolon; hh.addPoint( point ); } else if ( tok == "base" ) { stream >> (object&)hh >> semicolon; } else { in.ignore( "CONVEX", tok.c_str() ); } } hh.calculateBoundingPlanes(); return stream; } @ <>= if ( tok == "colorDistance" ) { stream >> hh.colorDistance >> semicolon; } else if ( tok == "specialColor" ) { unsigned int ii; color* nn = new color( hh.myScene ); stream >> ii >> *nn; if ( ii >= hh.specialColors.size() ) { hh.specialColors.resize( ii+1, 0 ); } color* oo = hh.specialColors[ ii ]; if ( oo != 0 ) { delete oo; } hh.specialColors[ ii ] = nn; } @ \section{The Class Definition} \label{sec:convex-class} This class includes all of the methods declared above. And, it includes some version identification information. <>= class convex : public csginter { private: <> protected: <> public: <> public: static const char* id; }; @ \section{Source Files} The following sections assemble the source files for the [[convex]] class from the chunks above. \subsection{[[convex.h]]} The header file the [[convex]] class includes the [[iostream]], [[string]], and [[map]] headers from the standard C++ libraries and the header file for the [[object]] base class and then incorporates the class defined in \ref{sec:convex-class} above. All of this is wrapped in syntactic sugar to avoid problems should this file be included more than once. <>= #ifndef _NKLEIN_CONVEX_H_ #define _NKLEIN_CONVEX_H_ 1 #include #include #include #include "object.h" <> #endif /*_NKLEIN_CONVEX_H_*/ @ \subsection{[[convex.cc]]} Herein, the implementations of the methods of the [[convex]] class are included as well as the the declarations and implementations of the derived classes. <>= #include #include #include #include #include "input.h" #include "cylinder.h" #include "halfspace.h" #include "inter.h" #include "convex.h" const char* convex::id = "NKVERSION: convex( RT_VERSION )"; <> @ ./rt2.7.2007.05.17/nws/coxeter.nw0100644000077300007650000001703310602337114014122 0ustar patpat@ \chapter{Coxeter} \label{sec:coxeter} Before scaling, orienting, and position, the coxter object represents a Wythoff construction based upon the Coxeter-Dynkin diagram of the symmetry group of the vertexes. One can specify the incidence matrix for the Coxeter-Dynkin diagram. The diagonal elements are used to determine the starting vertex. One can specify a debug flag which has the raytracer emit (to standard error) the number of vertexes and the number of cells. <>= coxeter_params ::= coxeter_incidence_matrix | 'debug' ';' | 'colorDistance' real ';' | 'specialColor' integer '{' color_parameters '}' ';' | 'base' '{' object_parameters '}' ';' ; coxeter_incidence_matrix ::= 'matrix' real_matrix ';' | 'incidence' real_matrix ';' ; @ See \S\ref{sec:convex} for more information about the [[colorDistance]] and [[specialColor]] parameters. See the examples in \S\ref{sec:sample-coxeter} for a good starting point on using the incidence matrix. The following snippets are used so that the object's factory method can create instance of this class. <>= #include "inter.h" #include "convex.h" #include "coxeter.h" @ <>= if ( objectType == "coxeter" ) { coxeter* obj = new coxeter( ss ); stream >> *obj >> semicolon; return obj; } else @ \section{Constructor} The default constructor does nothing. <>= coxeter( const scene* ss ); @ <>= coxeter::coxeter( const scene* ss ) : convex( ss ) { } @ \section{Destructor} This destructor has nothing to do. <>= virtual ~coxeter( void ); @ <>= coxeter::~coxeter( void ) { } @ \section{Loading A Coxeter} This class inherits directly from the convex class defined in \S\ref{sec:convex}. The loading routine calculates the symmetry group of the vertexes, calculates an initial vertex, mirrors that vertex through the symmetry group, and feeds those points to the convex class to form their convex hull. The following method allows one to read in an coxeter from a stream. <>= friend std::istream& operator >> ( std::istream& in, coxeter& cc ); @ <>= std::istream& operator >> ( std::istream& stream, coxeter& hh ) { input in( stream ); basevec< mathvec< unsigned int > > imat; unsigned int limit = 1024; bool debug = false; while ( in.check() ) { char token[ input::MAX_TOKEN_LEN ]; if ( in.get( token, sizeof(token) ) == 0 ) { return stream; } std::string tok( token ); char semicolon; <> else if ( tok == "matrix" || tok == "incidence" ) { stream >> imat >> semicolon; } else if ( tok == "limit" ) { stream >> limit >> semicolon; } else if ( tok == "debug" ) { debug = true; stream >> semicolon; } else if ( tok == "base" ) { stream >> (object&)hh >> semicolon; } else { std::cerr << "COXETER: " << tok << std::endl; } } if ( imat.size() > 0 ) { unsigned int nn = imat.size(); <> <> <> <> } return stream; } @ <>= for ( unsigned int jj=0; jj < nn; ++jj ) { imat[jj].resize( nn, 0 ); } @ <>= basevec< mathvec< double > > dd; dd.resize( nn ); for ( unsigned int jj=0; jj < nn; ++jj ) { mathvec< double >& row( dd[ jj ] ); row.resize( nn, 0.0 ); row *= 0.0; row[ jj ] = 1.0; } for ( unsigned int jj=0; jj < (nn-1); ++jj ) { for ( unsigned int ii=jj+1; ii < nn; ++ii ) { unsigned int mm = imat[ ii ][ jj ]; unsigned int m2 = imat[ jj ][ ii ]; if ( m2 > mm ) { mm = m2; } if ( mm < 2 ) { mm = 2; } double cc = ::cos( M_PI / (double)( mm ) ); dd[ ii ][ jj ] = cc; dd[ jj ][ ii ] = cc; } } @ <>= basevec< mathvec< double > > aa; aa.resize( nn ); aa[ 0 ].resize( nn, 0.0 ); aa[ 0 ] *= 0.0; aa[ 0 ][ 0 ] = 1.0; for ( unsigned int kk=1; kk < nn; ++kk ) { mathvec< double >& cur( aa[ kk ] ); double ll = 0.0; cur.resize( nn, 0.0 ); cur *= 0.0; for ( unsigned int jj=0; jj < kk; ++jj ) { const mathvec< double >& versus( aa[ jj ] ); double ss = 0.0; for ( unsigned int ii=0; ii < jj; ++ii ) { ss += cur[ ii ] * versus[ ii ]; } cur[ jj ] = ( dd[ jj ][ kk ] - ss ) / versus[ jj ]; ll += cur[ jj ] * cur[ jj ]; } cur[ kk ] = ::sqrt( 1.0 - ll ); } @ <>= unsigned int oldSize = 0; basevec< mathvec< double > > xx; xx.resize( xx.size() + 1 ); xx[ 0 ].resize( nn ); <> unsigned int newSize = xx.size(); while ( newSize > oldSize && newSize < limit ) { unsigned int cntr = 0; for ( unsigned int jj=0; jj < nn; ++jj ) { for ( unsigned int ii=oldSize; ii < newSize; ++ii ) { mathvec< double > vv; <> <> } } oldSize = newSize; newSize += cntr; } if ( debug ) { std::cerr << "(" << xx.size() << ") vertexes" << std::endl; std::cerr << xx << std::endl; } for ( unsigned int jj=0; jj < xx.size(); ++jj ) { hh.addPoint( xx[ jj ] ); } hh.calculateBoundingPlanes( debug ); @ <>= mathvec< double > bb( nn ); for ( unsigned int ii=0; ii < nn; ++ii ) { bb[ ii ] = (double)imat[ ii ][ ii ]; } if ( ( bb ^ bb ) < 0.5 ) { bb[ 0 ] = 1.0; } xx[ 0 ] = bb.solve( aa ); if ( ( xx[ 0 ] ^ xx[ 0 ] ) < 0.5 ) { if ( debug ) { std::cerr << "bad solution: " << xx[0] << std::endl; } xx[ 0 ] = aa[ 0 ]; } else { xx[ 0 ].normalize(); if ( debug ) { std::cerr << aa << " * " << xx[0] << " = " << bb << std::endl; } } @ <>= vv = aa[ jj ]; vv *= -2.0 * ( aa[ jj ] ^ xx[ ii ] ); vv += xx[ ii ]; @ <>= bool unique = true; for ( unsigned int kk=0; unique && kk < newSize+cntr; ++kk ) { double dd = ( vv - xx[ kk ] ).magnitude(); unique = dd > 0.000001; } if ( unique ) { xx.resize( newSize + cntr + 1 ); xx[ newSize + cntr ] = vv; ++cntr; } @ \section{The Class Definition} \label{sec:coxeter-class} This class includes all of the methods declared above. And, it includes some version identification information. <>= class coxeter : public convex { public: <> public: static const char* id; }; @ \section{Source Files} The following sections assemble the source files for the [[coxeter]] class from the chunks above. \subsection{[[coxeter.h]]} The header file the [[coxeter]] class includes the [[iostream]], [[string]], and [[map]] headers from the standard C++ libraries and the header file for the [[object]] base class and then incorporates the class defined in \ref{sec:coxeter-class} above. All of this is wrapped in syntactic sugar to avoid problems should this file be included more than once. <>= #ifndef _NKLEIN_COXETER_H_ #define _NKLEIN_COXETER_H_ 1 #include #include #include #include "object.h" <> #endif /*_NKLEIN_COXETER_H_*/ @ \subsection{[[coxeter.cc]]} Herein, the implementations of the methods of the [[coxeter]] class are included as well as the the declarations and implementations of the derived classes. <>= #include #include #include #include "input.h" #include "halfspace.h" #include "inter.h" #include "convex.h" #include "coxeter.h" const char* coxeter::id = "NKVERSION: coxeter( RT_VERSION )"; <> @ ./rt2.7.2007.05.17/nws/csg-inter.nw0100644000077300007650000002571110032117721014343 0ustar patpat@ \chapter{Inter} \label{sec:inter} The intersection is a CSG (Constructive Solid Geometry) primitive. If this object contains sub-objects $A_i$, then this object represents the object with boundary $ \partial \bigcap A_i $. The intersection contains zero or more sub-objects. And, it can specify parameters from the base object class. <>= csg_intersection_params ::= 'object' object_type_and_params ';' | 'base' '{' object_parameters '}' ';' ; @ The following snippets are used so that the object's factory method can create instance of this class. <>= #include "inter.h" @ <>= if ( objectType == "intersection" || objectType == "inter" ) { csginter* obj = new csginter( ss ); stream >> *obj >> semicolon; return obj; } else @ The [[inter]] class is a subclass of the [[object]] class from \ref{sec:object}. It contains a list of sub-objects. <>= std::vector< object* > objs; @ \section{Constructor} The default constructor does nothing. <>= csginter( const scene* ss ); @ <>= csginter::csginter( const scene* ss ) : object( ss ) { } @ \section{Destructor} This destructor has to release all of the sub-objects. <>= virtual ~csginter( void ); @ <>= csginter::~csginter( void ) { std::vector< object* >::iterator it; for ( it=this->objs.begin(); it != this->objs.end(); ++it ) { delete *it; } }; @ \section{Setting The Number of Dimensions} This method has to update the dimensions of each of the sub-objects and of the base class. <>= virtual void setDimensions( unsigned int dd ); @ <>= void csginter::setDimensions( unsigned int dd ) { std::vector< object* >::iterator it; for ( it=this->objs.begin(); it != this->objs.end(); ++it ) { (*it)->setDimensions( dd ); } this->object::setDimensions( dd ); } @ \section{Intersection A Ray And A Inter} This first intersection method retrieves only the closest intersection to the ray's origin. The ray is specified by its direction and start. <>= virtual bool intersect( const mathvec< double >& direction, const mathvec< double >& start, intersection& hit ) const; @ <>= bool csginter::intersect( const mathvec< double >& direction, const mathvec< double >& start, intersection& hit ) const { std::vector< intersection* > hits; bool ret = this->intersect( direction, start, hits ); if ( ret ) { hit = *hits[ 0 ]; std::vector< intersection* >::iterator it; for ( it = hits.begin(); it != hits.end(); ++it ) { delete *it; } } return ret; } @ This second intersection method retrieves all intersections between this inter and the ray. The ray is specified by its direction and start. The array of hits is sorted in order of increasing distance from the start of the ray. <>= virtual bool intersect( const mathvec< double >& direction, const mathvec< double >& start, std::vector< intersection* >& hits ) const; @ The intersection of a set of objects is the complement of the union of the complements. Thus, this logic follows that of the union with inside-ness and outside-ness reversed. <>= bool csginter::intersect( const mathvec< double >& direction, const mathvec< double >& start, std::vector< intersection* >& hits ) const { hits.clear(); <> <> if ( allHit ) { <> } <> return hits.size() > 0; } @ <>= mathvec< double > rd = direction; rd.antirotate( this->orientation ); rd /= this->scale; rd.normalize(); mathvec< double > rp = start - this->center; rp.antirotate( this->orientation ); rp /= this->scale; @ <>= unsigned int len = this->objs.size(); std::vector< std::vector< intersection* > > hitLists( len ); std::vector< unsigned int > hitStarts( len ); bool allHit = true; bool amOutside = false; for ( unsigned int ii=0; allHit && ii < len; ++ii ) { std::vector< intersection* >& curHits( hitLists[ ii ] ); object* obj = this->objs[ ii ]; if ( obj->intersect( rd, rp, curHits ) ) { if ( ! amOutside ) { amOutside = curHits[ 0 ]->isOutside(); } } else { allHit = false; } hitStarts[ ii ] = 0; } @ <>= intersection* bestHit; unsigned int bestII = 0; unsigned int bestJJ = 0; do { bestHit = 0; if ( amOutside ) { <> } else { <> <> } if ( bestHit != 0 ) { <> } amOutside = !amOutside; } while ( bestHit != 0 ); @ <>= bool done = false; while ( !done ) { <> <> } @ <>= bool notSet = true; double dist = MAXFLOAT; for ( unsigned int ii=0; ii < len; ++ii ) { std::vector< intersection* >& curHits( hitLists[ ii ] ); unsigned int hStart = hitStarts[ ii ]; unsigned int hLen = curHits.size(); if ( hStart < hLen ) { intersection* hit = curHits[ hStart ]; if ( hit->isOutside() ) { double curDist = hit->getDistance(); if ( notSet || curDist < dist ) { bestII = ii; bestJJ = hStart; bestHit = hit; dist = curDist - 0.000001; notSet = false; } } } } if ( bestHit == 0 ) { break; } else { hitStarts[ bestII ] = bestJJ + 1; } @ Assume we're done unless something is outside. <>= bool insideAll = true; for ( unsigned int ii=0; insideAll && ii < len; ++ii ) { if ( ii == bestII ) { continue; } std::vector< intersection* >& curHits( hitLists[ ii ] ); unsigned int hLen = curHits.size(); for ( unsigned int jj=hitStarts[ ii ]; jj < hLen; ++jj ) { intersection* hit = curHits[ jj ]; double curDist = hit->getDistance(); if ( curDist <= dist ) { ++hitStarts[ ii ]; } else if ( hit->isOutside() ) { insideAll = false; break; } else { break; } } if ( hitStarts[ ii ] == hLen && hLen > 0 && curHits[ hLen-1 ] != 0 && curHits[ hLen-1 ]->isInside() ) { insideAll = false; } } if ( !insideAll ) { bestHit = 0; } else { done = true; } @ <>= bool notSet = true; double dist = MAXFLOAT; for ( unsigned int ii=0; ii < len; ++ii ) { std::vector< intersection* >& curHits( hitLists[ ii ] ); unsigned int hStart = hitStarts[ ii ]; unsigned int hLen = curHits.size(); if ( hStart < hLen ) { intersection* hit = curHits[ hStart ]; if ( hit->isInside() ) { double curDist = hit->getDistance(); if ( notSet || curDist < dist ) { bestII = ii; bestJJ = hStart; bestHit = hit; dist = curDist - 0.000001; notSet = false; } } } } @ <>= if ( bestHit != 0 ) { for ( unsigned int ii=0; ii < len; ++ii ) { if ( ii == bestII ) { continue; } std::vector< intersection* >& curHits( hitLists[ ii ] ); unsigned int hLen = curHits.size(); for ( unsigned int jj=hitStarts[ ii ]; jj < hLen; ++jj ) { intersection* hit = curHits[ jj ]; double curDist = hit->getDistance(); if ( curDist <= dist ) { ++hitStarts[ ii ]; } } } } @ <>= std::vector< intersection* >& curHits( hitLists[ bestII ] ); curHits[ bestJJ ] = 0; hitStarts[ bestII ] = bestJJ+1; bestHit->reorient( this->scale, this->orientation, this->center ); bestHit->setDistance( ( bestHit->getPosition() - start ).magnitude() ); if ( this->gotColor ) { bestHit->recolor( this->chroma ); } hits.insert( hits.end(), bestHit ); @ <>= for ( unsigned int ii=0; ii < len; ++ii ) { std::vector< intersection* >& curHits( hitLists[ ii ] ); unsigned int hLen = curHits.size(); for ( unsigned int jj=0; jj < hLen; ++jj ) { delete curHits[ jj ]; } curHits.clear(); } @ \section{Checking If A Point Is Inside A Intersection} <>= virtual bool inside( const mathvec< double >& start ) const; virtual bool _inside( const mathvec< double >& rp ) const; @ <>= bool csginter::inside( const mathvec< double >& start ) const { mathvec< double > rp = start - this->center; rp.antirotate( this->orientation ); rp /= this->scale; return this->_inside( rp ); } bool csginter::_inside( const mathvec< double >& rp ) const { unsigned int len = this->objs.size(); bool in = len > 0; for ( unsigned int ii=0; in && ii < len; ++ii ) { in = this->objs[ ii ]->inside( rp ); } return in; } @ \section{Loading A Inter} The following method allows one to read in an inter from a stream. <>= friend std::istream& operator >> ( std::istream& in, csginter& cc ); @ <>= std::istream& operator >> ( std::istream& stream, csginter& cc ) { input in( stream ); while ( in.check() ) { char token[ input::MAX_TOKEN_LEN ]; if ( in.get( token, sizeof(token) ) == 0 ) { return stream; } std::string tok( token ); char semicolon; if ( tok == "object" ) { object* nn = object::read( stream, cc.myScene ); if ( nn != 0 ) { cc.objs.insert( cc.objs.end(), nn ); } else { std::cerr << "INTER failed to get an object!" << std::endl; } } else if ( tok == "base" ) { stream >> (object&)cc >> semicolon; } else { in.ignore( "INTER", tok.c_str() ); } } return stream; } @ \section{The Class Definition} \label{sec:inter-class} This class includes all of the methods declared above. And, it includes some version identification information. <>= class csginter : public object { protected: <> public: <> public: static const char* id; }; @ \section{Source Files} The following sections assemble the source files for the [[inter]] class from the chunks above. \subsection{[[inter.h]]} The header file the [[inter]] class includes the [[iostream]], [[string]], and [[map]] headers from the standard C++ libraries and the header file for the [[object]] base class and then incorporates the class defined in \ref{sec:inter-class} above. All of this is wrapped in syntactic sugar to avoid problems should this file be included more than once. <>= #ifndef _NKLEIN_INTER_H_ #define _NKLEIN_INTER_H_ 1 #include #include #include #include "object.h" <> #endif /*_NKLEIN_INTER_H_*/ @ \subsection{[[inter.cc]]} Herein, the implementations of the methods of the [[inter]] class are included. <>= #include #include #include #ifndef MAXFLOAT #include #endif #include "input.h" #include "inter.h" const char* csginter::id = "NKVERSION: csginter( RT_VERSION )"; <> @ ./rt2.7.2007.05.17/nws/csg-set.nw0100644000077300007650000001764410032117726014030 0ustar patpat@ \chapter{Set} \label{sec:set} The set is a CSG (Constructive Solid Geometry) primitive. If this object contains sub-objects $A_i$, then this object represents the object with boundary $ \bigcup \partial{}A_i $. The set contains zero or more sub-objects. And, it can specify parameters from the base object class. <>= csg_set_params ::= 'object' object_type_and_params ';' | 'base' '{' object_parameters '}' ';' ; @ The following snippets are used so that the object's factory method can create instance of this class. <>= #include "set.h" @ <>= if ( objectType == "set" ) { csgset* obj = new csgset( ss ); stream >> *obj >> semicolon; return obj; } else @ The [[set]] class is a subclass of the [[object]] class from \ref{sec:object}. It contains a list of sub-objects. <>= std::vector< object* > objs; @ \section{Constructor} The default constructor does nothing. <>= csgset( const scene* ss ); @ <>= csgset::csgset( const scene* ss ) : object( ss ) { } @ \section{Destructor} This destructor has to release all of the sub-objects. <>= virtual ~csgset( void ); @ <>= csgset::~csgset( void ) { std::vector< object* >::iterator it; for ( it=this->objs.begin(); it != this->objs.end(); ++it ) { delete *it; } }; @ \section{Setting The Number of Dimensions} This method has to update the dimension of all of its sub-objects and the base class. <>= virtual void setDimensions( unsigned int dd ); @ <>= void csgset::setDimensions( unsigned int dd ) { std::vector< object* >::iterator it; for ( it=this->objs.begin(); it != this->objs.end(); ++it ) { (*it)->setDimensions( dd ); } this->object::setDimensions( dd ); } @ \section{Intersection A Ray And A Set} This first intersection method retrieves only the closest intersection to the ray's origin. The ray is specified by its direction and start. <>= virtual bool intersect( const mathvec< double >& direction, const mathvec< double >& start, intersection& hit ) const; @ <>= bool csgset::intersect( const mathvec< double >& direction, const mathvec< double >& start, intersection& hit ) const { std::vector< intersection* > hits; bool ret = this->intersect( direction, start, hits ); if ( ret ) { hit = *hits[ 0 ]; std::vector< intersection* >::iterator it; for ( it = hits.begin(); it != hits.end(); ++it ) { delete *it; } } return ret; } @ This second intersection method retrieves all intersections between this set and the ray. The ray is specified by its direction and start. The array of hits is sorted in order of increasing distance from the start of the ray. <>= virtual bool intersect( const mathvec< double >& direction, const mathvec< double >& start, std::vector< intersection* >& hits ) const; @ <>= bool csgset::intersect( const mathvec< double >& direction, const mathvec< double >& start, std::vector< intersection* >& hits ) const { <> <> if ( gotHit ) { <> } return gotHit; } @ <>= mathvec< double > rd = direction; rd.antirotate( this->orientation ); rd /= this->scale; rd.normalize(); mathvec< double > rp = start - this->center; rp.antirotate( this->orientation ); rp /= this->scale; @ <>= unsigned int len = this->objs.size(); std::vector< std::vector< intersection* > > hitLists( len ); std::vector< unsigned int > hitStarts( len ); bool gotHit = false; for ( unsigned int ii=0; ii < len; ++ii ) { std::vector< intersection* >& curHits( hitLists[ ii ] ); object* obj = this->objs[ ii ]; if ( obj->intersect( rd, rp, curHits ) ) { gotHit = true; } hitStarts[ ii ] = 0; } @ <>= unsigned int bestII = 0; unsigned int bestJJ = 0; intersection* bestHit; do { bestHit = 0; <> if ( bestHit != 0 ) { <> } } while ( bestHit != 0 ); @ <>= bool notSet = true; double dist = MAXFLOAT; for ( unsigned int ii=0; ii < len; ++ii ) { std::vector< intersection* >& curHits( hitLists[ ii ] ); unsigned int hStart = hitStarts[ ii ]; unsigned int hLen = curHits.size(); if ( hStart < hLen ) { intersection* hit = curHits[ hStart ]; double curDist = hit->getDistance(); if ( notSet || curDist < dist ) { bestII = ii; bestJJ = hStart; bestHit = hit; dist = curDist; notSet = false; } } } @ <>= std::vector< intersection* >& curHits( hitLists[ bestII ] ); curHits[ bestJJ ] = 0; hitStarts[ bestII ] = bestJJ+1; bestHit->reorient( this->scale, this->orientation, this->center ); bestHit->setDistance( ( bestHit->getPosition() - start ).magnitude() ); if ( this->gotColor ) { bestHit->recolor( this->chroma ); } hits.insert( hits.end(), bestHit ); @ \section{Checking If A Point Is Inside A Set} <>= virtual bool inside( const mathvec< double >& start ) const; virtual bool _inside( const mathvec< double >& rp ) const; @ <>= bool csgset::inside( const mathvec< double >& start ) const { mathvec< double > rp = start - this->center; rp.antirotate( this->orientation ); rp /= this->scale; return this->_inside( rp ); } bool csgset::_inside( const mathvec< double >& rp ) const { unsigned int len = this->objs.size(); bool outside = true; for ( unsigned int ii=0; outside && ii < len; ++ii ) { outside = ! this->objs[ ii ]->inside( rp ); } return ! outside; } @ \section{Loading A Set} The following method allows one to read in an set from a stream. <>= friend std::istream& operator >> ( std::istream& in, csgset& cc ); @ <>= std::istream& operator >> ( std::istream& stream, csgset& cc ) { input in( stream ); while ( in.check() ) { char token[ input::MAX_TOKEN_LEN ]; if ( in.get( token, sizeof(token) ) == 0 ) { return stream; } std::string tok( token ); char semicolon; if ( tok == "object" ) { object* nn = object::read( stream, cc.myScene ); if ( nn != 0 ) { cc.objs.insert( cc.objs.end(), nn ); } else { std::cerr << "SET failed to get an object!" << std::endl; } } else if ( tok == "base" ) { stream >> (object&)cc >> semicolon; } else { in.ignore( "SET", tok.c_str() ); } } return stream; } @ \section{The Class Definition} \label{sec:set-class} This class includes all of the methods declared above. And, it includes some version identification information. <>= class csgset : public object { protected: <> public: <> public: static const char* id; }; @ \section{Source Files} The following sections assemble the source files for the [[set]] class from the chunks above. \subsection{[[set.h]]} The header file the [[set]] class includes the [[iostream]], [[string]], and [[map]] headers from the standard C++ libraries and the header file for the [[object]] base class and then incorporates the class defined in \ref{sec:set-class} above. All of this is wrapped in syntactic sugar to avoid problems should this file be included more than once. <>= #ifndef _NKLEIN_SET_H_ #define _NKLEIN_SET_H_ 1 #include #include #include #include "object.h" <> #endif /*_NKLEIN_SET_H_*/ @ \subsection{[[set.cc]]} Herein, the implementations of the methods of the [[set]] class are included. <>= #include #include #include #ifndef MAXFLOAT #include #endif #include "input.h" #include "set.h" const char* csgset::id = "NKVERSION: csgset( RT_VERSION )"; <> @ ./rt2.7.2007.05.17/nws/csg-union.nw0100644000077300007650000002552710032117733014362 0ustar patpat@ \chapter{Union} \label{sec:union} The union is a CSG (Constructive Solid Geometry) primitive. If this object contains sub-objects $A_i$, then this object represents the object with boundary $ \partial \bigcup A_i $. The union contains zero or more sub-objects. And, it can specify parameters from the base object class. <>= csg_union_params ::= 'object' object_type_and_params ';' | 'base' '{' object_parameters '}' ';' ; @ The following snippets are used so that the object's factory method can create instance of this class. <>= #include "union.h" @ <>= if ( objectType == "union" ) { csgunion* obj = new csgunion( ss ); stream >> *obj >> semicolon; return obj; } else @ The [[union]] class is a subclass of the [[object]] class from \ref{sec:object}. It contains a list of sub-objects. <>= std::vector< object* > objs; @ \section{Constructor} The default constructor does nothing. <>= csgunion( const scene* ss ); @ <>= csgunion::csgunion( const scene* ss ) : object( ss ) { } @ \section{Destructor} This destructor has to release all of the sub-objects. <>= virtual ~csgunion( void ); @ <>= csgunion::~csgunion( void ) { std::vector< object* >::iterator it; for ( it=this->objs.begin(); it != this->objs.end(); ++it ) { delete *it; } }; @ \section{Setting The Number of Dimensions} This method has to update the dimension of all of its sub-objects and the base class. <>= virtual void setDimensions( unsigned int dd ); @ <>= void csgunion::setDimensions( unsigned int dd ) { std::vector< object* >::iterator it; for ( it=this->objs.begin(); it != this->objs.end(); ++it ) { (*it)->setDimensions( dd ); } this->object::setDimensions( dd ); } @ \section{Intersection A Ray And A Union} This first intersection method retrieves only the closest intersection to the ray's origin. The ray is specified by its direction and start. <>= virtual bool intersect( const mathvec< double >& direction, const mathvec< double >& start, intersection& hit ) const; @ <>= bool csgunion::intersect( const mathvec< double >& direction, const mathvec< double >& start, intersection& hit ) const { std::vector< intersection* > hits; bool ret = this->intersect( direction, start, hits ); if ( ret ) { hit = *hits[ 0 ]; std::vector< intersection* >::iterator it; for ( it = hits.begin(); it != hits.end(); ++it ) { delete *it; } } return ret; } @ This second intersection method retrieves all intersections between this union and the ray. The ray is specified by its direction and start. The array of hits is sorted in order of increasing distance from the start of the ray. <>= virtual bool intersect( const mathvec< double >& direction, const mathvec< double >& start, std::vector< intersection* >& hits ) const; @ <>= bool csgunion::intersect( const mathvec< double >& direction, const mathvec< double >& start, std::vector< intersection* >& hits ) const { hits.clear(); <> <> if ( gotHit ) { <> <> if ( hits.size() == 0 ) { intersection* nn = new intersection(); this->forgeHit( direction, start, *nn ); hits.insert( hits.end(), nn ); } } return gotHit; } @ <>= mathvec< double > rd = direction; rd.antirotate( this->orientation ); rd /= this->scale; rd.normalize(); mathvec< double > rp = start - this->center; rp.antirotate( this->orientation ); rp /= this->scale; @ <>= unsigned int len = this->objs.size(); std::vector< std::vector< intersection* > > hitLists( len ); std::vector< unsigned int > hitStarts( len ); bool gotHit = false; bool amInside = false; for ( unsigned int ii=0; ii < len; ++ii ) { std::vector< intersection* >& curHits( hitLists[ ii ] ); object* obj = this->objs[ ii ]; if ( obj->intersect( rd, rp, curHits ) ) { gotHit = true; if ( ! amInside ) { amInside = curHits[ 0 ]->isInside(); } } hitStarts[ ii ] = 0; } @ <>= intersection* bestHit; unsigned int bestII = 0; unsigned int bestJJ = 0; do { bestHit = 0; if ( amInside ) { <> } else { <> <> } if ( bestHit != 0 ) { <> } amInside = !amInside; } while ( bestHit != 0 ); @ <>= bool done = false; while ( !done ) { <> <> } @ <>= bool notSet = true; double dist = MAXFLOAT; for ( unsigned int ii=0; ii < len; ++ii ) { std::vector< intersection* >& curHits( hitLists[ ii ] ); unsigned int hStart = hitStarts[ ii ]; unsigned int hLen = curHits.size(); if ( hStart < hLen ) { intersection* hit = curHits[ hStart ]; if ( hit->isInside() ) { double curDist = hit->getDistance(); if ( notSet || curDist < dist ) { bestII = ii; bestJJ = hStart; bestHit = hit; dist = curDist - 0.000001; notSet = false; } } } } if ( bestHit == 0 ) { break; } else { hitStarts[ bestII ] = bestJJ + 1; } @ Assume we're done unless something is inside. <>= bool outsideAll = true; for ( unsigned int ii=0; outsideAll && ii < len; ++ii ) { if ( ii == bestII ) { continue; } std::vector< intersection* >& curHits( hitLists[ ii ] ); unsigned int hLen = curHits.size(); for ( unsigned int jj=hitStarts[ ii ]; jj < hLen; ++jj ) { intersection* hit = curHits[ jj ]; double curDist = hit->getDistance(); if ( curDist < dist ) { ++hitStarts[ ii ]; } else if ( hit->isInside() ) { outsideAll = false; break; } else { break; } } if ( hitStarts[ ii ] == hLen && hLen > 0 && curHits[ hLen-1 ] != 0 && curHits[ hLen-1 ]->isOutside() ) { outsideAll = false; } } if ( !outsideAll ) { bestHit = 0; } else { done = true; } @ <>= bool notSet = true; double dist = MAXFLOAT; for ( unsigned int ii=0; ii < len; ++ii ) { std::vector< intersection* >& curHits( hitLists[ ii ] ); unsigned int hStart = hitStarts[ ii ]; unsigned int hLen = curHits.size(); if ( hStart < hLen ) { intersection* hit = curHits[ hStart ]; if ( hit->isOutside() ) { double curDist = hit->getDistance(); if ( notSet || curDist < dist ) { bestII = ii; bestJJ = hStart; bestHit = hit; dist = curDist - 0.000001; notSet = false; } } } } @ <>= if ( bestHit != 0 ) { for ( unsigned int ii=0; ii < len; ++ii ) { if ( ii == bestII ) { continue; } std::vector< intersection* >& curHits( hitLists[ ii ] ); unsigned int hLen = curHits.size(); for ( unsigned int jj=hitStarts[ ii ]; jj < hLen; ++jj ) { intersection* hit = curHits[ jj ]; double curDist = hit->getDistance(); if ( curDist < dist ) { ++hitStarts[ ii ]; } } } } @ <>= std::vector< intersection* >& curHits( hitLists[ bestII ] ); curHits[ bestJJ ] = 0; hitStarts[ bestII ] = bestJJ+1; bestHit->reorient( this->scale, this->orientation, this->center ); bestHit->setDistance( ( bestHit->getPosition() - start ).magnitude() ); if ( this->gotColor ) { bestHit->recolor( this->chroma ); } hits.insert( hits.end(), bestHit ); @ <>= for ( unsigned int ii=0; ii < len; ++ii ) { std::vector< intersection* >& curHits( hitLists[ ii ] ); unsigned int hLen = curHits.size(); for ( unsigned int jj=0; jj < hLen; ++jj ) { delete curHits[ jj ]; } curHits.clear(); } @ \section{Checking If A Point Is Inside A Union} <>= virtual bool inside( const mathvec< double >& start ) const; virtual bool _inside( const mathvec< double >& rp ) const; @ <>= bool csgunion::inside( const mathvec< double >& start ) const { mathvec< double > rp = start - this->center; rp.antirotate( this->orientation ); rp /= this->scale; return this->_inside( rp ); } bool csgunion::_inside( const mathvec< double >& rp ) const { unsigned int len = this->objs.size(); bool outside = true; for ( unsigned int ii=0; outside && ii < len; ++ii ) { outside = ! this->objs[ ii ]->inside( rp ); } return ! outside; } @ \section{Loading A Union} The following method allows one to read in an union from a stream. <>= friend std::istream& operator >> ( std::istream& in, csgunion& cc ); @ <>= std::istream& operator >> ( std::istream& stream, csgunion& cc ) { input in( stream ); while ( in.check() ) { char token[ input::MAX_TOKEN_LEN ]; if ( in.get( token, sizeof(token) ) == 0 ) { return stream; } std::string tok( token ); char semicolon; if ( tok == "object" ) { object* nn = object::read( stream, cc.myScene ); if ( nn != 0 ) { cc.objs.insert( cc.objs.end(), nn ); } else { std::cerr << "UNION failed loading an object!" << std::endl; } } else if ( tok == "base" ) { stream >> (object&)cc >> semicolon; } else { in.ignore( "UNION", tok.c_str() ); } } return stream; } @ \section{The Class Definition} \label{sec:union-class} This class includes all of the methods declared above. And, it includes some version identification information. <>= class csgunion : public object { protected: <> public: <> public: static const char* id; }; @ \section{Source Files} The following sections assemble the source files for the [[union]] class from the chunks above. \subsection{[[union.h]]} The header file the [[union]] class includes the [[iostream]], [[string]], and [[map]] headers from the standard C++ libraries and the header file for the [[object]] base class and then incorporates the class defined in \ref{sec:union-class} above. All of this is wrapped in syntactic sugar to avoid problems should this file be included more than once. <>= #ifndef _NKLEIN_UNION_H_ #define _NKLEIN_UNION_H_ 1 #include #include #include #include "object.h" <> #endif /*_NKLEIN_UNION_H_*/ @ \subsection{[[union.cc]]} Herein, the implementations of the methods of the [[union]] class are included. <>= #include #include #include #ifndef MAXFLOAT #include #endif #include "input.h" #include "union.h" const char* csgunion::id = "NKVERSION: csgunion( RT_VERSION )"; <> @ ./rt2.7.2007.05.17/nws/cylinder.nw0100644000077300007650000003065710623062030014264 0ustar patpat@ \chapter{Cylinder} \label{sec:cylinder} The cylinder has a certain number of round dimensions ($r$) in an $n$-dimensional scene (where $0 \le r \le n$). The cylinder (before it is scale, oriented, and positioned) is all points $\vec{x}$ such that $ \sum_{i=1}{r} x_i^2 \le 1 $ and $\max_{i=r+1}^{n} x_i^2 \le 1$. The sphere is the special case where $r = n$ and the cube is the special case where $r = 0$ (or $r = 1$). The cylinder uses a parameter specifying $r$ the number of round dimensions and can specify the parameters for the object base class. <>= cylinder_params ::= 'roundDimensions' integer ';' | 'base' '{' object_parameters '}' ';' ; @ The following snippets are used so that the object's factory method can create instance of this class. <>= #include "cylinder.h" @ <>= if ( objectType == "cylinder" ) { cylinder* obj = new cylinder( ss ); stream >> *obj >> semicolon; return obj; } else @ The [[cylinder]] class is a subclass of the [[object]] class from \ref{sec:object}. It implements spheres, cubes, and all of the cylinders in between. In addition to the properties of all [[object]]s, the cylinder tracks the number of round dimensions. If the number of round dimensions is $r$ and the number of dimensions overall is $n$, then the cylinder obeys the following: $$x_1^2 + x_2^2 + \cdots + x_r^2 \leq 1$$ $$\left| x_{r+1} \right| \leq 1$$ $$\left| x_{r+2} \right| \leq 1$$ $$\cdots$$ $$\left| x_{n} \right| \leq 1$$ <>= unsigned int roundDimensions; @ In addition, the class keeps a mask where the first round dimensions are ones and the remaining entries are zero. <>= mathvec< double > sphereMask; @ \section{Constructor} The default constructor does nothing. <>= cylinder( const scene* ss ); @ <>= cylinder::cylinder( const scene* ss ) : object( ss ) { } @ There is a constructor which takes a radius and makes this a sphere. <>= cylinder( double radius, const scene* ss ); @ <>= cylinder::cylinder( double radius, const scene* ss ) : object( ss ) { this->defaultScale = radius; this->roundDimensions = ~0U; } @ \section{Destructor} This destructor has nothing to do. <>= virtual ~cylinder( void ); @ <>= cylinder::~cylinder( void ) { }; @ \section{Setting The Number of Dimensions} Even though this method is virtual, there is an implementation that derived classes should invoke. <>= virtual void setDimensions( unsigned int dd ); @ <>= void cylinder::setDimensions( unsigned int dd ) { this->sphereMask.resize( dd ); if ( this->roundDimensions == 1 ) { this->roundDimensions = 0; } if ( this->roundDimensions > dd ) { this->roundDimensions = dd; } for ( unsigned int ii=0; ii < this->roundDimensions; ++ii ) { this->sphereMask[ ii ] = 1.0; } for ( unsigned int ii=this->roundDimensions; ii < dd; ++ii ) { this->sphereMask[ ii ] = 0.0; } this->object::setDimensions( dd ); } @ \section{Intersection A Ray And A Cylinder} This first intersection method retrieves only the closest intersection to the ray's origin. The ray is specified by its direction and start. <>= virtual bool intersect( const mathvec< double >& direction, const mathvec< double >& start, intersection& hit ) const; @ <>= bool cylinder::intersect( const mathvec< double >& direction, const mathvec< double >& start, intersection& hit ) const { <> if ( !hitSphere || !hitCube ) { if ( this->_inside( rp ) ) { this->forgeHit( direction, start, hit ); return true; } else { return false; } } if ( t1 >= 0.000001 ) { mathvec< double >& nn( n1 ); double tt = t1; double normalFactor = 1.0; <> hit.setOutside(); } else if ( t2 >= 0.000001 ) { mathvec< double >& nn( n2 ); double tt = t2; double normalFactor = -1.0; <> hit.setInside(); } else { return false; } return true; } @ <>= mathvec< double > rd = direction; rd.antirotate( this->orientation ); rd /= this->scale; rd.normalize(); mathvec< double > rp = start - this->center; rp.antirotate( this->orientation ); rp /= this->scale; double t1 = -MAXFLOAT; double t2 = MAXFLOAT; mathvec< double > n1; mathvec< double > n2; bool hitSphere = this->sphereIntersect( rd, rp, &t1, &t2 ); bool hitCube = hitSphere && this->cubeIntersect( rd, rp, &t1, &t2, n1, n2 ); @ <>= mathvec< double > spot = rp + ( rd * tt ); if ( nn.size() == 0 ) { nn = spot * this->sphereMask * normalFactor; nn.normalize(); } hit.setObjectPosition( spot ); hit.setObjectNormal( nn ); hit.setObjectDirection( rd ); hit.setPosition( spot ); hit.setNormal( nn ); hit.setDirection( rd ); hit.reorient( this->scale, this->orientation, this->center ); hit.setDistance( ( hit.getPosition() - start ).magnitude() ); hit.setObjectColor( &this->chroma ); @ This second intersection method retrieves all intersections between this cylinder and the ray. The ray is specified by its direction and start. The array of hits is sorted in order of increasing distance from the start of the ray. <>= virtual bool intersect( const mathvec< double >& direction, const mathvec< double >& start, std::vector< intersection* >& hits ) const; @ <>= bool cylinder::intersect( const mathvec< double >& direction, const mathvec< double >& start, std::vector< intersection* >& hits ) const { <> hits.clear(); if ( !hitSphere || !hitCube ) { if ( this->_inside( rp ) ) { intersection* hh = new intersection(); this->forgeHit( direction, start, *hh ); hits.insert( hits.end(), hh ); return true; } else { return false; } } if ( t1 >= 0.000001 ) { intersection* h1 = new intersection(); intersection& hit( *h1 ); mathvec< double >& nn( n1 ); double tt = t1; double normalFactor = 1.0; <> hit.setOutside(); hits.insert( hits.end(), h1 ); } if ( t2 >= 0.000001 ) { intersection* h2 = new intersection(); intersection& hit( *h2 ); mathvec< double >& nn( n2 ); double tt = t2; double normalFactor = -1.0; <> hit.setInside(); hits.insert( hits.end(), h2 ); } return hits.size() > 0; } @ \subsection{Intersecting With The Spherical Portions} <>= bool sphereIntersect( const mathvec< double >& direction, const mathvec< double >& start, double* t1, double* t2 ) const; @ <>= bool cylinder::sphereIntersect( const mathvec< double >& direction, const mathvec< double >& start, double* t1, double* t2 ) const { if ( this->roundDimensions == 0 ) { return true; } mathvec< double > rds = direction * this->sphereMask; mathvec< double > rps = start * this->sphereMask; double aa = rds ^ rds; double cc = ( rps ^ rps ) - 1.0; if ( aa < 0.000001 ) { return ( cc < 0.000001 ); } double bb = 2.0 * ( rds ^ rps ); double discriminant = bb * bb - 4.0 * aa * cc; if ( discriminant < 0.000001 ) { return false; } double root = ::sqrt( discriminant ); if ( aa > 0 ) { *t1 = ( -bb - root ) / ( 2.0 * aa ); *t2 = ( -bb + root ) / ( 2.0 * aa ); } else { *t1 = ( -bb + root ) / ( 2.0 * aa ); *t2 = ( -bb - root ) / ( 2.0 * aa ); } if ( *t2 < 0.000001 ) { return false; } return true; } @ \subsection{Intersecting With The Cubical Portions} <>= bool cubeIntersect( const mathvec< double >& direction, const mathvec< double >& start, double* t1, double* t2, mathvec< double >& n1, mathvec< double >& n2 ) const; @ <>= bool cylinder::cubeIntersect( const mathvec< double >& direction, const mathvec< double >& start, double* t1, double* t2, mathvec< double >& n1, mathvec< double >& n2 ) const { unsigned int dims = this->center.size(); if ( this->roundDimensions == dims ) { return true; } unsigned int n1dim = dims; double n1mag = 1.0; unsigned int n2dim = dims; double n2mag = 1.0; for ( unsigned int ii=this->roundDimensions; ii < dims; ++ii ) { double t1c; double t2c; double nn = direction[ ii ]; double ss = start[ ii ]; if ( ::fabs( nn ) < 0.000001 ) { if ( ss < -1.0 || ss > 1.0 ) { return false; } else { continue; } } t1c = ( -ss + 1.0 ) / nn; t2c = ( -ss - 1.0 ) / nn; if ( t1c < 0.000001 && t2c < 0.000001 ) { return false; } double mag = 1.0; if ( t1c > t2c ) { double tmp = t1c; t1c = t2c; t2c = tmp; mag = -1.0; } if ( t2c < *t1 || t1c > *t2 ) { return false; } if ( t1c > *t1 ) { *t1 = t1c; n1dim = ii; n1mag = mag; } if ( t2c < *t2 ) { *t2 = t2c; n2dim = ii; n2mag = mag; } } if ( n1dim < dims ) { n1.resize( dims, 0.0 ); n1[ n1dim ] = n1mag; } if ( n2dim < dims ) { n2.resize( dims, 0.0 ); n2[ n2dim ] = n2mag; } return true; } @ \section{Checking If A Point Is Inside A Cylinder} <>= virtual bool inside( const mathvec< double >& start ) const; virtual bool _inside( const mathvec< double >& rp ) const; @ <>= bool cylinder::inside( const mathvec< double >& start ) const { mathvec< double > rp = start - this->center; rp.antirotate( this->orientation ); rp /= this->scale; return this->_inside( rp ); } bool cylinder::_inside( const mathvec< double >& rp ) const { unsigned int dims = this->center.size(); for ( unsigned int ii=this->roundDimensions; ii < dims; ++ii ) { if ( ::fabs( rp[ ii ] ) > 1.0 ) { return false; } } double sum = 0.0; for ( unsigned int ii=0; ii < this->roundDimensions; ++ii ) { sum += rp[ ii ] * rp[ ii ]; } return sum <= 1.0; } @ \section{Loading A Cylinder} The following method allows one to read in an cylinder from a stream. <>= friend std::istream& operator >> ( std::istream& in, cylinder& cc ); @ <>= std::istream& operator >> ( std::istream& stream, cylinder& cc ) { input in( stream ); cc.roundDimensions = 0; while ( in.check() ) { char token[ input::MAX_TOKEN_LEN ]; if ( in.get( token, sizeof(token) ) == 0 ) { return stream; } std::string tok( token ); char semicolon; if ( tok == "roundDimensions" ) { stream >> cc.roundDimensions >> semicolon; } else if ( tok == "base" ) { stream >> (object&)cc >> semicolon; } else { in.ignore( "CYLINDER", tok.c_str() ); } } return stream; } @ \section{The Class Definition} \label{sec:cylinder-class} This class includes all of the methods declared above. And, it includes some version identification information. <>= class cylinder : public object { protected: <> <> public: <> public: static const char* id; }; @ \section{Source Files} The following sections assemble the source files for the [[cylinder]] class from the chunks above. \subsection{[[cylinder.h]]} The header file the [[cylinder]] class includes the [[iostream]] and [[string]] headers from the standard C++ libraries and the header file for the [[mathvec<>]] class and then incorporates the class defined in \ref{sec:cylinder-class} above. All of this is wrapped in syntactic sugar to avoid problems should this file be included more than once. <>= #ifndef _NKLEIN_CYLINDER_H_ #define _NKLEIN_CYLINDER_H_ 1 #include #include #include #include "object.h" <> #endif /*_NKLEIN_CYLINDER_H_*/ @ \subsection{[[cylinder.cc]]} Herein, the implementations of the methods of the [[cylinder]] class are included as well as the the declarations and implementations of the derived classes. <>= #include #include #include #ifndef MAXFLOAT #include #endif #include "input.h" #include "cylinder.h" const char* cylinder::id = "NKVERSION: cylinder( RT_VERSION )"; <> @ ./rt2.7.2007.05.17/nws/end.nw0100644000077300007650000000002107745455373013232 0ustar patpat@ \end{document} ./rt2.7.2007.05.17/nws/expr-binary.nw0100644000077300007650000001615610255630622014722 0ustar patpat@ \chapter{Binary Expressions} \label{sec:expr-binary} There are a few different binary operations one could employ in the raytracer. <>= binary_operation ::= '+' expr expr | '-' expr expr | '*' expr expr | '/' expr expr | '%' expr expr | 'div' expr expr | 'atan2' expr expr | '^' expr expr | 'pow' expr expr | 'max' expr expr | 'min' expr expr ; @ For example, if one wanted the red color to be the absolute value of the arctangent of the x- and y-coordinates, then one could specify: <>= channels [3]< abs atan2 pos 0 pos 1, 0, 0 >; @ The binary expression class tracks its evaluation function and its operand expressions. <>= double (*func)( double, double ); expr* left; expr* right; @ \section{Constructor} The binary expression is initialized with its evaluation function. <>= exprBinary( double (*_func)( double, double ) ) : func( _func ), left( 0 ), right( 0 ) { }; @ \section{Destructor} <>= ~exprBinary( void ) { delete this->right; delete this->left; }; @ \section{Checking For Constness} The binary expression is constant if and only if both of its operands are constant. <>= virtual bool isConstant( void ) const { return this->left->isConstant() && this->right->isConstant(); }; @ <>= virtual bool usesPosition( void ) const { return this->left->usesPosition() || this->right->usesPosition(); }; @ <>= virtual bool usesNormal( void ) const { return this->left->usesNormal() || this->right->usesNormal(); }; @ <>= virtual bool usesDirection( void ) const { return this->left->usesDirection() || this->right->usesDirection(); }; @ \section{Evaluating The Expression} To evaluate a binary operation, both of the operands are evaluated and passed to the function which evaluates this operation given the operands. <>= virtual double evaluate( const mathvec& pos, const mathvec& norm, const mathvec& dir ) { return (*this->func)( this->left->evaluate( pos, norm, dir ), this->right->evaluate( pos, norm, dir ) ); } @ \section{Reading In A Binary Expression} With a binary expression, there are two operands to read. <>= virtual std::istream& get( std::istream& in, const std::map< std::string, class portal* >& portals ) { delete this->left; this->left = expr::read( in, portals ); delete this->right; this->right = expr::read( in, portals ); return in; }; @ \section{The Binary Expression Table} \label{sec:BinaryExpressionTable-class} The following class is used in reading expressions to efficiently store and return named binary expressions. <>= class BinaryExpressionTable { protected: typedef double (*FunctionType)( double, double ); typedef std::map< std::string, FunctionType > TableType; typedef TableType::const_iterator const_iterator; TableType table; public: BinaryExpressionTable( void ); exprBinary* operator [] ( const std::string& name ) const; static double add( double aa, double bb ); static double sub( double aa, double bb ); static double mul( double aa, double bb ); static double div( double aa, double bb ); static double mod( double aa, double bb ); static double idiv( double aa, double bb ); static double min( double aa, double bb ); static double max( double aa, double bb ); public: static const char* id; }; const char* BinaryExpressionTable::id = "NKVERSION: BinaryExpressionTable( RT_VERSION )"; @ The constructor initializes the table of binary expressions with pointers to functions which implement the expressions. These are the binary expressions known to this raytracer. <>= BinaryExpressionTable::BinaryExpressionTable( void ) { this->table[ "+" ] = BinaryExpressionTable::add; this->table[ "-" ] = BinaryExpressionTable::sub; this->table[ "*" ] = BinaryExpressionTable::mul; this->table[ "/" ] = BinaryExpressionTable::div; this->table[ "%" ] = BinaryExpressionTable::mod; this->table[ "div" ] = BinaryExpressionTable::idiv; this->table[ "atan2" ] = (double (*)( double, double ))::atan2; this->table[ "^" ] = (double (*)( double, double ))::pow; this->table[ "min" ] = BinaryExpressionTable::min; this->table[ "max" ] = BinaryExpressionTable::max; } @ The array accessor for this table checks to see if the element is in the table. If it is, then it returns a constant expression for that element. Otherwise, it returns null. <>= exprBinary* BinaryExpressionTable::operator [] ( const std::string& name ) const { const_iterator it = this->table.find( name ); if ( it != this->table.end() ) { return new exprBinary( it->second ); } else { return 0; } } @ Most of the binary operations which this class implements itself are very straightforward. <>= double BinaryExpressionTable::add( double aa, double bb ) { return aa + bb; } double BinaryExpressionTable::sub( double aa, double bb ) { return aa - bb; } double BinaryExpressionTable::mul( double aa, double bb ) { return aa * bb; } double BinaryExpressionTable::div( double aa, double bb ) { return aa / bb; } @ The [[mod()]] function deserves special attention, however. Here, the remainder is determined through the use of the [[modf()]] from the math library. The [[modf()]] splits the quotient [[aa/bb]] into an integer portion [[ii]] and a remainder between zero and one [[rr]]. That remainder is then returned scaled back up into the range zero to [[bb]]. <>= double BinaryExpressionTable::mod( double aa, double bb ) { double ii; double rr = ::modf( aa / bb, &ii ); return rr * bb; } @ The [[idiv()]] function serves a similar purpose except that it returns the integer multiple of [[bb]] rather than the remainder. <>= double BinaryExpressionTable::idiv( double aa, double bb ) { double ii; (void) ::modf( aa / bb, &ii ); return ii * bb; } @ The [[min()]] and [[max()]] functions are easy. <>= double BinaryExpressionTable::min( double aa, double bb ) { if ( aa < bb ) { return aa; } else { return bb; } } double BinaryExpressionTable::max( double aa, double bb ) { if ( aa < bb ) { return bb; } else { return aa; } } @ \section{The Class Definition} \label{sec:expr-binary-class} This class inherits directly from the [[expr]] class. It includes all of the methods declared above. And, it includes some version identification information. <>= class exprBinary : public expr { public: <> protected: <> public: static const char* id; }; const char* exprBinary::id = "NKVERSION: exprBinary( RT_VERSION )"; @ ./rt2.7.2007.05.17/nws/expr-const.nw0100644000077300007650000000706110031146402014545 0ustar patpat@ \chapter{Constant Expressions} \label{sec:expr-const} There are several named constant expressions and numerical constants. <>= constant_expr ::= 'pi' | '2pi' | 'e' | 'sqrt2' | real ; @ The numerical constant is simply stored within this expression. <>= double value; @ \section{Constructor} The expression is initialized with a value. <>= exprConst( double _value ) : value( _value ) {}; @ \section{Checking For Constness} This expression is entirely constant. <>= virtual bool isConstant( void ) const { return true; }; @ <>= virtual bool usesPosition( void ) const { return false; }; @ <>= virtual bool usesNormal( void ) const { return false; }; @ <>= virtual bool usesDirection( void ) const { return false; }; @ \section{Evaluating The Expression} This method returns the value of the constant directly. <>= virtual double evaluate( const mathvec& /*position*/, const mathvec& /*normal*/, const mathvec& /*direction*/ ) { return this->value; } @ \section{Reading In A Constant Expression} With a constant expression, by the time it is initialized, it already has all of its information. This [[get()]] method doesn't have anything to do then. <>= virtual std::istream& get( std::istream& in, const std::map< std::string, class portal* >& /*portals*/ ) { return in; }; @ \section{The Constant Expression Table} \label{sec:ConstantExpressionTable-class} The following class is used in reading expressions to efficiently store and return named constant values. <>= class ConstantExpressionTable { protected: typedef std::map< std::string, double > TableType; typedef TableType::const_iterator const_iterator; TableType table; public: ConstantExpressionTable( void ); exprConst* operator [] ( const std::string& name ) const; public: static const char* id; }; const char* ConstantExpressionTable::id = "NKVERSION: ConstantExpressionTable( RT_VERSION )"; @ The constructor initializes the table of constant expressions with the known constants. These are the constant expressions known to this raytracer. <>= ConstantExpressionTable::ConstantExpressionTable( void ) { this->table[ "pi" ] = M_PI; this->table[ "2pi" ] = 2.0 * M_PI; this->table[ "e" ] = M_E; this->table[ "sqrt2" ] = M_SQRT2; } @ The array accessor for this table checks to see if the element is in the table. If it is, then it returns a constant expression for that element. Otherwise, it returns null. <>= exprConst* ConstantExpressionTable::operator [] ( const std::string& name ) const { const_iterator it = this->table.find( name ); if ( it != this->table.end() ) { return new exprConst( it->second ); } else { return 0; } } @ \section{The Class Definition} \label{sec:expr-const-class} This class inherits directly from the [[expr]] class. It includes all of the methods declared above. And, it includes some version identification information. <>= class exprConst : public expr { public: <> protected: <> public: static const char* id; }; const char* exprConst::id = "NKVERSION: exprConst( RT_VERSION )"; @ ./rt2.7.2007.05.17/nws/expr-dir.nw0100644000077300007650000000601110031144702014170 0ustar patpat@ \chapter{Direction Expressions} \label{sec:expr-direction} The color of an object can be a function of the direction from which it is viewed. The [[expr]] operand to this call is used as the coordinate index within the direction vector. <>= dir_expr ::= 'dir' expr ; @ As an example, suppose one wants a particular object to look bright blue when seen directly along the x-axis and less blue the further away from the x-axis one gets. One might specify the color as: <>= channels [3]< 0.5, 0.5, + 0.5 * 0.5 abs dir 0 >; @ That is to say that the red and green channels are always set at a half. But, the blue channel is a half plus half the absolute value of the x-coordinate in the direction vector. The direction expression needs a single operand telling which coordinate of the direction to use. <>= expr* operand; @ \section{Constructor} <>= exprDirection( void ) : operand( 0 ) { }; @ \section{Destructor} <>= ~exprDirection( void ) { delete this->operand; }; @ \section{Checking For Constness} As this depends upon the direction vector for the color, it cannot be taken as a constant. <>= virtual bool isConstant( void ) const { return false; }; @ <>= virtual bool usesPosition( void ) const { return this->operand->usesPosition(); }; @ <>= virtual bool usesNormal( void ) const { return this->operand->usesNormal(); }; @ <>= virtual bool usesDirection( void ) const { return true; }; @ \section{Evaluating The Expression} To evaluate the direction, the method here evaluates the operand expression, rounds the result to an integer, and returns that coordinate from the direction vector. <>= virtual double evaluate( const mathvec& pos, const mathvec& norm, const mathvec& dir ) { double op = this->operand->evaluate( pos, norm, dir ); unsigned int index = (unsigned int)( op + 0.5 ); return dir[ index ]; } @ \section{Reading In A Direction Expression} With a direction expression, there is one operand to read. <>= virtual std::istream& get( std::istream& in, const std::map< std::string, class portal* >& portals ) { delete this->operand; this->operand = expr::read( in, portals ); return in; }; @ \section{The Class Definition} \label{sec:expr-direction-class} This class inherits directly from the [[expr]] class. It includes all of the methods declared above. And, it includes some version identification information. <>= class exprDirection : public expr { public: <> protected: <> public: static const char* id; }; const char* exprDirection::id = "NKVERSION: exprDirection( RT_VERSION )"; @ ./rt2.7.2007.05.17/nws/expr-norm.nw0100644000077300007650000000551310031144227014375 0ustar patpat@ \chapter{Normal Expressions} \label{sec:expr-normal} The color of an object can be a function of the normal at that point. The [[expr]] operand to this call is used as the coordinate index within the normal. <>= norm_expr ::= 'norm' expr ; @ As an example, if one wanted to color a 3-D object based upon the normal of the object at the point of intersection with the x-coordinate giving the red channel, the y-coordinate giving the green channel, and the z-coordinate giving the blue channel, one would specify the color channels like this: <>= channels [3]< norm 0, norm 1, norm 2 >; @ The normal expression needs a single operand telling which coordinate of the normal to use. <>= expr* operand; @ \section{Constructor} <>= exprNormal( void ) : operand( 0 ) { }; @ \section{Destructor} <>= ~exprNormal( void ) { delete this->operand; }; @ \section{Checking For Constness} As this depends upon the normal vector for the color, it cannot be taken as a constant. <>= virtual bool isConstant( void ) const { return false; }; @ <>= virtual bool usesPosition( void ) const { return this->operand->usesPosition(); }; @ <>= virtual bool usesNormal( void ) const { return true; }; @ <>= virtual bool usesDirection( void ) const { return this->operand->usesDirection(); }; @ \section{Evaluating The Expression} To evaluate the normal, the method here evaluates the operand expression, rounds the result to an integer, and returns that coordinate from the normal vector. <>= virtual double evaluate( const mathvec& pos, const mathvec& norm, const mathvec& dir ) { double op = this->operand->evaluate( pos, norm, dir ); unsigned int index = (unsigned int)( op + 0.5 ); return norm[ index ]; } @ \section{Reading In A Normal Expression} With a normal expression, there is one operand to read. <>= virtual std::istream& get( std::istream& in, const std::map< std::string, class portal* >& portals ) { delete this->operand; this->operand = expr::read( in, portals ); return in; }; @ \section{The Class Definition} \label{sec:expr-normal-class} This class inherits directly from the [[expr]] class. It includes all of the methods declared above. And, it includes some version identification information. <>= class exprNormal : public expr { public: <> protected: <> public: static const char* id; }; const char* exprNormal::id = "NKVERSION: exprNormal( RT_VERSION )"; @ ./rt2.7.2007.05.17/nws/expr-pos.nw0100644000077300007650000000534510031146061014224 0ustar patpat@ \chapter{Position Expressions} \label{sec:expr-position} The color of an object can be a function of the position at that point. The [[expr]] operand to this call is used as the coordinate index within the position vector. <>= pos_expr ::= 'pos' expr ; @ For example, if one wanted an object to be colored more red the further it was along the w-axis, one might specify the color with: <>= channels [3]< + 0.5 * 0.5 pos 3, 0.2, 0.2 >; @ The position expression needs a single operand telling which coordinate of the position to use. <>= expr* operand; @ \section{Constructor} <>= exprPosition( void ) : operand( 0 ) { }; @ \section{Destructor} <>= ~exprPosition( void ) { delete this->operand; }; @ \section{Checking For Constness} As this depends upon the position vector for the color, it cannot be taken as a constant. <>= virtual bool isConstant( void ) const { return false; }; @ <>= virtual bool usesPosition( void ) const { return true; }; @ <>= virtual bool usesNormal( void ) const { return this->operand->usesNormal(); }; @ <>= virtual bool usesDirection( void ) const { return this->operand->usesDirection(); }; @ \section{Evaluating The Expression} To evaluate the direction, the method here evaluates the operand expression, rounds the result to an integer, and returns that coordinate from the position vector. <>= virtual double evaluate( const mathvec& pos, const mathvec& norm, const mathvec& dir ) { double op = this->operand->evaluate( pos, norm, dir ); unsigned int index = (unsigned int)( op + 0.5 ); return pos[ index ]; } @ \section{Reading In A Position Expression} With a position expression, there is an operand to read. <>= virtual std::istream& get( std::istream& in, const std::map< std::string, class portal* >& portals ) { delete this->operand; this->operand = expr::read( in, portals ); return in; }; @ \section{The Class Definition} \label{sec:expr-position-class} This class inherits directly from the [[expr]] class. It includes all of the methods declared above. And, it includes some version identification information. <>= class exprPosition : public expr { public: <> protected: <> public: static const char* id; }; const char* exprPosition::id = "NKVERSION: exprPosition( RT_VERSION )"; @ ./rt2.7.2007.05.17/nws/expr-ref.nw0100644000077300007650000000642710031143557014210 0ustar patpat@ \chapter{Reference Expressions} \label{sec:expr-reference} The reference expression refers to a channel of a pixel traced through a portal. The [[portal_name]] tells which portal this references and the [[expr]] operand is used to determine which channel to employ. <>= ref_expr ::= '@' portal_name expr ; @ For example, if each of the color channels (red, green, and blue) were to be pulled from a separate portal, the [[channels]] vector specified in the color may look like this: <>= channels [3]< @ red_portal 0, @ green_portal 1, @ blue_portal 2 >; @ Similarly, if one wished to use only the green channel from the trace into the poral as the output channel in a view's viewport, one might do something like this: <>= channels [1]< @ my_portal 1 >; @ The reference expression needs a pixel to reference and a single operand telling which coordinate of the pixel to use. <>= const mathvec< double >& pixel; expr* operand; @ \section{Constructor} The constructor initializes the pixel reference. <>= exprReference( const mathvec< double >& pp ) : pixel( pp ), operand( 0 ) { }; @ \section{Destructor} When this expression is destroyed, it must destroy its operand expression. <>= ~exprReference( void ) { delete this->operand; }; @ \section{Checking For Constness} As this depends upon the reference vector for the color, it cannot be taken as a constant. <>= virtual bool isConstant( void ) const { return false; }; @ <>= virtual bool usesPosition( void ) const { return true; }; @ <>= virtual bool usesNormal( void ) const { return true; }; @ <>= virtual bool usesDirection( void ) const { return true; }; @ \section{Evaluating The Expression} To evaluate this expression, the operand is evaluated. Then, the operand is rounded to the nearest integer. The rounded integer is used to select the channel from the pixel. <>= virtual double evaluate( const mathvec& pos, const mathvec& norm, const mathvec& dir ) { double op = this->operand->evaluate( pos, norm, dir ); unsigned int index = (unsigned int)( op + 0.5 ); return this->pixel[ index ]; } @ \section{Reading In A Reference Expression} With a reference expression, there is one operand to read. <>= virtual std::istream& get( std::istream& in, const std::map< std::string, class portal* >& portals ) { delete this->operand; this->operand = expr::read( in, portals ); return in; }; @ \section{The Class Definition} \label{sec:expr-reference-class} This class inherits directly from the [[expr]] class. It includes all of the methods declared above. And, it includes some version identification information. <>= class exprReference : public expr { public: <> protected: <> public: static const char* id; }; const char* exprReference::id = "NKVERSION: exprReference( RT_VERSION )"; @ ./rt2.7.2007.05.17/nws/expr-unary.nw0100644000077300007650000001420110031677576014574 0ustar patpat@ \chapter{Unary Expressions} \label{sec:expr-unary} There are a fair number of unary expressions available within the raytracer. <>= unary_operation ::= 'sin' expr | 'cos' expr | 'tan' expr | 'atan' expr | 'sinh' expr | 'cosh' expr | 'tanh' expr | 'sqrt' expr | 'cbrt' expr | 'exp' expr | 'log' expr | 'log10' expr | 'fabs' expr | 'floor' expr | 'ceil' expr | 'rint' expr | 'round' expr | 'gamma' expr | 'lgamma' expr | 'erf' expr ; @ For example, if one wanted a blue and yellow checker pattern on an object, one might specify the color using: <>= channels [3]< 0.5, 0.5, + 0.5 * 0.5 sign * * cos * 10 pos 0 cos * 10 pos 1 cos * 10 pos 2 >; @ This says that the blue channel will be one half plus one half times the sign the products of ten times the cosines of the x, y, and z coordinates of the object. The class maintains a pointer to a function which can evaluate this unary expression. It also tracks the operand expression. <>= double (*func)( double ); expr* operand; @ \section{Constructor} <>= exprUnary( double (*_func)( double ) ) : func( _func ), operand( 0 ) { }; @ \section{Destructor} <>= ~exprUnary( void ) { delete this->operand; }; @ \section{Checking For Constness} A unary expression is constant if and only if its argument is constant. <>= virtual bool isConstant( void ) const { return this->operand->isConstant(); }; @ <>= virtual bool usesPosition( void ) const { return this->operand->usesPosition(); }; @ <>= virtual bool usesNormal( void ) const { return this->operand->usesNormal(); }; @ <>= virtual bool usesDirection( void ) const { return this->operand->usesDirection(); }; @ \section{Evaluating The Expression} To evaluate a unary expression, the argument is evaluated, then the value is passed into the unary expression routine. <>= virtual double evaluate( const mathvec& pos, const mathvec& norm, const mathvec& dir ) { return (*this->func)( this->operand->evaluate( pos, norm, dir ) ); } @ \section{Reading In A Unary Expression} With a unary expression, there is one operand to read. <>= virtual std::istream& get( std::istream& in, const std::map< std::string, class portal* >& portals ) { delete this->operand; this->operand = expr::read( in, portals ); return in; }; @ \section{The Unary Expression Table} \label{sec:UnaryExpressionTable-class} The following class is used in reading expressions to efficiently store and return [[expr]] instances which evaulate unary expressions. <>= class UnaryExpressionTable { protected: typedef double (*FunctionType)( double ); typedef std::map< std::string, FunctionType > TableType; typedef TableType::const_iterator const_iterator; TableType table; public: UnaryExpressionTable( void ); exprUnary* operator [] ( const std::string& name ) const; static double sign( double ); public: static const char* id; }; const char* UnaryExpressionTable::id = "NKVERSION: UnaryExpressionTable( RT_VERSION )"; @ The constructor initializes the table of unary expressions with pointers to functions which perform the evaluation. In this case, all of these expressions are from the standard math libary. These are the unary expressions known to this raytracer. <>= UnaryExpressionTable::UnaryExpressionTable( void ) { this->table[ "sin" ] = (double (*)( double ))::sin; this->table[ "cos" ] = (double (*)( double ))::cos; this->table[ "tan" ] = (double (*)( double ))::tan; this->table[ "atan" ] = (double (*)( double ))::atan; this->table[ "sinh" ] = (double (*)( double ))::sinh; this->table[ "cosh" ] = (double (*)( double ))::cosh; this->table[ "tanh" ] = (double (*)( double ))::tanh; this->table[ "sqrt" ] = (double (*)( double ))::sqrt; this->table[ "cbrt" ] = (double (*)( double ))::cbrt; this->table[ "exp" ] = (double (*)( double ))::exp; this->table[ "log" ] = (double (*)( double ))::log; this->table[ "log10" ] = (double (*)( double ))::log10; this->table[ "fabs" ] = (double (*)( double ))::fabs; this->table[ "floor" ] = (double (*)( double ))::floor; this->table[ "ceil" ] = (double (*)( double ))::ceil; this->table[ "rint" ] = (double (*)( double ))::rint; this->table[ "round" ] = (double (*)( double ))::rint; this->table[ "sign" ] = UnaryExpressionTable::sign; this->table[ "gamma" ] = (double (*)( double ))::gamma; this->table[ "lgamma" ] = (double (*)( double ))::lgamma; this->table[ "erf" ] = (double (*)( double ))::erf; } @ The only unary expression not available directly from the standard math library is the [[sign()]] function: <>= double UnaryExpressionTable::sign( double vv ) { if ( vv > 0.000001 ) { return 1.0; } else if ( vv < -0.000001 ) { return -1.0; } else { return 0.0; } } @ The array accessor for this table checks to see if the element is in the table. If it is, then it returns a constant expression for that element. Otherwise, it returns null. <>= exprUnary* UnaryExpressionTable::operator [] ( const std::string& name ) const { const_iterator it = this->table.find( name ); if ( it != this->table.end() ) { return new exprUnary( it->second ); } else { return 0; } } @ \section{The Class Definition} \label{sec:expr-unary-class} This class inherits directly from the [[expr]] class. It includes all of the methods declared above. And, it includes some version identification information. <>= class exprUnary : public expr { public: <> protected: <> public: static const char* id; }; const char* exprUnary::id = "NKVERSION: exprUnary( RT_VERSION )"; @ ./rt2.7.2007.05.17/nws/expr.nw0100644000077300007650000002572210032120217013422 0ustar patpat@ \chapter{Prefix Notation Expressions} \label{sec:expr} Expressions are used in the color class to provide functional texturing. As an example, <>= expr ::= binary_operation | unary_operation | constant_expr | pos_expr | dir_expr | norm_expr | ref_expr ; @ As a complicated example, the following color will place bands on a 4-dimensional ball that correspond to the polar coordinates. <>= channels [3]< + 0.5 * 0.5 sign cos * 10 atan2 pos 3 pos 2 , + 0.5 * 0.5 sign cos * 10 atan2 sqrt + * pos 3 pos 3 * pos 2 pos 2 pos 1 , + 0.5 * 0.5 sign cos * 10 atan2 sqrt + + * pos 3 pos 3 * pos 2 pos 2 * pos 1 pos 1 pos 0 >; @ Here, the polar coordinates are given by these expressions: $$ x = \cos \theta $$ $$ y = \sin \theta \cos \phi $$ $$ z = \sin \theta \sin \phi \cos \psi $$ $$ w = \sin \theta \sin \phi \sin \psi $$ The red channel is banded according to $\psi$. The green channel is banded according to $\phi$. The blue channel is banded according to $\theta$. $$ \psi = \mathrm{atan} \frac{w}{z} $$ $$ \phi = \mathrm{atan} \frac{\sqrt{ z^2 + w^2 }}{y} $$ $$ \theta = \mathrm{atan} \frac{\sqrt{ y^2 + z^2 + w^2 }}{x} $$ \section{Destructor} The destructor here in the base class is simply to allow the derived classes to be destructed. <>= virtual ~expr( void ); @ <>= expr::~expr( void ) {} @ \section{Checking For Constness} This method is an abstract method which allows the upper layers to check whether this expression is constant or not. If it is constant, it will be replaced by an [[exprConst]] instance. <>= virtual bool isConstant( void ) const = 0; virtual bool usesPosition( void ) const = 0; virtual bool usesNormal( void ) const = 0; virtual bool usesDirection( void ) const = 0; @ \section{Evaluating The Expression} This method is an abstract method which the expression overrides to evaluate the expression. <>= virtual double evaluate( const mathvec& position, const mathvec& normal, const mathvec& direction ) = 0; @ \section{Loading An Expression} There is a virtual method [[get()]] defined so that the [[read()]] methods below can read in derived expressions without having to worry about how that actually works. <>= virtual std::istream& get( std::istream& in, const std::map< std::string, class portal* >& portals ) = 0; @ The following methods are factory methods which allow the raytracer to read expressions in from a stream or a string. <>= static expr* read( std::istream& in, const std::map& portals ); static expr* read( const char* str, const std::map& portals ); @ This is a rather complicated method as prefix notation can be a bit ugly. <>= expr* expr::read( std::istream& stream, const std::map& portals ) { input in( stream ); if ( in.check() ) { char token[ input::MAX_TOKEN_LEN ]; if ( in.get( token, sizeof(token) ) == 0 ) { return 0; } std::string tok( token ); if ( tok == "pos" ) { expr* nn = new exprPosition(); nn->get( stream, portals ); return nn; } else if ( tok == "dir" ) { expr* nn = new exprDirection(); nn->get( stream, portals ); return nn; } else if ( tok == "norm" ) { expr* nn = new exprNormal(); nn->get( stream, portals ); return nn; } else if ( tok == "@" ) { <> } <> <> <> } return 0; } @ To parse a reference expression, this function retrieves the name of the portal, then it uses that portal name to snag the instance of the portal. Then, it calls the reference expression's constructor with a reference to that portal's pixel. <>= if ( in.get( token, sizeof(token) ) == 0 ) { return 0; } std::string name( token ); std::map< std::string, class portal* >::const_iterator pp = portals.find( name ); if ( pp == portals.end() ) { return 0; } exprReference* rret = new exprReference( pp->second->getPixel() ); rret->get( stream, portals ); return rret; @ This raytracer supports a variety of binary operations for its expressions. These operations are stored in a table. The table itself is defined below in \ref{sec:BinaryExpressionTable-class}. <>= static const BinaryExpressionTable binaries; exprBinary* bret = binaries[ tok ]; if ( bret != 0 ) { bret->get( stream, portals ); if ( bret->isConstant() ) { mathvec< double > dd; exprConst* cret = new exprConst( bret->evaluate( dd, dd, dd ) ); delete bret; return cret; } else { return bret; } } @ This raytracer supports a variety of unary operations for its expressions. These operations are stored in a table. The table itself is defined below in \ref{sec:UnaryExpressionTable-class}. <>= static const UnaryExpressionTable unaries; exprUnary* uret = unaries[ tok ]; if ( uret != 0 ) { uret->get( stream, portals ); if ( uret->isConstant() ) { mathvec< double > dd; exprConst* cret = new exprConst( uret->evaluate( dd, dd, dd ) ); delete uret; return cret; } else { return uret; } } @ This raytracer keeps a list of common constants along with their numerical value. These constants can be used directly by name. The [[ConstantExpressionTable]] is defined below in \ref{sec:ConstantExpressionTable-class}. <>= static const ConstantExpressionTable constants; exprConst* cret = constants[ tok ]; if ( cret != 0 ) { cret->get( stream, portals ); return cret; } @ Alternatively, if the expression has not been any of the named constants above, this raytracer attempts to read it as a numeric constant. <>= double value; std::istringstream str( token ); str >> value; if ( ! str.fail() ) { return new exprConst( value ); } @ To read from a string, this method simply initializes a [[istringstream]] from the standard template library to provide the string as an [[istream]] for the previous method. <>= expr* expr::read( const char* str, const std::map& portals ) { std::istringstream in( str ); return read( in, portals ); } @ \section{Loading A Vector Of Expressions} \label{sec:expr-vector} The following methods are used to read in a vector of expressions. One would like to take advantage of the method in the [[basevec<>]] template class used for input. However, the [[basevec<>]] input method will not be able to invoke the [[read()]] method defined above. <>= static void read( std::istream& in, basevec< expr* >& exprs, const std::map< std::string, class portal* >& portals ); static void read( const char* str, basevec< expr* >& exprs, const std::map< std::string, class portal* >& portals ); @ As in the [[basevec<>]] template class input method from \ref{sec:basevec-input}, this method skips over the brackets and the opening less-than sign but saves the length. Then, it loops through that length reading in an expression for each spot in the vector skipping over separating commas. Once all of the expressions have been read, this method reads until the closing greater-than sign is found. <>= void expr::read( std::istream& in, basevec< expr* >& exprs, const std::map& portals ) { char bogus; unsigned int len; in.setf( std::ios::skipws ); in >> bogus; // "[" in >> len; in >> bogus >> bogus; // "]<" exprs.resize( len, (expr*)0 ); for (unsigned ii=0; ii < len; ++ii) { exprs[ ii ] = expr::read( in, portals ); if (ii < len-1) { in >> bogus; // "," } } while (bogus != '>' && in.good() ) { in >> bogus; // ">" } } @ This read method simply employs the method defined above. <>= void expr::read( const char* str, basevec< expr* >& exprs, const std::map& portals ) { std::istringstream in( str ); expr::read( in, exprs, portals ); } @ \section{The Expression Table Initializers} And, in order to ensure that the static tables [[binaries]], [[unaries]], and [[constants]] above all get constructed before any threaded execution begins, this compilation unit defines a global instance of a class whose constructor simply makes sure that the the [[read()]] method above gets invoked in such a way as to ensure that all of the relevant tables are checked. <>= class TableInitializer { public: TableInitializer( void ); public: static const char* id; }; const char* TableInitializer::id = "NKVERSION: TableInitializer( RT_VERSION )"; @ The constructor calls the read giving it an expression which has to exercise all three tables. Then, it deletes that expression. <>= TableInitializer::TableInitializer( void ) { std::map portals; expr* ee = expr::read( "+ sin pi 1", portals ); if ( ee != 0 ) { delete ee; } }; @ As mentioned above, there is a single global instance of this class to ensure that the tables above have been initialzed before any threading begins. <>= static TableInitializer __tableInitializer; @ \section{The Class Definition} \label{sec:expr-class} This class includes all of the methods declared above. And, it includes some version identification information. <>= class expr { public: <> public: static const char* id; }; @ \section{Source Files} The following sections assemble the source files for the [[expr]] class from the chunks above. \subsection{[[expr.h]]} The header file the [[expr]] class includes the [[iostream]] and [[string]] headers from the standard C++ libraries and the header file for the [[mathvec<>]] class and then incorporates the class defined in \ref{sec:expr-class} above. All of this is wrapped in syntactic sugar to avoid problems should this file be included more than once. <>= #ifndef _NKLEIN_EXPR_H_ #define _NKLEIN_EXPR_H_ 1 #include #include #include #include "mathvec.h" class scene; <> #endif /*_NKLEIN_EXPR_H_*/ @ \subsection{[[expr.cc]]} Herein, the implementations of the methods of the [[expr]] class are included as well as the the declarations and implementations of the derived classes and table classes. <>= #include #include #include #include "input.h" #include "expr.h" #include "portal.h" const char* expr::id = "NKVERSION: expr( RT_VERSION )"; <> <> <> <> <> <> @ ./rt2.7.2007.05.17/nws/extrusion.nw0100644000077300007650000002052510032101350014475 0ustar patpat@ \chapter{Extrusion} \label{sec:extrusion} The extrusion is a CSG (Constructive Solid Geometry) primitive. If this object is in an $n$-dimensional universe and specifies an internal dimension $k$ and contains a sub-object, then this object represents the extrusion of the $k$-dimensional sub-object into $n$ dimensions. The extrusion contains a single sub-object. And, it can specify parameters from the base object class. <>= csg_extrusion_params ::= 'object' object_type_and_params ';' | 'base' '{' object_parameters '}' ';' ; @ The following snippets are used so that the object's factory method can create instance of this class. <>= #include "extrusion.h" @ <>= if ( objectType == "extrusion" ) { extrusion* obj = new extrusion( ss ); stream >> *obj >> semicolon; return obj; } else @ The [[extrusion]] class is a subclass of the [[object]] class from \ref{sec:object}. It contains a number of dimensions for its sub-object and a sub-object. <>= unsigned int subDimensions; object* obj; @ <>= , subDimensions( 0 ), obj( 0 ) @ \section{Constructor} The default constructor does nothing. <>= extrusion( const scene* ss ); @ <>= extrusion::extrusion( const scene* ss ) : object( ss ) <> { } @ \section{Destructor} This destructor has to release the sub-object <>= virtual ~extrusion( void ); @ <>= extrusion::~extrusion( void ) { delete this->obj; }; @ \section{Setting The Number of Dimensions} This method has to set the number of dimensions on the sub-object and the base object class. <>= virtual void setDimensions( unsigned int dd ); @ <>= void extrusion::setDimensions( unsigned int dd ) { if ( this->subDimensions == 0 || this->subDimensions > dd ) { this->subDimensions = dd; } if ( this->obj != 0 ) { this->obj->setDimensions( this->subDimensions ); } this->object::setDimensions( dd ); } @ \section{Intersection A Ray And A Extrusion} This first intersection method retrieves only the closest intersection to the ray's origin. The ray is specified by its direction and start. <>= virtual bool intersect( const mathvec< double >& direction, const mathvec< double >& start, intersection& hit ) const; @ <>= bool extrusion::intersect( const mathvec< double >& direction, const mathvec< double >& start, intersection& hit ) const { if ( this->obj == 0 ) { return false; } <> bool ret = false; if ( ( rd ^ rd ) > 0.000001 ) { ret = this->obj->intersect( rd, rp, hit ); if ( ret ) { <> } } return ret; } @ <>= mathvec< double > rd = direction; rd.antirotate( this->orientation ); rd /= this->scale; mathvec< double > fullrd = rd; rd.resize( this->subDimensions, 0.0 ); fullrd.normalize(); rd.normalize(); mathvec< double > rp = start - this->center; rp.antirotate( this->orientation ); rp /= this->scale; mathvec< double > fullrp = rp; rp.resize( this->subDimensions, 0.0 ); @ <>= mathvec< double > hitPosition; if ( hit.getDistance() < MAXFLOAT / 2.0 ) { hitPosition = fullrd; rd.resize( fullrd.size(), 0.0 ); hitPosition *= hit.getDistance(); double distFactor = ( rd ^ fullrd ); if ( distFactor > 0.000001 ) { hitPosition /= distFactor; } hitPosition += fullrp; hit.setPosition( hitPosition ); } else { hitPosition = hit.getPosition(); hitPosition.resize( this->center.size(), 0.0 ); hit.setPosition( hitPosition ); } hit.setDirection( fullrd ); mathvec< double > hitNormal = hit.getNormal(); hitNormal.resize( this->center.size(), 0.0 ); hit.setNormal( hitNormal ); hit.reorient( this->scale, this->orientation, this->center ); hit.setDistance( ( hitPosition - start ).magnitude() ); if ( this->gotColor ) { hit.recolor( this->chroma ); } @ This second intersection method retrieves all intersections between this extrusion and the ray. The ray is specified by its direction and start. The array of hits is sorted in order of increasing distance from the start of the ray. <>= virtual bool intersect( const mathvec< double >& direction, const mathvec< double >& start, std::vector< intersection* >& hits ) const; @ <>= bool extrusion::intersect( const mathvec< double >& direction, const mathvec< double >& start, std::vector< intersection* >& hits ) const { if ( this->obj == 0 ) { return false; } <> hits.clear(); bool ret; if ( ( rd ^ rd ) > 0.000001 ) { ret = this->obj->intersect( rd, rp, hits ); if ( ret ) { for ( unsigned int ii=0; ii < hits.size(); ++ii ) { intersection& hit( *hits[ ii ] ); <> } } } else { ret = this->obj->inside( rp ); if ( ret ) { intersection* nn = new intersection(); this->forgeHit( direction, start, *nn ); hits.insert( hits.end(), nn ); } } return ret; } @ \section{Checking If A Point Is Inside An Extrusion} <>= virtual bool inside( const mathvec< double >& start ) const; virtual bool _inside( const mathvec< double >& rp ) const; @ <>= bool extrusion::inside( const mathvec< double >& start ) const { if ( this->obj == 0 ) { return false; } mathvec< double > rp = start - this->center; rp.antirotate( this->orientation ); rp /= this->scale; rp.resize( this->subDimensions, 0.0 ); return this->_inside( rp ); } bool extrusion::_inside( const mathvec< double >& rp ) const { if ( this->obj == 0 ) { return false; } return this->obj->inside( rp ); } @ \section{Loading A Extrusion} The following method allows one to read in an extrusion from a stream. <>= friend std::istream& operator >> ( std::istream& in, extrusion& cc ); @ <>= std::istream& operator >> ( std::istream& stream, extrusion& ee ) { input in( stream ); while ( in.check() ) { char token[ input::MAX_TOKEN_LEN ]; if ( in.get( token, sizeof(token) ) == 0 ) { return stream; } std::string tok( token ); char semicolon; if ( tok == "dimensions" ) { stream >> ee.subDimensions >> semicolon; } else if ( tok == "object" ) { object* nn = object::read( stream, ee.myScene ); if ( nn != 0 ) { delete ee.obj; ee.obj = nn; } else { std::cerr << "EXTRUSION failed to get an object!" << std::endl; } } else if ( tok == "base" ) { stream >> (object&)ee >> semicolon; } else { in.ignore( "EXTRUSION", tok.c_str() ); } } return stream; } @ \section{The Class Definition} \label{sec:extrusion-class} This class includes all of the methods declared above. And, it includes some version identification information. <>= class extrusion : public object { protected: <> public: <> public: static const char* id; }; @ \section{Source Files} The following sections assemble the source files for the [[extrusion]] class from the chunks above. \subsection{[[extrusion.h]]} The header file the [[extrusion]] class includes the [[iostream]], [[string]], and [[map]] headers from the standard C++ libraries and the header file for the [[object]] base class and then incorporates the class defined in \ref{sec:extrusion-class} above. All of this is wrapped in syntactic sugar to avoid problems should this file be included more than once. <>= #ifndef _NKLEIN_EXTRUSION_H_ #define _NKLEIN_EXTRUSION_H_ 1 #include #include #include #include "object.h" <> #endif /*_NKLEIN_EXTRUSION_H_*/ @ \subsection{[[extrusion.cc]]} Herein, the implementations of the methods of the [[extrusion]] class are included. <>= #include #include #include #ifndef MAXFLOAT #include #endif #include "input.h" #include "extrusion.h" const char* extrusion::id = "NKVERSION: extrusion( RT_VERSION )"; <> @ ./rt2.7.2007.05.17/nws/halfspace.nw0100644000077300007650000001773610600076642014415 0ustar patpat@ \chapter{Halfspace} \label{sec:halfspace} The halfspace (before it is scaled, oriented, and positioned) is all points with an x-coordinate less than or equal to zero. The halfspace itself requires no parameters beyond those defined in the object base class. <>= halfspace_params ::= 'base' '{' object_parameters '}' ';' ; @ The following snippets are used so that the object's factory method can create instance of this class. <>= #include "halfspace.h" @ <>= if ( objectType == "halfspace" ) { halfspace* obj = new halfspace( ss ); stream >> *obj >> semicolon; return obj; } else @ The halfspace requires no member variables. Its normal will be the x-axis. \section{Constructor} The default constructor does nothing except initialize the scene pointer. <>= halfspace( const scene* ss ); @ <>= halfspace::halfspace( const scene* ss ) : object( ss ) { } @ This constructor initializes from a given vector setting both the center and normal. <>= halfspace( const mathvec< double >& cc ); @ <>= halfspace::halfspace( const mathvec& cc ) : object( 0 ) { this->center = cc; this->orientation.resize( 1 ); this->orientation[ 0 ] = cc; this->orientation[ 0 ].normalize(); } @ This constructor initializes from a given center and normal. <>= halfspace( const mathvec< double >& cc, const mathvec< double >& nn ); @ <>= halfspace::halfspace( const mathvec& cc, const mathvec& nn ) : object( 0 ) { this->center = cc; this->orientation.resize( 1 ); this->orientation[ 0 ] = nn; this->orientation[ 0 ].normalize(); } @ \section{Destructor} This destructor has nothing to do. <>= virtual ~halfspace( void ); @ <>= halfspace::~halfspace( void ) { }; @ \section{Setting The Number of Dimensions} This method simply invokes the corresponding method on the base class. <>= virtual void setDimensions( unsigned int dd ); @ <>= void halfspace::setDimensions( unsigned int dd ) { this->object::setDimensions( dd ); } @ \section{Intersection A Ray And A Halfspace} This first intersection method retrieves only the closest intersection to the ray's origin. The ray is specified by its direction and start. <>= virtual bool intersect( const mathvec< double >& direction, const mathvec< double >& start, intersection& hit ) const; @ <>= bool halfspace::intersect( const mathvec< double >& direction, const mathvec< double >& start, intersection& hit ) const { <> if ( tt > 0.000001 ) { <> } else { return false; } return true; } @ <>= unsigned int len = this->center.size(); mathvec< double > rd = direction; rd.antirotate( this->orientation ); rd /= this->scale; rd.normalize(); mathvec< double > rp = start - this->center; rp.antirotate( this->orientation ); rp /= this->scale; mathvec< double > nn( 0.0, len ); if ( rp[ 0 ] > 0.0 ) { nn[ 0 ] = 1.0; } else { nn[ 0 ] = -1.0; } double tt; double dd = rd[ 0 ]; if ( ::fabs( dd ) > 0.000001 ) { tt = - rp[ 0 ] / dd; } else { tt = - 1.0; } @ <>= mathvec< double > spot = rp + ( rd * tt ); if ( rp[ 0 ] > 0.0 ) { hit.setOutside(); } else { hit.setInside(); } hit.setObjectPosition( spot ); hit.setObjectNormal( nn ); hit.setObjectDirection( rd.normalize() ); hit.setPosition( spot ); hit.setNormal( nn ); hit.setDirection( rd ); hit.reorient( this->scale, this->orientation, this->center ); hit.setDistance( ( hit.getPosition() - start ).magnitude() ); hit.setObjectColor( &this->chroma ); @ This second intersection method retrieves all intersections between this halfspace and the ray. The ray is specified by its direction and start. The array of hits is sorted in order of increasing distance from the start of the ray. <>= virtual bool intersect( const mathvec< double >& direction, const mathvec< double >& start, std::vector< intersection* >& hits ) const; @ <>= bool halfspace::intersect( const mathvec< double >& direction, const mathvec< double >& start, std::vector< intersection* >& hits ) const { <> hits.clear(); if ( tt > 0.000001 ) { intersection* hh = new intersection(); intersection& hit( *hh ); <> hits.insert( hits.end(), hh ); } else if ( rp[ 0 ] <= 0.0 ) { intersection* hh = new intersection(); this->forgeHit( direction, start, *hh ); hits.insert( hits.end(), hh ); } return hits.size() > 0; } @ We're also going to provide a way just to get the distance that a point is from the plane. <>= double distance( const mathvec< double >& start ) const; @ <>= double halfspace::distance( const mathvec< double >& start ) const { mathvec< double > rp = start - this->center; rp.antirotate( this->orientation ); rp /= this->scale; return rp[ 0 ]; } @ \section{Checking If A Point Is Inside A Halfspace} <>= virtual bool inside( const mathvec< double >& start ) const; virtual bool _inside( const mathvec< double >& rp ) const; @ <>= bool halfspace::inside( const mathvec< double >& start ) const { mathvec< double > rp = start - this->center; rp.antirotate( this->orientation ); rp /= this->scale; return this->_inside( rp ); } bool halfspace::_inside( const mathvec< double >& rp ) const { return rp[ 0 ] <= 0.0; } @ \section{Loading A Halfspace} The following method allows one to read in an halfspace from a stream. <>= friend std::istream& operator >> ( std::istream& in, halfspace& cc ); @ <>= std::istream& operator >> ( std::istream& stream, halfspace& hh ) { input in( stream ); while ( in.check() ) { char token[ input::MAX_TOKEN_LEN ]; if ( in.get( token, sizeof(token) ) == 0 ) { return stream; } std::string tok( token ); char semicolon; if ( tok == "base" ) { stream >> (object&)hh >> semicolon; } else { in.ignore( "HALFSPACE", tok.c_str() ); } } return stream; } @ \section{The Class Definition} \label{sec:halfspace-class} This class inherits directly from the object base class. This class includes all of the methods declared above. And, it includes some version identification information. <>= class halfspace : public object { public: <> public: static const char* id; }; @ \section{Source Files} The following sections assemble the source files for the [[halfspace]] class from the chunks above. \subsection{[[halfspace.h]]} The header file the [[halfspace]] class includes the [[iostream]] and [[string]] headers from the standard C++ libraries and the header file for the [[object]] class and then incorporates the class defined in \ref{sec:halfspace-class} above. All of this is wrapped in syntactic sugar to avoid problems should this file be included more than once. <>= #ifndef _NKLEIN_HALFSPACE_H_ #define _NKLEIN_HALFSPACE_H_ 1 #include #include #include #include "object.h" <> #endif /*_NKLEIN_HALFSPACE_H_*/ @ \subsection{[[halfspace.cc]]} Herein, the implementations of the methods of the [[halfspace]] class are included as well as the the declarations and implementations of the derived classes. <>= #include #include #include #include "input.h" #include "halfspace.h" const char* halfspace::id = "NKVERSION: halfspace( RT_VERSION )"; <> @ ./rt2.7.2007.05.17/nws/image-accum.nw0100644000077300007650000001730110032066203014612 0ustar patpat@ \chapter{Accum Images} \label{sec:image-accum} Unlike the other classes derived from the image class, this class does not actually write an output image. This class accumulates pixels from multiple frames and emits them to a different image instance. This class inherits directly from the image class defined in \S\ref{sec:image}. The accumulation method and the contained image are the parameters available for the accumulation image. The default method is averaging. <>= accum_parameters ::= 'method' accum_method_value ';' | 'image' image_type_and_parameters ';' ; accum_method_value ::= 'minimum' | 'min' | 'maximum' | 'max' | 'average' | 'avg' | 'first' ; @ There are four basic modes this accumulator can use. <>= typedef enum { MINIMUM, MAXIMUM, AVERAGE, FIRST } MethodType; @ This class tracks the contained image instance, a full frame of the image, a little information about the current offset into the image, the operating mode, the current pixel, and a full-on pixel. <>= image* sub; double* accumulator; unsigned int curIndex; unsigned int pixelsRemaining; MethodType method; mathvec< double > curPixel; mathvec< double > allOnes; @ \section{Constructor} The constructor simply has to set the pointers defined above to null values. <>= imageAccum( void ) : sub( 0 ), accumulator( 0 ) { }; @ \section{Destructor} The destructor here has to release any memory allocated for the outgoing file stream and the border-pixel buffer. <>= virtual ~imageAccum( void ) { delete this->sub; delete[] this->accumulator; }; @ \section{Setting The Image Information} This method overrides the one in the base class. It restricts the number of color channels to either three or one as those are the only values a Accum can use. After that, this method allocates a buffer it will use to output border pixels. <>= virtual void setSize( unsigned int ww, unsigned int hh, unsigned int dd, unsigned int cc ) { this->image::setSize( ww, hh, dd, cc ); this->sub->setSize( ww, hh, 1, cc ); this->pixelsRemaining = ww * hh * dd; unsigned int len = ww * hh * cc; this->accumulator = new double[ len ]; this->curIndex = 0; double initialValue = 0.0; if ( this->method == MINIMUM ) { initialValue = 1.0; } for ( unsigned int ii=0; ii < len; ++ii ) { this->accumulator[ ii ] = initialValue; } this->curPixel.resize( cc, 0.0 ); this->allOnes.resize( cc, 1.0 ); }; @ \section{Adding Pixels} The following methods are used by the [[view]] class in \ref{sec:view} to place pixels in the image. The first method here adds a single pixel value to the output image. If the pixel size is smaller than expected, the last value is repeated to fill any remaining output channels. On the other hand, if the pixel size is larger than expected, the average value is used for all channels. <>= virtual void add( const mathvec< double >& pixel ) { if ( pixel.size() <= this->channelCount ) { double lastVal = 0.0; for ( unsigned int ii=0; ii < pixel.size(); ++ii ) { lastVal = pixel[ ii ]; this->curPixel[ ii ] = lastVal; } for ( unsigned int ii=pixel.size(); ii < this->channelCount; ++ii ) { this->curPixel[ ii ] = lastVal; } } else { double total = 0.0; for ( unsigned int ii=0; ii < pixel.size(); ++ii ) { total += pixel[ ii ]; } double val = ( total / (double)pixel.size() ); for ( unsigned int ii=0; ii < this->channelCount; ++ii ) { this->curPixel[ ii ] = val; } } this->add(); }; @ To emit a border pixel, this method simply copies a single pixel from the border buffer. <>= virtual void addBorderPixel( void ) { this->curPixel = this->allOnes; this->add(); }; @ To emit a border row, this method copies a whole row from the border buffer. <>= virtual void addBorderRow( void ) { this->curPixel = this->allOnes; for ( unsigned int ii=0; ii < this->width; ++ii ) { this->add(); } }; @ This method is used to add the current pixel to the accumulator. <>= virtual void add( void ) { double* spot = &this->accumulator[ this->curIndex ]; this->curIndex += this->channelCount; switch ( this->method ) { case MINIMUM: { double curTotal = ( this->curPixel ^ this->allOnes ); double spotTotal = 0.0; <> if ( curTotal < spotTotal ) { <> } } break; case MAXIMUM: { double curTotal = ( this->curPixel ^ this->allOnes ); double spotTotal = 0.0; <> if ( curTotal > spotTotal ) { <> } } break; case AVERAGE: { for ( unsigned int ii=0; ii < this->channelCount; ++ii ) { spot[ ii ] += this->curPixel[ ii ] / (double)this->depth; } } break; case FIRST: { double spotTotal = 0.0; <> if ( spotTotal < 0.000001 ) { <> } } break; }; unsigned int len = this->width * this->height * this->channelCount; if ( this->curIndex >= len ) { this->curIndex = 0; } if ( --this->pixelsRemaining == 0 ) { mathvec< double > pixel( this->channelCount ); for ( unsigned int ii=0; ii < len; /*done*/ ) { for ( unsigned int kk=0; kk < this->channelCount; ++kk ) { pixel[ kk ] = this->accumulator[ ii++ ]; } this->sub->add( pixel ); } } }; @ <>= for ( unsigned int ii=0; ii < this->channelCount; ++ii ) { spotTotal += spot[ ii ]; } @ <>= for ( unsigned int ii=0; ii < this->channelCount; ++ii ) { spot[ ii ] = this->curPixel[ ii ]; } @ \section{Reading In A Accum} This segment of code gets included in the image read function to create an instance of this class if it is needed. <>= if ( tok == "accumulator" || tok == "accum" ) { image* nn = new imageAccum(); nn->get( stream ); return nn; } else @ With an accum image, the method and the subimage are the only available parameters. <>= virtual std::istream& get( std::istream& stream ) { input in( stream ); this->method = AVERAGE; while ( in.check() ) { char token[ input::MAX_TOKEN_LEN ]; if ( in.get( token, sizeof(token) ) == 0 ) { return stream; } std::string tok( token ); char semicolon; if ( tok == "method" ) { if ( in.get( token, sizeof(token) ) == 0 ) { return stream; } std::string meth( token ); if ( meth == "minimum" || meth == "min" ) { this->method = MINIMUM; } else if ( meth == "maximum" || meth == "max" ) { this->method = MAXIMUM; } else if ( meth == "average" || meth == "avg" ) { this->method = AVERAGE; } else if ( meth == "first" ) { this->method = FIRST; } } else if ( tok == "image" ) { this->sub = this->image::read( stream ); stream >> semicolon; } else { in.ignore( "ACCUM", tok.c_str() ); } } return stream; }; @ \section{The Class Definition} \label{sec:image-accum-class} This class includes all of the methods declared above. And, it includes some version identification information. <>= class imageAccum : public image { protected: <> public: <> protected: <> <> public: static const char* id; }; const char* imageAccum::id = "NKVERSION: imageAccum( RT_VERSION )"; @ ./rt2.7.2007.05.17/nws/image-png.nw0100644000077300007650000002060510032066207014313 0ustar patpat@ \chapter{PNG Images} \label{sec:image-png} This raytracer also supports output in the Portable Network Graphics (PNG) format. The code in this section allows output to PNG format. This class inherits directly from the image class defined in \S\ref{sec:image}. There are no parameters specific to the PNG. The only parameters are those of the base class. <>= png_parameters ::= 'common' '{' image_base '}' ';' ; @ The class tracks the stream for the output file. <>= std::ostream* out; @ The class also keeps a whole row of border pixels for any time a whole row of them is emitted. It also keeps track of several other buffers for output and the current location within the pixel buffer. <>= unsigned char* borderRow; unsigned char* tmpBuffer; png_bytep pixelBuffer; unsigned int rowSpot; @ The class also tracks some state from the PNG library. <>= png_structp pngPtr; png_infop infoPtr; @ The class also tracks how many pixels have been emitted for the current frame. <>= unsigned int pixelCount; @ \section{Constructor} The constructor simply has to set the pointers defined above to null values. <>= imagePNG( void ) : out( 0 ), borderRow( 0 ), tmpBuffer( 0 ), pixelBuffer( 0 ), pngPtr( 0 ), infoPtr( 0 ) { }; @ \section{Destructor} The destructor here has to release any memory allocated for the outgoing file stream and the border-pixel buffer. <>= virtual ~imagePNG( void ) { if ( this->pngPtr != 0 ) { ::png_write_end( this->pngPtr, this->infoPtr ); ::png_destroy_write_struct( &this->pngPtr, &this->infoPtr ); } delete this->out; delete[] this->pixelBuffer; delete[] this->borderRow; delete[] this->tmpBuffer; }; @ \section{Setting The Image Information} This method overrides the one in the base class. It restricts the number of color channels to either three or one as those are the only values a PNG can use. After that, this method allocates a buffer it will use to output border pixels. <>= virtual void setSize( unsigned int ww, unsigned int hh, unsigned int dd, unsigned int cc ) { if ( cc > 4 ) { cc = 4; } this->image::setSize( ww, hh, dd, cc ); unsigned int len = this->width * this->channelCount; delete[] this->borderRow; this->borderRow = new unsigned char[ len ]; delete[] this->tmpBuffer; this->tmpBuffer = new unsigned char[ len ]; delete[] this->pixelBuffer; this->pixelBuffer = new png_byte[ len ]; for ( unsigned int ii=0; ii < len; ++ii ) { this->borderRow[ ii ] = (unsigned char)0xFF; } this->pixelCount = 0; }; @ \section{Adding Pixels} The following methods are used by the [[view]] class in \ref{sec:view} to place pixels in the image. The first method here adds a single pixel value to the output image. If the pixel size is smaller than expected, the last value is repeated to fill any remaining output channels. On the other hand, if the pixel size is larger than expected, the average value is used for all channels. <>= virtual void add( const mathvec< double >& pixel ) { unsigned int curSample = 0; if ( pixel.size() <= this->channelCount ) { unsigned char lastVal = 0; for ( unsigned int ii=0; ii < pixel.size(); ++ii ) { int val = (int)( pixel[ ii ] * 255.0 + 0.5 ); lastVal = (unsigned char)( val<0 ) ? 0 : ( val>255 ) ? 255 : val ; this->tmpBuffer[ curSample++ ] = lastVal; } for ( unsigned int ii=pixel.size(); ii < this->channelCount; ++ii ) { this->tmpBuffer[ curSample++ ] = lastVal; } } else { int total = 0; for ( unsigned int ii=0; ii < pixel.size(); ++ii ) { int val = (int)( pixel[ ii ] * 255.0 + 0.5 ); total += ( val < 0 ) ? 0 : ( val > 255 ) ? 255 : val ; } unsigned char val = (unsigned char)( total / pixel.size() ); for ( unsigned int ii=0; ii < this->channelCount; ++ii ) { this->tmpBuffer[ curSample++ ] = val; } } this->write( this->tmpBuffer, 1 ); }; @ To emit a border pixel, this method simply copies a single pixel from the border buffer. <>= virtual void addBorderPixel( void ) { this->write( this->borderRow, 1 ); }; @ To emit a border row, this method copies a whole row from the border buffer. <>= virtual void addBorderRow( void ) { this->write( this->borderRow, this->width ); }; @ This method is used to emit pixels. There is a fair amount of code required to emit a PNG header. <>= void write( const unsigned char* buffer, unsigned int count ) { if ( this->pixelCount < count ) { if ( this->pngPtr != 0 ) { ::png_write_end( this->pngPtr, this->infoPtr ); ::png_destroy_write_struct( &this->pngPtr, &this->infoPtr ); } delete this->out; this->out = 0; this->pixelCount = this->width * this->height - count; } else { this->pixelCount -= count; } if ( this->out == 0 ) { std::string fname = this->getNumberedBasename() + ".png"; this->out = new std::ofstream( fname.c_str() ); this->pngPtr = ::png_create_write_struct( PNG_LIBPNG_VER_STRING, 0, 0, 0 ); if ( this->pngPtr == 0 ) { std::cerr << "Unable to create png write structure" << std::endl; return; } this->infoPtr = ::png_create_info_struct( this->pngPtr ); if ( this->infoPtr == 0 ) { std::cerr << "Unable to create png info structure" << std::endl; ::png_destroy_write_struct( &this->pngPtr, 0 ); return; } if ( ::setjmp( this->pngPtr->jmpbuf ) ) { std::cerr << "Something wrong during write png" << std::endl; ::png_destroy_write_struct( &this->pngPtr, &this->infoPtr ); } ::png_set_write_fn( this->pngPtr, this->out, imagePNG::writeData, imagePNG::flushData ); ::png_set_compression_level( this->pngPtr, Z_BEST_COMPRESSION ); static int colorTypes[] = { 0, PNG_COLOR_TYPE_GRAY, PNG_COLOR_TYPE_GRAY_ALPHA, PNG_COLOR_TYPE_RGB, PNG_COLOR_TYPE_RGB_ALPHA }; ::png_set_IHDR( this->pngPtr, this->infoPtr, this->width, this->height, 8, colorTypes[ this->channelCount ], PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT ); ::png_write_info( this->pngPtr, this->infoPtr ); this->rowSpot = 0; } count *= this->channelCount; for ( unsigned int ii=0; ii < count; ++ii ) { this->pixelBuffer[ rowSpot++ ] = buffer[ ii ]; } if ( rowSpot >= this->width * this->channelCount ) { ::png_write_row( this->pngPtr, this->pixelBuffer ); this->rowSpot = 0; } }; @ These methods are used to allow the PNG library to write to the output stream. <>= static void writeData( png_structp ctx, png_bytep buffer, png_size_t size ) { std::ofstream* dst = (std::ofstream*)::png_get_io_ptr( ctx ); dst->write( (const char*)buffer, size ); } static void flushData( png_structp ctx ) { std::ofstream* dst = (std::ofstream*)::png_get_io_ptr( ctx ); dst->flush(); } @ \section{Reading In A PNG} This segment of code gets included in the image read function to create an instance of this class if it is needed. <>= #ifdef USE_PNG if ( tok == "png" ) { image* nn = new imagePNG(); nn->get( stream ); return nn; } else #endif @ With a PNG image, the only information necessary is that information common to all images. <>= virtual std::istream& get( std::istream& stream ) { input in( stream ); while ( in.check() ) { char token[ input::MAX_TOKEN_LEN ]; if ( in.get( token, sizeof(token) ) == 0 ) { return stream; } std::string tok( token ); char semicolon; if ( tok == "common" ) { this->image::get( stream ); stream >> semicolon; } else { in.ignore( "PNG", tok.c_str() ); } } return stream; }; @ \section{The Class Definition} \label{sec:image-png-class} This class inherits directly from the image class defined in \S\ref{sec:image}. It includes all of the methods declared above. And, it includes some version identification information. <>= #ifdef USE_PNG #include class imagePNG : public image { public: <> protected: <> <> public: static const char* id; }; const char* imagePNG::id = "NKVERSION: imagePNG( RT_VERSION )"; #endif @ ./rt2.7.2007.05.17/nws/image-ppm.nw0100644000077300007650000001362210032066212014320 0ustar patpat@ \chapter{PPM Images} \label{sec:image-ppm} The Portable Pixmap Image (PPM) format is the simplest useful image format. The code in this section allows output to PPM format. This class inherits directly from the image class defined in \S\ref{sec:image}. There are no parameters specific to the PPM. The only parameters are those of the base class. <>= ppm_parameters ::= 'common' '{' image_base '}' ';' ; @ The class tracks the stream for the output file. <>= std::ostream* out; @ The class also keeps a whole row of border pixels for any time a whole row of them is emitted. <>= unsigned char* borderRow; @ The class also tracks how many pixels have been emitted for the current frame. <>= unsigned int pixelCount; @ \section{Constructor} The constructor simply has to set the pointers defined above to null values. <>= imagePPM( void ) : out( 0 ), borderRow( 0 ) { }; @ \section{Destructor} The destructor here has to release any memory allocated for the outgoing file stream and the border-pixel buffer. <>= virtual ~imagePPM( void ) { delete this->out; delete[] this->borderRow; }; @ \section{Setting The Image Information} This method overrides the one in the base class. It restricts the number of color channels to either three or one as those are the only values a PPM can use. After that, this method allocates a buffer it will use to output border pixels. <>= virtual void setSize( unsigned int ww, unsigned int hh, unsigned int dd, unsigned int cc ) { if ( cc > 3 ) { cc = 3; } else if ( cc < 3 ) { cc = 1; } this->image::setSize( ww, hh, dd, cc ); unsigned int len = this->width * this->channelCount; delete[] this->borderRow; this->borderRow = new unsigned char[ len ]; for ( unsigned int ii=0; ii < len; ++ii ) { this->borderRow[ ii ] = (unsigned char)0xFF; } this->pixelCount = 0; }; @ \section{Adding Pixels} The following methods are used by the [[view]] class in \ref{sec:view} to place pixels in the image. The first method here adds a single pixel value to the output image. If the pixel size is smaller than expected, the last value is repeated to fill any remaining output channels. On the other hand, if the pixel size is larger than expected, the average value is used for all channels. <>= virtual void add( const mathvec< double >& pixel ) { this->checkOutput(); if ( pixel.size() <= this->channelCount ) { unsigned char lastVal = 0; for ( unsigned int ii=0; ii < pixel.size(); ++ii ) { int val = (int)( pixel[ ii ] * 255.0 + 0.5 ); lastVal = (unsigned char)( val<0 ) ? 0 : ( val>255 ) ? 255 : val ; this->out->put( lastVal ); } for ( unsigned int ii=pixel.size(); ii < this->channelCount; ++ii ) { this->out->put( lastVal ); } } else { int total = 0; for ( unsigned int ii=0; ii < pixel.size(); ++ii ) { int val = (int)( pixel[ ii ] * 255.0 + 0.5 ); total += ( val < 0 ) ? 0 : ( val > 255 ) ? 255 : val ; } unsigned char val = (unsigned char)( total / pixel.size() ); for ( unsigned int ii=0; ii < this->channelCount; ++ii ) { this->out->put( val ); } } }; @ To emit a border pixel, this method simply copies a single pixel from the border buffer. <>= virtual void addBorderPixel( void ) { this->checkOutput(); this->out->write( (const char*)borderRow, this->channelCount ); }; @ To emit a border row, this method copies a whole row from the border buffer. <>= virtual void addBorderRow( void ) { this->checkOutput( this->width ); this->out->write( (const char*)borderRow, this->width*this->channelCount ); }; @ The output check decides if its time to output the next frame. The frame header is emitted if needed. <>= void checkOutput( unsigned int count = 1 ) { if ( this->pixelCount < count ) { delete this->out; this->out = 0; this->pixelCount = this->width * this->height - count; } else { this->pixelCount -= count; } if ( this->out == 0 ) { std::string fname = this->getNumberedBasename() + ".ppm"; this->out = new std::ofstream( fname.c_str() ); if ( this->channelCount == 1 ) { *this->out << "P5" << std::endl; } else { *this->out << "P6" << std::endl; } *this->out << this->width << " " << this->height << std::endl; *this->out << "255" << std::endl; } }; @ \section{Reading In A PPM} This segment of code gets included in the image read function to create an instance of this class if it is needed. <>= #ifdef USE_PPM if ( tok == "ppm" ) { image* nn = new imagePPM(); nn->get( stream ); return nn; } else #endif @ With a PPM image, the only information necessary is that information common to all images. <>= virtual std::istream& get( std::istream& stream ) { input in( stream ); while ( in.check() ) { char token[ input::MAX_TOKEN_LEN ]; if ( in.get( token, sizeof(token) ) == 0 ) { return stream; } std::string tok( token ); char semicolon; if ( tok == "common" ) { this->image::get( stream ); stream >> semicolon; } else { in.ignore( "PPM", tok.c_str() ); } } return stream; }; @ \section{The Class Definition} \label{sec:image-ppm-class} This class inherits directly from the image class defined in \S\ref{sec:image}. It includes all of the methods declared above. And, it includes some version identification information. <>= #ifdef USE_PPM class imagePPM : public image { public: <> protected: <> <> public: static const char* id; }; const char* imagePPM::id = "NKVERSION: imagePPM( RT_VERSION )"; #endif @ ./rt2.7.2007.05.17/nws/image.nw0100644000077300007650000001602410032066217013532 0ustar patpat@ \chapter{Image} \label{sec:image} Currently, there are three different image types supported. The [[ppm]] type outputs a Portable Pixel Map image. The [[png]] type outputs a Portable Network Graphics image. The [[accum]] type is a meta-image type. It contains another image instance which actually outputs the results. The [[accum]] type accumulates pixels across various frames and outputs an image where each pixel is a function of its values across all of the frames. <>= image_type_and_parameters ::= 'ppm' '{' ppm_parameters '}' ';' | 'png' '{' png_parameters '}' ';' | 'accumulator' '{' accum_parameters '}' ';' | 'accum' '{' accum_parameters '}' ';' ; @ The [[ppm]] images are defined in \S\ref{sec:image-ppm}. The [[png]] images are defined in \S\ref{sec:image-png}. The [[accum]] images are defined in \S\ref{sec:image-accum}. Both the [[ppm]] and the [[png]] include a [[base]] parameter which is responible for tracking the things common to all image classes. At the moment, the only thing common across image classes is the basename attribute which is used to create filenames for frames. <>= image_base ::= image_name ; image_name ::= 'basename' string ';' | 'filename' string ';' ; @ The [[image]] class is an abstract base-class for all of the image writers available. The base class keeps track of the width and height and number of the images to be written and the number of color channels for the image. <>= unsigned int width; unsigned int height; unsigned int depth; unsigned int channelCount; @ Additionally, this class tracks the basename for generated files and the number of files that are to be generated. <>= std::string basename; @ The image base class tracks how many output images have been created so that it can number them properly in the [[getNumberedBasename()]] method below. <>= unsigned int currentImage; @ \section{Contructor} The [[image]] class has a minimal constructor which simply resets the current image count. <>= image( void ); @ <>= image::image( void ) : currentImage( 0 ) { } @ \section{Destructor} The [[image]] class has a virtual destructor to ensure that the derived classes will be destructed properly. The destructor itself has nothing to do. <>= virtual ~image( void ); @ <>= image::~image( void ) { } @ \section{Setting The Image Information} The meta-information about the image is the width and height of each image, the depth of the image stack, and the number of color channels. These are set by the [[view]] at the beginning of the [[render()]] method. The image basename, however, is set during the reading of the image. <>= virtual void setSize( unsigned int ww, unsigned int hh, unsigned int dd, unsigned int cc ); virtual void setBasename( const std::string& bb ); @ <>= void image::setSize( unsigned int ww, unsigned int hh, unsigned int dd, unsigned int cc ) { this->width = ww; this->height = hh; this->depth = dd; this->channelCount = cc; } @ <>= void image::setBasename( const std::string& bb ) { this->basename = bb; } @ \section{Counting Output Images} The derived image classes will have to output numbered filenames. This method allows the code to appear in only one place. <>= virtual std::string getNumberedBasename( void ); @ If there is going to be more than one image, then the number is appended to the basename and returned. <>= std::string image::getNumberedBasename( void ) { std::ostringstream fname; fname << this->basename; if ( this->depth > 1 || this->currentImage > 1 ) { unsigned int digits = (unsigned int)( ::log10( (double)this->depth ) + 1.0000001 ); fname << std::setw( digits ) << std::setfill( '0' ); fname << this->currentImage++; } return fname.str(); } @ \section{Adding Pixels} The following methods are used by the [[view]] class in \ref{sec:view} to place pixels in the image. <>= virtual void add( const mathvec< double >& pixel ) = 0; virtual void addBorderPixel( void ) = 0; virtual void addBorderRow( void ) = 0; @ \section{Loading An Image} The following method is a factory method which allows the raytracer to read image instances in from a stream. <>= static image* read( std::istream& in ); @ Most of this method is actually incorporated from the derived classes. <>= image* image::read( std::istream& stream ) { input in( stream ); if ( in.check() ) { char token[ input::MAX_TOKEN_LEN ]; if ( in.get( token, sizeof(token) ) == 0 ) { return 0; } std::string tok( token ); <> { in.ignore( "IMAGE FACTORY", tok.c_str() ); } } return 0; } @ The following method allows one to read in the details common to all images from an input stream. <>= virtual std::istream& get( std::istream& stream ); @ <>= std::istream& image::get( std::istream& stream ) { input in( stream ); while ( in.check() ) { char token[ input::MAX_TOKEN_LEN ]; if ( in.get( token, sizeof(token) ) == 0 ) { return stream; } std::string tok( token ); if ( tok == "basename" || tok == "filename" ) { in.get( token, sizeof(token) ); this->basename = token; } else { in.ignore( "IMAGE", tok.c_str() ); } } return stream; } @ \section{The Class Definition} \label{sec:image-class} This class includes all of the methods declared above. And, it includes some version identification information. <>= class image { protected: <> <> public: <> public: static const char* id; }; @ \section{Source Files} The following sections assemble the source files for the [[image]] class from the chunks above. \subsection{[[image.h]]} The header file the [[image]] class includes the [[iostream]] and [[string]] headers from the standard C++ libraries and the header file for the [[mathvec<>]] class and then incorporates the class defined in \ref{sec:image-class} above. All of this is wrapped in syntactic sugar to avoid problems should this file be included more than once. <>= #ifndef _NKLEIN_IMAGE_H_ #define _NKLEIN_IMAGE_H_ 1 #include #include #include "mathvec.h" <> #endif /*_NKLEIN_IMAGE_H_*/ @ \subsection{[[image.cc]]} Herein, the implementations of the methods of the [[image]] class are included as well as the the declarations and implementations of the derived classes. <>= #include #include #include #include #include #include "input.h" #include "image.h" const char* image::id = "NKVERSION: image( RT_VERSION )"; <> <> @ ./rt2.7.2007.05.17/nws/input.nw0100644000077300007650000001015710600166333013611 0ustar patpat@ \chapter{Input Class} This input class allows one to use an input stream while tracking the brace-level and filtering out comments. <>= std::istream& in; unsigned int braceLevel; @ \section{Constructor} The constructor simply takes a reference to an input stream. It saves this reference and clears the brace level. <>= input( std::istream& _in ); @ <>= input::input( std::istream& _in ) : in( _in ), braceLevel( 0 ) { } @ \section{Checking An Input Stream} Most items will read things in a normal way. They don't particularly care about brace-level. And, they want an [[EOF]] when they get to the end of the information about them. That's what this function does. It keeps track of the brace-level, sucks up comments, and returns false when we're at the end of the object. <>= bool check( bool _ignoreEverything = false ); @ This routine leaves the [[istream]] in a state such that the next time we call it, we will get the next useful thing. Particularly, it skips over comments and tracks the current level of braces. <>= bool input::check( bool _ignoreEverything ) { unsigned int startBraceLevel = this->braceLevel; for (;;) { int ch = in.peek(); if ( ch < 0 ) { break; } else if ( ch == '{' ) { this->in.get(); ++this->braceLevel; } else if ( ch == '}' ) { this->in.get(); --this->braceLevel; } else if ( ch == ';' ) { if ( this->braceLevel == 0 || ( _ignoreEverything && this->braceLevel == startBraceLevel ) ) { break; } else { this->in.get(); } } else if ( ch == ',' ) { if ( this->braceLevel == 0 ) { break; } else { this->in.get(); } } else if ( ch == '#' ) { while ( ch >= 0 && ch != '\n' ) { ch = this->in.get(); } } else if ( isspace( ch ) ) { this->in.get(); } else if ( ! _ignoreEverything ) { return true; } else { this->in.get(); } } return false; } @ \section{Ignoring Part Of An Input Stream} <>= void ignore( const char* prefix, const char* token ); @ When an entity comes upon an unknown token, it usually wishes to ignore everything after up to and including the following semicolon. <>= void input::ignore( const char* prefix, const char* token ) { char ch; std::cerr << prefix << ": Ignoring " << token; while ( this->check( true ) ) { ch = this->in.get(); #ifndef NDEBUG std::cerr << ch; #endif }; ch = this->in.get(); #ifndef NDEBUG std::cerr << ch; #endif std::cerr << std::endl; } @ \section{Getting A Token} This routine reads in a token from the stream. If the token is longer than the buffer, the remaining portion of the token is sucked up, as well. <>= enum { MAX_TOKEN_LEN = 64 }; unsigned int get( char token[], unsigned int tokenLen ); @ <>= unsigned int input::get( char token[], unsigned int tokenLen ) { if ( ! this->check() ) { return 0; } unsigned int len = 0; int ch = this->in.peek(); while ( this->in.good() && !isspace( ch ) && ch != ',' && ch != ';' && ch != '>' && len < tokenLen-1 ) { ch = this->in.get(); *token++ = ch; ++len; ch = this->in.peek(); } *token = '\0'; while ( this->in.good() && !isspace( ch ) && ch != ',' && ch != ';' && ch != '>' ) { ch = this->in.get(); ch = this->in.peek(); } return len; } @ \section{Source Files} The following section assembles the header file and source file for the input routines from the chunks above. \subsection{[[input.h]]} The main routine requires no include files at the moment, but it will very soon. <>= #ifndef _NKLEIN_INPUT_H_ #define _NKLEIN_INPUT_H_ 1 #include class input { protected: <> public: <> public: static const char* id; }; #endif /* _NKLEIN_INPUT_H_ */ @ \subsection{[[input.cc]]} The main routine requires no include files at the moment, but it will very soon. <>= #include "input.h" const char* input::id = "NKVERSION: input( RT_VERSION )"; <> @ ./rt2.7.2007.05.17/nws/intersection.nw0100644000077300007650000001611110600075243015153 0ustar patpat@ \chapter{Intersection} \label{sec:intersection} The [[intersection]] class represents a single intersection between a ray and an object. The intersection class specifies the position and the normal at the point where the ray and object intersect, and whether the ray hit the object from the inside or not. <>= mathvec< double > position; mathvec< double > normal; mathvec< double > direction; bool inside; @ Additionally, the class holds the position, normal, and direction in the object's coordinates so that if the color of the object needs to be checked, the raytracer will not have to re-rotate the position and normal into the object's frame of reference. <>= mathvec< double > objectPosition; mathvec< double > objectNormal; mathvec< double > objectDirection; @ The class also holds a pointer to the color of the object and a record of the distance. <>= const color* objectColor; double distance; @ Additionally, it contains a buffer into which the object color can be evaluated. <>= mathvec< double > pixel; @ \section{Constructor} The default constructor does nothing except zero the color pointer. <>= intersection( void ); @ <>= intersection::intersection( void ) : objectColor( 0 ) { } @ \section{Setting The Intersection Attributes} The following methods can be used to set the attributes of this intersection point. These attributes are in the global frame of reference. <>= inline void setPosition( const mathvec< double >& pp ) { this->position = pp; }; inline void setNormal( const mathvec< double >& nn ) { this->normal = nn; }; inline void setDirection( const mathvec< double >& dd ) { this->direction = dd; }; inline void setInside( void ) { this->inside = true; }; inline void setOutside( void ) { this->inside = false; }; inline void setDistance( double dd ) { this->distance = dd; }; @ \section{Getting The Intersection Attributes} The following methods can be used to retrieve the attributes of this intersection point. These attributes are in the global frame of reference. <>= inline const mathvec< double >& getPosition( void ) const { return this->position; }; inline const mathvec< double >& getNormal( void ) const { return this->normal; }; inline const mathvec< double >& getDirection( void ) const { return this->direction; }; inline bool isInside( void ) const { return this->inside; } inline bool isOutside( void ) const { return ! this->inside; } inline const color* getColor( void ) const { return this->objectColor; } inline double getDistance( void ) const { return this->distance; } @ \section{Setting The Object Intersection Attributes} The following methods can be used to set the attributes of this intersection point. These attributes are in the object's frame of reference. <>= inline void setObjectPosition( const mathvec< double >& pp ) { this->objectPosition = pp; }; inline void setObjectNormal( const mathvec< double >& nn ) { this->objectNormal = nn; }; inline void setObjectDirection( const mathvec< double >& dd ) { this->objectDirection = dd; }; inline void setObjectColor( const color* cc ) { this->objectColor = cc; }; @ \section{Updating The Object Intersection Attributes} At the time this intersection is filled in, only the coordinates in the object's reference frame are known. This method is used to re-orient the intersection attributes back toward the global reference frame. <>= void reorient( const mathvec< double >& scale, const basevec< mathvec< double > >& orientation, const mathvec< double >& center ); @ <>= void intersection::reorient( const mathvec< double >& scale, const basevec< mathvec< double > >& orientation, const mathvec< double >& center ) { this->position *= scale; this->position.rotate( orientation ); this->position += center; this->direction *= scale; this->direction.rotate( orientation ); this->direction.normalize(); this->normal /= scale; this->normal.rotate( orientation ); this->normal.normalize(); } @ If there is a color specified in an object which contains the object intersected, then the color gets overridden. Along with the color, the position, normal, and direction must also be updated. As such, container objects should reorient objects using the above method before recoloring them. <>= void recolor( const color& cc ); @ <>= void intersection::recolor( const color& cc ) { this->setObjectColor( &cc ); this->setObjectPosition( this->getPosition() ); this->setObjectNormal( this->getNormal() ); this->setObjectDirection( this->getDirection() ); } @ \section{Querying The Intersection Color} The following method allows one to query the color of the intersection from the intersection's point of view. <>= void evaluate( double contribution, unsigned int height, mathvec< double >& pp ) const; @ <>= void intersection::evaluate( double contribution, unsigned int height, mathvec< double >& pp ) const { if ( this->pixel.size() == 0 ) { this->objectColor->evaluate( this->objectPosition, this->objectNormal, this->objectDirection, contribution, height, *(mathvec< double >*)&this->pixel ); } pp = this->pixel; } @ \section{The Class Definition} \label{sec:intersection-class} This class includes all of the methods declared above. And, it includes some version identification information. <>= class intersection { protected: <> public: <> public: static const char* id; }; @ \section{Source Files} The following sections assemble the source files for the [[intersection]] class from the chunks above. \subsection{[[intersection.h]]} The header file the [[intersection]] class includes the [[iostream]] and [[string]] headers from the standard C++ libraries and the header file for the [[mathvec<>]] class and then incorporates the class defined in \ref{sec:intersection-class} above. All of this is wrapped in syntactic sugar to avoid problems should this file be included more than once. <>= #ifndef _NKLEIN_INTERSECTION_H_ #define _NKLEIN_INTERSECTION_H_ 1 #include #include #include #include "color.h" <> #endif /*_NKLEIN_INTERSECTION_H_*/ @ \subsection{[[intersection.cc]]} Herein, the implementations of the methods of the [[intersection]] class are included as well as the the declarations and implementations of the derived classes. <>= #include #include #include #include "input.h" #include "intersection.h" const char* intersection::id = "NKVERSION: intersection( RT_VERSION )"; <> @ ./rt2.7.2007.05.17/nws/light.nw0100644000077300007650000001701210053432653013561 0ustar patpat@ \chapter{Light} \label{sec:light} The light class represents a point light source. The light has a position and a color. It can also specify a fall-off rate. This is the amount the distance to the lamp is scaled by before the inverse-squared effect is applied. It can also have a direction and a pair of angles. The smaller angle specifies the angular range off of the light direction that still gets full contribution of this light. The larger angle specifies the angular range off of the light direction beyond which no contribution is made from this light. <>= light_parameters ::= light_parameters light_param | /* empty */ ; light_param ::= light_pos | 'color' '{' color_parameters '}' ';' | 'falloff' real ';' | 'direction' real_vector ';' | 'angles' real ',' real ';' ; light_pos ::= 'position' real_vector ';' | 'center' real_vector ';' ; @ Colors are described in \S\ref{sec:color}. The special value [[0]] for the fall-off indicates that the light is the same intensity at any distance. This fall-off defaults to zero. <>= const scene* myScene; @ The [[light]] class represents a point source of illumination within the scene. It defines the position and color of the light as well as the other parameters of the source. <>= mathvec< double > position; color chroma; double falloff; mathvec< double > direction; double outerCosine; double cosineRange; @ \section{Constructor} The default constructor does little beyond initializing the light and its color with the current scene pointer. Additionally, it prepares the inner and outer angle parameters to have the light default to omnidirectional. <>= light( const scene* ss ); @ <>= light::light( const scene* ss ) : myScene( ss ), chroma( ss ), falloff( 0.0 ), outerCosine(-2.0), cosineRange(-1.0) { } @ \section{Setting The Number of Dimensions} When the number of spatial dimensions for the universe are set, this information is passed along to all of the constituent lights. The light resizes the position and direction vectors as well as the color accordingly. The direction of the light is normalized. <>= void setDimensions( unsigned int dd ); @ <>= void light::setDimensions( unsigned int dd ) { this->position.resize( dd, 0.0 ); this->chroma.setDimensions( dd ); this->direction.resize( dd, 0.0 ); double dmag = this->direction.magnitude(); if ( dmag >= 0.000001 ) { this->direction /= dmag; } } @ \section{Retreiving The Light Position} To query the light's position, one can invoke the following method. This is used by one of the universe's helper classes to determine the direction from the point of intersection to the light. <>= inline const mathvec< double >& getPosition( void ) const { return this->position; }; @ \section{Retreiving The Fall Off Factor} To query the light's fall-off factor, one can invoke the following method. <>= inline double getFallOff( void ) const { return this->falloff; }; @ \section{Querying The Light Color} The following method allows one to query the color of the light to a particular position, with a given normal, and from a given direction. <>= void evaluate( const mathvec< double >& position, const mathvec< double >& normal, const mathvec< double >& direction, double contribution, unsigned int height, mathvec< double >& pixel ) const; @ The method first invokes the [[evaluate]] method on the color of the light. Then, if angles were specified for this light, it rescales the contribution based on the angular difference. <>= void light::evaluate( const mathvec< double >& pos, const mathvec< double >& norm, const mathvec< double >& dir, double contribution, unsigned int height, mathvec< double >& pixel ) const { this->chroma.evaluate( pos, norm, dir, contribution, height, pixel ); if ( this->outerCosine > -1.5 ) { double cc = - ( dir ^ this->direction ); double diff = cc - this->outerCosine; if ( diff < 0.000001 ) { pixel *= 0.0; } else if ( diff < this->cosineRange ) { pixel *= diff / this->cosineRange; } } } @ \section{Loading A Light} The following method allows one to read in a light from a stream. <>= friend std::istream& operator >> ( std::istream& in, light& cc ); @ There are several keywords recognized in the light. One can specify the location of the light with the [[position]] or [[center]] vector. One specifies the light's direction with the [[direction]] vector. One specifies the inner and outer angles (in degrees) with the two values of the [[angles]] tag. One specifies the color of the light by specifying an instance of the color class (defined in \S\ref{sec:color}) using the [[color]] tag. <>= std::istream& operator >> ( std::istream& stream, light& ll ) { input in( stream ); while ( in.check() ) { char token[ input::MAX_TOKEN_LEN ]; if ( in.get( token, sizeof(token) ) == 0 ) { return stream; } std::string tok( token ); char semicolon; if ( tok == "position" || tok == "center" ) { stream >> ll.position >> semicolon; } else if ( tok == "direction" ) { stream >> ll.direction >> semicolon; } else if ( tok == "falloff" ) { stream >> ll.falloff >> semicolon; } else if ( tok == "angles" ) { <> } else if ( tok == "color" ) { stream >> ll.chroma >> semicolon; } else { in.ignore( "LIGHT", tok.c_str() ); } } return stream; } @ To calculate the angle parameters, the angles are read in. Then, their cosines are determined and sorted. Then, the cosine of the outer angle and the difference in cosines are stored in the light. <>= double inner; char comma; double outer; stream >> inner >> comma >> outer >> semicolon; inner = ::cos( inner * M_PI / 180.0 ); outer = ::cos( outer * M_PI / 180.0 ); if ( inner < outer ) { double tmp = inner; inner = outer; outer = tmp; } ll.outerCosine = outer; ll.cosineRange = inner - outer; @ \section{The Class Definition} \label{sec:light-class} This class includes all of the methods declared above. And, it includes some version identification information. <>= class light { protected: <> public: <> public: static const char* id; }; @ \section{Source Files} The following sections assemble the source files for the [[light]] class from the chunks above. \subsection{[[light.h]]} The header file for the light class includes the [[iostream]], [[string]], and [[map]] headers from the standard C++ libraries and the header files for the [[color]] class and then incorporates the class defined in \S\ref{sec:light-class} above. All of this is wrapped in syntactic sugar to avoid problems should this file be included more than once. <>= #ifndef _NKLEIN_LIGHT_H_ #define _NKLEIN_LIGHT_H_ 1 #include #include #include #include "color.h" <> #endif /*_NKLEIN_LIGHT_H_*/ @ \subsection{[[light.cc]]} Herein, the implementations of the methods of the [[light]] class are included. The implementation requires the header for the [[string]] class and the math library. <>= #include #include #include "input.h" #include "light.h" const char* light::id = "NKVERSION: light( RT_VERSION )"; <> @ ./rt2.7.2007.05.17/nws/main.nw0100644000077300007650000000652410026672532013406 0ustar patpat@ \chapter{Main Routine} \label{sec:main} The main routine of the raytracer is responsible for loading in the scene files from the command-line and rendering them. If no scenes are given on the command-line, it is assumed that one will be coming on standard-input. <
>= int main( int argc, const char* const argv[] ) { int ii; <
> if ( ii < argc ) { <
> } else { <
> } return 0; } @ If the argument, does not start with a dash (`[[-]]'), then it must be a file name. The only recognized argument at the moment is ``[[-t]]'' which specifies the number of threads to place in the thread pool. Unfortunately, at the moment, using any threads slows the system down immensely for some reason. So, this is not a wholly useful option. <
>= for ( ii=1; ii < argc; ++ii ) { std::string arg( argv[ ii ] ); if ( arg[0] != '-' ) { break; } else if ( arg == "-t" ) { <
> } else { std::cerr << "Unknown argument: " << arg << std::endl; <
> return __LINE__; } } @ The thread-count argument will be a simple integer specifying the number of threads to employ. Here, this code arbitrarily keep the count from exceeding [[100]]. <
>= std::istringstream str( argv[++ii] ); unsigned int count = 0; str >> count; if ( count > 100 ) { count = 100; } thread::instance()->setWorkerCount( count ); @ If there is an unrecognized argument, the usage statement is emitted to standard-error. <
>= std::cerr << "USAGE: " << argv[0]; std::cerr << " [-t threadCount]"; std::cerr << " file1 file2 ..." << std::endl; @ To read the files from the command-line, this code loops through the arguments on the command-line. With each argument, it attempts to open that as a file and read a scene from it. Once the scene is read, the scene's render method is invoked. The [[scene]] class is specified in \ref{sec:scene}. <
>= while ( ii < argc ) { std::ifstream stream( argv[ii++] ); if ( stream.good() ) { scene ss; stream >> ss; ss.render(); } else { std::cerr << "Couldn't open: " << argv[ii-1] << std::endl; } } @ To read in a scene from standard-input, the following code simply reads a scene from [[std::cin]] and invokes the scene's render method. The [[scene]] class is specified in \ref{sec:scene}. <
>= if ( std::cin.good() ) { scene ss; std::cin >> ss; ss.render(); } else { std::cerr << "Couldn't read standard input" << std::endl; } @ \section{Source Files} The following section assembles the source file for the main routine from the chunks above. \subsection{[[main.cc]]} The main routine utilizes [[fstream]]s to read scenes in from files. It uses [[iostream]]s to read scenes in from standard-input. It uses [[sstream]]s to parse integer command-line arguments. Further, it directly invokes the construcor and the render method of the [[scene]] class. And, it uses the [[nkthread]] system to set the number of threads in the thread pool. <>= #include #include #include #include "scene.h" #include "nkthread.h" <
> @ ./rt2.7.2007.05.17/nws/mathvec.nw0100644000077300007650000005651410623061253014110 0ustar patpat@ \chapter{Mathematical Vectors} An integer vector is expressed as an integer in square brackets which specifies the length of the vector. Following that, the vector is a comma-separated list of integers enclosed in angle brackets. <>= int_vector ::= '[' integer ']' '<' integer_list '>' ; integer_list ::= integer_list ',' integer | integer ; @ The number of elements in the list must be at least as great as the number given in the square brackets at the start. A real vector is expressed as an integer in square brackets which specifies the length of the vector. Following that, the vector is a comma-separated list of reals enclosed in angle brackets. <>= real_vector ::= '[' int ']' '<' real_list '>' ; real_list ::= real_list ',' real | real ; @ The number of elements in the list must be at least as great as the number given in the square brackets at the start. A real matrix is expressed as an integer in square brackets which specifies the number of rows in the vector. Following that, the matrix is a comma-separated list of real vectors enclosed in angle brackets. <>= real_matrix ::= '[' int ']' '<' real_vector_list '>' ; real_vector_list ::= real_vector_list ',' real_vector | real_vector ; @ The number of vectors in the list must be at least as great as the number given in the square brackets at the start. This template class extends the [[basevec<>]] class from section \ref{sec:basevec} to include operations for vector mathematics. The code in this raytracer uses two different types of these vectors. One is simply a vector of [[double]]s. The second type is a vector of [[unsigned int]]s used for counters. <>= template class mathvec< double >; template class mathvec< unsigned int >; template class basevec< mathvec< double > >; template class basevec< mathvec< unsigned int > >; @ The code in this raytracer also needs to orthogonalize matrixen of double-vectors. <>= template bool orthogonalize( basevec< mathvec< double > >& matrix, unsigned int dims ); @ And, in one instance, we need to transpose a matrix. <>= template void transpose( basevec< mathvec< double > >& matrix ); @ \section{Creating Vectors} There are several ways to create vectors. The most basice way is using the default constructor which simply initializes a zero-length vector. <>= mathvec(); @ <>= template < typename TT > mathvec< TT >::mathvec() : basevec< TT >() { } @ One could alternatively allocate a zero-vector of a fixed length. <>= mathvec( unsigned int len ); @ <>= template < typename TT > mathvec< TT >::mathvec( unsigned int len ) : basevec< TT >() { TT zero( 0U ); this->resize( len, zero ); } @ One could initialize a vector from a given value and length. <>= mathvec( const TT value, unsigned int len ); @ <>= template < typename TT > mathvec< TT >::mathvec( const TT value, unsigned int len ) : basevec< TT >( value, len ) { } @ One could initialize a vector from a given array and given length. <>= mathvec( const TT array[], unsigned int len ); @ <>= template < typename TT > mathvec< TT >::mathvec( const TT array[], unsigned int len ) : basevec< TT >( array, len ) { } @ One could copy an existing vector. This method makes use of the assignment operator defined next. <>= mathvec( const mathvec< TT >& other ); @ <>= template < typename TT > mathvec< TT >::mathvec( const mathvec< TT >& other ) : basevec< TT >( other ) { } @ One can also, craftily enough, assign a vector from a string representation of the vector. For example, one might assign a unit 3-vector using the string [["[3]< 1, 0, 0 >"]] <>= mathvec( const char* str ); @ <>= template < typename TT > mathvec< TT >::mathvec( const char* str ) : basevec< TT >( str ) { } @ \section{Comparing Vectors} It will frequently be necessary to see if two vectors are equal. As it's less computationally expensive to check to see if vectors are unequal, the following code implements the not-equal operator and then simply negates the result of the not-equal operator to get the equal-to operator. <>= bool operator != ( const mathvec< TT >& other ) const; bool operator == ( const mathvec< TT >& other ) const; @ For two vectors to be unequal, they must differ in size or in one of the components: $$\vec{v} \neq \vec{w} \leftrightarrow ( \dim(\vec{v}) \neq \dim(\vec{w}) ) \vee \bigvee_i ( v_i \neq w_i )$$ <>= template < typename TT > bool mathvec< TT >::operator != ( const mathvec< TT >& other ) const { if ( this->size() != other.size() ) { return true; } unsigned int len( this->size() ); for ( unsigned int ii=0; ii < len; ++ii ) { if ( (*this)[ ii ] != other[ ii ] ) { return true; } } return false; } @ For two vectors to be equal, they must not be unequal. $$\vec{v} = \vec{w} \leftrightarrow \neg ( \vec{v} \neq \vec{w} )$$ <>= template < typename TT > bool mathvec< TT >::operator == ( const mathvec< TT >& other ) const { return ! ( (*this) != other ); } @ \section{Scaling A Vector} One often needs to scale a vector. One can do this by multiplying by a constant: $\vec{v}' = \alpha \vec{v}$ or dividing by a constant: $\vec{v}' = \vec{v} / \beta = \frac{1}{\beta} \vec{v}$. There is a method whereby one can scale the current vector by multiplying each component by a scalar. <>= const mathvec< TT >& operator *= ( const TT& alpha ); @ To scale a vector by a scalar, one simply multiplies each component of the vector by the scalar: $$ \alpha\vec{v} = \sum_i \alpha{}v_i \hat{v}_i $$ <>= template < typename TT > const mathvec< TT >& mathvec< TT >::operator *= ( const TT& alpha ) { unsigned int len( this->size() ); for ( unsigned int ii=0; ii < len; ++ii ) { (*this)[ ii ] *= alpha; } return *this; } @ The above method is employed to implement methods whereby one can multiply a seperate vector by a constant. These methods use the copy constructor to copy the vector and then the method above to effect the scaling. There are methods here for pre- and post-multiplication by a scalar. <>= template < typename TT > const mathvec< TT > operator * ( const TT& alpha, const mathvec< TT >& vv ); @ <>= friend const mathvec< TT > operator * ( const TT& alpha, const mathvec< TT >& vv ); const mathvec< TT > operator * ( const TT& alpha ) const; @ <>= template < typename TT > const mathvec< TT > operator * ( const TT& alpha, const mathvec< TT >& vv ) { mathvec< TT > result( vv ); result *= alpha; return result; } @ <>= template < typename TT > const mathvec< TT > mathvec< TT >::operator * ( const TT& alpha ) const { mathvec< TT > result( *this ); result *= alpha; return result; } @ There is a method whereby one can scale the current vector by dividing each component by a scalar. <>= const mathvec< TT >& operator /= ( const TT& other ); @ To scale a vector by a dividing scalar, one simply divides each component of the vector by the scalar: $$ \vec{v} / \alpha = \sum_i ( v_i / \alpha ) \hat{v}_i $$ <>= template < typename TT > const mathvec< TT >& mathvec< TT >::operator /= ( const TT& alpha ) { unsigned int len( this->size() ); TT zero( 0U ); if ( alpha != zero ) { for ( unsigned int ii=0; ii < len; ++ii ) { (*this)[ ii ] /= alpha; } } else { for ( unsigned int ii=0; ii < len; ++ii ) { (*this)[ ii ] = zero; } } return *this; } @ This code only supports post-division of a vector by a scalar. <>= const mathvec< TT > operator / ( const TT& alpha ); @ <>= template < typename TT > const mathvec< TT > mathvec< TT >::operator / ( const TT& alpha ) { mathvec< TT > result( *this ); result /= alpha; return result; } @ \section{The Sum of Vectors} There are many occassions in a raytracer in which to add two vectors. <>= const mathvec< TT >& operator += ( const mathvec< TT >& other ); @ To sum two vectors, one simply sums the components: $$ \vec{v} + \vec{w} = \sum_i ( v_i + w_i ) \hat{v}_i = \sum_i ( v_i + w_i ) \hat{w}_i $$ <>= template < typename TT > const mathvec< TT >& mathvec< TT >::operator += ( const mathvec< TT >& other ) { unsigned int len( this->size() ); for ( unsigned int ii=0; ii < len; ++ii ) { (*this)[ ii ] += other[ ii ]; } return *this; } @ <>= const mathvec< TT > operator + ( const mathvec< TT >& other ) const; @ <>= template < typename TT > const mathvec< TT > mathvec< TT >::operator + ( const mathvec< TT >& other ) const { mathvec< TT > result( *this ); result += other; return result; } @ \section{The Difference of Vectors} There are many occasions in a raytracer in which one subtracts two vectors. <>= const mathvec< TT >& operator -= ( const mathvec< TT >& other ); @ To subtract a vector from another, one simply subtracts its compenents from the corresponding components of the other. $$ \vec{v} - \vec{w} = \sum_i ( v_i - w_i ) \hat{v}_i = \sum_i ( v_i - w_i ) \hat{w}_i $$ <>= template < typename TT > const mathvec< TT >& mathvec< TT >::operator -= ( const mathvec< TT >& other ) { unsigned int len( this->size() ); for ( unsigned int ii=0; ii < len; ++ii ) { (*this)[ ii ] -= other[ ii ]; } return *this; } @ <>= const mathvec< TT > operator - ( const mathvec< TT >& other ) const; @ <>= template < typename TT > const mathvec< TT > mathvec< TT >::operator - ( const mathvec< TT >& other ) const { mathvec< TT > result( *this ); result -= other; return result; } @ \section{The Elementwise Product of Vectors} To scale vectors by a different amount in each dimension, the raytracer uses elementwise products and quotients. <>= const mathvec< TT >& operator *= ( const mathvec< TT >& other ); @ To multiply two vectors elementwise, one simply multiplies the corresponding components. $$ \vec{v} \circ \vec{w} = \sum_i ( v_i \circ w_i ) \hat{v}_i = \sum_i ( v_i \circ w_i ) \hat{w}_i $$ <>= template < typename TT > const mathvec< TT >& mathvec< TT >::operator *= ( const mathvec< TT >& other ) { unsigned int len( this->size() ); for ( unsigned int ii=0; ii < len; ++ii ) { (*this)[ ii ] *= other[ ii ]; } return *this; } @ <>= const mathvec< TT > operator * ( const mathvec< TT >& other ) const; @ <>= template < typename TT > const mathvec< TT > mathvec< TT >::operator * ( const mathvec< TT >& other ) const { mathvec< TT > result( *this ); result *= other; return result; } @ \section{The Elementwise Quotient of Vectors} To scale vectors by a different amount in each dimension, the raytracer uses elementwise products and quotients. <>= const mathvec< TT >& operator /= ( const mathvec< TT >& other ); @ To divide one vector by another, one simply divides each component of the vector by the corresponding component of the other. $$ \vec{v} / \vec{w} = \sum_i ( v_i / w_i ) \hat{v}_i = \sum_i ( v_i / w_i ) \hat{w}_i $$ <>= template < typename TT > const mathvec< TT >& mathvec< TT >::operator /= ( const mathvec< TT >& other ) { TT zero( 0U ); unsigned int len( this->size() ); for ( unsigned int ii=0; ii < len; ++ii ) { if ( other[ ii ] != zero ) { (*this)[ ii ] /= other[ ii ]; } else { (*this)[ ii ] = zero; } } return *this; } @ <>= const mathvec< TT > operator / ( const mathvec< TT >& other ) const; @ <>= template < typename TT > const mathvec< TT > mathvec< TT >::operator / ( const mathvec< TT >& other ) const { mathvec< TT > result( *this ); result /= other; return result; } @ \section{The Dot Product of Two Vectors} To determine the angle between two vectors, one must use the dot-product of the vectors because: $$ cos\theta = \frac{\vec{v}\cdot\vec{w}}{ |\vec{v}|\cdot|\vec{w}| } $$ <>= const TT operator ^ ( const mathvec< TT >& other ) const; @ To calculate the dot product of two vectors one simply sums the products of the corresponding components. $$ \vec{v}\cdot\vec{w} = \sum_i v_i \cdot w_i $$ <>= template < typename TT > const TT mathvec< TT >::operator ^ ( const mathvec< TT >& other ) const { unsigned int len( this->size() ); TT result( 0U ); for ( unsigned int ii=0; ii < len; ++ii ) { result += (*this)[ ii ] * other[ ii ]; } return result; } @ \section{Normalizing A Vector} Many operations in a raytracer are simplest if the vectors are normalized. As such, the following methods can be used to determine the magnitude of a vector and normalize the vector. <>= TT magnitude( void ) const; mathvec< TT >& normalize( void ); @ The magnitude is simply the square root of the dot product of the vector with itself: $$ |\vec{v}| = \sqrt{ \vec{v}\cdot\vec{v} }$$ <>= template < typename TT > TT mathvec< TT >::magnitude( void ) const { return (TT)std::sqrt( (double)( (*this) ^ (*this) ) ); } @ The magnitude is simply the square root of the dot product of the vector with itself: $$ \hat{v} = \frac{ \vec{v} }{ |\vec{v}| }$$ <>= template < typename TT > mathvec< TT >& mathvec< TT >::normalize( void ) { *this /= this->magnitude(); return *this; } @ \section{Orthogonalizing A Matrix} Rather than require all input matrices to be fully specified and orthogonal, this method allows the matrices to be resized and orthogonalized. It uses the Gramm--Schmidt process. This is a summary of the Gramm--Schmidt process. Given linearly independent vectors $\vec{a}_0$, $\vec{a}_1$, $\vec{a}_2$, $\ldots \vec{a}_{n-1}$ and orthogonal vectors $\vec{v}_0$, $\vec{v}_1$, $\vec{v}_2$, $\ldots \vec{v}_{m-1}$, generate orthogonal vectors $\vec{y}_0$, $\vec{y}_1$, $\vec{y}_2$, $\ldots \vec{y}_{n-1}$ with the constraint that $\vec{y}_k = \vec{v}_k$ for $k < m$. To accomplish this, set $\vec{y}_k = \vec{v}_k$ for $k = 0$, $1$, $2$, $\ldots m-1$. Then, $$ \vec{y}_j = \vec{a}_j - \sum_{k = 0}^{j-1}{ { \vec{y}_k \cdot \vec{a}_j } \over { \vec{y}_k \cdot \vec{y}_k } }$$ This gives almost the whole picture. In reality, the $j$ subscript on the $\vec{y}$ items is somewhat independent of the $j$ subscript on the $\vec{a}$ items. This happens when the $\vec{a}_j$ is not linearly independent of the vectors $\vec{y}_0$, $\vec{y}_1$, $\vec{y}_2$, $\ldots \vec{y}_{j-1}$. This results in the calculated $\vec{y}_j$ being a zero vector. When this happens, we need to recalculate $\vec{y}_j$ using the next $\vec{a}$. So, the $j$ subscript on the $\vec{a}$ may increment faster than it does on the $\vec{y}$. In this scenario, all of the $\vec{y}_k$ are unit vectors, so the denominator of the fraction is always one. Additionally, in this scenario, all of the $\vec{a}_j$ are columns of the identity matrix, so the numerator is easy to calculate. <>= template < typename TT > bool orthogonalize( basevec< mathvec< TT > >& matrix, unsigned int dims ); @ <>= template < typename TT > bool orthogonalize( basevec< mathvec< TT > >& matrix, unsigned int dims ) { unsigned int originalSize = matrix.size(); <> <> return true; } @ <>= for ( unsigned int ii=0; ii < originalSize; ++ii ) { matrix[ ii ].resize( dims, 0.0 ); <> <> if ( zero ) { return false; } } @ <>= mathvec< double > vv( matrix[ ii ] ); for ( unsigned int jj=0; jj < ii; ++jj ) { matrix[ ii ] -= ( vv ^ matrix[ jj ] ) * matrix[ jj ]; } @ <>= double mag = matrix[ ii ].magnitude(); bool zero = ( mag < 0.000001 ); if ( ! zero ) { matrix[ ii ] /= mag; } @ <>= matrix.resize( dims ); unsigned int currentGuessColumn = 0; for ( unsigned int ii=originalSize; ii < dims; ++ii ) { matrix[ ii ].resize( dims, 0.0 ); <> <> <> if ( zero ) { --ii; } } @ <>= matrix[ ii ] *= 0.0; matrix[ ii ][ currentGuessColumn++ ] = 1.0; @ \section{Orthogonalizing A Matrix} It is comparatively easy to transpose a matrix. <>= template < typename TT > void transpose( basevec< mathvec< TT > >& matrix ); @ <>= template < typename TT > void transpose( basevec< mathvec< TT > >& matrix ) { unsigned int originalSize = matrix.size(); for ( unsigned int ii=0; ii < originalSize-1; ++ii ) { for ( unsigned int jj=ii+1; jj < originalSize; ++jj ) { TT tt = matrix[ ii ][ jj ]; matrix[ ii ][ jj ] = matrix[ jj ][ ii ]; matrix[ jj ][ ii ] = tt; } } } @ \section{Rotating A Vector} <>= mathvec< TT >& rotate( const basevec< mathvec< TT > >& matrix ); @ <>= template < typename TT > mathvec< TT >& mathvec< TT >::rotate( const basevec< mathvec< TT > >& matrix ) { mathvec< TT >& res( *this ); mathvec< TT > orig( *this ); for ( unsigned int ii=0; ii < this->size(); ++ii ) { TT value = 0; for ( unsigned int jj=0; jj < this->size(); ++jj ) { value += orig[ jj ] * matrix[ jj ][ ii ]; } res[ ii ] = value; } return res; } @ \section{Antirotating A Vector} <>= mathvec< TT >& antirotate( const basevec< mathvec< TT > >& matrix ); @ <>= template < typename TT > mathvec< TT >& mathvec< TT >::antirotate( const basevec< mathvec< TT > >& matrix ) { mathvec< TT >& res( *this ); mathvec< TT > orig( *this ); for ( unsigned int ii=0; ii < this->size(); ++ii ) { const mathvec< TT >& col( matrix[ ii ] ); TT value = 0; for ( unsigned int jj=0; jj < this->size(); ++jj ) { value += orig[ jj ] * col[ jj ]; } res[ ii ] = value; } return res; } @ \section{Solving A System Of Linear Equations} This is Gaussian elimination with partial pivoting as described in \textit{Numerical Methods and Analysis} by James L.~Buchanan and Peter R.~Turner. <>= mathvec< TT > solve( const basevec< mathvec< TT > >& _AA ); @ <>= template < typename TT > mathvec< TT > mathvec< TT >::solve( const basevec< mathvec< TT > >& _AA ) { unsigned int nn = this->size(); mathvec< TT > xx( nn ); <> for ( unsigned int jj=0; jj < nn-1; ++jj ) { <> <> } <> return xx; } @ <>= mathvec< unsigned int > perm( nn ); for ( unsigned int ii=0; ii < nn; ++ii ) { perm[ ii ] = ii; } basevec< mathvec< TT > > AA( _AA ); mathvec< TT > bb( *this ); static const TT zero = (TT)0; static const TT minusOne = (TT)-1; @ <>= TT pivot = AA[ perm[ jj ] ][ jj ]; if ( pivot < zero ) { pivot *= minusOne; } unsigned int piv = jj; unsigned int ptmp = perm[ jj ]; for ( unsigned int ii=jj+1; ii < nn; ++ii ) { TT cur = AA[ perm[ ii ] ][ jj ]; if ( cur < zero ) { cur *= minusOne; } if ( cur > pivot ) { pivot = cur; piv = ii; } } perm[ jj ] = perm[ piv ]; perm[ piv ] = ptmp; if ( (double)pivot < 0.000001 ) { return xx; } @ <>= unsigned int pj = perm[ jj ]; const mathvec< TT >& baseRow( AA[ pj ] ); for ( unsigned int ii=jj+1; ii < nn; ++ii ) { unsigned int pi = perm[ ii ]; mathvec< TT >& curRow( AA[ pi ] ); TT mm = curRow[ jj ] / baseRow[ jj ]; curRow[ jj ] = zero; bb[ pi ] -= mm * bb[ pj ]; for ( unsigned int kk=jj+1; kk < nn; ++kk ) { curRow[ kk ] -= mm * baseRow[ kk ]; } } @ <>= for ( unsigned int kk=0; kk < nn; ++kk ) { unsigned int ii = ( nn - 1 ) - kk; unsigned int pi = perm[ ii ]; const mathvec< TT >& curRow( AA[ pi ] ); xx[ ii ] = bb[ pi ]; for ( unsigned int jj=ii+1; jj < nn; ++jj ) { xx[ ii ] -= curRow[ jj ] * xx[ jj ]; } xx[ ii ] /= curRow[ ii ]; } @ \section{The Class Definition} \label{sec:mathvec-class} This class inherits directly from the [[vector<>]] template class in the standard template library. It includes all of the methods declared above. And, it includes some version identification information. <>= template < typename TT > class mathvec; @ <>= template < typename TT > class mathvec : public basevec< TT > { public: <> public: static const char* id; }; @ \section{Source Files} The following sections assemble the source files for the [[mathvec]] template class from the chunks above. \subsection{[[mathvec.h]]} The header file the [[mathvec]] template class includes the [[iostream]], [[vector]], and [[cmath]] headers from the standard C++ libraries and then incorporates the template defined in \ref{sec:mathvec-class} above. In order to make templates work out alright, this file also includes the implementations of the template methods. All of this is wrapped in syntactic sugar to avoid problems should this file be included more than once. <>= #ifndef _NKLEIN_MATHVEC_H_ #define _NKLEIN_MATHVEC_H_ 1 #include #include #include #include "basevec.h" <> <> <> <> <> <> #endif /*_NKLEIN_MATHVEC_H_*/ @ \subsection{[[mathvec.cc]]} The implementation file for the [[mathvec]] template class instantiates the types of vectors used in the raytracer. <>= #include "mathvec.h" template< typename TT > const char* mathvec::id = "NKVERSION: mathvec<>( RT_VERSION )"; <> @ ./rt2.7.2007.05.17/nws/nkthread.nw0100644000077300007650000001522610605624273014263 0ustar patpat@ \chapter{Thread} \label{sec:thread} This section implements the [[thread]] class which allows rendering to take place in multiple threads. The [[thread]] class is a singleton shared throughout the raytracer. It is used mainly within the [[universe]]'s [[evaluate()]] method to parallelize that. To serve its purposes, the [[thread]] class needs something to actually do the work required in the thread. To this end, it uses a specialized base-class called [[work]]. A class hoping to get work done in a thread will submit an instance of the [[work]] class to the [[thread]] singleton. <>= <> @ The [[work]] class is defined in \S\ref{sec:thread-work}. That work is passed on to an instance of the [[worker]] class if there is one available. If there is not, then the [[work]] is performed inline. <>= <> @ The [[worker]] class is defined in \S\ref{sec:thread-worker}. The [[thread]] class keeps a list of available workers. <>= #ifdef USE_PTHREADS pthread_mutex_t mutex; #endif std::deque< worker* > workers; @ The [[thread]] class is a singleton. This method passes along the pointer to this instance. <>= static thread* instance( void ); @ <>= thread* thread::instance( void ) { static thread mgr; return &mgr; }; @ \section{Constructor} The default constructor initializes the mutex. <>= thread( void ); @ <>= thread::thread( void ) { #ifdef USE_PTHREADS ::pthread_mutex_init( &this->mutex, 0 ); #endif } @ \section{Destructor} The default constructor clears out all of the workers. <>= ~thread( void ); @ <>= thread::~thread( void ) { this->setWorkerCount( 0 ); #ifdef USE_PTHREADS ::pthread_mutex_destroy( &this->mutex ); #endif } @ \section{Setting The Number Of Workers} To increase the number of workers, this method simply allocates new worker threads. The workers are defined in \S\ref{sec:thread-worker}. The workers add themselves to this manager from within their run-loop. To decrease the number of workers, the extra workers are removed and deleted. <>= void setWorkerCount( unsigned int nn ); @ <>= void thread::setWorkerCount( unsigned int nn ) { std::vector< worker* > tmp; this->lock(); unsigned int original = this->workers.size(); if ( original < nn ) { for ( unsigned int ii=original; ii < nn; ++ii ) { new worker(); } } else if ( original > nn ) { tmp.resize( original - nn ); for ( unsigned int ii=nn; ii < original; ++ii ) { tmp[ ii - nn ] = this->workers.front(); this->workers.pop_front(); } } #ifdef USE_PTHREADS ::pthread_setconcurrency( nn+1 ); #endif this->unlock(); for ( unsigned int ii=0; ii < tmp.size(); ++ii ) { delete tmp[ ii ]; } } @ \section{Make A Worker Available Again} When a worker has completed its work, it invokes this method on that manager to put itself back in the queue of workers. <>= void makeWorkerAvailable( worker* ww ); @ <>= void thread::makeWorkerAvailable( worker* ww ) { this->lock(); this->workers.push_back( ww ); this->unlock(); } @ \section{Starting Work} A piece of work invokes this method in order to get itself going. This method attempts to pull an available worker from the queue. If it succeeds, then this work is assigned to that worker and started. Otherwise, the work is done entirely in-line. <>= void start( thread::work* ww ); @ <>= void thread::start( thread::work* ww ) { worker* wr = 0; this->lock(); if ( this->workers.size() > 0 ) { wr = this->workers.front(); this->workers.pop_front(); } this->unlock(); if ( wr == 0 ) { ww->perform(); ww->finish(); } else { wr->lock(); wr->setWork( ww ); wr->wakeup(); wr->unlock(); } } @ \section{Locking And Unlocking The Mutex} These methods are used to lock and unlock the manager. They simply invoke the corresponding POSIX mutex methods. <>= void lock( void ); void unlock( void ); @ <>= void thread::lock( void ) { #ifdef USE_PTHREADS ::pthread_mutex_lock( &this->mutex ); #endif } @ <>= void thread::unlock( void ) { #ifdef USE_PTHREADS ::pthread_mutex_unlock( &this->mutex ); #endif } @ \section{Waiting On A Condition} This method is invoked in the worker's main loop to wait for work to become available to it. The worker's [[wakeup()]] method signals that the worker's thread should now have some work to do. <>= void wait( void* cond ); @ <>= void thread::wait( void* cond ) { #ifdef USE_PTHREADS ::pthread_cond_wait( (pthread_cond_t*)cond, &this->mutex ); #endif } @ \section{The Class Definition} \label{sec:thread-class} This class includes all of the methods declared above. And, it includes some version identification information. <>= class thread { public: <> <> protected: <> public: <> friend class thread::worker; protected: <> public: static const char* id; }; @ \section{Source Files} The following sections assemble the source files for the [[thread]] class from the chunks above. \subsection{[[nkthread.h]]} The header file the [[thread]] class includes the [[deque]] header from the standard C++ libraries and the header file for the POSIX threads interface. Then, it goes on to include the thread manager class defined in \ref{sec:thread-class} above. All of this is wrapped in syntactic sugar to avoid problems should this file be included more than once. <>= #ifndef _NKLEIN_THREAD_H_ #define _NKLEIN_THREAD_H_ 1 #include #ifdef USE_PTHREADS # include #endif <> #endif /*_NKLEIN_THREAD_H_*/ @ \subsection{[[nkthread.cc]]} Herein, the implementations of the methods of the [[thread]] class are included as well as the the declarations and implementations of its support classes. <>= #include #include #include "nkthread.h" <> <> <> const char* thread::id = "NKVERSION: thread( RT_VERSION )"; const char* thread::work::id = "NKVERSION: thread::work( RT_VERSION )"; const char* thread::worker::id = "NKVERSION: thread::worker( RT_VERSION )"; <> @ ./rt2.7.2007.05.17/nws/object.nw0100644000077300007650000002520610602474714013730 0ustar patpat@ \chapter{Object} \label{sec:object} This class serves as the base class for all geometric object. It keeps track of the attributes common to all such objects. <>= object_parameters ::= 'scale' real_vector ';' | 'orientation' real_matrix ';' | 'center' real_vector ';' | 'color' '{' color_parameters '}' ';' ; @ There are a variety of objects which inherit from this base class. <>= object_type_and_params ::= 'halfspace' '{' halfspace_params '}' ';' | 'cylinder' '{' cylinder_params '}' ';' | 'quadratic' '{' quadratic_params '}' ';' | 'convex' '{' convex_params '}' ';' | 'coxeter' '{' coxeter_params '}' ';' | 'complement' '{' complement_params '}' ';' | 'union' '{' csg_union_params '}' ';' | 'intersection' '{' csg_intersection_params '}' ';' | 'extrusion' '{' extrusion_params '}' ';' ; @ The object keeps track of the scene to which it belongs. <>= const scene* myScene; @ The object class is a base class common to all geometric objects. It defines some properties shared by all objects: scale, orientation, center, and color. <>= double defaultScale; mathvec< double > scale; basevec< mathvec< double > > orientation; mathvec< double > center; color chroma; bool gotColor; @ Many objects will also need to forge transparent hits a great distance away. The following static member of the object class allows that to happen easily. <>= static color fakeColor; @ <>= color object::fakeColor( "channels [3]< 0 , 0 , 0 >;\n" "reflectiveness 0.0;\n" "specularness 0.0;\n" "transparency 1.0;\n" ); @ \section{Contructor} This contructor initializes the scene information. <>= object( const scene* ss ); @ <>= object::object( const scene* ss ) : myScene( ss ), defaultScale( 1.0 ), chroma( ss ), gotColor(false) { }; @ \section{Destructor} This destructor is simply a place-holder to ensure that the base classes are destructed properly. <>= virtual ~object( void ); @ <>= object::~object( void ) { }; @ \section{Setting The Number of Dimensions} Even though this method is virtual, there is an implementation that derived classes should invoke. It resizes the scaling vector, the orientation matrix, the center vector, and the color. <>= virtual void setDimensions( unsigned int dd ); @ <>= void object::setDimensions( unsigned int dd ) { this->scale.resize( dd, this->defaultScale ); ::orthogonalize( this->orientation, dd ); this->center.resize( dd, 0.0 ); this->chroma.setDimensions( dd ); } @ \section{Retreiving The Common Attributes} These methods allow one to query the attributes common to all objects. <>= inline const mathvec< double >& getScale( void ) const { return this->scale; }; inline const basevec< mathvec< double > >& getOrientation( void ) const { return this->orientation; }; inline const mathvec< double >& getCenter( void ) const { return this->center; }; inline const color& getColor( void ) const { return this->chroma; }; inline color* getColorPtr( void ) { return &this->chroma; }; @ \section{Setting The Common Attributes} These methods allow one to set some of the attributes common to all objects. <>= inline void setScale( const mathvec< double >& ss ) { this->scale = ss; }; inline void setOrientation( const basevec< mathvec< double > >& oo ) { this->orientation = oo; }; inline void setCenter( const mathvec< double >& cc ) { this->center = cc; }; @ \section{Intersection A Ray And An Object} This first intersection method retrieves only the closest intersection to the ray's origin. The ray is specified by its direction and start. This is a pure-virtual method which must be overridden by the derived class. <>= virtual bool intersect( const mathvec< double >& direction, const mathvec< double >& start, intersection& hit ) const = 0; @ This second intersection method retrieves all intersections between this object and the ray. The ray is specified by its direction and start. The array of hits is sorted in order of increasing distance from the start of the ray. This is a pure-virtual method which be overridden by the derived class. <>= virtual bool intersect( const mathvec< double >& direction, const mathvec< double >& start, std::vector< intersection* >& hits ) const = 0; @ \section{Checking If A Point Is Inside An Object} The following methods are used to determine if a point is inside the object. The first method [[inside()]] is used when the point is not yet in object coordinates. The other method [[_inside()]] is used when the point has already be oriented into the object's coordinate system. <>= virtual bool inside( const mathvec< double >& start ) const = 0; virtual bool _inside( const mathvec< double >& start ) const = 0; @ \section{Querying The Object Color} The following method allows one to query the color of the object at a particular position, with a given normal, and from a given direction. <>= void evaluate( const mathvec< double >& position, const mathvec< double >& normal, const mathvec< double >& direction, double contribution, unsigned int height, mathvec< double >& pixel ) const; @ This method simply calls the appropriate method on the color. <>= void object::evaluate( const mathvec< double >& position, const mathvec< double >& normal, const mathvec< double >& direction, double contribution, unsigned int height, mathvec< double >& pixel ) const { this->chroma.evaluate( position, normal, direction, contribution, height, pixel ); } @ \section{Forging A Hit} There are times when an object needs to forge a hit an infinite distance away. For example, when the entire ray is below the plane of a halfspace, the halfspace forges a hit an infinite distance away so that this object is not ignored when taken as part of an intersection of two objects. This method provides a common way for objects to forge this hit information. <>= void forgeHit( const mathvec< double >& direction, const mathvec< double >& start, intersection& hit ) const; @ <>= void object::forgeHit( const mathvec< double >& direction, const mathvec< double >& start, intersection& hit ) const { mathvec< double > pos = direction; pos *= MAXFLOAT; pos += start; mathvec< double > norm = direction; norm *= -1.0; hit.setPosition( pos ); hit.setNormal( norm ); hit.setDirection( direction ); hit.setObjectPosition( pos ); hit.setObjectNormal( norm ); hit.setObjectDirection( direction ); hit.setInside(); hit.setDistance( MAXFLOAT ); hit.setObjectColor( &object::fakeColor ); } @ \section{Reading Parts Common To All Objects} The following method allows one to read in an object from a stream. <>= friend std::istream& operator >> ( std::istream& in, object& cc ); @ <>= std::istream& operator >> ( std::istream& stream, object& ll ) { input in( stream ); ll.gotColor = false; while ( in.check() ) { char token[ input::MAX_TOKEN_LEN ]; if ( in.get( token, sizeof(token) ) == 0 ) { return stream; } std::string tok( token ); char semicolon; if ( tok == "scale" ) { stream >> ll.scale >> semicolon; } else if ( tok == "orientation" ) { stream >> ll.orientation >> semicolon; } else if ( tok == "antiorientation" ) { stream >> ll.orientation >> semicolon; ::orthogonalize( ll.orientation, ll.orientation[0].size() ); ::transpose( ll.orientation ); } else if ( tok == "center" ) { stream >> ll.center >> semicolon; } else if ( tok == "color" ) { stream >> ll.chroma >> semicolon; ll.gotColor = true; } else { in.ignore( "OBJECT", tok.c_str() ); } } return stream; } @ \section{Loading An Object} The following method allows one to read in an object from a stream. <>= static object* read( std::istream& in, const scene* ss ); @ This method pulls code in from all of the derived objects through the [[<>]] chunk which filled in more in each particular object's source. <>= object* object::read( std::istream& stream, const scene* ss ) { input in( stream ); while ( in.check() ) { char token[ input::MAX_TOKEN_LEN ]; if ( in.get( token, sizeof(token) ) == 0 ) { return 0; } std::string objectType( token ); char semicolon; <> { in.ignore( "OBJECT READER", objectType.c_str() ); } } return 0; } @ \section{The Class Definition} \label{sec:object-class} This class includes all of the methods declared above. And, it includes some version identification information. <>= class object { protected: <> protected: <> public: <> public: static const char* id; }; @ \section{Source Files} The following sections assemble the source files for the [[object]] class from the chunks above. \subsection{[[object.h]]} The header file the [[object]] class includes the [[iostream]], [[string]], and [[map]] headers from the standard C++ libraries and the header file for the [[intersection]] class and then incorporates the class defined in \ref{sec:object-class} above. All of this is wrapped in syntactic sugar to avoid problems should this file be included more than once. <>= #ifndef _NKLEIN_OBJECT_H_ #define _NKLEIN_OBJECT_H_ 1 #include #include #include #include "intersection.h" <> #endif /*_NKLEIN_OBJECT_H_*/ @ \subsection{[[object.cc]]} Herein, the implementations of the methods of the [[object]] class are included. Also, the header files for the derived objects are included via the [[<>]] chunk that is appended to in each derived class's source file. Those includes allow the [[<>]] chunks used above to function properly here. <>= #include #include #include #ifndef MAXFLOAT #include #endif #include "input.h" #include "object.h" <> const char* object::id = "NKVERSION: object( RT_VERSION )"; <> <> @ ./rt2.7.2007.05.17/nws/portal.nw0100644000077300007650000002104210030743502013742 0ustar patpat@ \chapter{Portal} \label{sec:portal} Most views will contain a viewport. That view is an instance of the color class defined in \S\ref{sec:color}. For that color to actually represent a view into a universe, the color must contain a portal. The portal refers to a universe by name. Additionally, it defines a point within that universe to be its center, it defines an orientation for the view into that universe, and it provides a scaling for the universe. <>= portal_parameters ::= portal_parameters portal_param | /* empty */ ; portal_param ::= 'scale' real_vector ';' | 'orientation' real_matrix ';' | 'center' real_vector ';' | 'universe' universe_name ';' ; @ The portal, if it is to be useful, must refer to a universe by name. If the scale is omitted, it is assumed to be a scaling factor of one in every dimension. If the orientation is omitted, it is assumed to be the identity matrix. If the center is omitted, it is assumed to be the zero vector. The portal class contains a pointer to the scene to which it belongs. <>= const scene* myScene; @ The portal class contains a pointer the universe into which it peers. But, until all of the universes have been loaded, it has to satisfy itself with just the name of the universe. <>= const universe* univ; std::string universeName; @ It contains a place to store its output pixel once evaluated. <>= mathvec< double > pixel; @ Additionally, it contains places to track the scale, orientation, and center. <>= mathvec< double > scale; basevec< mathvec< double > > orientation; mathvec< double > center; @ \section{Constructor} The constructor for the portal class merely caches the scene pointer it is given and zeros the universe pointer. <>= portal( const scene* ss ); @ <>= portal::portal( const scene* ss ) : myScene( ss ), univ( 0 ) { } @ \section{Destructor} The destructor for the portal does nothing. <>= ~portal( void ); @ <>= portal::~portal( void ) { } @ \section{Retrieving A Reference To Its Pixel Value} The expression subclass defined in \S\ref{sec:expr-reference} can be used to refer to a pixel value traced through this portal. As such, it needs to retrieve a reference to that pixel value. <>= const mathvec< double >& getPixel( void ) const { return this->pixel; }; @ \textit{Note:} for some complex scenes (or maybe even some not-so complex scenes) running multi-threaded could cause this buffer to be overwritten after it is calculated but before it is used. At the moment, I am not making any attempt to lock out this possibility. \section{Setting Up The Number Of Dimensions} The following method is invoked to bring the portal to the number of dimensions required by the enclosing extrusion, universe, or view. This is done after the portal is read and before any traces are performed so that once we get to tracing, all of the vectors and matrixen should be the correct size. <>= void setDimensions( unsigned int dd ); @ This method resizes the scaling vector padding any new dimensions with ones. It orthogonalizes the orientation matrix. And, it resizes the center point padding any new dimensions with zeros. <>= void portal::setDimensions( unsigned int dd ) { this->scale.resize( dd, 1.0 ); ::orthogonalize( this->orientation, dd ); this->center.resize( dd, 0.0 ); } @ \section{Casting A Ray Into The Portal} The following method allows one to cast a ray into a portal. <>= bool evaluate( const mathvec< double >& position, const mathvec< double >& direction, double contribution, unsigned int height, unsigned int channelCount ); @ This method ensures that the universe exists. Then, it reorients the incoming vectors, resizes those to the number of dimensions of the universe, clears out the pixel buffer, and sends the ray into the universe. <>= bool portal::evaluate( const mathvec< double >& position, const mathvec< double >& direction, double contribution, unsigned int height, unsigned int channelCount ) { <> <> <> this->pixel.resize( channelCount, 0.0 ); return this->univ->evaluate( rp, rd, contribution, height-1, this->pixel ); } @ If the universe pointer is null but its name is not, then this method attempts to get a pointer to the universe from the enclosing scene. If it should fail, this method returns false. <>= if ( this->univ == 0 && this->universeName != "" ) { this->univ = this->myScene->getUniverse( this->universeName ); } if ( this->univ == 0 ) { return false; } @ To reorient the incoming vector, the direction is rotated, scaled, and then renormalized while the position is rotated, scaled, and recentered. <>= mathvec< double > rd = direction; rd.rotate( this->orientation ); rd /= this->scale; rd.normalize(); mathvec< double > rp = position; rp.rotate( this->orientation ); rp /= this->scale; rp += this->center; @ If the number of dimensions in the incoming vectors is not the same as that of the universe, the incoming vectors are rescaled. After this rescaling process, the direction vector may need to be renormalized. If the direction vector cannot be renormalized, this method bails. <>= unsigned int dims = this->univ->getDimensions(); if ( rp.size() != dims ) { rp.resize( dims, 0.0 ); rd.resize( dims, 0.0 ); double magdir = rd.magnitude(); if ( magdir >= 0.000001 ) { rd /= magdir; } else { this->pixel *= 0.0; return false; } } @ \section{Loading A Portal} The following method allows one to read a portal from an input stream. <>= friend std::istream& operator >> ( std::istream& in, portal& pp ); @ There are four valid keywords within the portal: [[scale]], [[orientation]], [[center]], and [[universe]]. For each of these, the appropriate parameter is read. <>= std::istream& operator >> ( std::istream& stream, portal& pp ) { input in( stream ); while ( in.check() ) { char token[ input::MAX_TOKEN_LEN ]; if ( in.get( token, sizeof(token) ) == 0 ) { return stream; } std::string tok( token ); char semicolon; if ( tok == "scale" ) { stream >> pp.scale >> semicolon; } else if ( tok == "orientation" ) { stream >> pp.orientation >> semicolon; } else if ( tok == "center" ) { stream >> pp.center >> semicolon; } else if ( tok == "universe" ) { if ( in.get( token, sizeof(token) ) == 0 ) { return stream; } pp.universeName = token; } else { in.ignore( "PORTAL", tok.c_str() ); } } return stream; } @ \section{The Class Definition} \label{sec:portal-class} This class includes all of the methods declared above. And, it includes some version identification information. <>= class portal { protected: <> public: <> public: static const char* id; }; @ \section{Source Files} The following sections assemble the source files for the portal class from the chunks above. \subsection{[[portal.h]]} The header file the portal class includes the [[iostream]] and [[string]] headers from the standard C++ libraries and the header file for the [[mathvec<>]] class. It pre-declares the scene and universe classes, and then incorporates the class defined in \S\ref{sec:portal-class} above. All of this is wrapped in syntactic sugar to avoid problems should this file be included more than once. <>= #ifndef _NKLEIN_PORTAL_H_ #define _NKLEIN_PORTAL_H_ 1 #include #include #include "mathvec.h" class scene; class universe; <> #endif /*_NKLEIN_PORTAL_H_*/ @ \subsection{[[portal.cc]]} Herein, the implementations of the methods of the portal class are included. The implementation requires the [[string]] and [[stringstream]] classes from the standard C++ library, the header for the input subsystem, the header for the universe class, the header for the scene class, and the declaration of the portal class itself. <>= #include #include #include "input.h" #include "universe.h" #include "scene.h" #include "portal.h" const char* portal::id = "NKVERSION: portal( RT_VERSION )"; <> @ ./rt2.7.2007.05.17/nws/quadratic.nw0100644000077300007650000002304510032072605014424 0ustar patpat@ \chapter{Quadratic} \label{sec:quadratic} The quadratic surface is specified using a matrix $M$, a vector $\vec{V}$, and a scalar $S$. The quadratic surface (before it is scaled, oriented, and positined) is all points $\vec{x}$ satisfying: $$ \vec{x}^T M \vec{x} + \vec{V}^T \vec{x} + S \le 0 $$ The quadratic surface must specify the matrix $M$ of squared terms, the vector $V$ of linear terms, and the scalar $S$. It can also specify the parameters for the object base class. <>= quadratic_params ::= 'squares' real_matrix ';' | 'linears' real_vector ';' | 'scalar' real ';' | 'base' '{' object_parameters '}' ';' ; @ The following snippets are used so that the object's factory method can create instance of this class. <>= #include "quadratic.h" @ <>= if ( objectType == "quadratic" ) { quadratic* obj = new quadratic( ss ); stream >> *obj >> semicolon; return obj; } else @ <>= basevec< mathvec< double > > squares; mathvec< double > linears; double scalar; @ \section{Constructor} The default constructor does nothing. <>= quadratic( const scene* ss ); @ <>= quadratic::quadratic( const scene* ss ) : object( ss ) { } @ \section{Destructor} This destructor has nothing to do. <>= virtual ~quadratic( void ); @ <>= quadratic::~quadratic( void ) { } @ \section{Setting The Number of Dimensions} Even though this method is virtual, there is an implementation that derived classes should invoke. <>= virtual void setDimensions( unsigned int dd ); @ <>= void quadratic::setDimensions( unsigned int dd ) { this->squares.resize( dd ); for ( unsigned int ii=0; ii < dd; ++ii ) { this->squares[ ii ].resize( dd, 0.0 ); } this->linears.resize( dd ); this->object::setDimensions( dd ); } @ \section{Intersection A Ray And A Quadratic} This first intersection method retrieves only the closest intersection to the ray's origin. The ray is specified by its direction and start. <>= virtual bool intersect( const mathvec< double >& direction, const mathvec< double >& start, intersection& hit ) const; @ <>= bool quadratic::intersect( const mathvec< double >& direction, const mathvec< double >& start, intersection& hit ) const { <> if ( ! hitQuadratic ) { if ( this->_inside( rp ) ) { this->forgeHit( direction, start, hit ); return true; } return false; } if ( t1 >= 0.000001 ) { mathvec< double > nn; double tt = t1; <> } else if ( t2 >= 0.000001 ) { mathvec< double > nn; double tt = t2; <> } else { return false; } return true; } @ <>= mathvec< double > rd = direction; rd.antirotate( this->orientation ); rd /= this->scale; rd.normalize(); mathvec< double > rp = start - this->center; rp.antirotate( this->orientation ); rp /= this->scale; double t1 = -1.0; double t2 = -1.0; double AA = 0.0; double BB = 0.0; double CC = this->scalar; unsigned int len = this->squares.size(); for ( unsigned int ii=0; ii < len; ++ii ) { for ( unsigned int jj=0; jj < len; ++jj ) { double ss = this->squares[ ii ][ jj ]; AA += ss * rd[ ii ] * rd[ jj ]; BB += ss * rd[ ii ] * rp[ jj ]; BB += ss * rp[ ii ] * rd[ jj ]; CC += ss * rp[ ii ] * rp[ jj ]; } double ll = this->linears[ ii ]; BB += ll * rd[ ii ]; CC += ll * rp[ ii ]; } bool hitQuadratic = false; if ( ::fabs( AA ) > 0.000001 ) { double DD = BB * BB - 4.0 * AA * CC; if ( DD > 0.000001 ) { double dd = ::sqrt( DD ); t1 = ( - BB - dd ) / ( 2.0 * AA ); t2 = ( - BB + dd ) / ( 2.0 * AA ); if ( t2 < t1 ) { double tmp = t1; t1 = t2; t2 = tmp; } hitQuadratic = t2 >= 0.000001; } } else if ( ::fabs( BB ) > 0.000001 ) { t1 = -CC / BB; hitQuadratic = t1 >= 0.000001; } @ <>= mathvec< double > spot = rp + ( rd * tt ); nn.resize( len ); for ( unsigned int ii=0; ii < len; ++ii ) { double vv = this->linears[ ii ]; for ( unsigned int jj=0; jj < len; ++jj ) { double ff = ( this->squares[ ii ][ jj ] + this->squares[ jj ][ ii ] ); vv += ff * spot[ jj ]; } nn[ ii ] = vv; } if ( this->_inside( rp ) ) { nn *= -1.0; hit.setInside(); } else { hit.setOutside(); } nn.normalize(); hit.setObjectPosition( spot ); hit.setObjectNormal( nn ); hit.setObjectDirection( rd ); hit.setPosition( spot ); hit.setNormal( nn ); hit.setDirection( rd ); hit.reorient( this->scale, this->orientation, this->center ); hit.setDistance( ( hit.getPosition() - start ).magnitude() ); hit.setObjectColor( &this->chroma ); @ This second intersection method retrieves all intersections between this quadratic and the ray. The ray is specified by its direction and start. The array of hits is sorted in order of increasing distance from the start of the ray. <>= virtual bool intersect( const mathvec< double >& direction, const mathvec< double >& start, std::vector< intersection* >& hits ) const; @ <>= bool quadratic::intersect( const mathvec< double >& direction, const mathvec< double >& start, std::vector< intersection* >& hits ) const { <> hits.clear(); if ( !hitQuadratic ) { if ( this->_inside( rp ) ) { intersection* hh = new intersection(); hits.insert( hits.end(), hh ); this->forgeHit( direction, start, *hh ); } } else { if ( t1 >= 0.000001 ) { intersection* h1 = new intersection(); hits.insert( hits.end(), h1 ); intersection& hit( *h1 ); mathvec< double > nn; double tt = t1; <> hit.setOutside(); } if ( t2 >= 0.000001 ) { intersection* h2 = new intersection(); hits.insert( hits.end(), h2 ); intersection& hit( *h2 ); mathvec< double > nn; double tt = t2; <> hit.setInside(); } } return hits.size() > 0; } @ \section{Checking If A Point Is Inside A Quadratic} <>= virtual bool inside( const mathvec< double >& start ) const; virtual bool _inside( const mathvec< double >& rp ) const; @ <>= bool quadratic::inside( const mathvec< double >& start ) const { mathvec< double > rp = start - this->center; rp.antirotate( this->orientation ); rp /= this->scale; return this->_inside( rp ); } bool quadratic::_inside( const mathvec< double >& rp ) const { unsigned int len = this->center.size(); double sum = this->scalar; for ( unsigned int ii=0; ii < len; ++ii ) { double vv = this->linears[ ii ]; for ( unsigned int jj=0; jj < len; ++jj ) { vv += this->squares[ ii ][ jj ] * rp[ jj ]; } sum += vv * rp[ ii ]; } return sum <= 0.0; } @ \section{Loading A Quadratic} The following method allows one to read in an quadratic from a stream. <>= friend std::istream& operator >> ( std::istream& in, quadratic& cc ); @ <>= std::istream& operator >> ( std::istream& stream, quadratic& qq ) { input in( stream ); qq.scalar = 0.0; while ( in.check() ) { char token[ input::MAX_TOKEN_LEN ]; if ( in.get( token, sizeof(token) ) == 0 ) { return stream; } std::string tok( token ); char semicolon; if ( tok == "squares" ) { stream >> qq.squares >> semicolon; } else if ( tok == "linears" ) { stream >> qq.linears >> semicolon; } else if ( tok == "scalar" ) { stream >> qq.scalar >> semicolon; } else if ( tok == "base" ) { stream >> (object&)qq >> semicolon; } else { in.ignore( "QUADRATIC", tok.c_str() ); } } qq.linears.resize( qq.squares.size(), 0.0 ); for ( unsigned int ii=0; ii < qq.squares.size(); ++ii ) { qq.squares[ ii ].resize( qq.squares.size(), 0.0 ); } return stream; } @ \section{The Class Definition} \label{sec:quadratic-class} This class includes all of the methods declared above. And, it includes some version identification information. <>= class quadratic : public object { protected: <> public: <> public: static const char* id; }; @ \section{Source Files} The following sections assemble the source files for the [[quadratic]] class from the chunks above. \subsection{[[quadratic.h]]} The header file the [[quadratic]] class includes the [[iostream]], [[string]], and [[map]] headers from the standard C++ libraries and the header file for the [[object]] base class and then incorporates the class defined in \ref{sec:quadratic-class} above. All of this is wrapped in syntactic sugar to avoid problems should this file be included more than once. <>= #ifndef _NKLEIN_QUADRATIC_H_ #define _NKLEIN_QUADRATIC_H_ 1 #include #include #include #include "object.h" <> #endif /*_NKLEIN_QUADRATIC_H_*/ @ \subsection{[[quadratic.cc]]} Herein, the implementations of the methods of the [[quadratic]] class are included as well as the the declarations and implementations of the derived classes. <>= #include #include #include #include "input.h" #include "quadratic.h" const char* quadratic::id = "NKVERSION: quadratic( RT_VERSION )"; <> @ ./rt2.7.2007.05.17/nws/rt.sty0100644000077300007650000000061207752000652013272 0ustar patpat\ProvidesPackage{rt} \usepackage{noweb} \usepackage{graphicx} \usepackage{xspace} \usepackage{color} \usepackage[bookmarks=true,colorlinks=true]{hyperref} %\usepackage{prelim2e} \newcommand{\Href}[1]{\href{#1}{\url{#1}}} \newcommand{\furl}[1]{\footnote{\Href{#1}}} \pagestyle{noweb} \noweboptions{smallcode,longxref} \newcommand{\Prog}{\textsc{N-Dimensional Raytracer}\xspace} \endinput ./rt2.7.2007.05.17/nws/sample-compl.nw0100644000077300007650000000440210031676614015045 0ustar patpat@ \section{Rendering Of A Complement Of A Sphere} \begin{figure} \centerline{\includegraphics[width=5.0in]{../Image/compl.jpg}} \caption{A rendering of the intersection of a cube and the complement of a sphere versus the intersection of a cube and a sphere} \label{fig:compl} \end{figure} This sample renders the intersection of a cube with the complement of a sphere as well as the intersection of a cube with a sphere for comparison. The resulting image appears in figure \ref{fig:compl}. <>= view { <> }; universe myuniverse { <> }; @ The size of the image is specified to be 256 units at one dot per unit without any fish-eye effect. <>= units [2]< 2.56, 1.28 >; dotsPerUnit [2]< 300, 300 >; viewDepth 6; @ The viewport simply places the viewer slightly down the x-axis. <>= viewport { portal myportal { universe myuniverse ; center [3]< -12, 0, 0 >; }; channels [3]< @ myportal 0 , @ myportal 1 , @ myportal 2 >; }; @ Then, the output image information is specified. <>= image ppm { common { basename compl; }; }; @ This is a three-dimensional universe with a little bit of ambient light, a slightly blue sky, and a couple of lights. <>= dimensions 3; ambientLight { channels [3]< 0.1 , 0.1 , 0.1 >; }; skyColor { channels [3]< 0.2 , 0.2 , 0.6 >; }; light { position [3]< -10, 5, 15 >; falloff 0.1; color { channels [3]< 0.6 , 0.6 , 0.6 >; }; }; light { position [3]< -15, -5, 5 >; falloff 0.1; color { channels [3]< 0.8 , 0.8 , 0.8 >; }; }; @ <>= object intersection { <> object complement { <> }; base { center [3]< 0, 1, 0 >; orientation [2]< [3]< 3, 2, 1 >, [3]< 1, 0, -3 > >; }; }; object intersection { <> <> base { center [3]< 0, -1, 0 >; orientation [2]< [3]< 3, 2, 1 >, [3]< 1, 0, -3 > >; }; }; @ <>= object cylinder { roundDimensions 3; base { scale [3]< 0.85, 0.85, 0.85 >; color { channels [3]< 1.0 , 0.6 , 0.6 >; }; }; }; @ <>= object cylinder { roundDimensions 0; base { scale [3]< 0.7, 0.7, 0.7 >; color { channels [3]< 0.4 , 1.0 , 0.4 >; }; }; }; @ ./rt2.7.2007.05.17/nws/sample-coxeter.nw0100644000077300007650000000703710600103073015375 0ustar patpat@ \section{Rendering Of 3-Dimensional Coxeters} \label{sec:sample-coxeter} \begin{figure} \centerline{\includegraphics[width=5.0in]{../Image/coxeter.jpg}} \caption{A rendering of a cube, an icosahedron, and an dodecahedron} \label{fig:coxeter} \end{figure} This sample shows how to generate a regular polytope based upon the Coxeter-Dynkin diagram of the symmetry group of the vertexes. The resulting image appears in figure \ref{fig:coxeter}. <>= view { <> }; universe myuniverse { <> }; @ The width of the image is specified to be 2.56 units at 300 dots per unit. The height of the image is specified to be 1.28 units at 300 dots per unit. The viewer is expected to be six units from the image. <>= units [2]< 2.56, 1.28 >; dotsPerUnit [2]< 300, 300 >; viewDepth 6; @ The viewpoint sets the viewer back down the x-axis a ways. <>= viewport { portal myportal { universe myuniverse ; center [3]< -12, 0, 0 >; }; channels [3]< @ myportal 0 , @ myportal 1 , @ myportal 2 >; }; @ Then, the output image information is specified. <>= image ppm { common { basename coxeter; }; }; @ This is a three-dimensional universe with a little bit of ambient light, a slightly blue sky, and a couple of lights. <>= dimensions 3; ambientLight { channels [3]< 0.1 , 0.1 , 0.1 >; }; skyColor { channels [3]< 0.2 , 0.2 , 0.6 >; }; light { position [3]< -10, 5, 15 >; falloff 0.1; color { channels [3]< 0.8 , 0.8 , 0.8 >; }; }; light { position [3]< -15, -5, 5 >; falloff 0.1; color { channels [3]< 1.0 , 1.0 , 1.0 >; }; }; @ There is a red dodecahedron, next to a green icosahedron, next to a blue cube. <>= object coxeter { # # o--5--*-----* # matrix [3]< [3]< 1, 5, 2 >, [3]< 5, 0, 3 >, [3]< 2, 3, 0 > >; <> base { scale [3]< 0.8, 0.8, 0.8 >; <> center [3]< 0, -1.5, 0 >; color { channels [3]< 1.0 , 0.2 , 0.2 >; specularness 0.3; reflectiveness 0.1; transparency 0.4; }; }; }; object coxeter { # # *--5--*-----o # matrix [3]< [3]< 0, 5, 2 >, [3]< 5, 0, 3 >, [3]< 2, 3, 1 > >; <> base { scale [3]< 0.8, 0.8, 0.8 >; <> center [3]< 0, 0, 0 >; color { channels [3]< 0.2 , 1.0 , 0.2 >; specularness 0.3; reflectiveness 0.1; transparency 0.4; }; }; }; object coxeter { # # o--4--*-----* # matrix [3]< [3]< 1, 4, 2 >, [3]< 4, 0, 3 >, [3]< 2, 3, 0 > >; <> base { scale [3]< 0.8, 0.8, 0.8 >; <> center [3]< 0, 1.5, 0 >; color { channels [3]< 1.0 , 1.0 , 0.2 >; specularness 0.3; reflectiveness 0.1; transparency 0.4; }; }; }; @ <>= colorDistance 0.05; specialColor 1 { channels [3]< 0.2 , 0.2 , 0.2 >; specularness 0.3; reflectiveness 0.1; }; specialColor 0 { channels [3]< 1.0 , 0.5 , 0.5 >; specularness 0.3; reflectiveness 0.1; }; @ All of these are shown over a reflective plane to add to the ambience. <>= object halfspace { base { center [3]< 0, 0, -0.75 >; orientation [1]< [3]< 0, 0, 1 > >; color { channels [3]< 0.8 , 0.8 , 1.0 >; reflectiveness 0.8; }; }; }; @ All of these shapes are tipped the same way. <>= orientation [2]< [3]< 1, 2, 5 >, [3]< -2, 1, 0 > >; @ ./rt2.7.2007.05.17/nws/sample-cylinders.nw0100644000077300007650000000556610031676633015744 0ustar patpat@ \section{Rendering Of 3-Dimensional Cylinders} \begin{figure} \centerline{\includegraphics[width=5.0in]{../Image/cylinders.jpg}} \caption{A rendering of a sphere, a cylinder, and a cube} \label{fig:cylinders} \end{figure} This sample renders the three three-dimensional cylinder objects. The resulting image appears in figure \ref{fig:cylinders}. There is a red cube, next to a green cylinder, next to a blue sphere. Each is slightly reflective. <>= view { <> }; universe myuniverse { <> }; @ The width of the image is specified to be 2.56 units at 300 dots per unit. The height of the image is specified to be 1.28 units at 300 dots per unit. This is no fish-eye effect. And, the viewer is expected to be six units from the image. <>= units [2]< 2.56, 1.28 >; dotsPerUnit [2]< 300, 300 >; fishEye [2]< 0, 0 >; viewDepth 6; @ The view into the universe starts at twelve units down the x-axis and peers into the universe called [[myuniverse]]. <>= viewport { portal myportal { universe myuniverse ; center [3]< -12, 0, 0 >; }; channels [3]< @ myportal 0 , @ myportal 1 , @ myportal 2 >; }; @ The output image information is specified. Here, a [[ppm]] image is used since the [[png]] features may not be availabe on all systems. <>= image ppm { common { basename cylinders; }; }; @ This is a three-dimensional universe with a little bit of ambient light, a slightly blue sky, and a couple of lights. <>= dimensions 3; ambientLight { channels [3]< 0.1 , 0.1 , 0.1 >; }; skyColor { channels [3]< 0.2 , 0.2 , 0.6 >; }; light { position [3]< -10, 5, 15 >; falloff 0.1; color { channels [3]< 0.8 , 0.8 , 0.8 >; }; }; light { position [3]< -15, -5, 5 >; falloff 0.1; color { channels [3]< 1.0 , 1.0 , 1.0 >; }; }; @ There is a red cube, next to a green cylinder, next to a slightly reflective blue sphere. <>= object cylinder { roundDimensions 0; base { scale [3]< 0.8, 0.8, 0.8 >; <> center [3]< 0, -2.5, 0 >; color { channels [3]< 1.0 , 0.2 , 0.2 >; specularness 0.3; reflectiveness 0.3; }; }; }; object cylinder { roundDimensions 2; base { scale [3]< 0.8, 0.8, 0.8 >; <> center [3]< 0, 0, 0 >; color { channels [3]< 0.2 , 1.0 , 0.2 >; specularness 0.3; reflectiveness 0.3; }; }; }; object cylinder { roundDimensions 3; base { scale [3]< 1.0, 1.0, 1.0 >; <> center [3]< 0, 2.5, 0 >; color { channels [3]< 0.2 , 0.2 , 1.0 >; specularness 0.3; reflectiveness 0.3; }; }; }; @ Each of the cylinders is tipped slightly for a more interesting image. <>= orientation [2]< [3]< 1, 1, 1 >, [3]< -1, 1, 0 > >; @ ./rt2.7.2007.05.17/nws/sample-extrusion.nw0100644000077300007650000000456310031676642016004 0ustar patpat@ \section{Rendering Of An Extrusion Of A Quadratic} \begin{figure} \centerline{\includegraphics[width=3.0in]{../Image/extrusion.jpg}} \caption{A rendering of the intersection of a sphere and an extrusion of a quadratic} \label{fig:extrusion} \end{figure} This sample renders the intersection of a unit sphere with the extrusion into three dimensions of the quadratic solid: $$ x^2 + xy - y^2 + x + y + \frac{1}{4} \le 0 $$ The resulting image appears in figure \ref{fig:extrusion}. <>= view { <> }; universe myuniverse { <> }; @ The size of the image is specified to be 1.28 units at three hundred dot per unit without any fish-eye effect. The viewer is expected to be six units from the image. <>= units [2]< 1.28, 1.28 >; dotsPerUnit [2]< 300, 300 >; viewDepth 6; @ The viewport moves the viewer down the x-axis a small way. <>= viewport { portal myportal { universe myuniverse ; center [3]< -15, 0, 0 >; }; channels [3]< @ myportal 0 , @ myportal 1 , @ myportal 2 >; }; @ Then, the output image information is specified. <>= image ppm { common { basename extrusion; }; }; @ This is a three-dimensional universe with a little bit of ambient light, a slightly blue sky, and a couple of lights. <>= dimensions 3; ambientLight { channels [3]< 0.1 , 0.1 , 0.1 >; }; skyColor { channels [3]< 0.2 , 0.2 , 0.6 >; }; light { position [3]< -10, 5, 15 >; falloff 0.1; color { channels [3]< 0.6 , 0.6 , 0.6 >; }; }; light { position [3]< -15, -5, 5 >; falloff 0.1; color { channels [3]< 0.8 , 0.8 , 0.8 >; }; }; @ Here is the intersection of the objects. The extrusion says that the items inside the extrusion are 2-dimensional. The universe that the extrusion sits in is three-dimensional. <>= object intersection { object extrusion { dimensions 2; object quadratic { squares [2]< [2]< 1, 1 >, [2]< 0, -1 > >; linears [2]< 1, 1 >; scalar 0.25; }; base { color { channels [3]< 1.0 , 0.2 , 0.2 >; specularness 0.4; phong 5; }; }; }; object cylinder { roundDimensions 3; base { scale [3]< 1, 1, 1 >; color { channels [3]< 0.2 , 1.0 , 0.2 >; }; }; }; base { orientation [2]< [3]< 5, 0, -1 >, [3]< 0, 1, 0 > >; }; }; @ ./rt2.7.2007.05.17/nws/sample-inside.nw0100644000077300007650000000424110031676651015210 0ustar patpat@ \section{Rendering From Inside The Union Of A Cube And A Cylinder} \begin{figure} \centerline{\includegraphics[width=3.0in]{../Image/inside.jpg}} \caption{A rendering from inside the union of a cube and a cylinder} \label{fig:inside} \end{figure} This sample renders a fish-eyed view from inside the intersection of a reflective cube and a cylinder. The resulting image appears in figure \ref{fig:inside}. <>= view { <> }; universe myuniverse { <> }; @ The size of the image is specified to be 2.56 units at one 300 dots per unit with some fish-eye effect. <>= units [2]< 2.56, 2.56 >; dotsPerUnit [2]< 300, 300 >; fishEye [2]< 8, 8 >; viewDepth 6; traceDepth 18; @ The viewport sets the viewer right at the center of the universe. <>= viewport { portal myportal { universe myuniverse ; center [3]< 0, 0, 0 >; }; channels [3]< @ myportal 0 , @ myportal 1 , @ myportal 2 >; }; @ Then, the output image information is specified. <>= image ppm { common { basename inside; }; }; @ This is a three-dimensional universe with a little bit of ambient light, a slightly blue sky, and a couple of lights. <>= dimensions 3; ambientLight { channels [3]< 0.1 , 0.1 , 0.1 >; }; skyColor { channels [3]< 0.2 , 0.2 , 0.6 >; }; light { position [3]< -10, 5, 15 >; falloff 0.0; color { channels [3]< 0.3 , 0.3 , 0.3 >; }; }; light { position [3]< -15, -5, 5 >; falloff 0.0; color { channels [3]< 0.4 , 0.4 , 0.4 >; }; }; @ Here are the cylinder and the cube. <>= object union { object cylinder { roundDimensions 0; base { scale [3]< 30.0, 30.0, 30.0 >; orientation [2]< [3]< 1, 1, 1 >, [3]< -1, 1, 0 > >; center [3]< 15, 0, 0 >; color { channels [3]< 0.7 , 0.2 , 0.2 >; specularness 0.3; reflectiveness 0.2; }; }; }; object cylinder { roundDimensions 2; base { scale [3]< 40.0, 40.0, 40.0 >; orientation [2]< [3]< 1, 1, 1 >, [3]< -1, 1, 0 > >; center [3]< -15, 0, 0 >; color { channels [3]< 0.2 , 0.7 , 0.2 >; specularness 0.3; }; }; }; }; @ ./rt2.7.2007.05.17/nws/sample-inter.nw0100644000077300007650000000573610031676655015074 0ustar patpat@ \section{Rendering Of The Union Of Two Spheres} \begin{figure} \centerline{\includegraphics[width=5.0in]{../Image/inter.jpg}} \caption{A cutaway rendering of a intersection of two spheres} \label{fig:intersection} \end{figure} This sample two spheres along with their intersection. The entire scene is shown cut-away so that one can see what really goes on inside the objects. The resulting image appears in figure \ref{fig:intersection}. <>= view { <> }; universe myuniverse { <> }; @ The width of the image is specified to be 2.56 units at 300 dots per unit. The height of the image is specified to be 1.28 units at 300 dots per unit. The viewer is expected to be six units away from the image. <>= units [2]< 2.56, 1.28 >; dotsPerUnit [2]< 300, 300 >; viewDepth 6; @ The viewport places the viewer slightly down the x-axis. <>= viewport { portal myportal { universe myuniverse ; center [3]< -12, 0, 0 >; }; channels [3]< @ myportal 0 , @ myportal 1 , @ myportal 2 >; }; @ Then, the output image information is specified. <>= image ppm { common { basename inter; }; }; @ This is a three-dimensional universe with a little bit of ambient light, a slightly blue sky, and a couple of lights. <>= dimensions 3; ambientLight { channels [3]< 0.1 , 0.1 , 0.1 >; }; skyColor { channels [3]< 0.2 , 0.2 , 0.6 >; }; light { position [3]< -10, 5, 15 >; falloff 0.1; color { channels [3]< 0.8 , 0.8 , 0.8 >; }; }; light { position [3]< -15, -5, 5 >; falloff 0.1; color { channels [3]< 1.0 , 1.0 , 1.0 >; }; }; @ This is the box used to cutaway the real objects. <>= object intersection { object cylinder { roundDimensions 0; base { scale [3]< 1.4, 5, 1 >; center [3]< 1, 0, 0 >; color { channels [3]< 1.0 , 1.0 , 1.0 >; transparency 1.0; specularness 0.0; reflectiveness 0.0; }; }; }; object set { <> }; }; @ This is the intersection of the two spheres. <>= object intersection { object cylinder { roundDimensions 3; base { scale [3]< 0.75, 0.75, 0.75 >; center [3]< 0, 1.5, 0 >; color { channels [3]< 1.0 , 0.2 , 0.2 >; }; }; }; object cylinder { roundDimensions 3; base { scale [3]< 0.75, 0.75, 0.75 >; center [3]< 0, 1.0, 0 >; color { channels [3]< 0.2 , 0.2 , 1.0 >; }; }; }; }; @ This is the two spheres without the intersectioning. <>= object set { object cylinder { roundDimensions 3; base { scale [3]< 0.75, 0.75, 0.75 >; center [3]< 0, -1.0, 0 >; color { channels [3]< 1.0 , 0.2 , 0.2 >; }; }; }; object cylinder { roundDimensions 3; base { scale [3]< 0.75, 0.75, 0.75 >; center [3]< 0, -1.5, 0 >; color { channels [3]< 0.2 , 0.2 , 1.0 >; }; }; }; }; @ ./rt2.7.2007.05.17/nws/sample-justColor.nw0100644000077300007650000000440410031164224015706 0ustar patpat@ \section{Simple Rendering Without Raytracing} \begin{figure} \centerline{\includegraphics[width=3.0in]{../Image/justColor.jpg}} \caption{A simple rendering without the need for a portal} \label{fig:justColor} \end{figure} This sample renders a view which does not depend upon any geometric objects or lighting of them. The color is determined solely as a function of the view direction. The resulting image appears in figure \ref{fig:justColor}. Sadly, this image reminds the author of a glaucoma test. <>= view { <> }; @ The view is set to wrap around if the fish-eye effect is great enough, although there is no fish-eye effect here. The gamma value is set to neutral for speed. And, the border is set to zero because this is a single-frame image. <>= wrap; gamma 1.0; border 0; @ The width and height of the image are both specified to be 256 units at 3 dots per unit without any fish-eye effect. The viewer is expected to be six units away from the image. <>= units [2]< 256, 256 >; dotsPerUnit [2]< 3, 3 >; fishEye [2]< 0, 0 >; viewDepth 6; @ The viewport is used to specify the color. Notably, the channel array in the viewport shows that the color is a function of the viewing direction. If the view direction is a unit vector $\vec{d}$, then the color channels are an RGB vector: $\left< \frac{1}{2} + \frac{3}{4}\sin \pi d_x, \frac{1}{2} + \frac{3}{4}\sin \pi d_y, \frac{1}{2} + \frac{3}{4}\sin \pi d_z \right>$. The color values get clipped to the range $[0,1]$. <>= viewport { channels [3]< + 0.5 * 0.75 sin * pi dir 0 , + 0.5 * 0.75 sin * pi dir 1 , + 0.5 * 0.75 sin * pi dir 2 >; scale [3]< 1, 1, 1 >; orientation [3]< [3]< 1, 0, 0 >, [3]< 0, 1, 0 >, [3]< 0, 0, 1 > >; center [3]< 0, 0, 0 >; }; @ The default scale, orientation, and center are shown explicitly here for reference. This viewport is an exceptional case. For most images, one will want the viewport to contain a portal into a universe. This, however, simply functionally color the image. Finally, the output image information is specified. Here, a [[ppm]] image is used since the [[png]] features may not be availabe on all systems. <>= image ppm { common { basename justColor; }; }; @ ./rt2.7.2007.05.17/nws/sample-quadratic.nw0100644000077300007650000000415710031676665015725 0ustar patpat@ \section{Rendering Of A Quadratic Solid} \begin{figure} \centerline{\includegraphics[width=3.0in]{../Image/quadratic.jpg}} \caption{A rendering of a quadratic surface} \label{fig:quadratic} \end{figure} This sample renders a quadratic solid. In this case, it is the solid described by: $$x^2 + xy - xz - y^2 + yz + z^2 + x + y + z + \frac{1}{2} \le 0$$ The resulting image appears in figure \ref{fig:quadratic}. <>= view { <> }; universe myuniverse { <> }; @ The size of the image is specified to be 1.28 units in each direction at three hundred dots per unit without any fish-eye effect. The viewer is expected to be six units from the image. <>= units [2]< 1.28, 1.28 >; dotsPerUnit [2]< 300, 300 >; viewDepth 6; @ The viewport puts the viewer a little ways down the x-axis. <>= viewport { portal myportal { universe myuniverse ; center [3]< -15, 0, 0 >; }; channels [3]< @ myportal 0 , @ myportal 1 , @ myportal 2 >; }; @ Then, the output image information is specified. <>= image ppm { common { basename quadratic; }; }; @ This is a three-dimensional universe with a little bit of ambient light, a slightly blue sky, and a couple of lights. <>= dimensions 3; ambientLight { channels [3]< 0.1 , 0.1 , 0.1 >; }; skyColor { channels [3]< 0.2 , 0.2 , 0.6 >; }; light { position [3]< -10, 5, 15 >; falloff 0.1; color { channels [3]< 0.6 , 0.6 , 0.6 >; }; }; light { position [3]< -15, -5, 5 >; falloff 0.1; color { channels [3]< 0.8 , 0.8 , 0.8 >; }; }; @ This specifies the quadratic object. The matrix of [[squares]] specifies the coefficients for the terms of order two. The [[linears]] vector specifies the coefficients for the terms of order one. And, the scalar specifies an offset. <>= object quadratic { squares [3]< [3]< 1, 1, -1 >, [3]< 0, -1, 1 >, [3]< 0, 0, 1 > >; linears [3]< 1, 1, 1 >; scalar 0.5; base { color { channels [3]< 1.0 , 0.2 , 0.2 >; specularness 0.4; phong 10; }; }; }; @ ./rt2.7.2007.05.17/nws/sample-space.nw0100644000077300007650000000622610031676671015037 0ustar patpat@ \section{Rendering Of Two Halfspaces} \begin{figure} \centerline{\includegraphics[width=5.0in]{../Image/space.jpg}} \caption{A fish-eyed rendering of two halfspaces} \label{fig:halfspace} \end{figure} This sample renders a view into a universe where the viewpoint is directly between two halfspaces. The halfspace directly in front of the viewpoint is checkered blue and peach. The halfspace directly behind the viewpoint is checkered indigo and greenish yellow. The view is fish-eyed and wrapped so that one can see more than the whole way around so that the plane in front shows up again on the fringes of the image. The resulting image is in figure \ref{fig:halfspace}. <>= view { <> }; universe myuniverse { <> }; @ The view is set to wrap around to provide a prettier image. The gamma value is set to neutral for speed. And, the border is set to zero because this is a single frame image. <>= wrap; gamma 1.0; border 0; @ The width of the image is specified to be 2.56 units at 300 dots per unit. The height of the image is specified to be 1.28 units at 300 dots per unit. There is a huge fish-eye effect which causes the plane in front of the viewpoint to actually show up again. If [[wrap]] had not been set above, the outer edge would be white instead of wrapping around. And, the viewer is expected to be sitting six units from the image. <>= units [2]< 2.56, 1.28 >; dotsPerUnit [2]< 300, 300 >; fishEye [2]< 30, 30 >; viewDepth 6; @ The viewport into the universe is straightforward. It starts slightly down the x-axis. <>= viewport { portal myportal { universe myuniverse ; center [3]< -12, 0, 0 >; }; channels [3]< @ myportal 0 , @ myportal 1 , @ myportal 2 >; }; @ then, the output image information is specified. <>= image ppm { common { basename space; }; }; @ This is a three-dimensional universe with a little bit of ambient light, a slightly blue sky, and a couple of lights. <>= dimensions 3; ambientLight { channels [3]< 0.1 , 0.1 , 0.1 >; }; skyColor { channels [3]< 0.2 , 0.2 , 0.6 >; }; light { position [3]< -10, 5, 15 >; falloff 0.1; color { channels [3]< 0.4 , 0.4 , 0.4 >; }; }; light { position [3]< -15, -5, 5 >; falloff 0.1; color { channels [3]< 0.5 , 0.5 , 0.5 >; }; }; @ There is one plane at the origin oriented so its normal points at the viewpoint. Technically, this isn't a plane. It is the entire halfspace beyond the plane. But, the rays here will only hit the surface of the plane. <>= object halfspace { base { orientation [1]< [1]< -1 > >; color { channels [3]< + 0.5 * 0.5 * cos pos 1 cos pos 2 , 0.5 , 0.5 >; }; }; }; @ The second plane sits directly behind the viewpoint as far from the viewpoint as the viewpoint is from the other plane. This plane is also oriented so its normal points toward the viewpoint. <>= object halfspace { base { center [1]< -24 >; orientation [1]< [1]< 1 > >; color { channels [3]< 0.5 , 0.5 , + 0.5 * 0.5 * cos pos 1 cos pos 2 >; }; }; }; @ ./rt2.7.2007.05.17/nws/sample-spot.nw0100644000077300007650000000331710031700616014712 0ustar patpat@ \section{Rendering Of Directional Spot Lights} \begin{figure} \centerline{\includegraphics[width=5.0in]{../Image/spot.jpg}} \caption{Two directional spot lights shining on a plane} \label{fig:spot} \end{figure} This sample shows two directional spot lights shining on a plane. The resulting image is in figure \ref{fig:spot}. <>= view { <> }; universe myuniverse { <> }; @ The view is 2.56 units wide and 1.28 units high at 300 dots per unit. There is no fish-eye effect. The viewer is expected to be six units from the image. <>= units [2]< 2.56, 1.28 >; dotsPerUnit [2]< 300, 300 >; viewDepth 6; @ The viewport places the viewer a fair distance back the x-axis so that the full spread of the spotlights is visible. <>= viewport { portal myportal { universe myuniverse ; center [3]< -100, 0, 0 >; }; channels [3]< @ myportal 0 , @ myportal 1 , @ myportal 2 >; }; @ Then, the output image is specified. <>= image ppm { common { basename spot; }; }; @ Both spotlights are positioned. <>= dimensions 3; ambientLight { channels [3]< 0.1 , 0.1 , 0.1 >; }; skyColor { channels [3]< 0.2 , 0.2 , 0.6 >; }; light { position [3]< -10, 5, 15 >; falloff 0.05; direction [3]< 10, -5, -15 >; angles 10, 15; color { channels [3]< 0.4 , 0.4 , 0.4 >; }; }; light { position [3]< -15, -5, 5 >; falloff 0.05; direction [3]< 15, 5, -5 >; angles 40, 50; color { channels [3]< 0.5 , 0.5 , 0.5 >; }; }; @ And, a plane is positioned for them to shine upon. <>= object halfspace { base { orientation [1]< [1]< -1 > >; color { channels [3]< 0.5 , 0.2 , 0.8 >; }; }; }; @ ./rt2.7.2007.05.17/nws/sample-union.nw0100644000077300007650000000554710031676740015076 0ustar patpat@ \section{Rendering Of The Union Of Two Spheres} \begin{figure} \centerline{\includegraphics[width=5.0in]{../Image/union.jpg}} \caption{A cutaway rendering of a union of two spheres} \label{fig:union} \end{figure} This sample two spheres along with their union. The entire scene is shown cut-away so that one can see what really goes on inside the objects. The resulting image appears in figure \ref{fig:union}. <>= view { <> }; universe myuniverse { <> }; @ The width of the image is specified to be 2.56 units at 300 dots per unit. The height of the image is specified to be 1.28 units at 300 dots per unit. The viewer is expected to be six units away from the image. <>= units [2]< 2.56, 1.28 >; dotsPerUnit [2]< 300, 300 >; viewDepth 6; @ The viewport places the viewer slightly down the x-axis. <>= viewport { portal myportal { universe myuniverse ; center [3]< -12, 0, 0 >; }; channels [3]< @ myportal 0 , @ myportal 1 , @ myportal 2 >; }; @ Then, the output image information is specified. <>= image ppm { common { basename union; }; }; @ This is a three-dimensional universe with a little bit of ambient light, a slightly blue sky, and a couple of lights. <>= dimensions 3; ambientLight { channels [3]< 0.1 , 0.1 , 0.1 >; }; skyColor { channels [3]< 0.2 , 0.2 , 0.6 >; }; light { position [3]< -10, 5, 15 >; falloff 0.1; color { channels [3]< 0.8 , 0.8 , 0.8 >; }; }; light { position [3]< -15, -5, 5 >; falloff 0.1; color { channels [3]< 1.0 , 1.0 , 1.0 >; }; }; @ This is the box used to cutaway the real objects. <>= object intersection { object cylinder { roundDimensions 0; base { scale [3]< 1.4, 5, 1 >; center [3]< 1, 0, 0 >; color { channels [3]< 1.0 , 1.0 , 1.0 >; transparency 1.0; specularness 0.0; reflectiveness 0.0; }; }; }; object set { <> }; }; @ This is the union of the two spheres. <>= object union { object cylinder { roundDimensions 3; base { scale [3]< 0.75, 0.75, 0.75 >; center [3]< 0, 1.5, 0 >; color { channels [3]< 1.0 , 0.2 , 0.2 >; }; }; }; object cylinder { roundDimensions 3; base { scale [3]< 0.75, 0.75, 0.75 >; center [3]< 0, 1.0, 0 >; color { channels [3]< 0.2 , 0.2 , 1.0 >; }; }; }; }; @ This is the two spheres without the unioning. <>= object set { object cylinder { roundDimensions 3; base { scale [3]< 0.75, 0.75, 0.75 >; center [3]< 0, -1.0, 0 >; color { channels [3]< 1.0 , 0.2 , 0.2 >; }; }; }; object cylinder { roundDimensions 3; base { scale [3]< 0.75, 0.75, 0.75 >; center [3]< 0, -1.5, 0 >; color { channels [3]< 0.2 , 0.2 , 1.0 >; }; }; }; }; @ ./rt2.7.2007.05.17/nws/samples.nw0100644000077300007650000000007707763161031014124 0ustar patpat@ \backmatter \chapter{Sample Input Files} \label{sec:samples} ./rt2.7.2007.05.17/nws/scene.nw0100644000077300007650000001446110026670064013554 0ustar patpat@ \chapter{Scene} \label{sec:scene} The scene is the top-level input for this raytracer. The scene contains zero or more views\footnote{Technically, if it has no views, it isn't going to render anything, so there's not much point in it.} and zero or more named universes. <>= scene ::= scene_parameters ; scene_parameters ::= scene_parameters scene_param | /*empty*/ ; scene_param ::= 'view' '{' view_parameters '}' ';' | 'universe' universe_name '{' universe_parameters '}' ';' ; universe_name ::= string ; @ Views are defined in \S\ref{sec:view}. Universes are defined in \S\ref{sec:universe}. The scene class provides two major functions in this raytracer. First, it is the top-level encapsulation of all that is known for a given trace. Any entity wishing to use a universe as a texture will get a handle to that universe through the scene in which the entity is contained. Secondly, the scene's [[render()]] method loops through all of the views and invokes the [[render()]] method on each one of them. The scene class contains an array of views and a map of universe pointers. The map of universes is indexed by name. <>= typedef std::vector< const view* > ViewList; ViewList views; typedef std::map< std::string, const universe* > UniverseMap; UniverseMap universes; @ \section{Constructor} The default constructor does nothing. <>= scene( void ); @ <>= scene::scene( void ) { } @ \section{Destructor} The destructor cleans out the views and universes. <>= ~scene( void ); @ All of this would be unneeded if the universe map and the view list had actual instances rather than pointers in them. But, there would be a great deal of copying around instances of sizeable instances if that were the case. <>= scene::~scene( void ) { UniverseMap::iterator uu; for ( uu=this->universes.begin(); uu != this->universes.end(); ++uu ) { delete uu->second; } ViewList::iterator vv; for ( vv=this->views.begin(); vv != this->views.end(); ++vv ) { delete *vv; } } @ \section{Retrieving A Pointer To A Universe} Colors which wish to reference a given universe in the scene will query the scene with the name of the universe. <>= const universe* getUniverse( const std::string& name ) const { UniverseMap::const_iterator uu = this->universes.find( name ); if ( uu != this->universes.end() ) { return uu->second; } else { return 0; } }; @ \section{Rendering The Scene} The following method is used to render the scene. <>= void render( void ) const; @ This method simply loops through each view and invokes the render method of the view. <>= void scene::render( void ) const { ViewList::const_iterator vv; for ( vv=this->views.begin(); vv != this->views.end(); ++vv ) { (*vv)->render(); } } @ This would be a convenient place to break off into separate threads. However, for most cases with multiple views, one would rather complete an output image as quickly as possible in order to monitor the progress of the scene. As such, it is doubtful that one would prefer to be rendering multiple files at the same time since it would take longer for the first output image to complete. As such, this method simply goes serially through the views. \section{Loading A Scene} The following method allows one to read in a scene from an input stream. <>= friend std::istream& operator >> ( std::istream& in, scene& ss ); @ There are only two valid keywords at the top-level of the scene. These are [[view]] and [[universe]]. <>= std::istream& operator >> ( std::istream& stream, scene& ss ) { input in( stream ); while ( in.check() ) { char token[ input::MAX_TOKEN_LEN ]; if ( in.get( token, sizeof(token) ) == 0 ) { return stream; } std::string tok( token ); char semicolon; if ( tok == "view" ) { <> } else if ( tok == "universe" ) { <> } else { in.ignore( "SCENE", tok.c_str() ); } } return stream; } @ When a view is encountered, a new instance is allocated passing in a pointer to the scene. After that, the view is read in from the input stream. Then, the view is appended to the list of views. <>= view* vv = new view( (const scene*)&ss ); stream >> *vv >> semicolon; ss.views.insert( ss.views.end(), vv ); @ When a universe is encountered, its name is read in. Then, a new universe instance is allocated passing in a pointer to the scene. After that, the universe is read in from the input stream. Then, the universe is added by name to the map of universes. <>= if ( in.get( token, sizeof(token) ) == 0 ) { return stream; } std::string name( token ); universe* uu = new universe( (const scene*)&ss ); stream >> *uu >> semicolon; ss.universes[ name ] = uu; @ \section{The Class Definition} \label{sec:scene-class} This class includes all of the methods declared above. And, it includes some version identification information. <>= class scene { protected: <> public: <> public: static const char* id; }; @ \section{Source Files} The following sections assemble the source files for the scene class from the chunks above. \subsection{[[scene.h]]} The header file for the scene class includes the [[iostream]], [[string]], and [[map]] headers from the standard C++ libraries and the header files for the [[view]] and [[universe]] classes and then incorporates the class defined in \S\ref{sec:scene-class} above. All of this is wrapped in syntactic sugar to avoid problems should this file be included more than once. <>= #ifndef _NKLEIN_SCENE_H_ #define _NKLEIN_SCENE_H_ 1 #include #include #include #include "view.h" #include "universe.h" <> #endif /*_NKLEIN_SCENE_H_*/ @ \subsection{[[scene.cc]]} Herein, the implementations of the methods of the scene class are included. The implementation requires the header for the input subsystem and the declaration of the scene class itself. <>= #include "input.h" #include "scene.h" const char* scene::id = "NKVERSION: scene( RT_VERSION )"; <> @ ./rt2.7.2007.05.17/nws/start.nw0100644000077300007650000000074407745536651013634 0ustar patpat\documentclass[pdftex]{book} \usepackage{rt} \def\nwbegincode#1{\par\nobreak \begingroup\setupcode\newlines\parindent=0pt\parskip=0pt \let\oendmoddef=\endmoddef \let\oplusendmoddef=\plusendmoddef \hsize=\codehsize\noindent\catcode`\^^M=\active} \def\nwendcode{\endgroup} \begin{document} @ \begin{titlepage} \title{ \Prog Development \\ \normalsize{Revision: [[RT_VERSION]]} } \author{ Patrick~A.~Stein } \end{titlepage} \maketitle \tableofcontents ./rt2.7.2007.05.17/nws/thread-work.nw0100644000077300007650000000516710605630503014706 0ustar patpat@ \chapter{Work} \label{sec:thread-work} This section implements the [[work]] class used by the thread. The class contains a mutual exclusion lock and a condition. The mutex and condition are used to wait until the work has been performed. <>= #ifdef USE_PTHREADS pthread_mutex_t mutex; pthread_cond_t condition; #endif bool done; @ \section{Constructor} The constructor initializes the mutex and condition. <>= work( void ); @ <>= thread::work::work( void ) : done( true ) { #ifdef USE_PTHREADS ::pthread_mutex_init( &this->mutex, 0 ); ::pthread_cond_init( &this->condition, 0 ); #endif } @ \section{Destructor} The destructor destroys the mutex and condition. <>= virtual ~work( void ); @ <>= thread::work::~work( void ) { #ifdef USE_PTHREADS ::pthread_cond_destroy( &this->condition ); ::pthread_mutex_destroy( &this->mutex ); #endif } @ \section{Performing The Work} To actually perform the work, the derived class must override the [[perform()]] method. <>= virtual void perform( void ) = 0; @ To get things going, the caller should invoke the [[start()]] method. <>= void start( void ); @ <>= void thread::work::start( void ) { this->done = false; thread* mgr = thread::instance(); mgr->start( this ); } @ One can wait for the work to be completed. <>= void wait( void ); @ <>= void thread::work::wait( void ) { #ifdef USE_PTHREADS ::pthread_mutex_lock( &this->mutex ); while ( !this->done ) { ::pthread_cond_wait( &this->condition, &this->mutex ); } ::pthread_mutex_unlock( &this->mutex ); #endif } @ One can declare that the work is finished. This method notifies all parties which are waiting on the condition that the work has been completed. <>= void finish( void ); @ <>= void thread::work::finish( void ) { #ifdef USE_PTHREADS ::pthread_mutex_lock( &this->mutex ); #endif this->done = true; #ifdef USE_PTHREADS ::pthread_cond_broadcast( &this->condition ); ::pthread_mutex_unlock( &this->mutex ); #endif } @ \section{The Class Definition} \label{sec:thread-work-class} This class includes all of the methods declared above. And, it includes some version identification information. <>= class work { protected: <> public: <> public: static const char* id; }; @ ./rt2.7.2007.05.17/nws/thread-worker.nw0100644000077300007650000000713210605627612015236 0ustar patpat@ \chapter{Worker} \label{sec:thread-worker} This section implements the [[worker]] class used by the thread. The class contains a condition variable used to sit and wait for more work. <>= #ifdef USE_PTHREADS pthread_mutex_t mutex; pthread_cond_t condition; pthread_t myThread; #endif @ The class also contains a pointer to the work it is supposed to do. <>= thread::work* todo; bool done; @ \section{Constructor} The constructor initializes the condition variable and the work pointer. It also creates a thread for this worker. <>= worker( void ); @ <>= thread::worker::worker( void ) : todo( 0 ), done( false ) { #ifdef USE_PTHREADS ::pthread_mutex_init( &this->mutex, 0 ); ::pthread_cond_init( &this->condition, 0 ); ::pthread_create( &this->myThread, 0, ThreadWorkerLoopStarter, this ); #endif } @ \section{Destructor} The destructor signals that the thread should end. Then, it waits for the thread to end. Then, it destroys the condition. <>= virtual ~worker( void ); @ <>= thread::worker::~worker( void ) { this->lock(); this->done = true; this->wakeup(); this->unlock(); #ifdef USE_PTHREADS ::pthread_join( this->myThread, 0 ); ::pthread_cond_destroy( &this->condition ); ::pthread_mutex_destroy( &this->mutex ); #endif } @ \section{Assigning Work} The manager uses this method to assign work to this worker. <>= void setWork( thread::work* ww ) { this->todo = ww; }; @ \section{Waking Up} Once the work has been assigned, this worker is awakened. <>= void wakeup( void ); @ <>= void thread::worker::wakeup( void ) { #ifdef USE_PTHREADS ::pthread_cond_signal( &this->condition ); #endif } @ <>= void lock( void ); void wait( void ); void unlock( void ); @ <>= void thread::worker::lock( void ) { #ifdef USE_PTHREADS ::pthread_mutex_lock( &this->mutex ); #endif } @ <>= void thread::worker::wait( void ) { #ifdef USE_PTHREADS ::pthread_cond_wait( &this->condition, &this->mutex ); #endif } <>= void thread::worker::unlock( void ) { #ifdef USE_PTHREADS ::pthread_mutex_unlock( &this->mutex ); #endif } @ \section{Loop For Work} This first part here is a simple trampoline method used to get the thread started. <>= extern "C" void* ThreadWorkerLoopStarter( void* arg ); @ <>= void* ThreadWorkerLoopStarter( void* arg ) { thread::worker* me = (thread::worker*)arg; return me->loop(); } @ <>= void* loop( void ); @ <>= void* thread::worker::loop( void ) { #ifdef USE_PTHREADS thread* mgr = thread::instance(); for (;;) { this->todo = 0; mgr->makeWorkerAvailable( this ); this->lock(); do { if ( this->done ) { this->unlock(); return 0; } this->wait(); } while ( this->todo == 0 ); this->unlock(); this->todo->perform(); this->todo->finish(); } #endif return 0; } @ \section{The Class Definition} \label{sec:thread-worker-class} This class includes all of the methods declared above. And, it includes some version identification information. <>= class worker { protected: <> public: <> public: static const char* id; }; @ ./rt2.7.2007.05.17/nws/universe-inter.nw0100644000077300007650000000677610026722204015442 0ustar patpat@ \chapter{Universe Intersection Work} \label{sec:universe-intersection-work} This is a helper class used by the universe class from \S\ref{sec:universe} to check whether a given ray intersects a given object. This helper class descends directly from the threading system's [[work]] class (define in \S\ref{sec:thread-work}) so that this work could potentially be performed in a subthread. This class will store references to the ray parameters and the object. It will record the intersection of the ray and the object if they intersect and track whether or not they did intersect. <>= const mathvec< double >* position; const mathvec< double >* direction; const object* obj; intersection hit; bool gotHit; @ \section{Constructor} The constructor does nothing in particular. <>= intersectionWork( void ) { }; @ \section{Destructor} The destructor waits for the work to finish if it has not already done. <>= virtual ~intersectionWork( void ) { this->wait(); }; @ \section{Setting Up The Work} This method is used to give the ray and object to this class and to have the class begin work checking whether the ray intersects the object or not. <>= void set( const mathvec< double >& pp, const mathvec< double >& dd, const object* oo ) { this->position = &pp; this->direction = ⅆ this->obj = oo; this->gotHit = false; this->start(); }; @ \section{Performing The Work} To actually perform the work, this method invokes the intersection method on the object. It ignores any hits that are beyond half way to virtual infinity (though I'm not entirely sure it should). <>= virtual void perform( void ) { this->gotHit = this->obj->intersect( *this->direction, *this->position, this->hit ); if ( this->gotHit && this->hit.getDistance() > MAXFLOAT / 2.0 ) { this->gotHit = false; } }; @ \section{Checking The Work} When someone wants to know whether the ray intersected the object, they invoke the following method. The method makes sure the work has been completed and then returns the answer. <>= bool wasHit( void ) { this->wait(); return this->gotHit; }; @ If someone is curious about the distance the hit was along the ray, they invoke the following method. The method makes sure the work has been completed and then returns the answer. <>= double getDistance( void ) { this->wait(); return this->hit.getDistance(); }; @ If someone is curious about the actual intersection instance they invoke the following method. The method makes sure the work has been completed and then returns the answer. <>= const intersection& getIntersection( void ) { this->wait(); return this->hit; }; @ \section{The Class Definition} \label{sec:intersection-work-class} This class includes all of the methods declared above. And, it includes some version identification information. <>= class intersectionWork : public thread::work { protected: <> public: <> public: static const char* id; }; const char* intersectionWork::id = "NKVERSION: intersectionWork( RT_VERSION )"; @ ./rt2.7.2007.05.17/nws/universe-refl.nw0100644000077300007650000000722510026717372015251 0ustar patpat@ \chapter{Universe Reflection Work} \label{sec:universe-reflection-work} This is a helper class used by the universe class from \S\ref{sec:universe} to check the color contribution of the ray reflected from a given intersection point. This helper class descends directly from the threading system's [[work]] class (define in \S\ref{sec:thread-work}) so that this work could potentially be performed in a subthread. This class will store a reference to the ray direction, a reference to the intersection information, the contribution, the number of levels of raytracing still available, and a pointer to the universe. It will record the resulting pixel color and amount of the contribution. <>= const mathvec< double >& reflectedDirection; const intersection& hit; unsigned int height; double contribution; const universe* univ; double amount; mathvec< double > pixel; @ \section{Constructor} The constructor initializes the reflected direction reference, the hit reference, the raytracing height remaining, the contribution of this ray, and the pointer to the universe. Then, it checks the reflectiveness of the object. It then decides whether or not the contribution is worth checking. If it is, then processing is started. Otherwise, the amount is zeroed and the lock on this work is released. <>= reflectionWork( const mathvec< double >& rr, const intersection& hh, double cn, unsigned int hg, const universe* uu ) : reflectedDirection( rr ), hit( hh ), height( hg ), contribution( cn ), univ( uu ) { const color* cc = hit.getColor(); this->amount = cc->getReflectiveness(); if ( this->contribution * this->amount > 0.000001 ) { this->start(); } else { this->amount = 0.0; this->finish(); } }; @ \section{Destructor} The destructor waits for the work to be completed if it has not already finished. <>= virtual ~reflectionWork( void ) { this->wait(); }; @ \section{Performing The Work} To do the work, a starting point for the reflected ray is determined. Then, the new ray is traced in the universe. <>= virtual void perform( void ) { mathvec< double > pos = this->hit.getPosition(); pos += this->reflectedDirection * 0.000001; if ( this->univ->evaluate( pos, this->reflectedDirection, this->contribution, this->height-1, this->pixel ) == false ) { this->amount = 0.0; } }; @ \section{Checking The Work} When someone wants to know how much the reflected ray should contribute, they invoke the following method. The method makes sure the work has been completed and then returns the answer. <>= inline double getAmount( void ) { this->wait(); return this->amount; }; @ When someone wants to know what color the reflected ray should contribute, they invoke the following method. The method makes sure the work has been completed and then returns the answer. <>= const mathvec< double >& getPixel( void ) { this->wait(); return this->pixel; }; @ \section{The Class Definition} \label{sec:reflection-work-class} This class includes all of the methods declared above. And, it includes some version identification information. <>= class reflectionWork : public thread::work { protected: <> public: <> public: static const char* id; }; const char* reflectionWork::id = "NKVERSION: reflectionWork( RT_VERSION )"; @ ./rt2.7.2007.05.17/nws/universe-refr.nw0100644000077300007650000001373410032117525015250 0ustar patpat@ \chapter{Universe Refraction Work} \label{sec:universe-refraction-work} This is a helper class used by the universe class from \S\ref{sec:universe} to check the color contribution of the ray refracted from a given intersection point. This helper class descends directly from the threading system's [[work]] class (define in \S\ref{sec:thread-work}) so that this work could potentially be performed in a subthread. This class will store a reference to the intersection information, the contribution, the number of levels of raytracing still available, the contribution of this ray, the index of refraction outside the object hit, and a pointer to the universe. It will record the resulting pixel color and amount of the contribution. <>= const intersection& hit; unsigned int height; double contribution; double indexOfRefraction; const universe* univ; double amount; mathvec< double > pixel; @ \section{Constructor} The constructor initializes the hit reference. The constructor initializes the hit reference, the raytracing height remaining, the contribution of this ray, the ambient index of refrection, and the pointer to the universe. Then, it checks the transparency of the object. It then decides whether or not the contribution is worth checking. If it is, then processing is started. Otherwise, the amount is zeroed and the lock on this work is released. <>= refractionWork( const intersection& hh, double cn, unsigned int hg, double ior, const universe* uu ) : hit( hh ), height( hg ), contribution( cn ), indexOfRefraction( ior ), univ( uu ) { const color* cc = hit.getColor(); this->amount = cc->getTransparency(); if ( this->contribution * this->amount > 0.000001 ) { this->start(); } else { this->amount = 0.0; this->finish(); } }; @ \section{Destructor} The destructor waits for the work to complete for proceeding. <>= virtual ~refractionWork( void ) { this->wait(); }; @ \section{Performing The Work} Assuming that the index of refraction of the current medium is $i_1$ and that of the next medium is $i_2$, the refracted vector $\vec{r}_2$ is related to the incoming directional vector $\vec{r}_1$ via the normal at the point of contact $\vec{n}$ by the Snell's law: \begin{equation} \frac{i_1}{i_2} = \frac{ \left| \vec{r}_2 - ( \vec{r}_2 \cdot \vec{n} ) \vec{n} \right| }{ \left| \vec{r}_1 - ( \vec{r}_1 \cdot \vec{n} ) \vec{n} \right| } \label{eq:snells-law} \end{equation} The resulting vector $\vec{r}_2$ is in the same plane as $\vec{r}_1$ and $\vec{n}$. Thus, it can be expressed as a linear combination of the two: $$ \vec{r}_2 = \alpha\vec{r}_1 + \beta\vec{n} $$ Substituting that into equation \ref{eq:snells-law} and using the fact that both $\vec{r}_1$ and $\vec{n}$ are unit vectors, one obtains: \begin{eqnarray*} \frac{i_1}{i_2} &=& \frac{ \left| \alpha\vec{r}_1 + \beta\vec{n} - \left( ( \alpha\vec{r}_1 + \beta\vec{n} ) \cdot \vec{n} \right) \vec{n} \right| }{ \left| \vec{r}_1 - ( \vec{r}_1 \cdot \vec{n} ) \vec{n} \right| } \\ &=& \frac{ \left| \alpha \left( \vec{r}_1 - ( \vec{r}_1 \cdot \vec{n} ) \vec{n} \right) \right| }{ \left| \vec{r}_1 - ( \vec{r}_1 \cdot \vec{n} ) \vec{n} \right| } \\ &=& \alpha \end{eqnarray*} The further restriction that $\vec{r_2}$ be a unit vector requires that $$\left( \alpha\vec{r}_1 + \beta\vec{n} \right)^2 = 1$$ $$\alpha^2 + 2\alpha\beta(\vec{r}_1\cdot\vec{n}) + \beta^2 - 1 = 0$$ $$\beta = -\alpha(\vec{r}_1\cdot\vec{n}) + \sqrt{ \alpha^2 \left( (\vec{r}_1\cdot\vec{n})^2 - 1 \right) }$$ @ The normal vector in this method is the negative of the one expected by the equations above. As such, it is inverted before calculations get underway. <>= virtual void perform( void ) { mathvec< double > pos = this->hit.getPosition(); mathvec< double > dir = this->hit.getDirection(); const color* cc = this->hit.getColor(); double hitIOR = cc->getIndexOfRefraction(); double ior1; double ior2; if ( this->hit.isOutside() ) { ior1 = this->indexOfRefraction; ior2 = hitIOR; } else { ior1 = hitIOR; ior2 = 1.0; } if ( ::fabs( ior1 - ior2 ) > 0.000001 ) { mathvec< double > norm = this->hit.getNormal(); norm *= -1.0; double rn = ( dir ^ norm ); if ( rn >= -0.000001 ) { double alpha = ior1 / ior2; double beta = - alpha * rn + ::sqrt( 1.0 + alpha * alpha * ( rn * rn - 1.0 ) ); dir *= alpha; norm *= beta; dir += norm; } else { this->amount = 0.0; } } pos += dir * 0.000001; if ( this->univ->evaluate( pos, dir, ior2, this->contribution, this->height-1, this->pixel ) == false ) { this->amount = 0.0; } }; @ \section{Checking The Work} When someone wants to know how much the refracted ray should contribute, they invoke the following method. The method makes sure the work has been completed and then returns the answer. <>= inline double getAmount( void ) { this->wait(); return this->amount; }; @ When someone wants to know what color the refracted ray should contribute, they invoke the following method. The method makes sure the work has been completed and then returns the answer. <>= const mathvec< double >& getPixel( void ) { this->wait(); return this->pixel; }; @ \section{The Class Definition} \label{sec:refraction-work-class} This class includes all of the methods declared above. And, it includes some version identification information. <>= class refractionWork : public thread::work { protected: <> public: <> public: static const char* id; }; const char* refractionWork::id = "NKVERSION: refractionWork( RT_VERSION )"; @ ./rt2.7.2007.05.17/nws/universe-shad.nw0100644000077300007650000001555510031353016015230 0ustar patpat@ \chapter{Universe Shadow Work} \label{sec:universe-shadow-work} This is a helper class used by the universe class from \S\ref{sec:universe} to determine the color contribution of a light on a particular spot. This helper class descends directly from the threading system's [[work]] class (define in \S\ref{sec:thread-work}) so that this work could potentially be performed in a subthread. This class will store a pointer to the reflected ray's direction, a pointer to the intersection information, a pointer to the light in question, the contribution expected of this pixel, the number of levels of raytracing still available, and a pointer to the universe. It will record the amount of contribution expected from this light, the color of the diffuse contribution from this light, the color of the specular contribution from this light, and the combined diffuse and specular results. <>= const mathvec< double >* reflectedDirection; const intersection* hit; const light* lamp; double contribution; unsigned int height; const universe* univ; mathvec< double > diffusePixel; mathvec< double > specularPixel; double amount; mathvec< double > pixel; @ The combined results are actually not recorded until the value is requested. This is so that if, for example, the reflected ray were not traced because the maximum number of raytracing levels had been exceeded, the proportion that would be contributed by the reflected ray is simply added into the diffuse portion of the pixel. The code in this helper class has no way of telling when such things would occur. As such, it simply waits to be told. \section{Constructor} The constructor does nothing <>= shadowWork( void ) { } @ \section{Destructor} The destructor waits for the work to be completed if it has not already finished. <>= virtual ~shadowWork( void ) { this->wait(); }; @ \section{Preparing The Work} The initialization method here records the parameters needed and kicks off the processing. <>= void set( const mathvec< double >* rr, const intersection* hh, const light* ll, double cn, unsigned int hg, const universe* uu ) { this->reflectedDirection = rr; this->hit = hh; this->lamp = ll; this->contribution = cn; this->height = hg; this->univ = uu; this->start(); }; @ \section{Performing The Work} The actual work of this helper class is in determining whether there is a direct line of sight from the point in question and the light of interest. If the light is on the wrong side of the surface, it cannot contribute. And, if the light is blocked, it cannot contribute. Otherwise, this method goes on to calculate the diffuse contribution from the light and the specular contribution from it. Then, it masks the diffuse reflected light by the object color. <>= virtual void perform( void ) { <> mathvec< double > norm = this->hit->getNormal(); this->amount = norm ^ dir; double distFact = ( lampDist * this->lamp->getFallOff() ); if ( ::fabs( distFact ) > 0.0000001 ) { this->amount /= distFact * distFact; } const color* cc = this->hit->getColor(); if ( this->amount > 0.0 || cc->getTransparency() > 0.000001 ) { this->diffusePixel.resize( cc->getChannelCount(), 0.0 ); <> } if ( this->amount > 0.0 ) { <> <> <> } }; @ This portion determines the starting point and direction from the hit to the light in question. <>= mathvec< double > pos = this->hit->getPosition(); mathvec< double > dir = this->lamp->getPosition(); dir -= pos; double lampDist = dir.magnitude(); dir /= lampDist; pos += dir * 0.000001; @ To check for blockage of light, this method invokes the [[checkShadow]] method on the universe instance. That method is described in detail in \S\ref{sec:universe::checkShadow}. <>= this->univ->checkShadow( pos, dir, lampDist, this->contribution, this->height, this->amount, this->diffusePixel ); @ The diffuse contribution from the light is determined by invoking the [[evaluate]] method on the light. <>= this->lamp->evaluate( pos, norm, dir, this->contribution, this->height, this->diffusePixel ); @ The specular contribution initially starts with the color from the light. It is then rescaled based upon the Phong parameter of the object and the angle that light is from the reflected ray. <>= this->specularPixel = this->diffusePixel; double specularness = cc->getSpecularness(); if ( specularness > 0.000001 ) { double phong = cc->getPhong(); double cosAngle = ( *this->reflectedDirection ^ dir ); double factor = ::pow(cosAngle,phong) * specularness; this->specularPixel *= factor; } else { this->specularPixel *= 0.0; } @ The diffuse contribution is masked by the color of the object since purely red objects do not reflect green or blue light. The specular contribution is unaffected by the object's color. <>= mathvec< double > objPixel; this->hit->evaluate( this->contribution, this->height, objPixel ); this->diffusePixel *= objPixel; @ \section{Checking The Work} When someone wants to know how much this light should contribute, they invoke the following method. The method makes sure the work has been completed and then returns the answer. <>= inline double getAmount( void ) { this->wait(); return this->amount; }; @ When someone wants to know the color of the contribution from this light, they invoke the following method. It waits for the work to be completed. This method then rescales the diffuse contribution, adds in the specular contribution, and returns the result. <>= const mathvec< double >& getPixel( double diffuseAmount ) { this->wait(); this->pixel = this->diffusePixel; this->pixel *= diffuseAmount; this->pixel += this->specularPixel; return this->pixel; }; @ \section{The Class Definition} \label{sec:shadow-work-class} This class includes all of the methods declared above. And, it includes some version identification information. <>= class shadowWork : public thread::work { protected: <> public: <> public: static const char* id; }; const char* shadowWork::id = "NKVERSION: shadowWork( RT_VERSION )"; @ ./rt2.7.2007.05.17/nws/universe.nw0100644000077300007650000004322210177077440014322 0ustar patpat@ \chapter{Universe} \label{sec:universe} A universe instance has a certain number of spatial dimensions. It contains an optional sky color, an optional color of the ambient light, zero or more point light sources, and zero or more objects. <>= universe_parameters ::= universe_parameters universe_param | /* empty */ ; universe_param ::= universe_dimensions | universe_sky | universe_ambient | quickRender ';' | 'light' '{' light_params '}' ';' | 'object' object_type_and_params ';' ; universe_dimensions ::= 'dimensions' integer ';' | 'dims' integer ';' ; universe_sky ::= 'skyColor' '{' color_params '}' ';' | 'sky' '{' color_params '}' ';' ; universe_ambient ::= 'ambientLight' '{' color_params '}' ';' | 'ambient' '{' color_params '}' ';' ; @ Lights are described in \S\ref{sec:light}. Objects are described in \S\ref{sec:object}. Color parameters are described in \S\ref{sec:color}. @ The universe instance holds a pointer to the scene to which it belongs. Colors within the scene can contain portals into other universes in the scene. The scene instance is used to match up those portals to the universes they reference. <>= const scene* myScene; @ The universe class specifies its number of spatial dimensions. It also contains point light sources and objects. Additionally, it defines ambient light, a sky color, and a quick rendering flag. <>= unsigned int dimensions; std::vector< light* > lights; std::vector< object* > objects; color ambientLight; bool gotAmbient; color skyColor; bool quickRender; @ \section{Constructor} The default constructor does very little. Mostly, it passes the scene pointer on to its constituent colors. The only other thing it does is record that it has not received a color for the ambient light in the universe. <>= universe( const scene* ss ); @ <>= universe::universe( const scene* ss ) : myScene( ss ), ambientLight( ss ), gotAmbient( false ), skyColor( ss ), quickRender( false ) { } @ \section{Destructor} The destructor cleans out the lights and objects arrays. <>= ~universe( void ); @ <>= universe::~universe( void ) { for ( unsigned int ii=0; ii < this->objects.size(); ++ii ) { delete objects[ ii ]; } for ( unsigned int ii=0; ii < this->lights.size(); ++ii ) { delete lights[ ii ]; } } @ \section{Getting And Setting The Number Of Dimensions} The following method allows the portals to query the number of spatial dimensions for this universe so that the portal can upgrade (or downgrade) its vectors to the proper number of dimensions for this universe. <>= inline unsigned int getDimensions( void ) const { return this->dimensions; }; @ When the number of spatial dimensions for the universe are set, this information is passed along to all of the constituent lights and objects so that they can resize their position vectors, scaling vectors, and orientation matrices accordingly. <>= void setDimensions( unsigned int dims ); @ <>= void universe::setDimensions( unsigned int dims ) { this->dimensions = dims; for ( unsigned int ii=0; ii < this->lights.size(); ++ii ) { this->lights[ ii ]->setDimensions( this->dimensions ); } for ( unsigned int ii=0; ii < this->objects.size(); ++ii ) { this->objects[ ii ]->setDimensions( this->dimensions ); } this->ambientLight.setDimensions( dims ); this->skyColor.setDimensions( dims ); } @ \section{Casting A Ray Into The Universe} The following method allows one to cast a ray into a universe. <>= bool evaluate( const mathvec< double >& position, const mathvec< double >& direction, double contribution, unsigned int height, mathvec< double >& pixel ) const; @ This method assumes that the index of refraction of the air in the universe is 1.0. Then, it turns around and invokes the method which follows to actually trace the ray. <>= bool universe::evaluate( const mathvec< double >& position, const mathvec< double >& direction, double contribution, unsigned int height, mathvec< double >& pixel ) const { return this->evaluate( position, direction, 1.0, contribution, height, pixel ); } @ If one prefers to specify the ambient index of refraction in the universe, one can do so using this method instead. In particular, refracted rays that are interior to an object will specify the index of refraction of the object as opposed to that of air. <>= bool evaluate( const mathvec< double >& position, const mathvec< double >& direction, double indexOfRefraction, double contribution, unsigned int height, mathvec< double >& pixel ) const; @ If the [[height]] parameter is zero, then this ray has already undergone as many reflections, refractions, or portal pass-throughs as allowed by the view. If the contribution left for this pixel to provide is tiny, this pixel is abandoned. Otherwise, the universe attempts to find the closest point of intersection of this ray with an object in the universe. After that, it determines the color of that spot on that object based upon the lighting in the universe and the color of the object. <>= bool universe::evaluate( const mathvec< double >& position, const mathvec< double >& direction, double indexOfRefraction, double contribution, unsigned int height, mathvec< double >& pixel ) const { if ( height == 0 || contribution < 0.000001 ) { return false; } else { <> if ( this->quickRender ) { <> } else { <> } return true; } } @ To find the closest intersection of the ray with an object in the universe, this method employs a helper class. It instantiates one instance of this helper class for every object. Each instance of the helper class is responsible for intersecting the ray with the given object. Then, this code loops through and checks to see which intersection was the closest to the origin of the ray. The helper class for intersections is defined in \S\ref{sec:universe-intersection-work}. <>= pixel *= 0.0; <> intersectionWork* closest = 0; double closestDistance = MAXFLOAT; for ( unsigned int ii=0; ii < this->objects.size(); ++ii ) { if ( intersections[ ii ].wasHit() && intersections[ ii ].getDistance() < closestDistance ) { closest = &intersections[ ii ]; closestDistance = closest->getDistance(); } } @ If there were no intersections, then the pixel is filled in from the sky color and returned. <>= if ( closest == 0 ) { mathvec< double > normal = direction * -1.0; this->skyColor.evaluate( position, normal, direction, contribution, height, pixel ); pixel *= contribution; return true; } @ Otherwise, the point of intersection is copied and the helper class instances are released. <>= intersection hit = closest->getIntersection(); intersections.resize(0); @ To prepare the helper classes which intersect the ray with the objects, this method simply creates an array of the intersections big enough for one for each object. Then, each helper instance is intialized with the vector and the object for which that helper instance is responsible. <>= std::vector< intersectionWork > intersections( this->objects.size() ); for ( unsigned int ii=0; ii < this->objects.size(); ++ii ) { intersections[ ii ].set( position, direction, this->objects[ ii ] ); } @ To fudge the color for quick rendering, we simply evaluate the color of the object as if there were 100% ambient white light and then scale this color by the dot-product of the normal with the direction. <>= mathvec< double > ndir = hit.getNormal(); double dot = -( ndir ^ direction ); dot = 1.0 - 0.75 * ( 1.0 - dot ); if ( dot < 0.25 ) { dot = 0.25; } hit.evaluate( contribution, height, pixel ); pixel *= dot; @ Once a hit is recorded, then the reflected ray is calculated. This reflected ray is passed to a helper class which evaluates the color contribution from the reflected ray. At the same time, another helper class is instantiated to evaluate the direciton and color of the refracted ray. The helper class for reflected rays is defined in \S\ref{sec:universe-reflection-work}. The helper class for refracted rays is defined in \S\ref{sec:universe-refraction-work}. <>= mathvec< double > ndir = hit.getNormal(); mathvec< double > rdir = hit.getDirection(); // reflected ray ndir *= -2.0 * ( rdir ^ ndir ); rdir += ndir; reflectionWork reflected( rdir, hit, contribution, height, this ); refractionWork refracted( hit, contribution, height, indexOfRefraction, this ); @ In addition, there is a helper class instance for each light in the universe which is used to determine the color contribution of a given light source on the point of intersection. Each of these instances is given a reference to the reflected ray, the intersection, its light, and other parameters needed to check the contribution of the light source. This helper class will call back to this universe to see if the path from the light to the current intersection spot is blocked by another object. The helper class for lighting contribution is defined in \S\ref{sec:universe-shadow-work}. <>= std::vector< shadowWork > shadows( this->lights.size() ); for ( unsigned int ii=0; ii < shadows.size(); ++ii ) { shadows[ ii ].set( &rdir, &hit, this->lights[ ii ], contribution, height, this ); } @ The incoming pixel is resized to the appropriate number of color channels. Then, the ambient light's contribution is calculated. <>= if ( pixel.size() < hit.getColor()->getChannelCount() ) { pixel.resize( hit.getColor()->getChannelCount() ); } if ( this->gotAmbient ) { mathvec< double > normal = direction * -1.0; hit.evaluate( contribution, height, pixel ); mathvec< double > ambientPixel; this->ambientLight.evaluate( position, normal, direction, contribution, height, ambientPixel ); pixel *= ambientPixel; } else { pixel *= 0.0; } @ After this, contribution of the reflected ray and the refracted ray are added in. Then, the contribution from each point light source in the universe is figured in. This whole amount then is scaled down based upon the contribution this ray was supposed to have. <>= double reflectedAmount = reflected.getAmount(); if ( reflectedAmount > 0.000001 ) { pixel += reflectedAmount * reflected.getPixel(); } double refractedAmount = refracted.getAmount(); if ( refractedAmount > 0.000001 ) { pixel += refractedAmount * refracted.getPixel(); } for ( unsigned int ii=0; ii < shadows.size(); ++ii ) { double amount = shadows[ ii ].getAmount(); if ( amount > 0.000001 ) { double diffuseness = 1.0 - reflectedAmount - refractedAmount; pixel += amount * shadows[ ii ].getPixel( diffuseness ); } } pixel *= contribution; @ \section{Checking For Shadows} \label{sec:universe::checkShadow} There were helper class instances used above whose purpose was to evaluate the contribution of a particular light toward the color of an intersection point. That helper class calculates the vector from the point of intersection toward the light. This method is used to be sure that that vector does not intersect any opaque objects in the universe before it gets to the light. <>= void checkShadow( const mathvec< double >& position, const mathvec< double >& direction, double lampDistance, double contribution, unsigned int height, double& amount, mathvec< double >& pixel ) const; @ This method takes advantage of the same code as the [[evaluate()]] method of the preceding section to instantiate helper instances to check for intersections with objects. Then, it evaluates the color contribution of this light. At the time this method is invoked, the pixel has already been initialized with the color of the light. <>= void universe::checkShadow( const mathvec< double >& position, const mathvec< double >& direction, double lampDistance, double contribution, unsigned int height, double& amount, mathvec< double >& pixel ) const { <> <> } @ For every transparent object that was hit on the way to the lamp, the pixel color is filtered by the color and transparency of the object. If an opaque object is encountered, then this method clears the contribution amount for this lamp and bails out. <>= for ( unsigned int ii=0; ii < this->objects.size(); ++ii ) { if ( intersections[ ii ].wasHit() && intersections[ ii ].getDistance() < lampDistance ) { const color* cc = intersections[ ii ].getIntersection().getColor(); double tt = cc->getTransparency(); if ( tt < 0.000001 ) { amount = 0.0; break; } else { mathvec< double > objPixel; if ( tt < 0.999999 ) { intersections[ ii ].getIntersection().evaluate( contribution * tt, height, objPixel ); objPixel *= ( 1.0 - tt ); objPixel *= pixel; pixel *= tt; pixel += objPixel; } else { pixel *= tt; } amount *= tt; } } } @ \section{Loading A Universe} The following method allows one to read in a universe from a stream. <>= friend std::istream& operator >> ( std::istream& in, universe& cc ); @ There are a variety of keywords recognized in the universe. One can specify the number of spatial dimensions in the universe with the [[dimensions]] or [[dims]] value. One specifies the ambient light by specifying an instance of the color class (defined in \S\ref{sec:color}) using the [[ambientLight]] or [[ambient]] tag. One specifies the sky color by specifying an instance of the color class using the [[skyColor]] or [[sky]] tag. One specifies a light by specifying an instance of the light class (defined in \S\ref{sec:light}) using the [[light]] tag. One specifies an object by specifying an instance of the object class (defined in \S\ref{sec:object}). If the [[quickRender]] flag is present, then there will be no reflected ray, refracted ray, or shadow checking at all. <>= std::istream& operator >> ( std::istream& stream, universe& uu ) { input in( stream ); unsigned int dims = 2; uu.gotAmbient = false; while ( in.check() ) { char token[ input::MAX_TOKEN_LEN ]; if ( in.get( token, sizeof(token) ) == 0 ) { return stream; } std::string tok( token ); char semicolon; if ( tok == "dimensions" || tok == "dims" ) { stream >> dims >> semicolon; } else if ( tok == "ambientLight" || tok == "ambient" ) { stream >> uu.ambientLight >> semicolon; uu.gotAmbient = true; } else if ( tok == "skyColor" || tok == "sky" ) { stream >> uu.skyColor >> semicolon; } else if ( tok == "quickRender" ) { stream >> semicolon; uu.quickRender = true; } else if ( tok == "light" ) { light* nn = new light( uu.myScene ); stream >> *nn >> semicolon; uu.lights.insert( uu.lights.end(), nn ); } else if ( tok == "object" ) { object* nn = object::read( stream, uu.myScene ); if ( nn != 0 ) { uu.objects.insert( uu.objects.end(), nn ); } } else { in.ignore( "UNIVERSE", tok.c_str() ); } } uu.setDimensions( dims ); return stream; } @ \section{The Class Definition} \label{sec:universe-class} This class includes all of the methods declared above. And, it includes some version identification information. <>= class universe { protected: <> public: <> public: static const char* id; }; @ \section{Source Files} The following sections assemble the source files for the [[universe]] class from the chunks above. \subsection{[[universe.h]]} The header file for the universe class includes the [[iostream]], [[string]], and [[map]] headers from the standard C++ libraries and the header files for the [[light]] and [[object]] classes and then incorporates the class defined in \S\ref{sec:universe-class} above. All of this is wrapped in syntactic sugar to avoid problems should this file be included more than once. <>= #ifndef _NKLEIN_UNIVERSE_H_ #define _NKLEIN_UNIVERSE_H_ 1 #include #include #include #include "light.h" #include "object.h" <> #endif /*_NKLEIN_UNIVERSE_H_*/ @ \subsection{[[universe.cc]]} Herein, the implementations of the methods of the [[universe]] class are included as well as the the declarations and implementations of the helper classes. The implementation requires the definition of [[MAXFLOAT]] which it may get from the math header or from the [[values.h]] header, the header for the input subsystem, the header for the threading subsystem, and the declaration of the universe class itself. The implementation file also includes the definitions and implementations of all of the helper classes it requires. <>= #include #ifndef MAXFLOAT #include #endif #include "input.h" #include "nkthread.h" #include "universe.h" const char* universe::id = "NKVERSION: universe( RT_VERSION )"; <> <> <> <> <> @ ./rt2.7.2007.05.17/nws/view.nw0100644000077300007650000006136410600166004013425 0ustar patpat@ \chapter{View} \label{sec:view} Most views will contain a viewport. That view is an instance of the color class defined in \S\ref{sec:color}. For that color to actually represent a view into a universe, the color must contain a portal. The view contains a great deal of information about the shape and resolution of the view. It contains an instance of the color class at which it will cast rays. It also contains zero or more output image specifications. <>= view_parameters ::= view_parameters view_param | /* empty */ ; view_param ::= view_units | view_dpu | view_depth | view_fisheye | view_wrap | 'gamma' real ';' | 'border' integer ';' | 'composite' integer ';' | 'vertical' ';' | view_trace_depth | view_viewport | 'image' image_type_and_parameters ';' ; @ The [[gamma]] specifies a gamma value to be applied to each output color sample. If the [[gamma]] is not specified, it defaults to one. The [[border]] is the number of pixels of border the raytracer will put around each frame of the output images. The [[border]] defaults to one. The [[composite]] parameter specifies the number of dimensions the raytracer should composite into the output image. The default for [[composite]] is to cover all dimensions of the output image. If there are more output dimensions to the image than are specified as the [[composite]], then the raytracer will generate a sequence of images as it scans through the excess dimensions. The [[vertical]] flag is used to indicate that composite frames should stack vertically before they stack horizontally. For a four-dimensional scene, the output will be a three-dimensional image cube. But, as all of the supported image formats are two-dimensional, one has the choice of either outputing a sequence of two-dimensional frames as separate images by specifying a [[composite]] value of two or as a sequence of two-dimensional frames concatenated together into one larger image by specifying a [[composite]] value of three. If the [[composite]] value exceeds the number of dimensions or is zero, it will be set to that number of dimensions of the output image. @ The following parameters are used to specify the shape and resolution of the view. <>= view_units ::= 'units' real_vector ';' | 'unitsPerDimension' real_vector ';' ; view_dpu ::= 'dotsPerUnit' real_vector ';' | 'dpu' real_vector ';' | 'dpi' real_vector ';' ; view_depth ::= 'viewDepth' real ';' | 'depth' real ';' ; view_fisheye ::= 'fishEye' real_vector ';' ; view_wrap ::= 'wrapAround' ';' | 'wrap' ';' ; @ The view is a certain number of units in each dimensions. Those units are specified with either the [[units]] or [[unitsPerDimension]] keywords. There is no default for this parameter. The viewer of the resulting image is to be sitting a number of those units away from the image. That distance between the viewer and the resulting image is given as [[viewDepth]] or [[depth]]. The default [[viewDepth]] is twelve units. The resulting output image will have a number of dots per unit of measure specified with [[dotsPerUnit]], [[dpu]], or [[dpi]]. The [[dotsPerUnit]] parameter has no default and must be a vector of the same length as the [[units]] vector. The view may be fish-eyed in any of its dimensions. The amount of fish-eye effect is given per dimension in the vector [[fishEye]]. If one wants the fish-eye effect to wrap around beyond $180^\circ$, then one must specify wrapping with either the [[wrapAround]] or [[wrap]] keywords. For example, if one were viewing a three-dimensional scene with no fish-eye effect and the desired output image will be five inches wide and three inches high at 300 dots per inch with the viewer expected to be eighteen inches from the page, one would specify: <>= units [2]< 5, 3 >; dpu [2]< 300, 300 >; viewDepth 18; @ If one wanted specify that this image would be very fish-eyed in the horizontal direction, but not at all fish-eyed in the vertical direction, and that the fish-eye effect be allowed to exceed $180^\circ$, one would add: <>= fishEye [2]< 15, 0 >; wrap; @ The fish-eye factor determines how much the view-angle in that direction is scaled. For example, if the output image were to be ten inches in a given direction for a viewer at a depth of five inches, the viewing angle for that direction would be $90^\circ$. If one specified a fish-eye factor of $\alpha$ for that direction, this $90^\circ$ viewing angle would be stretched up to a $\left( 90 \cdot ( 1 + \alpha ) \right)^\circ$ viewing angle. Negative fish-eye factors are acceptable, though letting the fish-eye factor $\alpha$ dip below negative one ends up simply being a mirror-imaged version of the case with a fish-eye factor of $(-1 - \alpha)$. @ If one is tracing a scene with a large number of highly reflective surfaces, one can get into large amounts of work with very little return for the effort. As such, one can limit the number of times any particular ray will be reflected. <>= view_trace_depth ::= 'traceDepth' integer ';' | 'maxDepth' integer ';' ; @ The default [[traceDepth]] is twelve reflections. The viewport for the view is simply an instance of the color class (which likely contains at least one portal). <>= view_viewport ::= 'viewport' '{' color_parameters '}' ';' | 'color' '{' color_parameters '}' ';' ; @ The color class is defined in \S\ref{sec:color} and the portal class in \S\ref{sec:portal}. There are currently three image types supported: [[png]], [[ppm]], and [[accum]]. <>= image_type_and_parameters ::= 'png' '{' png_image_parameters '}' | 'ppm' '{' ppm_image_parameters '}' | 'accum' '{' accum_image_parameters '}' ; @ The [[png]] image type is described in \S\ref{sec:image-png}. The [[ppm]] image type is described in \S\ref{sec:image-ppm}. The [[accum]] image type is described in \S\ref{sec:image-accum}. @ The view class contains a pointer to the scene to which it belongs. <>= const scene* myScene; @ The view class contains a viewport. The viewport is an instance of the [[color]] class defined in \ref{sec:color}. To be useful in actually raytracing, the viewport's color should make use of a portal. <>= color viewport; @ The view class represents the way the scene will be output. It defines the extents of the view area in pixels, the angular extents of the view, whether that angle can wrap around beyond $180^\circ$, a desired gamma correction, and the number of pixels to put on the border of each subimage in the composite image. <>= mathvec< unsigned int > size; mathvec< double > angularExtents; bool wrap; double gamma; unsigned int border; @ The view also tracks how many of the dimensions are supposed to be composited into each output image. <>= unsigned int composite; @ The view also tracks the maximum raytracing depth allowed. <>= unsigned int traceDepth; @ Internally, the view class needs to permute the current pixel's coordinates so that it can output the image in the proper scan order. <>= mathvec permutation; std::vector contributesToWidth; std::vector needsBorders; bool vertical; @ The view class also maintains a list of output images to write to. <>= std::vector< image* > images; @ \section{Constructor} The view constructors sets up some simple defaults. <>= wrap( false ), gamma( 1.0 ), border( 1 ), composite( 0 ), traceDepth( 12 ) @ The default constructor does nothing more than prepare the defaults. <>= view( const scene* ss ); @ <>= view::view( const scene* ss ) : myScene( ss ), viewport( ss ), <> { } @ \section{Destructor} The view destructor loops through and releases each of the output images. <>= ~view( void ); @ <>= view::~view( void ) { for ( unsigned int ii=0; ii < this->images.size(); ++ii ) { delete this->images[ ii ]; } } @ \section{Rendering The View} The following method is used to render the view. <>= void render( void ) const; @ This method prepares a vector to be a counter of which pixel is currently being rendered. Then, this method determines the width and height of each image in the sequence and the number of images in the sequence. After that, this method loops through every pixel of every output image, calculates the direction to cast the ray for that pixel evaluates the pixel, and writes it to each image instance held by the view. <>= void view::render( void ) const { <> <> <> <> mathvec< double > position( 0.0, this->size.size() + 1 ); mathvec< double > direction( this->size.size() + 1 ); mathvec< double > normal; mathvec< double > pixel; for ( unsigned int kk=0; kk < depth; ++kk ) { for ( unsigned int jj=0; jj < height; ++jj ) { for ( unsigned int ii=0; ii < width; ++ii ) { if ( this->calculateDirection( coordinates, direction ) ) { <> <> <> } else { <> } this->incrementDirection( coordinates ); } } } } @ The render method needs to keep track of the current pixel coordinates so that it will know which direction to cast a ray and when to put in border pixels. <>= mathvec< unsigned int > coordinates( 0U, this->size.size() ); @ To determine the width and height, this method starts by assuming the width and height are both one. Then, it loops through the [[size]] vector. If the dimension contributes to the width, then the width is multiplied by that dimension. If the dimension contributes to the height, then the height is multiplied by that dimension. <>= unsigned int width = 1; unsigned int height = 1; unsigned int wdirs = 0; unsigned int hdirs = 0; for ( unsigned int ii=0; ii < this->composite; ++ii ) { bool bb = this->contributesToWidth[ ii ]; if ( bb ) { width = width * this->size[ ii ]; ++wdirs; } else { height = height * this->size[ ii ]; ++hdirs; } } if ( wdirs < 1 ) { width += 2 * this->border; } if ( hdirs < 1 ) { height += 2 * this->border; } @ The number of output images in the sequence is the product of all of the sizes not used within each composite image. <>= unsigned int depth=1; for ( unsigned int ii=this->composite; ii < this->size.size(); ++ii ) { depth *= this->size[ ii ]; } @ Once the width, height, and number of the output images is determined, the [[setSize()]] method is called on each image instance contained within this view. <>= for ( unsigned int ii=0; ii < this->images.size(); ++ii ) { this->images[ ii ]->setSize( width, height, depth, this->viewport.getChannelCount() ); } @ In case the viewport depends on the normal, then the method manufactures one from the direction. <>= normal = direction * -1.0; @ To evaluate the pixel, this method first evaluates the color of the viewport and then performs gamma correction on it. <>= this->viewport.evaluate( position, normal, direction, 1.0, this->traceDepth, pixel ); unsigned int len = pixel.size(); for ( unsigned int ii=0; ii < len; ++ii ) { double val = pixel[ ii ]; if ( val > 0.0 ) { pixel[ ii ] = ::pow( val, this->gamma ); } } @ To write out the pixel, this method loops through all of the contained image instances and passes the pixel along. <>= for ( unsigned int ll=0; ll < this->images.size(); ++ll ) { this->images[ ll ]->add( pixel ); } @ To write out a border pixel, this method loops through all of the contained image instances and passes the pixel along. <>= for ( unsigned int ll=0; ll < this->images.size(); ++ll ) { this->images[ ll ]->addBorderPixel(); } @ \section{Calculating The Viewing Direction From The Pixel Coordinates} At each step of its rendering loop, the view has to turn the pixel coordinates into a direction to cast a ray. This method handles that process. It returns false if the pixel should be a border pixel or if wrapping is not turned on and the cast ray would be more than $180^\circ$ off of directly forward. <>= bool calculateDirection( const mathvec< unsigned int >& coordinates, mathvec< double >& direction ) const; @ This method creates a direction vector based upon the current pixel's coordinates. If the current pixel's coordinate on a given axis is the first pixel of eleven along that axis, the pixel will be at the beginning of the angular extents for that dimension. If the current pixel's coordinate on a given axis is the sixth of eleven along that axis, the pixel will be at the center of the angular extents for that dimension. All of these angles are the measured away from the x-axis and toward the given axis. <>= bool view::calculateDirection( const mathvec< unsigned int >& coordinates, mathvec< double >& direction ) const { unsigned int dims = coordinates.size(); direction[ 0 ] = 0.0; <> <> } @ The following code starts building a direction vector. At each coordinate, the proportion that this pixel number is of the total extent of pixels along this axis is calculated and recorded in the direction vector. If this pixel falls within the border, however, this method returns false immediately so that the calling code can emit a border pixel. <>= for ( unsigned int ii=0; ii < dims; ++ii ) { unsigned int index = this->permutation[ ii ] + 1; unsigned int bb = 0; if ( this->needsBorders[ ii ] ) { bb = this->border; } double is = (double)( this->size[ ii ] - 2*bb ); double ss = is / 2.0 - 0.5; if ( ss < 0.000001 ) { direction[ index ] = 0.0; } else { unsigned int cc = coordinates[ ii ]; double tt = (double)( cc - bb ) - ss; if ( cc < bb || cc + bb >= this->size[ ii ] ) { return false; } direction[ index ] = this->angularExtents[ ii ] * tt / ss; } } @ The whole direction vector at this point represents the angular displacements along each axis. In order to ``normalize'' this, the following code takes this whole vector to represent a single angular displacement in the direction given. Then, the vector is scaled so that the direction is multiplied by the sine of the angle while the forward coordinate becomes the cosine. If wrapping is not turned on and this represents an angle greater than $\pi$ radians, this method returns false just as it would if this were a border pixel. <>= double mag = direction.magnitude(); if ( this->wrap == false && mag > M_PI ) { return false; } else { if ( mag < 0.000001 ) { direction *= 0.0; direction[ 0 ] = 1.0; } else { direction *= -::sin( mag ) / mag; direction[ 0 ] = ::cos( mag ); } return true; } @ \section{Incrementing The Pixel Coordinates} This method increments the coordinates of the pixel. It does this, making sure that the coordinates ``roll over'' at appropriate points. This method considers the coordinate vector in order. It is shuffled by the permutation when it is referred to, rather than here. <>= void incrementDirection( mathvec< unsigned int >& coordinates ) const; @ The loop increments the first element of the coordinates. If that element overflows, it is reset to zero and the loop continues on. If the element does not overflow, then the loop exits immediately. In this way, the early entries in the vector always scan faster than the later entries. <>= void view::incrementDirection( mathvec< unsigned int >& coordinates ) const { unsigned int dims = coordinates.size(); for ( unsigned int ii=0; ii < dims; ++ii ) { if ( ++coordinates[ ii ] < this->size[ ii ] ) { break; } else { coordinates[ ii ] = 0; } } } @ \section{Loading A View} The following method allows one to read in a view from a stream. <>= friend std::istream& operator >> ( std::istream& in, view& cc ); @ There are a variety of keywords recognized in the view. One can specify the size in universe units of each scan direction with the [[unitsPerDimension]] or [[units]] vector. One can specify the number of pixels to devote to each unit with the [[dotsPerUnit]], [[dpu]], or [[dpi]] vector. One can specify the observer's depth from the image in universe units with the [[viewDepth]] or [[depth]] value. One can specify the amount of fish-eye effect to put in each axis using the [[fishEye]] vector. One can specify that wrapping should take place with the [[wrapAround]] or [[wrap]] keyword. One can specify an amount of gamma correction to be performed on the image pixels with the [[gamma]] value. One can specify the number of units of border to put around frames of a composite image using the [[border]] value. One can specify the number of dimensions to composite together with the [[composite]] value. One can specify the maximum number of reflections and refractions one should do in tracing a ray using the [[traceDepth]] or [[maxDepth]] value. One specifies the view into the world by specifying an instance of the color class (defined in \S\ref{sec:color}) using the [[viewport]] or [[color]] tag. And, one can specify any number of output images by specifying an instantiation of the image class (defined in \S\ref{sec:image}) using the [[image]] tag. <>= std::istream& operator >> ( std::istream& stream, view& vv ) { mathvec< double > units; mathvec< double > dpu; mathvec< double > fishEye; double viewDepth = 12.0; vv.vertical = false; input in( stream ); while ( in.check() ) { char token[ input::MAX_TOKEN_LEN ]; if ( in.get( token, sizeof(token) ) == 0 ) { return stream; } std::string tok( token ); char semicolon; if ( tok == "unitsPerDimension" || tok == "units" ) { stream >> units >> semicolon; } else if ( tok == "dotsPerUnit" || tok == "dpu" || tok == "dpi" ) { stream >> dpu >> semicolon; } else if ( tok == "viewDepth" || tok == "depth" ) { stream >> viewDepth >> semicolon; } else if ( tok == "fishEye" ) { stream >> fishEye >> semicolon; } else if ( tok == "wrapAround" || tok == "wrap" ) { vv.wrap = true; stream >> semicolon; } else if ( tok == "gamma" ) { stream >> vv.gamma >> semicolon; } else if ( tok == "border" ) { stream >> vv.border >> semicolon; } else if ( tok == "composite" ) { stream >> vv.composite >> semicolon; } else if ( tok == "vertical" ) { vv.vertical = true; stream >> semicolon; } else if ( tok == "traceDepth" || tok == "maxDepth" ) { stream >> vv.traceDepth >> semicolon; } else if ( tok == "viewport" || tok == "color" ) { stream >> vv.viewport >> semicolon; } else if ( tok == "image" ) { image* nn = image::read( stream ); vv.images.insert( vv.images.end(), nn ); stream >> semicolon; } else { in.ignore( "VIEW", tok.c_str() ); } } <> <> <> vv.viewport.setDimensions( dims+1 ); return stream; } @ The following code verifies that the units per dimension array and the dots per unit array both have the same length. Then, it goes on to clip the number of composite dimensions to the appropriate range and expand the [[fishEye]] vector to the appropriate size. <>= unsigned int dims = units.size(); if ( dims == 0 ) { std::cerr << "View: length dimensions are zero" << std::endl; return stream; } dpu.resize( dims, 1.0 ); if ( vv.composite == 0 || vv.composite > dims ) { vv.composite = dims; } unsigned int ii; fishEye.resize( dims, 0.0 ); @ For the composite dimensions, the odd dimensions will contribute to the width and the even dimensions will contribute to the height. Except that things get a little wonkier when the [[vertical]] flag is set. In particular, we're going to swap the last odd and even dimensions. The code involved will need to ensure that the width dimensions are the fastest scanning. To that end, the [[permutation]] array is prepared to re-order the pixel coordinates. <>= vv.permutation.resize( dims ); vv.contributesToWidth.resize( vv.composite ); vv.needsBorders.resize( dims, false ); unsigned int evenDims = vv.composite / 2; unsigned int oddDims = vv.composite - evenDims; for (ii = 0; ii < oddDims; ++ii) { vv.permutation[ii] = ii * 2; vv.contributesToWidth[ ii ] = true; } for (ii = oddDims; ii < vv.composite; ++ii) { vv.permutation[ii] = ( ii - oddDims ) * 2 + 1; vv.contributesToWidth[ ii ] = false; } for (ii = vv.composite; ii < dims; ++ii) { vv.permutation[ii] = ii; } if ( vv.vertical && oddDims > 0 && evenDims > 0 ) { <> } unsigned int wdims = 0; unsigned int hdims = 0; for ( ii = 0; ii < vv.composite; ++ii ) { if ( vv.contributesToWidth[ ii ] ) { ++wdims; } else { ++hdims; } } for ( ii = 0; ii < vv.composite; ++ii ) { if ( vv.contributesToWidth[ ii ] ) { vv.needsBorders[ ii ] = ( --wdims > 0 ); } else { vv.needsBorders[ ii ] = ( --hdims > 0 ); } } for ( ii = vv.composite; ii < dims; ++ii ) { vv.needsBorders[ ii ] = false; } @ First, if there are an odd number of composite dimensions, slide the last odd dimensions to the end of the evens. Then, swap the matching odd and evens. <>= if ( ( vv.composite & 1 ) == 1 ) { unsigned int tt = vv.permutation[ oddDims - 1 ]; for ( ii=oddDims; ii < vv.composite; ++ii ) { vv.permutation[ ii - 1 ] = vv.permutation[ ii ]; } vv.permutation[ vv.composite-1 ] = tt; vv.contributesToWidth[ oddDims - 1 ] = false; --oddDims; ++evenDims; } for ( ii=1; ii < oddDims; ++ii ) { unsigned int tt = vv.permutation[ ii ]; vv.permutation[ ii ] = vv.permutation[ ii + oddDims ]; vv.permutation[ ii + oddDims ] = tt; } @ Actually, we could just save [[oddDims]] rather than [[contributesToWidth]], but the code feels much more readable this way. The first [[oddDims]] members of [[contributesToWidth]] should be [[true]] whilst the remaining are [[false]]. From the [[units]] and [[dpu]], the following code determines the size of the output image. At the same time, it uses the viewing depth and the [[fishEye]] array to compute the angular viewing extents in each dimension. <>= vv.size.resize( dims ); vv.angularExtents.resize( dims ); for (ii = 0; ii < dims; ++ii) { unsigned int permuted = vv.permutation[ii]; double un = units[permuted]; double len = dpu[permuted] * un; double baseAngle; vv.size[ ii ] = (unsigned int)(::fabs( len ) + 0.5); if ( permuted+1 != vv.composite && permuted+2 != vv.composite ) { vv.size[ ii ] += 2 * vv.border; } baseAngle = atan2( un, 2.0 * viewDepth ); vv.angularExtents[ ii ] = baseAngle * ( 1.0 + fishEye[permuted]); } @ \section{The Class Definition} \label{sec:view-class} This class includes all of the methods declared above. And, it includes some version identification information. <>= class view { protected: <> public: <> public: static const char* id; }; @ \section{Source Files} The following sections assemble the source files for the view class from the chunks above. \subsection{[[view.h]]} The header file for the view class includes the [[iostream]], [[string]], and [[map]] headers from the standard C++ libraries and the header files for the [[color]] and [[image]] classes and then incorporates the class defined in \S\ref{sec:view-class} above. All of this is wrapped in syntactic sugar to avoid problems should this file be included more than once. <>= #ifndef _NKLEIN_VIEW_H_ #define _NKLEIN_VIEW_H_ 1 #include #include #include #include "color.h" #include "image.h" <> #endif /*_NKLEIN_VIEW_H_*/ @ \subsection{[[view.cc]]} Herein, the implementations of the methods of the view class are included. The implementation requires the math-library header for the definition of sines and cosines, the header for the input subsystem, and the declaration of the view class itself. <>= #include #include "input.h" #include "view.h" const char* view::id = "NKVERSION: view( RT_VERSION )"; <> @ ./rt2.7.2007.05.17/Scene/0040755000077300007650000000000010602310325012323 5ustar patpat./rt2.7.2007.05.17/Scene/compl.rt0100644000077300007650000000647710600166654014033 0ustar patpatview { units [2]< 2.56, 1.28 >; dotsPerUnit [2]< 300, 300 >; viewDepth 6; viewport { portal myportal { universe myuniverse ; center [3]< -12, 0, 0 >; }; channels [3]< @ myportal 0 , @ myportal 1 , @ myportal 2 >; }; image ppm { common { basename compl; }; }; }; universe myuniverse { dimensions 3; ambientLight { channels [3]< 0.1 , 0.1 , 0.1 >; }; skyColor { channels [3]< 0.2 , 0.2 , 0.6 >; }; light { position [3]< -10, 5, 15 >; falloff 0.1; color { channels [3]< 0.6 , 0.6 , 0.6 >; }; }; light { position [3]< -15, -5, 5 >; falloff 0.1; color { channels [3]< 0.8 , 0.8 , 0.8 >; }; }; object intersection { object cylinder { roundDimensions 0; base { scale [3]< 0.7, 0.7, 0.7 >; color { channels [3]< 0.4 , 1.0 , 0.4 >; }; }; }; object complement { object cylinder { roundDimensions 3; base { scale [3]< 0.85, 0.85, 0.85 >; color { channels [3]< 1.0 , 0.6 , 0.6 >; }; }; }; }; base { center [3]< 0, 1, 0 >; orientation [2]< [3]< 3, 2, 1 >, [3]< 1, 0, -3 > >; }; }; object intersection { object cylinder { roundDimensions 0; base { scale [3]< 0.7, 0.7, 0.7 >; color { channels [3]< 0.4 , 1.0 , 0.4 >; }; }; }; object cylinder { roundDimensions 3; base { scale [3]< 0.85, 0.85, 0.85 >; color { channels [3]< 1.0 , 0.6 , 0.6 >; }; }; }; base { center [3]< 0, -1, 0 >; orientation [2]< [3]< 3, 2, 1 >, [3]< 1, 0, -3 > >; }; }; }; ./rt2.7.2007.05.17/Scene/coxeter.rt0100644000077300007650000001416410600167321014352 0ustar patpatview { units [2]< 2.56, 1.28 >; dotsPerUnit [2]< 300, 300 >; viewDepth 6; viewport { portal myportal { universe myuniverse ; center [3]< -12, 0, 0 >; }; channels [3]< @ myportal 0 , @ myportal 1 , @ myportal 2 >; }; image ppm { common { basename coxeter; }; }; }; universe myuniverse { dimensions 3; ambientLight { channels [3]< 0.1 , 0.1 , 0.1 >; }; skyColor { channels [3]< 0.2 , 0.2 , 0.6 >; }; light { position [3]< -10, 5, 15 >; falloff 0.1; color { channels [3]< 0.8 , 0.8 , 0.8 >; }; }; light { position [3]< -15, -5, 5 >; falloff 0.1; color { channels [3]< 1.0 , 1.0 , 1.0 >; }; }; object coxeter { # # o--5--*-----* # matrix [3]< [3]< 1, 5, 2 >, [3]< 5, 0, 3 >, [3]< 2, 3, 0 > >; colorDistance 0.05; specialColor 1 { channels [3]< 0.2 , 0.2 , 0.2 >; specularness 0.3; reflectiveness 0.1; }; specialColor 0 { channels [3]< 1.0 , 0.5 , 0.5 >; specularness 0.3; reflectiveness 0.1; }; base { scale [3]< 0.8, 0.8, 0.8 >; orientation [2]< [3]< 1, 2, 5 >, [3]< -2, 1, 0 > >; center [3]< 0, -1.5, 0 >; color { channels [3]< 1.0 , 0.2 , 0.2 >; specularness 0.3; reflectiveness 0.1; transparency 0.4; }; }; }; object coxeter { # # *--5--*-----o # matrix [3]< [3]< 0, 5, 2 >, [3]< 5, 0, 3 >, [3]< 2, 3, 1 > >; colorDistance 0.05; specialColor 1 { channels [3]< 0.2 , 0.2 , 0.2 >; specularness 0.3; reflectiveness 0.1; }; specialColor 0 { channels [3]< 1.0 , 0.5 , 0.5 >; specularness 0.3; reflectiveness 0.1; }; base { scale [3]< 0.8, 0.8, 0.8 >; orientation [2]< [3]< 1, 2, 5 >, [3]< -2, 1, 0 > >; center [3]< 0, 0, 0 >; color { channels [3]< 0.2 , 1.0 , 0.2 >; specularness 0.3; reflectiveness 0.1; transparency 0.4; }; }; }; object coxeter { # # o--4--*-----* # matrix [3]< [3]< 1, 4, 2 >, [3]< 4, 0, 3 >, [3]< 2, 3, 0 > >; colorDistance 0.05; specialColor 1 { channels [3]< 0.2 , 0.2 , 0.2 >; specularness 0.3; reflectiveness 0.1; }; specialColor 0 { channels [3]< 1.0 , 0.5 , 0.5 >; specularness 0.3; reflectiveness 0.1; }; base { scale [3]< 0.8, 0.8, 0.8 >; orientation [2]< [3]< 1, 2, 5 >, [3]< -2, 1, 0 > >; center [3]< 0, 1.5, 0 >; color { channels [3]< 1.0 , 1.0 , 0.2 >; specularness 0.3; reflectiveness 0.1; transparency 0.4; }; }; }; object halfspace { base { center [3]< 0, 0, -0.75 >; orientation [1]< [3]< 0, 0, 1 > >; color { channels [3]< 0.8 , 0.8 , 1.0 >; reflectiveness 0.8; }; }; }; }; ./rt2.7.2007.05.17/Scene/cylinders.rt0100644000077300007650000000642210600166525014700 0ustar patpatview { units [2]< 2.56, 1.28 >; dotsPerUnit [2]< 300, 300 >; fishEye [2]< 0, 0 >; viewDepth 6; viewport { portal myportal { universe myuniverse ; center [3]< -12, 0, 0 >; }; channels [3]< @ myportal 0 , @ myportal 1 , @ myportal 2 >; }; image ppm { common { basename cylinders; }; }; }; universe myuniverse { dimensions 3; ambientLight { channels [3]< 0.1 , 0.1 , 0.1 >; }; skyColor { channels [3]< 0.2 , 0.2 , 0.6 >; }; light { position [3]< -10, 5, 15 >; falloff 0.1; color { channels [3]< 0.8 , 0.8 , 0.8 >; }; }; light { position [3]< -15, -5, 5 >; falloff 0.1; color { channels [3]< 1.0 , 1.0 , 1.0 >; }; }; object cylinder { roundDimensions 0; base { scale [3]< 0.8, 0.8, 0.8 >; orientation [2]< [3]< 1, 1, 1 >, [3]< -1, 1, 0 > >; center [3]< 0, -2.5, 0 >; color { channels [3]< 1.0 , 0.2 , 0.2 >; specularness 0.3; reflectiveness 0.3; }; }; }; object cylinder { roundDimensions 2; base { scale [3]< 0.8, 0.8, 0.8 >; orientation [2]< [3]< 1, 1, 1 >, [3]< -1, 1, 0 > >; center [3]< 0, 0, 0 >; color { channels [3]< 0.2 , 1.0 , 0.2 >; specularness 0.3; reflectiveness 0.3; }; }; }; object cylinder { roundDimensions 3; base { scale [3]< 1.0, 1.0, 1.0 >; orientation [2]< [3]< 1, 1, 1 >, [3]< -1, 1, 0 > >; center [3]< 0, 2.5, 0 >; color { channels [3]< 0.2 , 0.2 , 1.0 >; specularness 0.3; reflectiveness 0.3; }; }; }; }; ./rt2.7.2007.05.17/Scene/extrusion.rt0100644000077300007650000000523310600167265014745 0ustar patpatview { units [2]< 1.28, 1.28 >; dotsPerUnit [2]< 300, 300 >; viewDepth 6; viewport { portal myportal { universe myuniverse ; center [3]< -15, 0, 0 >; }; channels [3]< @ myportal 0 , @ myportal 1 , @ myportal 2 >; }; image ppm { common { basename extrusion; }; }; }; universe myuniverse { dimensions 3; ambientLight { channels [3]< 0.1 , 0.1 , 0.1 >; }; skyColor { channels [3]< 0.2 , 0.2 , 0.6 >; }; light { position [3]< -10, 5, 15 >; falloff 0.1; color { channels [3]< 0.6 , 0.6 , 0.6 >; }; }; light { position [3]< -15, -5, 5 >; falloff 0.1; color { channels [3]< 0.8 , 0.8 , 0.8 >; }; }; object intersection { object extrusion { dimensions 2; object quadratic { squares [2]< [2]< 1, 1 >, [2]< 0, -1 > >; linears [2]< 1, 1 >; scalar 0.25; }; base { color { channels [3]< 1.0 , 0.2 , 0.2 >; specularness 0.4; phong 5; }; }; }; object cylinder { roundDimensions 3; base { scale [3]< 1, 1, 1 >; color { channels [3]< 0.2 , 1.0 , 0.2 >; }; }; }; base { orientation [2]< [3]< 5, 0, -1 >, [3]< 0, 1, 0 > >; }; }; }; ./rt2.7.2007.05.17/Scene/inside.rt0100644000077300007650000000534310600175462014160 0ustar patpatview { units [2]< 2.56, 2.56 >; dotsPerUnit [2]< 300, 300 >; fishEye [2]< 8, 8 >; viewDepth 6; traceDepth 18; viewport { portal myportal { universe myuniverse ; center [3]< 0, 0, 0 >; }; channels [3]< @ myportal 0 , @ myportal 1 , @ myportal 2 >; }; image ppm { common { basename inside; }; }; }; universe myuniverse { dimensions 3; ambientLight { channels [3]< 0.1 , 0.1 , 0.1 >; }; skyColor { channels [3]< 0.2 , 0.2 , 0.6 >; }; light { position [3]< -10, 5, 15 >; falloff 0.0; color { channels [3]< 0.3 , 0.3 , 0.3 >; }; }; light { position [3]< -15, -5, 5 >; falloff 0.0; color { channels [3]< 0.4 , 0.4 , 0.4 >; }; }; object union { object cylinder { roundDimensions 0; base { scale [3]< 30.0, 30.0, 30.0 >; orientation [2]< [3]< 1, 1, 1 >, [3]< -1, 1, 0 > >; center [3]< 15, 0, 0 >; color { channels [3]< 0.7 , 0.2 , 0.2 >; specularness 0.3; reflectiveness 0.2; }; }; }; object cylinder { roundDimensions 2; base { scale [3]< 40.0, 40.0, 40.0 >; orientation [2]< [3]< 1, 1, 1 >, [3]< -1, 1, 0 > >; center [3]< -15, 0, 0 >; color { channels [3]< 0.2 , 0.7 , 0.2 >; specularness 0.3; }; }; }; }; }; ./rt2.7.2007.05.17/Scene/inter.rt0100644000077300007650000001031010600167133014010 0ustar patpatview { units [2]< 2.56, 1.28 >; dotsPerUnit [2]< 300, 300 >; viewDepth 6; viewport { portal myportal { universe myuniverse ; center [3]< -12, 0, 0 >; }; channels [3]< @ myportal 0 , @ myportal 1 , @ myportal 2 >; }; image ppm { common { basename inter; }; }; }; universe myuniverse { dimensions 3; ambientLight { channels [3]< 0.1 , 0.1 , 0.1 >; }; skyColor { channels [3]< 0.2 , 0.2 , 0.6 >; }; light { position [3]< -10, 5, 15 >; falloff 0.1; color { channels [3]< 0.8 , 0.8 , 0.8 >; }; }; light { position [3]< -15, -5, 5 >; falloff 0.1; color { channels [3]< 1.0 , 1.0 , 1.0 >; }; }; object intersection { object cylinder { roundDimensions 0; base { scale [3]< 1.4, 5, 1 >; center [3]< 1, 0, 0 >; color { channels [3]< 1.0 , 1.0 , 1.0 >; transparency 1.0; specularness 0.0; reflectiveness 0.0; }; }; }; object set { object intersection { object cylinder { roundDimensions 3; base { scale [3]< 0.75, 0.75, 0.75 >; center [3]< 0, 1.5, 0 >; color { channels [3]< 1.0 , 0.2 , 0.2 >; }; }; }; object cylinder { roundDimensions 3; base { scale [3]< 0.75, 0.75, 0.75 >; center [3]< 0, 1.0, 0 >; color { channels [3]< 0.2 , 0.2 , 1.0 >; }; }; }; }; object set { object cylinder { roundDimensions 3; base { scale [3]< 0.75, 0.75, 0.75 >; center [3]< 0, -1.0, 0 >; color { channels [3]< 1.0 , 0.2 , 0.2 >; }; }; }; object cylinder { roundDimensions 3; base { scale [3]< 0.75, 0.75, 0.75 >; center [3]< 0, -1.5, 0 >; color { channels [3]< 0.2 , 0.2 , 1.0 >; }; }; }; }; }; }; }; ./rt2.7.2007.05.17/Scene/justColor.rt0100644000077300007650000000115010600166407014660 0ustar patpatview { wrap; gamma 1.0; border 0; units [2]< 256, 256 >; dotsPerUnit [2]< 3, 3 >; fishEye [2]< 0, 0 >; viewDepth 6; viewport { channels [3]< + 0.5 * 0.75 sin * pi dir 0 , + 0.5 * 0.75 sin * pi dir 1 , + 0.5 * 0.75 sin * pi dir 2 >; scale [3]< 1, 1, 1 >; orientation [3]< [3]< 1, 0, 0 >, [3]< 0, 1, 0 >, [3]< 0, 0, 1 > >; center [3]< 0, 0, 0 >; }; image ppm { common { basename justColor; }; }; }; ./rt2.7.2007.05.17/Scene/quadratic.rt0100644000077300007650000000347610600166632014666 0ustar patpatview { units [2]< 1.28, 1.28 >; dotsPerUnit [2]< 300, 300 >; viewDepth 6; viewport { portal myportal { universe myuniverse ; center [3]< -15, 0, 0 >; }; channels [3]< @ myportal 0 , @ myportal 1 , @ myportal 2 >; }; image ppm { common { basename quadratic; }; }; }; universe myuniverse { dimensions 3; ambientLight { channels [3]< 0.1 , 0.1 , 0.1 >; }; skyColor { channels [3]< 0.2 , 0.2 , 0.6 >; }; light { position [3]< -10, 5, 15 >; falloff 0.1; color { channels [3]< 0.6 , 0.6 , 0.6 >; }; }; light { position [3]< -15, -5, 5 >; falloff 0.1; color { channels [3]< 0.8 , 0.8 , 0.8 >; }; }; object quadratic { squares [3]< [3]< 1, 1, -1 >, [3]< 0, -1, 1 >, [3]< 0, 0, 1 > >; linears [3]< 1, 1, 1 >; scalar 0.5; base { color { channels [3]< 1.0 , 0.2 , 0.2 >; specularness 0.4; phong 10; }; }; }; }; ./rt2.7.2007.05.17/Scene/space.rt0100644000077300007650000000441710600166415013777 0ustar patpatview { wrap; gamma 1.0; border 0; units [2]< 2.56, 1.28 >; dotsPerUnit [2]< 300, 300 >; fishEye [2]< 30, 30 >; viewDepth 6; viewport { portal myportal { universe myuniverse ; center [3]< -12, 0, 0 >; }; channels [3]< @ myportal 0 , @ myportal 1 , @ myportal 2 >; }; image ppm { common { basename space; }; }; }; universe myuniverse { dimensions 3; ambientLight { channels [3]< 0.1 , 0.1 , 0.1 >; }; skyColor { channels [3]< 0.2 , 0.2 , 0.6 >; }; light { position [3]< -10, 5, 15 >; falloff 0.1; color { channels [3]< 0.4 , 0.4 , 0.4 >; }; }; light { position [3]< -15, -5, 5 >; falloff 0.1; color { channels [3]< 0.5 , 0.5 , 0.5 >; }; }; object halfspace { base { orientation [1]< [1]< -1 > >; color { channels [3]< + 0.5 * 0.5 * cos pos 1 cos pos 2 , 0.5 , 0.5 >; }; }; }; object halfspace { base { center [1]< -24 >; orientation [1]< [1]< 1 > >; color { channels [3]< 0.5 , 0.5 , + 0.5 * 0.5 * cos pos 1 cos pos 2 >; }; }; }; }; ./rt2.7.2007.05.17/Scene/spot.rt0100644000077300007650000000325210600166471013667 0ustar patpatview { units [2]< 2.56, 1.28 >; dotsPerUnit [2]< 300, 300 >; viewDepth 6; viewport { portal myportal { universe myuniverse ; center [3]< -100, 0, 0 >; }; channels [3]< @ myportal 0 , @ myportal 1 , @ myportal 2 >; }; image ppm { common { basename spot; }; }; }; universe myuniverse { dimensions 3; ambientLight { channels [3]< 0.1 , 0.1 , 0.1 >; }; skyColor { channels [3]< 0.2 , 0.2 , 0.6 >; }; light { position [3]< -10, 5, 15 >; falloff 0.05; direction [3]< 10, -5, -15 >; angles 10, 15; color { channels [3]< 0.4 , 0.4 , 0.4 >; }; }; light { position [3]< -15, -5, 5 >; falloff 0.05; direction [3]< 15, 5, -5 >; angles 40, 50; color { channels [3]< 0.5 , 0.5 , 0.5 >; }; }; object halfspace { base { orientation [1]< [1]< -1 > >; color { channels [3]< 0.5 , 0.2 , 0.8 >; }; }; }; }; ./rt2.7.2007.05.17/Scene/union.rt0100644000077300007650000001030110600166746014030 0ustar patpatview { units [2]< 2.56, 1.28 >; dotsPerUnit [2]< 300, 300 >; viewDepth 6; viewport { portal myportal { universe myuniverse ; center [3]< -12, 0, 0 >; }; channels [3]< @ myportal 0 , @ myportal 1 , @ myportal 2 >; }; image ppm { common { basename union; }; }; }; universe myuniverse { dimensions 3; ambientLight { channels [3]< 0.1 , 0.1 , 0.1 >; }; skyColor { channels [3]< 0.2 , 0.2 , 0.6 >; }; light { position [3]< -10, 5, 15 >; falloff 0.1; color { channels [3]< 0.8 , 0.8 , 0.8 >; }; }; light { position [3]< -15, -5, 5 >; falloff 0.1; color { channels [3]< 1.0 , 1.0 , 1.0 >; }; }; object intersection { object cylinder { roundDimensions 0; base { scale [3]< 1.4, 5, 1 >; center [3]< 1, 0, 0 >; color { channels [3]< 1.0 , 1.0 , 1.0 >; transparency 1.0; specularness 0.0; reflectiveness 0.0; }; }; }; object set { object union { object cylinder { roundDimensions 3; base { scale [3]< 0.75, 0.75, 0.75 >; center [3]< 0, 1.5, 0 >; color { channels [3]< 1.0 , 0.2 , 0.2 >; }; }; }; object cylinder { roundDimensions 3; base { scale [3]< 0.75, 0.75, 0.75 >; center [3]< 0, 1.0, 0 >; color { channels [3]< 0.2 , 0.2 , 1.0 >; }; }; }; }; object set { object cylinder { roundDimensions 3; base { scale [3]< 0.75, 0.75, 0.75 >; center [3]< 0, -1.0, 0 >; color { channels [3]< 1.0 , 0.2 , 0.2 >; }; }; }; object cylinder { roundDimensions 3; base { scale [3]< 0.75, 0.75, 0.75 >; center [3]< 0, -1.5, 0 >; color { channels [3]< 0.2 , 0.2 , 1.0 >; }; }; }; }; }; }; }; ./rt2.7.2007.05.17/TODO.oo30100644000077300007650000000652410600241212012455 0ustar patpat[Ysۼվ@}igJk;ڬ}_ H"EP4÷9q=;~g3r K!.05(rG_渱xP&@wZ&|C3梉Š;j}6iН-DLt:=>6Hf,3RMaI)^Iʿ>r"|YHLG9\<&+Oib#旻 WxbM-򲹻zG AL-d'S L,?0vѿCX*UjYL[lb+(t/-\( >CKF^>A:9Hu׾=}HݦsBvN)1UW GxD'o(?3KLR&~*}9n0JW`c;q'a!K|rH~zyofiw; 8{VTo8^<4Rvf.r;華 vdMXOT3^u#Ӷ1 v&iߡw[9`-U[vӛYckQ*fJ1&^k I~xpX-xj^ggoB$qN?v8EJe@28dOnPܸY`IE[jdwy/A!-YUa_@ Yf!ÑVaantF7.ta]wIۇ J3N==?me3JŲОimHc0l$MuغPXs-5lr)J Z_Z|܈`Y {ؓ$f?Hx.;\R fV ;&)صSA4 rOXY3t0jbcaCplk0G:Wpx^;1i4+FJK J9qXAuhjv l)K7aE 9s`3+.E|_+vH''ym~]X/6U~p e&,4 kzVJԬ pێ;l74hf_z6?#&_E`7P0[jKb.5ݜJ/M 6|S2wLxsÍRNjw8;lK/FzuwKM!P$Dp SC>žw_(Lkջ87,п)2Wq0+K!LM$)̵DE GY_%HPL/n~{!Hi2jtVfak+9Zj +^7_8¡Rd&-4yAcΌIB4ݥeI6G :DE(YdFV|tM (墋q4,Uh\Ŋ7vO `-8&a\/0RRcԶ[IA8B QOtSy[2%`Q =1=` l=_cꕎҤHy0-U%&π_G"_e#ѥfLd2%5K}OD#lekA8]GHº#BP$tA b/ekMk:&k% mRaWpuڂH!v 纕nk "s I"CC-$>z "qItsx}ߤg?m "l^;CVl&+Vՙ6F1o0QFk쐳A!É &/|:F