File List

Here is a list of all files with brief descriptions:

AABB.cpp [code]
AABB.h [code]
AABB.inl [code]
AbsorbentBSDF.cpp [code]	Ideal, cool, black-body absorbent material (absorbs all incoming light)
AbsorbentBSDF.h [code]
accel.h [code]	Convenience header which includes all public acceleration headers
AggregateBSDF.cpp [code]	Linear combination of different BSDF implementations, where the coefficients are determined either a priori (inherent property described in scenefile) or via a texture map lookup
AggregateBSDF.h [code]
algebra.h [code]	Convenience header which includes all headers in the linear algebra package (Matrix.h, Vector.h, and Point.h)
arch.h [code]	Contains architechure-specific definitions
ArgsParser.cpp [code]
ArgsParser.h [code]
BidirectionalPathTracer.cpp [code]
BidirectionalPathTracer.h [code]
Blob.cpp [code]	Blobby isosurface composed of a set of MetaObjects, all of which combine to form a scalar field whose contour at this blob's threshold value defines the surface. Upon initialization (Blob::init), the implicit surface is polygonized into triangles using a variant of the well-known Marching Cubes algorithm
Blob.h [code]
BoxFilter.cpp [code]	2D symmetric box filter (unweighted area filtering)
BoxFilter.h [code]
BSDF.cpp [code]
BSDF.h [code]	Abstract representation of a BSDF defined at a single point on a surface in 3-space
Camera.cpp [code]	Abstract camera that all Milton cameras subclass, representing a mapping from film-space to world-space and vice-versa. Cameras may optionally also specify an OpenGL preview projection matrix that can be used by OpenGLRenderer. Film-space is represented by (slightly modified) Normalized Device Coordinates (NDC), which are unit film-plane coordinates, with (x,y) both ranging inbetween 0 and 1. NDC lie in the unit square [0,1]^2, where [0,0] gets mapped to the upper left corner of the corresponding Viewport/Image, and [1,1] is the lower right corner. NDC film-space allows for mapping rendering results onto an arbitrarily-sized Viewport/Image
Camera.h [code]
cameras.h [code]	Convenience header which includes all public camera headers
Canvas.cpp [code]
Canvas.h [code]
ColorUtils.cpp [code]
ColorUtils.h [code]
common.h [code]	Contains includes and definitions used throughout this project
Cone.cpp [code]	Representation of a vertical 3D cone enclosed in the unit box (-.5,-.5,-.5) to (.5,.5,.5) -- the tip is at (0,.5,0)
Cone.h [code]
ContUniformSampler.cpp [code]	Represents a continuous uniform distribution X ~ U(min, max) f(x) = 1 / (max - min)
ContUniformSampler.h [code]
core.h [code]	Convenience header which includes all core public milton headers
Cube.cpp [code]	Representation of a unit cube in 3-space from (-.5,-.5,-.5) to (.5,.5,.5)
Cube.h [code]
Cylinder.cpp [code]	Representation of a vertical 3D cylinder enclosed in the unit box (-.5,-.5,-.5) to (.5,.5,.5)
Cylinder.h [code]
DefaultRenderOutput.cpp [code]	Records point samples from a renderer and reconstructs the underlying image, using a default reconstruction reconstruction filter
DefaultRenderOutput.h [code]
DielectricBSDF.cpp [code]	Wavelength-dependent, thin dielectric BSDF defined at a single point on a surface in 3-space. The opacity input controls the transmittance versus reflectance of different wavelengths. A pure specular mirror may be obtained by creating a dielectric BSDF with zero opacity. Conversely, a purely transparent surface may be obtained by creating a dielectric with full opacity. Note that a completely transparent surface will still reflect some light (in proportion to Fresnel's Laws) because refraction is undefined past a critical angle when light is traveling between a lighter and denser medium. When this happens, some light is reflected regardless of the opacity parameter, and this is typically known as total internal reflection
DielectricBSDF.h [code]
DiffuseBSDF.cpp [code]	Ideal diffuse BSDF (lambertian) defined at a single point on a surface in 3-space
DiffuseBSDF.h [code]
DirectIllumination.cpp [code]	Interface for estimating direct illumination from all luminaires in a scene to a given surface point on a surface
DirectIllumination.h [code]
DiscreteUniformSampler.cpp [code]	Represents a discrete uniform distribution X ~ U(min, max) p(x) = 1 / (max - min)
DiscreteUniformSampler.h [code]
DissolveSampleGenerator.cpp [code]
DissolveSampleGenerator.h [code]	Cool dissolve effect which generates point samples uniformly over a given 2D domain. The order in which the samples are generated looks random, but it is actually quite deterministic and guaranteed to "visit" every bucket in the domain
dynamic.h [code]	Convenience header which includes all public dynamic plugin headers
DynamicPlugin.h [code]
Emitter.cpp [code]
Emitter.h [code]	Abstract representation of emittance defined at a single point on a surface in 3-space (describing a light)
EmitterSampler.cpp [code]	Sampler which selects a point on an emitter (light source) in the scene with probability proportional to radiant exitance
EmitterSampler.h [code]
EnvironmentMap.cpp [code]	Environment map using latitude-longitude format. An environment map roughly models distant illumination surrounding a scene by conceptually surrounding the scene with a spherical emitter that emits light inwards according to a distribution defined by a 2D 'environment' texture map that is projected onto the surface of the sphere. Note the term HDR environment map is thrown around a lot; the only difference is that the underlying environment texture is stored in some type of high dynamic range format, such as OpenEXR or HDR
EnvironmentMap.h [code]
Event.cpp [code]	Represents a single event which was sampled from a Sampler. The internal value of this event is stored in a variant using boost::any, where the concrete value of type T can be extracted using Event<T>::getValue()
Event.h [code]
ExponentialSampler.cpp [code]	Represents an exponential distribution: X ~ Exp(lambda) ; lambda > 0 f(x) = lambda * exp(-lambda * x) ; x >= 0 E(X) = 1 / lambda Var(X) = 1 / (lambda ^ 2)
ExponentialSampler.h [code]
exrinput.cpp [code]
exrinput.h [code]
FileRenderOutput.cpp [code]	Records point samples from a renderer and naively reconstructs the underlying image by storing samples into the bin/pixel which they fall into, overwriting previous samples, and not using any reconstruction filter. Writes results out to the given file in a custom format upon completion of rendering
FileRenderOutput.h [code]
Filter.cpp [code]	Templated representation of an N-dimensional filter function in T^N
Filter.h [code]
filters.h [code]	Convenience header which includes all Filter implementations
Fresnel.h [code]
GaussianFilter.cpp [code]	2D discrete, symmetric gaussian filter (separable like most of the other filters, but we're not taking advantage of this to make the filter framework cleaner and more cohesive), centered at the origin
GaussianFilter.h [code]
generators.h [code]	Convenience header which includes all SampleGenerator implementations
GLState.cpp [code]	Utility wrapper classes for accessing and synchronizing OpenGL state in a cleaner, more object-oriented manner, grouping similar state items with each other
GLState.h [code]
Gui.cpp [code]
Gui.h [code]
HDRImage.cpp [code]	HDR image class supporting a 128- or 256-bit RgbaHDR pixel format
HDRImage.h [code]
HDRImage.inl [code]	HDR image class supporting a 128- or 256-bit RgbaHDR pixel format
HDRUtils.cpp [code]
HDRUtils.h [code]
HilbertSampleGenerator.cpp [code]	Recursive space-filling L-System represented graphically
HilbertSampleGenerator.h [code]
IFeatures.cpp [code]	Utility base class for managing large amounts of (possibly) optional functionality in a clean and consistent manner. The template type 'Feature' needs to support bitwise computations
IFeatures.h [code]
Image.cpp [code]	Abstract image class supporting a standard 32-bit Rgba pixel format, as well as an extended, 128- or 256-bit floating-point RgbaHDR pixel format for high dynamic range images
image.h [code]	Convenience header which includes all public milton image headers
Image.h [code]
Image.inl [code]	Abstract image class supporting a standard 32-bit Rgba pixel format, as well as an extended, 128- or 256-bit floating-point RgbaHDR pixel format for high dynamic range images
ImageCanvas.cpp [code]
ImageCanvas.h [code]
Implicit.cpp [code]	Abstract representation of an implicit shape in 3-space
Implicit.h [code]
IndexOfRefraction.cpp [code]	Catalog of various common indices of refraction
IndexOfRefraction.h [code]
InstancedShape.cpp [code]	Acts as a proxy for a shape which has been instanced
InstancedShape.h [code]
Intersectable.cpp [code]	Interface for an intersectable object in 3-space, with some extra functionality specific to accelerating spatial intersection queries
Intersectable.h [code]
IPathGenerator.h [code]
JitteredSampleGenerator.cpp [code]	Jittered point sample generation over a given 2D domain where M*N samples are generated randomly within M*N uniformly-spaced subdomains
JitteredSampleGenerator.h [code]
JointContUniformSampler.cpp [code]	Represents a uniform distribution on [min,max)^N ; N > 0, which could be used, for example, for choosing a random UV coordinate (e.g, where N = 2, min = 0, max = 1)
JointContUniformSampler.h [code]
JointEvent.cpp [code]	Represents a single event which was sampled from a JointSampler. The internal value of this event is stored in a variant using boost::any, where the concrete value of type T can be extracted using Event<T>::getValue()
JointEvent.h [code]
JointSampler.cpp [code]	Represents an abstract joint random variable that can be sampled according to several discrete/continuous probability distribution(s)
JointSampler.h [code]
kdTreeAccel.cpp [code]	An N-dimensional kd-Tree is an axis-aligned binary spatial partitioning data structure. Each internal node is split along one of the N principle axes, where the split plane is typically chosen at each node based on some sort of heuristic. This kd-Tree implementation supports several common split plane generation methods, namely: spatial midpoint, median of geometry, and surface area heuristic (SAH). Note that a kd-Tree constructed by choosing the spatial midpoint along the current split axis as the next split plane is equivalent to an Octree. Also note that though the SAH produces the best quality tree overall with respect to visibility tests, it can take a long time to build and is thus mainly suitable for static scenes (whereas other acceleration data structures may be more appropriate for dynamic geometry & animations). The SAH kd-Tree may be tweaked with several parameters. See kdTreeAccelParams for more info. The O(nlog n) SAH construction has been implemented as opposed to the O(n) or O(n^2) alternatives (using std::sort for internal sorting). This choice was made because the O(n) solutions which exist both have large constants (which diminish their utility in practice), and are nowhere near as readable or easy to understand as the relatively straightforward O(nlog n) alternative
kdTreeAccel.h [code]
KernelFilter.cpp [code]	2D discrete, symmetric filter which can be compactly / efficiently stored / applied using a 2D kernel (array)
KernelFilter.h [code]
LanczosSincFilter.cpp [code]	2D symmetric Lanczos filter whose aim is to approximate a truncated sinc (the ideal reconstruction filter) while minimizing the amount of visible ringing resulting from the truncation
LanczosSincFilter.h [code]
loaders.h [code]	Convenience header which includes all public loader headers
Log.cpp [code]
Log.h [code]
Log.inl [code]	Unified logging functionality for Milton debugging output
LSystem.cpp [code]	Models a Lindenmayer System, which may be used to simulate a varient of effects in Nature, such as plant growth and fractals
LSystem.h [code]
main.cpp [code]
MarchingCubes.cpp [code]	Marching Cubes is a well-known algorithm for generating a polygonal approximation to an isosurface defined over a scalar field. This class is a fairly standard implementation of Marching Cubes in 3D that generates triangular meshes as output
MarchingCubes.h [code]
MarchingCubesData.inl [code]
Material.cpp [code]	Abstract representation of a surface Material, defined without respect to the underlying surface (loose coupling between Shapes and Materials from the point-of-view of a Material, but all Shapes know about their surface Material). Materials subclass PropertyMap, and it is through this interface that Material properties may be set (ex: diffuse color, texture/bump/color map(s), index of refraction of interior volume, etc.)
Material.h [code]
materials.h [code]	Convenience header which includes all public Material headers, including BSDFs, Emitters, and Sensors
Matrix.cpp [code]	Provides basic functionality for a templated, arbitrarily-sized matrix
Matrix.h [code]
Matrix.inl [code]	Provides basic functionality for a templated, arbitrarily-sized matrix
Mesh.cpp [code]	Representation of a triangular mesh stored in the obj format. It consists of a list of vertices's and a list of faces that contain indices in the vertex list
Mesh.h [code]
MeshLoader.cpp [code]	Static class which loads mesh data from external files in either OBJ or PLY formats (file extensions '.obj' and '.ply' respectively)
MeshLoader.h [code]
MeshLoaderOBJ.cpp [code]
MeshLoaderOBJ.h [code]	Loads OBJ meshes from an external source ('.obj' file extension). Wrapper around obj-parser-0.1
MeshLoaderPLY.cpp [code]	Loads PLY meshes from an external source ('.ply' file extension). Wrapper around ply-parser-0.1
MeshLoaderPLY.h [code]
MeshTriangle.cpp [code]	Basic representation of a MeshTriangle with optional UV coordinates
MeshTriangle.h [code]
MetaBall.cpp [code]	A MetaObject exerts a positive or negative 'charge' in a scalar field, whose isocontours (level sets) define blobby surfaces with different threshold values corresponding to the contour level. MetaObjects positively or negatively affect their neighboring MetaObjects depending on their 'strength' and 'negative' attributes. A MetaBall exerts a non-zero charge (aka influence) over a spherical region emanating from a single point, 'position', out to a maximum distance of 'radius'
MetaBall.h [code]
MetaObject.cpp [code]	A MetaObject exerts a positive or negative 'charge' in a scalar field, whose isocontours (level sets) define blobby surfaces with different threshold values corresponding to the contour level. MetaObjects positively or negatively affect their neighboring MetaObjects depending on their 'strength' and 'negative' attributes. 'strength' defines the initial charge of the object, and 'negative' is a boolean which defaults to false, denoting whether or not this MetaObject has a positive or a negative impact on surrounding MetaObjects. MetaObject is an abstract class, and specific implementations define how its initial charge dissipates throughout the field
MetaObject.h [code]
milton.h [code]	Convenience header which includes all public headers used throughout the Milton library
MiltonApp.cpp [code]	Main entrypoint for Qt-based frontend which comes bundled with Milton (including a non-graphical 'nox' mode for remote / batch rendering)
MiltonApp.h [code]
MiltonJSONSceneLoader.cpp [code]	Scene loader for Milton JSON scene format
MiltonJSONSceneLoader.h [code]
MiltonParams.h [code]
MitchellFilter.cpp [code]	2D symmetric Mitchell filter which is parameterized to tradeoff between 'ringing' and 'blurring' that other filters tend towards in difficult reconstruction cases
MitchellFilter.h [code]
ModifiedPhongBSDF.cpp [code]	Physically-correct modified phong model for glossy/specular surfaces, defined at a single point on a surface in 3-space. The modified phong model has two inputs: Kd, and Ks in [0, 1] subject to Kd + Ks <= 1, where Kd and Ks represent the diffuse and specular reflectivity of the surface respectively (fraction of incoming energy that is reflected diffusely/specularly). A third input, n, represents the specular shininess of the surface, where higher values of n correspond to tighter / sharper specular highlights, and lower values of n correspond to wider / glossier highlights
ModifiedPhongBSDF.h [code]
MultipleImportanceSampler.cpp [code]	"Optimally" combines samples taken from multiple sampling distributions with respect to a function, 'f', whose value we are trying to integate over a given domain,'D'. D is assumed to be the union of the domains of the individual underlying distributions. The goal of importance sampling is to reduce variance while approximating the integral of f over D by drawing random samples across D according to some probability density function p which is proportional to f. By drawing more samples from the regions where f is large (concentrating our sampling effort on the "important" regions of the domain), and similarly drawing less samples from the regions where f is small (focusing less effort in the "unimportant" regions of the domain), the variance of our estimate overall is reduced, as long as we compensate for our uneven sampling rate by weighting each sample by the inverse probability with which it was sampled. Think of importance sampling this way: if we have only one shot at sampling f (only one sample because of very limited 'resources'), we would like to concentrate that one sample in the region of the domain that will contribute the most to the value of the integral we are ultimately trying to approximate. By biasing our sampling technique to weigh "important", "large" regions of the domain with respect to f, we get more bang for our buck and correspondingly end up with a much lower variance estimator. If we were to instead naively sample uniformly across the domain, D, there's a good chance that our one, precious sample would be wasted by sampling a location, x, that is unimportant, where f(x) is relatively small. A perfect estimator would take samples from a distribution p, across D, whose probabilities were distributed directly proportional to f. This is, however, unreasonable, since if we knew the exact values of f across D, we wouldn't have to approximate the integral of f over D in the first place. We can, however, still greatly reduce variance by using knowledge about f to guide our sampling process and instead, sample according to either an approximation of f, or possibly according to some factorization of f into separate functions f1, f2, etc, some of which may be easier to draw samples from. As long as our sampling process attempts to draw samples from areas in D where f is "known" to be large and avoids regions in D where f is "known" to be small, our sampler will be more efficient and our overall variance will be reduced
MultipleImportanceSampler.h [code]
Mutation.h [code]
NaiveRenderOutput.cpp [code]	Records point samples from a renderer and naively reconstructs the underlying image by storing samples into the bin/pixel which they fall into, overwriting previous samples, and not using any reconstruction filter
NaiveRenderOutput.h [code]
NaiveSpatialAccel.cpp [code]	Naive/identity spatial acceleration (no acceleration) which runs through all primitives linearly when testing for intersections
NaiveSpatialAccel.h [code]
NormalSampler.cpp [code]
NormalSampler.h [code]	Represents a normal distribution: X ~ N(u, sigma^2) f(x) = 1/(sqrt(2*pi*sigma^2)*exp(-(x-u)^2/(2*sigma^2))) The normal distribution (aka Gaussian) is parameterized by its mean and variance and is referred to as the standard normal distribution when when it has mean zero and variance one. The normal distribution is probably the single most important distribution in all of probability because of its ubiquity in describing natural phenomena and because of the Central Limit Theorem, which says that the sum of a sufficiently large number of iid random variables, each with finite mean and varirance, will be approximately normally distributed. This allows one to study almost any distribution in terms of one, standard normal, distribution, simplifying many computations and proofs all over both applied and theoretical statistics
NullEmitter.cpp [code]	Null emitter which doesn't emit any light, defined at a single point in 3-space
NullEmitter.h [code]
NullSensor.cpp [code]
NullSensor.h [code]	Null sensor which doesn't emit any importance
OmniEmitter.cpp [code]	Point emitter / light which emits light uniformly in every direction, defined at a single point in 3-space (omnidirectional)
OmniEmitter.h [code]
OpenGLCanvas.cpp [code]	Provides an OpenGL rendering view
OpenGLCanvas.h [code]
OpenGLRenderer.cpp [code]	OpenGL preview renderer
OpenGLRenderer.h [code]
OrientedEmitter.cpp [code]
OrientedEmitter.h [code]	Area emitter/light which emits light uniformly across a 2D domain, defined at a single point in 3-space, and restricted to the local positive hemisphere (oriented along hemisphere about local surface normal)
outputs.h [code]	Convenience header which includes all public render output headers
Path.cpp [code]	Core data structure for manipulating a sequence x0,x1,...,xk of points on scene surfaces. Paths are the central unit in the path integral formulation of light transport, upon which path tracing, bidirectional path tracing, and MLT are all founded
Path.h [code]
PathTracer.cpp [code]	Unbiased path tracer with support for efficient direct illumination
PathTracer.h [code]
PathVertex.cpp [code]
PathVertex.h [code]	A Path is composed of zero or more PathVertex vertices stored in a PathVertexList. Each PathVertex stores the underlying SurfacePoint, representing a single point on a surface (and all relevant associated metadata, eg, UV coords, normal, BSDF, etc.). In addition to storing the underlying SurfacePoint, each PathVertex also stores a set of carefully chosen, local values which facilitate efficient computation of the unweighted, bidirectional contributions of all possible combinations of light and eye subpaths. Specifically, 'alphaL' and 'alphaE' store the cumulative light and eye contributions respectively, with respect to this vertex' index within its parent Path
PinholeCamera.cpp [code]	Basic pinhole camera using perspective projection (aka Camera Obscura)
PinholeCamera.h [code]
Plane.cpp [code]	Representation of a unit plane in the y=0 plane from (-.5,0,-.5) to (.5,0,.5)
Plane.h [code]
Point.cpp [code]	Provides basic functionality for a homogeneous point
Point.h [code]
Point.inl [code]	Provides basic functionality for a homogenous Point
PointSample.cpp [code]	Represents the value of a generic function ({x,y} -> any) evaluated at a particular 2D point
PointSample.h [code]
PointSampleRenderer.cpp [code]	Abstraction of renderers which construct their output by point sampling a 2D domain (the film plane). The steps of generating point samples across this domain (SampleGenerator), evaluating the samples (PointSampleRenderer/SampleConsumer), and storing/using the evaluated samples (RenderOutput) have been abstracted from each other
PointSampleRenderer.h [code]
PointShape.cpp [code]	Representation of a single point in 3-space (used to represent point lights and pinhole cameras)
PointShape.h [code]
ProgressiveFilterValue.h [code]
PropertyMap.cpp [code]	Bare-bones map used throughout Milton for holding custom initialization parameters/options/information
PropertyMap.h [code]
Random.cpp [code]	Provides static functionality for generating base random numbers, wrapping around boost::random, shared by all Samplers
Random.h [code]
Ray.cpp [code]
Ray.h [code]
RayCaster.cpp [code]	Simple, non-recursive raycaster
RayCaster.h [code]
RayTracer.cpp [code]	Abstract ray tracing engine, with the following concrete implementations: WhittedRayTracer, StochasticRayTracer
RayTracer.h [code]
ReconstructionRenderOutput.cpp [code]	Records point samples from a renderer and attempts to reconstruct the underlying image by filtering samples with a reconstruction filter
ReconstructionRenderOutput.h [code]
Renderer.cpp [code]	Abstract rendering engine which attempts to evaluate a rendering equation over a given 2D domain (the film plane) and pipes its output to an equally abstract RenderOutput (generally an image wrapper, but allowing for distributed rendering)
Renderer.h [code]
renderers.h [code]	Convenience header which includes all public renderer headers
RenderOutput.cpp [code]	Records point samples from a renderer which may be used to construct an output image on a local or distributed machine
RenderOutput.h [code]
RenderThread.cpp [code]
RenderThread.h [code]	Intermediary for communicating/blocking between Gui and non-Gui threads in Qt
ResourceManager.cpp [code]	Static resource manager synchronized across all Milton threads, containing references to loaded images, global logging utilities, and user-definable options which may be used to affect Milton functionality. Many user-definable options that are supported are aimed at dynamic, on-the-fly debugging changes (whether or not to preview kd-Trees built from Meshes, for instance)
ResourceManager.h [code]
Rgba.h [code]	32-bit and HDR (128- or 256-bit floating point) Rgba structs
Rgba.inl [code]	32-bit and 128-bit Rgba structs
RgbaImage.cpp [code]	Image class supporting a standard 32-bit Rgba pixel format
RgbaImage.h [code]
RgbaImage.inl [code]	Image class supporting a standard 32-bit Rgba pixel format
rgbe.cpp [code]	Utilities for reading and writing Ward's rgbe image format
rgbe.h [code]	Utilities for reading and writing Ward's rgbe image format
SampleConsumer.cpp [code]	Threaded point sample evaluation (represents the 'consumer' in the classic producer/consumer problem)
SampleConsumer.h [code]
SampleGenerator.cpp [code]
SampleGenerator.h [code]	Point sample generation over the 2D unit interval [0,1]^2
SampleGeneratorThread.cpp [code]	Threaded PointSample generation over the 2D unit interval [0,1]^2 (represents the 'producer' in the classic producer/consumer problem)
SampleGeneratorThread.h [code]
Sampler.cpp [code]	Represents an abstract random variable that can be sampled according to some discrete/continuous probability distribution
Sampler.h [code]
ScalarField.cpp [code]	Represents a possibly bounded 3D scalar field (function from R^3 -> R which may be non-zero only within a bounded domain -- its AABB or Axis-Aligned-Bounding-Box)
ScalarField.h [code]
Scene.cpp [code]	Contains all primitive and material data representing a given 3D scene
Scene.h [code]
SceneGraph.cpp [code]	Bare-bones scene graph used during scene parsing
SceneGraph.h [code]
SceneLoader.cpp [code]	Abstract scene loader
SceneLoader.h [code]
Sensor.cpp [code]	Representation of importance defined at a single point on a surface in 3-space (describing a sensor / camera)
Sensor.h [code]
SensorSampler.h [code]
Shape.cpp [code]	Abstract representation of a shape in 3-space
Shape.h [code]
shapes.h [code]	Convenience header which includes all supported Shape headers
ShapeSet.cpp [code]	Represents a collection of shapes which all have the same transformation
ShapeSet.h [code]
SharedLibrary.cpp [code]
SharedLibrary.h [code]
SharedLibraryCommon.h [code]
SharedLibraryManager.cpp [code]
SharedLibraryManager.h [code]
SharedLibraryPlatform.cpp [code]
SharedLibraryPlatform.h [code]
SIMD.cpp [code]	Contains useful/common definitions for working with SSE intrinsics
SIMD.h [code]	Contains useful/common definitions for working with SSE intrinsics
sort.cpp [code]
sort.h [code]
SpatialAccel.cpp [code]	Generic interface for intersection acceleration data structures used for ray visibility testing and sampling during rendering
SpatialAccel.h [code]
SpectralSampleSet.cpp [code]	Templated set of spectral values (wavelength-dependeht), sampled at N distinct wavelengths. Specific SpectralSampleSet instances include SpectralRadianceSet, in which each sample represents the radiance at a single wavelength with units Watts / (m^2 sr), and SpectralScalarSet, where each wavelength-dependent sample represents a unitless scalar that can be used to attenuate SpectralRadianceSet
SpectralSampleSet.h [code]
SpectralSampleSet.inl [code]	Templated set of spectral values (wavelength-dependeht), sampled at N distinct wavelengths. Specific SpectralSampleSet instances include SpectralRadianceSet, in which each sample represents the radiance at a single wavelength with units Watts / (m^2 sr), and SpectralScalarSet, where each wavelength-dependent sample represents a unitless scalar that can be used to attenuate SpectralRadianceSet
Sphere.cpp [code]	Representation of a 3D sphere with radius .5, enclosed in the unit box (-.5,-.5,-.5) to (.5,.5,.5)
Sphere.h [code]
stats.h [code]	Convenience header which includes all statistics package headers
StochasticSampleGenerator.cpp [code]	Stochastic point sample generation over a given 2D domain where samples are generated completely randomly over the entire domain
StochasticSampleGenerator.h [code]
SuperSampleGenerator.cpp [code]	Brute force super sampling, where sub-bin (sub-pixel) sampling is done via an auxillary SampleGenerator
SuperSampleGenerator.h [code]
SurfacePoint.cpp [code]	Core class representing a single point on the surface of a Shape, which was likely generated by either an intersection with a Ray or random sampling on the surface of the shape. SurfacePoint encapsulates all of the different information about a surface point and is used for shading evaluation (BSDF), emittance evaluation (Emitter), and so-called importance evaluation (Sensor)
SurfacePoint.h [code]
ThinLensCamera.cpp [code]	Thin lens camera approximation supporting common camera inputs and allowing for depth of field
ThinLensCamera.h [code]
Timer.h [code]
Transformable.cpp [code]	Represents a Shape which is defined in its own local "object space" and knows how to transform itself into the global "world space"
Transformable.h [code]
Transformable.inl [code]	Represents a Shape which is defined in its own local "object space" and knows how to transform itself into the global "world space"
Triangle.cpp [code]	Basic representation of a Triangle with optional UV coordinates
Triangle.h [code]
TriangleFilter.cpp [code]	2D symmetric triangle filter (aka linear/tent filter)
TriangleFilter.h [code]
UniformOnSphereSampler.cpp [code]	Represents a uniform distribution on the surface of an N-dimensional unit sphere (with parameter N > 0 and radius = 1)
UniformOnSphereSampler.h [code]
UniformSampleGenerator.cpp [code]
UniformSampleGenerator.h [code]	Uniform point sample generation over the unit interval, where samples are generated uniformly in a grid over the entire domain
UniformSampler.cpp [code]	Represents a uniform distribution (either discrete or continuous)
UniformSampler.h [code]
utilities.h [code]	Contains utility definitions used throughout all of my projects
utils.h [code]	Convenience header which includes all public milton utility headers
UV.h [code]
Vector.cpp [code]	Provides basic functionality for a constant-sized Vector
Vector.h [code]
Vector.inl [code]	Provides basic functionality for a constant-sized Vector
Vector3.h [code]	Standard specialized implementation of a 3-element vector
Vector3.inl [code]	Standard specialized implementation of a 3-element vector
Vector3SSE.cpp [code]	Specialized implementation of Vector3, accelerated to support efficient SIMD vectorization via SSE intrinsics
Vector3SSE.h [code]	Specialized implementation of Vector3, accelerated to support efficient SIMD vectorization via SSE intrinsics
Vector3SSE.inl [code]	Specialized implementation of Vector3, accelerated to support efficient SIMD vectorization via SSE intrinsics
Viewport.h [code]
Visualization.cpp [code]
Visualization.h [code]	Extracts out non-essential functionality (visualizations, user interaction) from Canvases
WeightedEvent.h [code]
WhittedRayTracer.cpp [code]	Classic Whitted-style raytracer; for a concise introduction to raytracing, see http://www.raytracing.co.uk/study/ray_intro.htm
WhittedRayTracer.h [code]