Content Comparison

Buffer that holds a chunk of rays and results.

Simple implementation of the MemoryAllocator class that forwards all requests to the malloc/free ANSI functions.

A range within an array [first, last).

The AtlasMesh implementation used for the packer and anything else that needs not to know whether we have one mesh or several.

A chart consists of a connected region of the mesh, which has a mapping into a single connected region in UV space.

Describe how you would like charting to be performed.

This tells the packer how to parameterise your stuff.

An AtlasMesh consists of a number of triangle faces, each composed of three vertices.

A specific corner of a triangle in the mesh can be identified though an AtlasMeshTriangleCorner.

An AtlasMesh has a simple vertex format, carrying a single 3D coordinate describing the model, and a single 2D "UV" coordinate though which to provide a unique unwrapping of the mesh into a UV atlas that can be used as high quality light map.

A specification describing that a specified vertex needs to duplicated, and that some of the m_Corner of the mesh faces need to be relinked to the copy.

A basic memory allocator.

A single edge of a bounding box.

A single face of a bounding box.

Details about a chart that failed to parametise well.

A finite ray with near and far clipping planes.

A convex hull of a set of points.

Builds ConvexHull objects.

A covariance matrix.

Used for building CovarianceMatrix.

A line between two points.

Winding order (clockwise/counterclockwise).

A fixed size array.

A class representing a 2d linear transform between UVs.

A type for freeing objects using GEO_ALIGNED_FREE. This is for use in GeoAutoPtr.

A storage unit for a page based allocation system.

A type of std::allocator, that passes memory requests through to the Geo heap functions This is used as the default allocator argument for the STL-like GeoMap/GeoList containers.

A custom std::allocator, that uses simple malloc/free.

Basic templated dynamic array class.

STL adaptor to make the GeoArray look like a proper STL container.

Given the lack of a template typedef, and how common it is to want a GeoAutoPtr with Array dtor, adding a new class to provide this destruction policy by default.

Adaptor to allow storing of pointers in a container (calls GEO_DELETE on each pointer upon array destruction)

Adaptor to allow container to own the pointed-to value data (calls GEO_DELETE() on each pointer upon container destruction)

Adaptor to allow container to own the pointed-to value data (calls GEO_DELETE() on each pointer upon container destruction)

A value type to take ownership of a raw object allocated on the heap and bind its life-time to the scope of this class.

Adaptor to allow storing of IGeoReleasable pointers in a container (calls Release() on each pointer upon array destruction)

Adaptor to allow container to own the pointed-to value data (calls Release() on each pointer upon container destruction)

Given the lack of a template typedef, and how common it is to want a GeoAutoPtr with Release dtor, adding a new class to provide this destruction policy by default.

A simple bit array wrapper, stored in an array of u32s.

Container for a set of bits.

class GeoBlueNoise Adapted from: Bridson, Robert, "Fast Poisson Sampling in Arbitrary Dimensions", ACM SIGGRAPH 2007 sketches

Builds a pallet of blue noise samples, each in a disk of radius 1.

class GeoBlueNoiseRayPalette

This class represents an axis aligned bounding box.

This class represents a bounding sphere.

Simple IGeoStream implementation that saves/loads data into/from memory and performs all read/write operations on this copy.

An implementation of IGeoInputStream that uses another stream to fill an internal buffer.

Basic wrapper around a critical section object.

MemoryAllocator implementation which fills allocated memory with a given value.

A type for deleting objects of type T using specific delete function. This is for use in GeoAutoPtr.

A type for deleting objects of type T using DeleteArray().

A type for deleting objects of type T using GEO_DELETE.

A simple storage class for a floating point cube map.

An IGeoRayTracingContext that implements the Intel Embree raytracer.

A hash functor for a null-terminated string.

Description of a single error reported via an IGeoProgressProxy.

Event that can be manually triggered.

The file manager deals with locating resources given a path and a filename.

Simple IGeoStream implementation that saves/loads data from a file.

An associative container with performance OlogN and only one allocation.

