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.

Maps numbers 0-63 onto ascii characters.

Big static buffer for errors, as we may have run low on memory by the time we need to print stuff.

Names of the ray-tracing APIs.

Should we avoid showing message boxes etc., as there is no-one to deal with them?

The coefficients to calculate the luminance from a colour specified in linear sRGB space These values are determined by the CIE 1931 colour space standard and the definition of the sRGB primaries.

Largest representable negative float.

Largest representable negative half-float (=-(2 - 2^-10) * 2^15)

Largest representable positive float.

Largest representable positive half-float (=(2 - 2^-10) * 2^15)

Smallest representable positive float.

Stores the previous exception filter in InstallGeoErrorHandler(), so it can be restored in RemoveGeoErrorHandler().

Smallest float such that 1.f + g_UnitEpsilon != 1.f.

This has the value of g_VecEpsilonF broadcast into all elements.

A general epsilon for use with the IsUnitLength function.

A mask value of 'false' = 0x00000000.

A mask value of 'true' = 0xffffffff.

An internal epsilon used inside the vector normalisation functions.

Some common useful constants.

Some common useful constants.

These are all the masks for the implementation Users should go through the API to access these.

These are all the masks for the implementation Users should go through the API to access these.

These are all the masks for the implementation Users should go through the API to access these.

These are all the masks for the implementation Users should go through the API to access these.

These are all the masks for the implementation Users should go through the API to access these.

These are all the masks for the implementation Users should go through the API to access these.

These are all the masks for the implementation Users should go through the API to access these.

These are all the masks for the implementation Users should go through the API to access these.

These are all the masks for the implementation Users should go through the API to access these.

These are all the masks for the implementation Users should go through the API to access these.

These are all the masks for the implementation Users should go through the API to access these.

These are all the masks for the implementation Users should go through the API to access these.

These are all the masks for the implementation Users should go through the API to access these.

These are all the masks for the implementation Users should go through the API to access these.

These are all the masks for the implementation Users should go through the API to access these.

These are all the masks for the implementation Users should go through the API to access these.

These are all the masks for the implementation Users should go through the API to access these.

Some common useful constants.

Some common useful constants.

Some common useful constants.

Some common useful constants.

Some common useful constants.

Some common useful constants.

Some common useful constants.

Some common useful constants.

Some common useful constants.

Some common useful constants.

Some common useful constants.

Some common useful constants.

Some common useful constants.

Some common useful constants.

Unit vectors.

Unit vectors.

Unit vectors.

Unit vectors.

Some common useful constants.

Should we wait before exiting the process, when an unhandled exception is encountered.

This cpu supports AVX.

This cpu supports F16C.

This cpu supports FMA3.

This cpu supports FMA4.

This cpu supports mmx technology.

This cpu supports version 1 of SSE.

This cpu supports version 2 of SSE.

This cpu supports version 3 of SSE.

This cpu supports version 4.1 of SSE.

This cpu supports version 4.2 of SSE.

This cpu supports the Supplemental Streaming SIMD Extensions 3 (SSSE3).

A thread handle value that is never valid.

The maximum number of log handlers that can be installed per log message type.

Maximum length of a log message.

Minimum required buffer size needed for GeoLogMsgType().

Define the order in which the message types are represented in internal data structures.

The number of types of log message.

The size of an SHA-1 hash.

A bit mask for containing all the valid message types.

Return the absolute value of a number.

Return the absolute value of a number.

Return the absolute value of a number.

Returns a vector with the Abs function applied to all 4 elements.

Return the absolute value of a number.

Apply barycentric weights to triangle vertex attributes.

Function to make a string by concatenating an array of elements using IGeoStream::operator<< to convert each element to a string and placing the given separator between each element.

Converts a C-string of Base64 into raw binary.

Converts raw binary into Base64 for storage in text files.

Bloat a triangle by a specified amount.

Construct a kd-tree of points.

Generic swap that works for any built-in type <= 8 bytes.

Generic swap that works for any built-in type <= 8 bytes.

Generic swap that works for any built-in type <= 8 bytes.

Fundamental byte-swapping macros.

Fundamental byte-swapping macros.

Fundamental byte-swapping macros.

Fundamental byte-swapping macros.

Byte swap an array of 16-bit values.

Byte swap an array of 32-bit values.

