Class List
Here are the classes, structs, unions and interfaces with brief descriptions:| AABB | 3-Dimensional Axis-Aligned Bounding Box |
| AbsorbentBSDF | Ideal, cool, black-body absorbent material (absorbs all incoming light) |
| AggregateBSDF | 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 |
| ArgsParser | |
| BidirectionalPathTracer | Unbiased bidirectional path tracer with support for efficient direct illumination |
| Blob | 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. 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 |
| BoxFilter | 2D symmetric box filter (unweighted area filtering) |
| BSDF | Abstract representation of a BSDF defined at a single point on a surface in 3-space |
| BSDFNode | |
| Camera | 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 |
| CameraUIListener | Provides basic Maya-inspired camera UI modifiers for trackball rotation, dollying (translation along look vector), and panning (translation along uv film plane) |
| Canvas | Provides a generic Canvas interface, shared between OpenGL canvases and pixel-based canvases |
| CanvasContainer | |
| Cone | 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) |
| ContUniformSampler | Represents a continuous uniform distribution X ~ U(min, max) f(x) = 1 / (max - min) |
| Cube | Representation of a unit cube in 3-space from (-.5,-.5,-.5) to (.5,.5,.5) |
| Cylinder | Representation of a vertical 3D cylinder enclosed in the unit box (-.5,-.5,-.5) to (.5,.5,.5) |
| DefaultRenderOutput | Records point samples from a renderer and reconstructs the underlying image, using a default reconstruction reconstruction filter |
| DielectricBSDF | 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 |
| DiffuseBSDF | Ideal diffuse BSDF (lambertian) defined at a single point on a surface in 3-space |
| DirectIllumination | Interface for estimating direct illumination from all luminaires in a scene to a given surface point on a surface |
| DiscreteUniformSampler | Represents a discrete uniform distribution X ~ U(min, max) p(x) = 1 / (max - min) |
| DissolveSampleGenerator | 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 |
| DissolveSG< SG > | |
| Emitter | Abstract representation of emittance defined at a single point on a surface in 3-space (describing a light) |
| EmitterSampler | Sampler which selects a point on an emitter (light source) in the scene with probability proportional to radiant exitance |
| EnvironmentMap | 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 |
| Event | Represents a single event which was sampled from a Sampler. The internal value of this event is stored as a variant using boost::any, where the concrete value of type T can be extracted using Event<T>::getValue() |
| ExponentialSampler | 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) |
| FileRenderOutput | 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 |
| Filter< N, T > | Templated representation of a symmetric N-dimensional filter function in T^N centered at zero with known max support (where the function is zero outside of that radius of that support; ie, support is equivalent to diameter) |
| Fresnel | Utility class encapsulating Fresnel's Law which computes the fraction of incident power that is reflected when light travels across an interface defined by the boundary between two media with different indices of refraction |
| GaussianFilter | 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 |
| GLAlphaStateItem | |
| GLBlendStateItem | |
| GLcolor | |
| GLColorStateItem | |
| GLDepthStateItem | |
| GLFogStateItem | |
| GLPointStateItem | |
| GLPrimitiveStateItem | |
| GLState | Utility wrapper classes for accessing and synchronizing OpenGL state in a cleaner, more object-oriented manner, grouping similar state items with each other |
| GLStateItem | |
| GLStencilStateItem | |
| Gui | Top level GUI application |
| HDRImage | HDR image class supporting a 128- or 256-bit RgbaHDR pixel format |
| HDRUtils | Utilities for reading and writing HDR, OpenEXR, and PFM high dynamic range image formats |
| HilbertSampleGenerator | Recursive space-filling L-System represented graphically |
| HilbertSG< SG > | |
| IFeatures | 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 |
| Image | 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 | Provides a Qt canvas for displaying 2D raster data |
| Implicit | Abstract representation of an implicit shape in 3-space |
| IndexOfRefraction | Catalog of various common indices of refraction |
| InstancedShape | Acts as a proxy for a shape which has been instanced |
| InteractionInfo | |
| InteractionListener | Extracts out non-essential functionality (visualizations, user interaction, etc.) from Canvases |
| Intersectable | Interface for an intersectable object in 3-space, with some extra functionality specific to accelerating spatial intersection queries |
| IntersectDebugTester | Debugging info when a pixel is clicked on an ImageCanvas |
| IPathGenerator | Interface responsible for generating valid light-to-eye paths |
| JitteredSampleGenerator | Jittered point sample generation over a given 2D domain where M*N samples are generated randomly within M*N uniformly-spaced subdomains |
| JitteredSG< SG > | |
| JointContUniformSampler | 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) |
| JointEvent | 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() |
| JointSampler | Represents an abstract joint random variable that can be sampled according to several discrete/continuous probability distribution(s) |
| JSONParseData | |
| JSONVisitor | |
| JSONVisitorValue | |
| kdTreeAccel | 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::BuildParams | Parameters controlling construction of a kdTreeAccel |
| KernelFilter | 2D discrete, symmetric filter which can be compactly / efficiently stored / applied using a 2D kernel (array) |
| LanczosSincFilter | 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 |
| LocalSyscallProxy | |
| Log | Unified Logging interface |
| LSystem | Models a Lindenmayer System, which may be used to simulate a varient of effects in Nature, such as plant growth and fractals |
| MainSyscallProxy | |
| MarchingCubes | 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 |
| Material | 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.) |
| Matrix< M, N, T > | A Matrix is templated to store M rows and N columns of data of type T. If left off, T will default to a "real_t" data type. Also, if N is not specified, the template will default to a square MxM matrix |
| Mesh | 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 |
| MeshData | Temporary struct for loading mesh data |
| MeshLoader | Static class which loads mesh data from external files in either OBJ or PLY formats (file extensions '.obj' and '.ply' respectively) |
| MeshLoaderOBJ | Loads OBJ meshes from an external source ('.obj' file extension). Wrapper around obj-parser-0.1 |
| MeshLoaderPLY | Loads PLY meshes from an external source ('.ply' file extension). Wrapper around ply-parser-0.1 |
| MeshTriangle | Basic representation of a MeshTriangle with optional UV coordinates |
| MeshTriangleFast | |
| MetaBall | 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' |
| MetaObject | 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 |
| MiltonApp | Main entrypoint for Qt-based frontend which comes bundled with Milton (including a non-graphical 'nox' mode for remote / batch rendering) |
| MiltonJSONSceneLoader | Scene loader for Milton JSON scene format |
| MiltonParams | MiltonApp parameters parsed from the commandline and overrideable by MiltonApp users / subclasses |
| MitchellFilter | 2D symmetric Mitchell filter which is parameterized to tradeoff between 'ringing' and 'blurring' that other filters tend towards in difficult reconstruction cases |
| ModifiedPhongBSDF | 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 |
| MultipleImportanceSampler | "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 |
| Mutation | |
| NaiveRenderOutput | 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 |
| NaiveSpatialAccel | Naive/identity spatial acceleration (no acceleration) which runs through all primitives linearly when testing for intersections |
| NormalSampler | 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 | Null emitter which doesn't emit any light, defined at a single point in 3-space |
| NullSensor | Null sensor which doesn't emit any importance |
| OmniEmitter | Point emitter / light which emits light uniformly in every direction, defined at a single point in 3-space (omnidirectional) |
| OpenGLCanvas | Provides an OpenGL rendering view |
| OpenGLRenderer | OpenGL preview renderer |
| OrientedEmitter | 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) |
| ParseData | Wrapper for data which may be loaded externally |
| Path | 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 |
| PathTracer | Unbiased path tracer with support for efficient direct illumination |
| PathVertex | 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 | Basic pinhole camera using perspective projection (aka Camera Obscura) |
| Plane | Representation of a unit plane in the y=0 plane from (-.5,0,-.5) to (.5,0,.5) |
| Point< N, T > | A Point is templated to store N elements of data of type T. If left off, T will default to a "real_t" data type |
| PointSample | Represents the value of a generic function ({x,y} -> any) evaluated at a particular 2D point |
| PointSampleRenderer | 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 |
| PointShape | Representation of a single point in 3-space (used to represent point lights and pinhole cameras) |
| ProgressiveFilterValue< T > | Normalized value composed of a progressive sum of N contributions, each of which has an associated weight |
| PropertyMap | Bare-bones map used throughout Milton for holding custom initialization parameters/options/information |
| Random | Provides static functionality for generating base random numbers, wrapping around boost::random, shared by all Samplers |
| Ray | 3-Dimensional Ray (origin + direction), including several optimization fields (inverse direction and "mailbox ID") |
| RayCaster | Simple, non-recursive raycaster |
| RayTracer | Abstract ray tracing engine, with the following concrete implementations: WhittedRayTracer, StochasticRayTracer |
| ReconstructionRenderOutput | Records point samples from a renderer and attempts to reconstruct the underlying image by filtering samples with a reconstruction filter |
| Renderer | 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) |
| RenderOutput | Records point samples from a renderer which may be used to construct an output image on a local or distributed machine |
| RenderThread | Intermediary for communicating/blocking between Gui and non-Gui threads in Qt |
| ResourceManager | 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) |
| Rgba32 | Standard 32-bit RGBA pixel with red, green, blue, and alpha channels, all with integer values in the range [0, 255] |
| RgbaHDR | Standard 128- or 256-bit RGBA pixel with floating-point red, green, blue, and alpha channels |
| RgbaImage | Image class supporting a standard 32-bit Rgba pixel format |
| rgbe_header_info | |
| SampleConsumer | Threaded point sample evaluation (represents the 'consumer' in the classic producer/consumer problem) |
| SampleGenerator | Point sample generation over the 2D unit interval [0,1]^2 |
| SampleGeneratorThread | Threaded PointSample generation over the 2D unit interval [0,1]^2 (represents the 'producer' in the classic producer/consumer problem) |
| Sampler | Represents an abstract random variable that can be sampled according to some discrete/continuous probability distribution |
| ScalarField | 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) |
| Scene | Contains all primitive and material data representing a given 3D scene |
| SceneGraph | Bare-bones scene graph used during scene parsing |
| SceneLoader | Abstract scene loader |
| SceneNode | |
| SceneNodeInstance | |
| SceneNodeMaterial | |
| SceneNodeShape | |
| SceneNodeTransform | |
| Sensor | Representation of importance defined at a single point on a surface in 3-space (describing a sensor / camera) |
| SensorSampler | Sampler which selects a point on a sensor (camera) in the scene. Successive invocations of SensorSampler |
| Shape | Abstract representation of a shape in 3-space |
| ShapeSet | Represents a collection of shapes which all have the same transformation |
| SharedLibrary | |
| SharedLibraryManager | |
| SharedLibraryPlatform | |
| SharedLibraryPlatformPosix | POSIX-compliant dl* interface (dlopen, dlsym, dlclose, dlerror...) |
| SharedLibraryReference | |
| SpatialAccel | Generic interface for intersection acceleration data structures used for ray visibility testing and sampling during rendering |
| SpectralSample | |
| SpectralSampleSet | 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 | Representation of a 3D sphere with radius .5, enclosed in the unit box (-.5,-.5,-.5) to (.5,.5,.5) |
| SSEAligned | 128-bit SSE (Streaming SIMD Extension) registers require 16-byte alignment which necessitates special care when allocating objects containing SSE data types both on the stack and on the heap (via the new operator) |
| StochasticSampleGenerator | Stochastic point sample generation over a given 2D domain where samples are generated completely randomly over the entire domain |
| StochasticSG< SG > | |
| SuperSampleGenerator | Brute force super sampling, where sub-bin (sub-pixel) sampling is done via an auxillary SampleGenerator |
| SuperSG< SG > | |
| SurfacePoint | 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::SurfacePointNormal | Convenience stand-in normal which plays nicely with shapes that don't support the concept of a normal (ex. point lights) |
| ThinLensCamera | Thin lens camera approximation supporting common camera inputs and allowing for depth of field |
| Timer | Small utility timer |
| Transformable | Represents a Shape which is defined in its own local "object space" and knows how to transform itself into the global "world space" |
| Triangle | Basic representation of a Triangle with optional UV coordinates |
| TriangleFilter | 2D symmetric triangle filter (aka linear/tent filter) |
| UniformOnSphereSampler | Represents a uniform distribution on the surface of an N-dimensional unit sphere (with parameter N > 0 and radius = 1) |
| UniformSampleGenerator | Uniform point sample generation over the unit interval, where samples are generated uniformly in a grid over the entire domain |
| UniformSampler< T > | Represents a uniform distribution (either discrete or continuous), parameterized by [min,max) |
| UniformSG< SG > | |
| UV | UV coordinate wrapper for texture coordinates |
| Vector< N, T > | A Vector is templated to store N elements of data of type T. If left off, T will default to a "real_t" data type, where a real_t is assumed to be either a float or a double |
| Vector< 3, real_t > | Specialized template implementation for Vector3, accelerated to support efficient SIMD vectorization via SSE intrinsics |
| Viewport | Represents a square domain over [0,1]^2, overlaid with a conceptual grid of uniformly-sized tiles (representing pixels) |
| WeightedEvent | Represents an event sampled by a Sampler that has been coupled with an arbitrary real-valued weight in [0,1] |
| WhittedRayTracer | Classic Whitted-style raytracer; for a concise introduction to raytracing, see http://www.raytracing.co.uk/study/ray_intro.htm |
Generated on 28 Feb 2009 for Milton by
1.5.6