Default comparison functor for the GeoFixedBinarySearchMap.

A std::allocator that passes memory requests through to a single underlying GeoAllocationPage.

To make usage of this pool class a bit less painful, create template holding classes for typedefs; since template typedefs do not exist, this is the closest you can get.

To make usage of this pool class a bit less painful, create template holding classes for typedefs; since template typedefs do not exist, this is the closest you can get.

This is a simple string class template that always uses a fixed amount of memory for a single string.

This class contains all the information about the results of a GeoFlattenAndPack call.

Allow safe conversion between a float and its representative bit pattern.

A (16 bit) floating point texture for input and output.

Sets the state of the floating point control word, and restores the original value when the object is destroyed.

This class measures frame rate and also computes a running average of the last n frames.

A type for freeing objects using GEO_FREE. This is for use in GeoAutoPtr.

A really simple texture where all elements are T.

A 128 bit identifier used to uniquely identify objects in the precompute.

Convenience value type for a half float.

A const handle into the hash table.

A hash functor for a null-terminated string.

A generic hashing functor.

A non-const handle into the hash table.

The hash table.

A functor which hashes a char string.

Basic templated dynamic immutable array class.

Event for handling input messages.

Represents a range of integers, e.g. between 10 and 20.

A value type to take ownership of a raw object allocated on the heap and handle calling AddRef() and Release().

A fast implementation of a set associative container, this one using a sorted array of key values to lookup a similar array of value pointers.

Debugging output representation of a line segment.

Our implementation of an STL list, with some modifications.

Our implementation of an STL map, with some modifications.

Fully featured MemoryAllocator implementation that handles memory tracking, leak detection, stack traces, reporting and more.

A memory pool.

Simple IGeoStream implementation that saves/loads data to a block of memory.

Non axis aligned bounding box. Note the "m_Pos" of this class is the CORNER (origin), not the centre.

A type for not destroying anything.

A generic pair class. Inherits things like CopyConstructible or Assignable from its argument types.

A plane with an origin and two basis vectors in the plane.

Single precision 2 dimensional point class.

Integer 2 dimensional point class.

Single precision 3 dimensional point class.

Integer 3 dimensional point class.

GeoPriorityQueue.

Helper class to manage an IGeoProgressProxy.

Simple FIFO queue.

Any class which wishes to use the queue Walk function must inherit from this class to define its callback interface.

Given the lack of a template typedef, and how common it is to want a GeoRefPtr with Array dtor, adding a new class to provide this destruction policy by default.

Base class for reference counted resources.

A value type to take ownership of a raw object allocated on the heap and track a reference count between multiple instances of this class.

Given the lack of a template typedef, and how common it is to want a GeoRefPtr with Release dtor, adding a new class to provide this destruction policy by default.

A type for deleting objects of type T using Release(). This is for use in GeoAutoPtr.

A simple CPU 8 bit per channel texture.

A simple CPU 8 bit per channel texture element.

A simple utility for aquiring a lock for the duration of a function.

Inherit from this class to add singleton behaviour to your class.

The 3D hash table.

STL string replacement.

A simple task timer Construct a GeoTimer, then as each task begins simply create a local GeoTimer::Task object to automatically start and stop the clock.

A basic replacement for 'strtok'.

A very simple utility class that wraps some common parsing functionality around a GeoTokenList.

Simple representation of a triangle.

A generic triple class. Inherits things like CopyConstructible or Assignable from its argument types.

Given the lack of a template typedef, and how common it is to want a GeoUniquePtr with Delegate dtor, adding a new class to provide this destruction policy by default.

A value type to take ownership of a raw object allocated on the heap and bind its life-time to the scope of this class.

Given the lack of a template typedef, and how common it is to want a GeoUniquePtr with Release dtor, adding a new class to provide this destruction policy by default.

A really simple texture where all elements are float vectors.

Variant class for storing name/value pairs in a map, where the value is a subset of common value types.

Single precision 3 dimensional vector class.

Single precision 4 dimensional vector class.