Byte swap an array of 64-bit values.

Byte swap an array of 32-bit float values.

Compute the cube map texel coordinate for a given direction and cubemap resolution.

Generate a direction vector for a cubemap texel coordinate.

Generate a direction vector for a cubemap texel UV coordinate.

Compute the next whole number greater than a.

Checks if the given object has all it's 'padding' fields set to zero.

Clamp a numeric type T to the given range.

Gives the closest point in triangle abc to point p.

Combine the values in statsA and statsB so that the properties of each member are retained over the whole set.

Read a type that used to be GeoString<wchar_t>, and is now GeoString<char>

Compress the input stream with the ZLib library, placing the result in the output stream.

Compute a AABB bounds object for each split point in a kd-tree.

Computes the difference between two vector arrays.

Constructs a float which is exactly equal to 1x2^exponent.

The 4 float components of v128 correspond to the native ordering of the 4 byte components of u32.

Convert a float to a half.

Convert an array of floats to an array of halves.

Convert a half to a float.

Convert an array of halves to an array of floats.

Convert an array of v128s to an array of half vectors.

The 4 float components of v128 correspond to the native ordering of the 4 byte components of u32.

The 4 float components of v128 correspond to the native ordering of the 4 byte components of u32.

Appends the contents of the 'source' GeoList to the 'dest' GeoList.

Copies error data to the Windows clipboard.

Copy the contents of the source IGeoStream (src) to the destination GeoMemoryStream (dst).

Returns the number of consecutive trailing zero bits.

Removes leading and trailing whitespace characters from the provided string.

Double precision vector operators.

Breaks into the debugger if the given current position would advance beyond the given target position after advancing by the given number of bytes.

Deserialises a list of line segments from a file.

Display a text string, which should containing html, in the default browser.

Perform an integer division that rounds the result to the next integer.

Double precision vector operators.

Return true if all corresponding matrix elements are exactly equal.

Returns true if all elements of a and b are within g_VecEpsilon of each other.

Return true if all corresponding matrix elements are within an epsilon.

Returns true if Abs(a - b) is less than the epsilon.

Converts a float into a signed integer using a faster method than the standard C truncation convention which requires a rounding mode change.

Checks that testFile exists.

Checks that testFile exists and is newer than exemplarFile.

Checks that the file named filename can be written to.

Find array index for first element that matches data, returns -1 if no match.

Compute the next whole number smaller than a.

Free a previously loaded file.

Convert from a vector.

Convert a string to a GUID by hashing.

Convert a string to a GUID by hashing.

Helper function to generate fast poisson samples in the 2D unit square.

Helper function to generate sobol samples in the 2D unit square.

Safe forwarding to Intel GPA functions (tests if Dll has been loaded before making the call)

Safe forwarding to Intel GPA functions (tests if Dll has been loaded before making the call)

Safe forwarding to Intel GPA functions (tests if Dll has been loaded before making the call)

Safe forwarding to Intel GPA functions (tests if Dll has been loaded before making the call)

Safe forwarding to Intel GPA functions (tests if Dll has been loaded before making the call)

Safe forwarding to Intel GPA functions (tests if Dll has been loaded before making the call)

Safe forwarding to Intel GPA functions (tests if Dll has been loaded before making the call)

Safe forwarding to Intel GPA functions (tests if Dll has been loaded before making the call)

Safe forwarding to Intel GPA functions (tests if Dll has been loaded before making the call)

Templated function equivalent of GEO_DELETE_ARRAY A handy template so you don't have to enter the type param (and potentially get it wrong)

Templated function equivalent of GEO_DELETE A handy template so you don't have to enter the type param (and potentially get it wrong)

Align the supplied pointer to the supplied boundary.

Align the supplied value to the supplied boundary.

Equivalent to atof.

Equivalent to atoi.

Attach a log handler which will be passed messages of the requested types.

Attach a default set of system log handlers, appropriate to the content in which it is called.

Construct a filename for use in the underlying platform filesystem API.

Platform specific thread creation function.

Delete a file.

Calls destructor on object.

Calls destructor on object.

Detach all log handlers for the specified message types.

Detach a previously attached log handler, it if was previously attached.

Creates a directory and all the directories leading up to it.

Delete a directory and all its files, without user prompts.

A safe alternative to fclose.