Implementation of the MemoryAllocator class (on Windows) that uses VirtualAlloc and VirtualProtect to provide similar memory overwrite detection as the Application Verifier.

IGeoStream implementation that saves/loads data from a zlib compressed file.

A Mersenne Twister RNG.

Comparison class for std::sort.

A utility for identifying pairs of "identical" vertices in a vertex buffer.

A link between two vertices.

An IffReader allows you to use an IGeoStream to read Iff format binary files easily.

Presents an interface compatible with IffWriter, writes a text version of the binary IFF.

An IffWriter allows you to use an IGeoStream to create Iff format binary files easily.

Cross platform Event class.

An IGeoInputStream allows you to read memory/files in a consistent manner, and is an extension point for users wishing to control where data is stored.

An interface for informing a client about the current progress of an operation.

Ray-tracing context.

A class implementing IGeoReleasable is usually created by the Enlighten libraries and so must have Release() called in order to return the memory.

A class implementing IGeoSerialisable adds the ability to save and load instances of the type from an IGeoStream.

An IGeoStream allows you to read/write memory/files in a consistent manner, and is an extension point for users wishing to control where data is stored.

Small helper class to ensure init/cleanup are called when object is created/destroyed.

An interface used by the raytracers to fill their internal mesh data structures.

A class that provides this interface can process tty string commands.

Handles tty initialisation events.

Class providing this interface is a source of tty commands and may need polling.

A class that provides this interface can display tty output strings.

Matrix definition.

Single-precision 4x4 matrix class.

Class used to override memory allocation and freeing.

Base class for classes that are meant to be noncopyable.

Class allowing a value object (integer, string, etc) to be optional, by storing a current value, default value and a boolean to state which is valid.

Represents four unsigned integer values packed into a single 32-bit register and named XYZW.

Scope control struct which instruments a block of code for performance analysis.

A leaf node in a kd-tree of points.

A splitting node in a kd-tree of points.

A bounding box for both branches of a PointSplit node.

Common construction state for a point kd-tree.

A little class to time a task.

stores a fragment of a triangle i.e. a triangle clipped to a pixel box

records details of the input triangle

stores a rasterization vertex, including barycentric coordinates

A single ray.

The result of a ray intersection test.

Base class for classes that are meant to be releasable.

Ring Buffer class.

A mesh container that can be stored to disk and used later as a ray tracing mesh.

A ray tracing mesh that is a collection of other meshes.

A class that times the interval between construction and destruction, adding this number of ticks to the counter provided.

A class that times the interval between construction and destruction, adding the number of milliseconds to the counter provided.

Simple scope control of a class with static Start() and Stop() functions.

SH Helper class.

The 'super-duper' random number generator with shuffle (an LCG).

Result structure used for comparing input lighting buffers.

Inherit from this class to provide a specific tty command processing type.

Class that writes a 2D block of memory to disk as a texture file.

A generic tree structure, where each node contains an item by value.

Utility for doing vertex-based chart identification.

A simple implementation of an IGeoProgressProxy that uses printf to communicate with the user.

Provides a type id for the given type.

Double precision vector class.

Policy to write pointers as a range with the given element count.

Defines an N-byte block of padding which is zeroed on construction.

Location of a box relative to a plane.

An enum for the types of parametisation results we can get.

Enumeration used to control behaviour of various endian swapping functions.

Controls how the hardware is used by Enlighten to generate precompute data.

PC CPU vendors.

The severity of an error.

enum eGeoLogContext

enum eGeoLogMsgType

enum eGeoLogSystemState

Enumeration for those cases at runtime that we need to do separate functionality for each platform.

Location of a point relative to a plane.

Ray-tracing APIs.

Shuffle constants for the GEO_VSHUFFLE macro.

To avoid pulling in the entire stdio header, use our own values for GeoFSeek.

Use CPU only. Allow multiple concurrent tasks between separate processes.

Use CPU only. Block task if another Enlighten precompute task is running.

Default is to use CPU only.