A safe alternative to feof.

A safe alternative to ferror. Returns a non-zero value to indicate an error.

GeoFOpen.

A safe alternative to fread.

A safe alternative to fseek.

A safe alternative to ftell.

A safe alternative to fwrite.

Get the platform this code was compiled for.

Platform specific thread accessor function.

Returns a text string containing the platform name.

Atomically add amount to value pointed to by addend, returns the new value.

Atomically add amount to value pointed to by addend, returns the new value.

Atomically decrement value pointed to by addend, returns the new value.

Atomically sets a value, and returns its previous value.

Atomically sets a value, and returns its previous value.

Atomically increment value pointed to by addend, returns the new value.

Atomically increment value pointed to by addend, returns the new value.

Atomically subtract amount to value pointed to by addend, returns new value.

Check if the supplied value is aligned to the given alignment.

Check if the supplied address is aligned to the given alignment.

Return true if at least one logger is attached for all of the specified message types.

A log message handler for writing messages to the debugger output channel.

A log message handler for displaying messages in a popup box.

A log message handler for writing messages to stdout.

To support the MS error message format (see http://tinyurl.com/6hm53bz) allow user to set an Origin, otherwise just leave empty.

It is convenient to have a textual label for a given channel easily available.

Messages are passed through the logger using a "printf()" like function.

Messages are passed through the logger using a "printf()" like function.

Function to construct a GeoRect from the minimum and maximum X and Y co-ordinates.

Function to construct a GeoRect from the minimum and maximum X and Y co-ordinates.

Function to construct a GeoRect from a minimum X and Y co-ordinate, a width and a height.

Functions to get various co-ordinates from a rect.

Functions to get various co-ordinates from a rect.

Functions to get various co-ordinates from a rect.

Functions to get various co-ordinates from a rect.

Functions to get various co-ordinates from a rect.

Functions to get various co-ordinates from a rect.

Platform specific thread release function.

Rename a file.

Platform specific thread resume function.

Platform specific set thread affinity function.

Platform specific thread sleep function.

Equivalent to sprintf.

Begin a statistics block.

End a statistics block.

Log a single statistic, as a name/value pair.

Log a single statistic, as a name/value pair.

Log a single statistic, as a name/value pair.

Log a single statistic, as a name/value pair.

Log a single statistic, as a name/value pair.

Log a single statistic, as a name/value pair.

Log a single statistic, as a name/value pair.

Begin a StatusXml file.

End the StatusXml file (note that you may wish to set the filename to NULL after this)

The event handler for the StatusXml file.

Set the name of the StatusXml file writer. If not called, no file is created.

Equivalent to strcat.

Equivalent to strcmp.

Equivalent to strcpy.

Equivalent to stricmp.

Equivalent to strlen.

Equivalent to strlwr.

Equivalent to strncat.

Equivalent to strncmp.

Equivalent to strncpy.

Simple interpretation of the strtoXXX family of functions, returning a Geo::s16.

Simple interpretation of the strtoXXX family of functions, returning a Geo::s32.

Simple interpretation of the strtoXXX family of functions, returning a Geo::s64.

Simple interpretation of the strtoXXX family of functions, returning a Geo::u16.

Simple interpretation of the strtoXXX family of functions, returning a Geo::u32.

Simple interpretation of the strtoXXX family of functions, returning a Geo::u64.

Platform specific thread comparison function.

Unhandled exception filter, registered by InstallGeoErrorHandler()

Equivalent to vscprintf.

Equivalent to vsprintf.

Platform specific thread wait function.

Platform specific thread yield function.

Compute the barycentric weights in a triangle given a position.

Retrieve the processors features as a set of flags.

Get the PC CPU vendor.

Get the PC CPU vendor as a string.

====================================================================== Given an exception code, returns a pointer to a static string with a

description of the exception

Get the previously set file system prefix for the current platform.

Extract the exponent of the given float, accounting for the bias (i.e. the result is in the range -127 to +128).

Extracts the mantissa of the given float.

Gets the name of the given ray-tracing API.

Returns the path to the application Documents directory on the current iOS device/simulator.

============================================================================= Given a linear address, locates the module, section, and offset containing that address.

Get the number of logical cores.

Read 16 float values from a string and build a Matrix. Same argument order as the 16 float constructor.

Gets the currently set memory allocator, or NULL if none has been set yet.

Compute a normal from three vertices. The windingOrder parameter determines which side of the triangle the normal is for.

The number of page faults that occurred during the process life.

The peak amount of memory allocated by the process.

Get an absolute path to a temporary file you can open for reading/writing.

The total amount of memory currently allocated (allocations minus deallocations)

The total amount of memory currently allocated by the process.

Get the total amount of system physical memory.

Parses a v128 from the given string.

Parses a v128 from the given string, ignoring the W-component and instead setting it to the given value.

Convert a 4-element array of half floats to a v128.

Convert a 4-element array of half floats to a v128.

This is the same as HashWord() on big-endian machines.

This will create a simple u32 hash from the (case-sensitive) string supplied.

Hash a variable-length key of bytes into a 32-bit value.

Hashes the given array of bytes using SHA1 and returns a string representing the hash.

Hashes the given array of bytes using SHA1. The outputBytes parameter must have at least HASH_SIZE_SHA1 bytes allocated.

Produce a hash from a string of Geo::u32 This works on all machines.

Array version of the per-vertex function of the same name.

Sets up program-wide error handling behaviour, including the unhandled exception handler.

Intersect a triangle by a ray. If ignoreBackFaces is true then the windingOrder parameter determines which side of the triangle is the front.

Invoke the file open callback, if set.

Returns true if all of the 4 elements of v are finite.

Check that the weights are finite.

Returns true if all of the 16 elements of m are finite.

Test if barycentric weights encode a position inside the triangle.

Returns true if little endian.

Returns true if u is multiple of the specified power of 2.

Returns true if p is multiple of the specified power of 2.

Returns true if all of the 16 elements of m are finite.

Returns true if any of the 4 elements of v are NANs.

Returns true if the matrix is a valid permutation matrix, where each column and each row consists of a single positive or negative "1" and the rest "0".

Return true is unsignedInt is a power of 2 or not.

Returns whether the given character is a whitespace character.

Double precision vector operators.

Linearly interpolate between a and b with factor s.

Linearly interpolated between the corresponding components of a and b.

A safe alternative to ferror.

Load a file and append a null terminator.

Load the Intel Graphics Performance Analyzer Dll and initialise all utilised function pointers.

Load an Interface object from a stream. Interface must have same functional API as an IGeoSerialisable.

Load a Precompute interface from disk, using the given filename.

Load an IGeoSerialisable interface from disk, using the given compressed or uncompressed file.

Locate the leaf index for a given point in a kd-tree.

Locate a set of leaf indices that overlap a box.

Locate a set of leaf indices that overlap a point.

Locate a set of leaf indices that intersect a box.

Calculate the logarithm with specified base of the given number;.

Log ray tracing timings.

Returns an array range for first and last.

Factory method to create appropriate file stream like object.

Creates a GeoError struct by filling in the given error code, textual message and payload data.

Function to create a Geo::GeoPair, similar to the STL function std::make_pair.

Function to create a Geo::GeoTriple, extended from MakeGeoPair.

Creates a GeoString containing the 16 elements of the matrix (space-separated) in a form compatible with GetMatrixFromString.

Creates a GeoString containing the 16 elements of the matrix (space-separated) in a form compatible with GetMatrixFromString.

Returns a vector where each element has the maximum value of the corresponding values in a and b NOTE - the Min3 template function will work with the v128 type as well.

Gets the component-wise maximum of two points.

Return the Max of a and b.

Return the Max of {a,b,c}.

Construct the inverse of the view matrix for a specific cubemap face.

Construct a view matrix for a specific cubemap face.

Construct a matrix from a quaternion.

Determinant (returned as a broadcast float)

This will generate a report on memory leaks, and attempt to release the leaks.

Deconstruct the matrix to retrieve the rotation part as a quaternion.

Deconstruct the matrix to retrieve the translation part as a vector.

Returns a vector where each element has the minimum value of the corresponding values in a and b NOTE - the Min3 template function will work with the v128 type as well.

Return the Max of a and b.

Return the Min of {a,b,c}.

with a precomputed 1/determinant

Generalised inverse.

Inverts assuming only rotation and translation.

Return a modulo b.

Map from a linear z-order space filling curve back to x, y and z components.

Map from x, y and z components to a linear z-order space filling curve.

Generate a popup window, indicating either an error or a warning otherwise.

Generate a popup window, indicating either an error or a warning otherwise.

Determinant (returned as a broadcast float)

Safer static cast that 'protects' against underflow/overflow.

Operator - (component-wise subtraction)

Double precision vector operators.

The unary - operator. Equivalent to (VZero() - v);.

Operator overloads for GeoList.

Comparison operators for allocator classes.

Comparison operators for allocator classes.

Comparison operators for allocator classes.

Double precision vector operators.

Operator * (component-wise multiplication)

Inplace *.

Operator / (component-wise division)

Double precision vector operators.

Inplace /.

The unary + operator (effectively a no-op)

Operator + (component-wise addition)

Inplace +.

Allow GeoPoint3 to be used as a key for GeoMap.

Allow GeoPoint3D to be used as a key for GeoMap.

Operator overloads for GeoList.

Functions to write items to a stream as text.

Writes a GeoVariant to an IGeoStream as text, commonly used to write properties in Xml.

Functions to write items to a stream as text.

Functions to write items to a stream as text.

Functions to write items to a stream as text.

Functions to write items to a stream as text.

Functions to write items to a stream as text.

Functions to write items to a stream as text.

Functions to write items to a stream as text.

Functions to write items to a stream as text.

Operator overloads for GeoList.

Inplace -.

Comparison operators for allocator classes.

Array equality testing function.

Equality operator.

Comparison operators for allocator classes.

Comparison operators for allocator classes.

Operator overloads for GeoList.

Operator overloads for GeoList.

Operator overloads for GeoList.

Packs a single-precision floating point number into a floating point number with the given number of exponent and mantissa bits.

Pack a v128 colour value into a u32 in RGBM format.

Packs a 4-vector of single-precision floating point numbers into a "shared exponent" 999e5 format.

Sends a GeoError object to the listeners attached to the GeoPrintf handlers.

Since printf(...) in an exception handler seems to disappear into the ether when the process opened in a pipe We will print to both the screen and the shared memory block of OutputDebugString()

Since printf(...) in an exception handler seems to disappear into the ether when the process opened in a pipe We will print to both the screen and the shared memory block of OutputDebugString()

Print a basic report to the LOG_INFO stream.

Puts text into the windows clipboard.

Assumes q is unit.

Converts quaternion into euler angles in XYZ order, stored in those components.

Construct a matrix from a quaternion.

Flips inputs to be on the same hyper-hemisphere. Use QFullSlerp if desired.

q* = -xyz, +w

Does not flip inputs to be on the same hyper-hemisphere. Use QClosestSlerp if desired.

q* = -xyz, +w

Assumes a and b are unit.

quat multiply.

Assumes q is unit.

rasterize a triangle

rasterize a triangle regardless of winding order

Helper function to read a GeoArray from an IGeoInputStream, with all memory issues monitored and errors reported to GeoPrintf.

Helper function to read a GeoArray from an IGeoInputStream.

Helper function to read a GeoArray from an IGeoInputStream, with all memory issues monitored and errors reported to GeoPrintf.

Helper function to read a GeoMap from an IGeoInputStream, with all memory issues monitored and errors reported to GeoPrintf.

default implementation of overloadable reader function

ReadObject adapter for ReadArray.

Ensure that boolean values are read/written 'efficiently' and portably.

Allow the IGeoStream implementation to treat a GeoString as a value object, so that you can call Read/Write as you would a fundamental type.

Unregister the unhandled exception handler.

This will round the number u to the next multiple of a power of 2 if the number isn't already a multiple of the power of 2.

Round a 32bit unsigned int to the next power of 2.

Round a 64bit unsigned int to the next power of 2.

This will round the number u down to the previous multiple of a power of 2 if the number isn't already a multiple of the power of 2.

Given a GeoArray of pointers, and a destruct function (or any type that has operator()), destroy the elements and clear the array.

Scoped safe release function.

Save a file.

Save an IGeoSerialisable interface to disk, using the given filename.

Save an IGeoSerialisable interface to disk in compressed format, using the given filename.

Save the object in both binary and text form with the given filename.

Save an IGeoSerialisable interface to disk, using the given filename.

Function to scale a bounding box.

Serialises a list of line segments to a file.

Set the function to be called when a file is opened, or a null pointer to disable the callback.

Set a file system prefix for the current platform.

Set the memory allocator.

Sets whether the program will wait before exiting when an unhandled exception is encountered.

Function to parse incoming string into an array of floats.

Function to parse incoming string into an array of integers.

Drop into the debugger.

Optimised std::swap compatible function.

Optimised std::swap compatible function.

A generic swap function. Template parameter T must be CopyConstructable and Assignable.

Initialise platform-specific OS basics.

Return the current system time in seconds since 1970-01-01T00:00:00.

Returns the current performance counter.

Returns the number of system performance counter ticks in a second.

Tidyup platform-specific OS basics.

Write out raysets representing the ray distributions for debugging and visualisation.

Convert to a vector.

Uncompress a stream created by the CompressStream function above into a new stream.

Random unsigned 32 bit integer, [0, 0xffffffff] (inclusive)

Random double, [-1, 1] (inclusive)

Random float, [-1, 1] (inclusive)

Random double, [0, 1)

Random float, [0, 1)

Random double, [0, 1] (inclusive)

Random float, [0, 1] (inclusive)

Random double, (0, 1)

Random float, (0, 1)

Union of two bounding boxes.

Unacks a single-precision floating point number from a floating point number with the given number of exponent and mantissa bits.

Unpacks a 4-vector of single-precision floating point numbers from a "shared exponent" 999e5 format.

Unpack an rgbm colour into a v128.

Convert a v128 to a 4-element array of half floats.

Convert a v128 to a 4-element array of half floats.

Creates a GeoString representation of the vector (space-separated).

Creates a GeoString representation of the vector (space-separated).

Construct a v128 by broadcasting a float into all elements.

Construct a v128 by converting an integer to a float and broadcasting it into all elements.

Return ceil(v).

Compares all corresponding elements to see if a == b (exact equals).

Compares all corresponding elements to see if a >= b.

Compares all corresponding elements to see if a > b.

Tests all elements of v to see if they are finite or not.

Tests all elements of v to see if any of them are NANs.

Compares all corresponding elements to see if a <= b.

Compares all corresponding elements to see if a < b.

Compares all corresponding elements to see if a == b (exact equals).

Compares all corresponding elements to see if a >= b.

Compares all corresponding elements to see if a > b.

Compares all corresponding elements to see if a <= b.

Compares all corresponding elements to see if a < b.

Construct a v128 from 4 floats. Fairly slow.

Re-intreprets 4 ints as floats and construct a vector from them.

Construct a uint32x4_t from 4 uint32s, without reinterpreting as floats. Result is a vector of uint32s.

Cross the first 3 elements of each.

Cross the first 3 elements of each.

Converts quaternion into euler angles in XYZ order, stored in those components.

Returns the fractional part of each element of v.

Returns a mask with everything but the 4 sign bits set.

Returns a mask with just the 4 sign bits set.

Determines if the point 'c' is to the left of the line formed by joining 'a' and 'b'.

Double precision vector operators.

Load a 4-float array from 16-byte aligned memory.

Load a 4-float array from arbitrarily aligned memory. Cannot be null.

This is a vector multiply accumulate operation returning (a * b) + c.

Return -v. You can use the operator overload instead if you prefer.

Normalise the intensity of a colour vector to have unit luminance.

This is a bitwise & operation.

This is a bitwise ~ operation.

This is a bitwise | operation.

This is a bitwise ^ operation.

Packs the X component from each of the four vectors into a single vector.

Returns a vector perpendicular to v (with one of its components being zero).

Return 1.f / v. (inaccurate)

Return 1.f / v. (fast approximate where available. If not, implemented as VRecip)

Return 1.f / sqrt(v). (inaccurate)

Return 1.f / sqrt(v). (more accurate)

Return 1.f / sqrt(v). (inaccurate)

Reverses the order of the components from xyzw to wzyx.

Determines if the point 'c' is to the right of the line formed by joining 'a' and 'b'.

Calculates a * s + b * t.

Returns the specified permutation of the parameter vector. Any permutation is valid.

Calculates the signed area of the given triangle in 2D space (z-coordinates ignored)

Spherical linear interpolation between 'a' and 'b', with weight 't'.

Return sqrt(v). (more inaccurate than the reciprocal version on non-sse hardware)

Tests the flags produced by the VCompareWithFlags* operations.

Tests the flags produced by the VCompareWithFlags* operations.

Tests the flags produced by the VCompareWithFlags* operations.

Tests the flags produced by the VCompareWithFlags* operations.

A fully-zeroed out vector.

Will a conversion of mode result in moving to the current platform? If the result is true, the (incoming) data should be swapped before use.

A generic within function.

Helper function to write a GeoArray to an IGeoStream.

Helper function to write a GeoArray to an IGeoStream. Deals with arrays of values.

Helper function to write a GeoImmutableArray to an IGeoStream. Deals with arrays of values.

Helper function to write a GeoArray to an IGeoStream.

Helper function to write a GeoArray to an IGeoStream.

Write an array to the stream.

Save a GeoMemoryStream to disk, modifying the file only if the contents change (or the file didn't exist).

Helper function to write a GeoMap to an IGeoStream.

WriteObject adapter for WriteArray.

WriteObject adapter for WriteArray.

Write a blittable range object to the stream.

Allow the IGeoStream implementation to treat a GeoString as a value object, so that you can call Read/Write as you would a fundamental type.

Ensure that boolean values are read/written 'efficiently' and portably.

Write a GeoPair that is not blittable because it contains padding.

default implementation of overloadable writer function

Write the object using the policy in binary form with the given filename.

Write the object using the policy in both binary and text form with the given filename.

Write a blittable property.

Write a range property to the stream.

Write a blittable range object to the stream.

Write a range property to the stream.

Write a non-blittable range to the stream.

============================================================

Walks the stack, and writes the results to the report file

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.

Arrays of triangles.

Arrays of vertices.

Container for barycentric weights expanded to a triplet for convenience.

A chunk of clipped rays.

A bit mask containing one or more message type flags.

path: path to the file being opened.

An 8-bit colour.

String type used for file paths.

String type that can contain a textual GeoGuid representation.

A log handler is a function which gets called when messages are passed using GeoPrintf().

An internal handler count variable; signed because -1 is used to indicate an empty handler list.

String type used for networking.

A plane in 3D. xyz are the ABC coefficients for the plane normal and w satisfies Ax + By + Cz + D = 0.

A GeoRect is actually just a 4-vector (Geo::v128).

String type used for internal symbol matching.

When threading is unavailable, just use a void* as the unsupported type.

Return type of a thread function.

Thread start function prototype.

String type used for user interface and feedback.

String type used for file paths when ASCII is required (rare).

The type to pass with a function argument so that the compiler does the minimum amount of work.

A offset type, similar to size_t (off_t is not supported on all used platforms)

Quaternion definition.

callback function for rasterization

A chunk of rays.

The default ray tracing context to use when casting single rays.

Signed 16-bit integer.

Signed 32-bit integer.

Signed 32-bit integer.

Signed 64-bit integer.

Signed 64-bit integer.

Signed 8-bit integer.

A value that uniquely identifies a type within a single executable or dynamic library.

Unsigned 16-bit integer.

Unsigned 32-bit integer.

Unsigned 32-bit integer.

Unsigned 64-bit integer.

Unsigned 64-bit integer.

Unsigned 8-bit integer.

A 4-float intrinsic vector type laid out as {x,y,z,w} - the same way you would lay out a structure.

Type that should be used for passing v128s as parameters.

On x86 you can't pass more than 3 v128s by value, so we need an extra typedef for the 4th and above vector parameters to make them by-ref on x86.

Contains the resulting bounds information. This must be at least as long as splitArray.

The kd-tree split nodes, as built by BuildPointKdTree().

The kd-tree leaf nodes, as built by BuildPointKdTree().

An array of bounding boxes to match the ranges of the corresponding leaf nodes in leafArray. The array length and layout must match leafArray.

Statistics on the difference.

The first vector to compare.

The second vector to compare.

Number of elements in the two vectors.

Vector for masking out certain elements of the input vectors.

- The list of line segments to read.

- Name of the file to read line segment list from.

Value to check alignment of.

Must be a power of two.

Address to check. A NULL address will be classified as aligned regardless of alignment.

Must be a power of two.

The key (the unaligned variable-length array of bytes)

The length of the key, counting by bytes

Can be any 4-byte value