PVRCore Classes#

AsyncScheduler#

Defined in Threading.h

Class Documentation#

template<typename ValueType, typename FutureType, void (*worker)(FutureType)> class AsyncScheduler#

The AsyncScheduler is an abstract Scheduling system of a homogeneous task queue running on a background thread, i.e. a queue of work of a particular type. It provides its child classes wioth access to the actual queue and the synchronization semaphores in order to facilitate easier implementation. Specifically, it is expected that the user will provide functions to enqueue and dequeue work, while this class provides the running loop (actually executing the tasks, calling the callbacks etc.

Template Parameters

ValueType – The type of the return value that will be returned by the functions
FutureType – The type of the future (which will also be the input to the worker function)
worker – The function pointer that will be called to perform the work

Public Types

typedef std::shared_ptr<IFrameworkAsyncResult<ValueType>> AsyncResult#: The type of result throughout this class.

Public Functions

inline uint32_t getNumApproxQueuedItem()#

The approximate number of queued items. (Unsynchronized for performance).

Returns: The number of queued items (currently visible to this thread)

inline uint32_t getNumQueuedItems()#

The precise number of queued items at the time of calling. Although it is poosible that (if the queue is currently producing or consuming) the number has changed by the time it is used (even if immediately), nevertheless getting the number is synchronized hence precise at the time of querying it.

Returns: The number of queued items (access is synchronized)

inline virtual ~AsyncScheduler()#: Destructor (virtual)

Protected Functions

inline AsyncScheduler()#: Constructor (empty, spawns worker thread and waits)

Protected Attributes

Semaphore _workSemaphore#: This semaphore is the counter for enqueued work. Signal it once when adding work to the queue.

Semaphore _queueSemaphore#: This is basically a mutex for the queue. Wait on it to lock the queue, then signal it when done.

std::deque<FutureType> _queue#: This is the work queue. Each item enqueued will be processed by worker.

std::string _myInfo#: String information regarding the tasks operations.

IFrameworkAsyncResult#

Defined in Threading.h

Inheritance Relationships#

Base Type#

public pvr::async::IFrameworkCleanupObject< T > (IFrameworkCleanupObject)

Class Documentation#

template<typename T> class IFrameworkAsyncResult : public pvr::async::IFrameworkCleanupObject<T>#

An object that is intended to be used as an asynchronous return value. When you wish to perform a task in another thread, when “kicking” that task you should “immediately” (before the task is complete) return such an object, and use it to check when the task is complete, and retrieve its return value. Will provide both cleanup semantics (which should at least ensure the objects are safe to destroy and operations are pending on them), and functions to both query completion and (blockingly) get the return value. To implement this class, you must implement the abstract functions get_ (that actually waits for and returns the result, and _isComplete, which actually queries if the result is ready.

Template Parameters: T – The type of the return value of the task (for example, Texture)

Public Types

typedef T ValueType#: The type of the return value.

typedef std::shared_ptr<IFrameworkAsyncResult<T>> PointerType#: A smart pointer to this result object (not the wrapped value)

typedef void (*Callback)(PointerType)#: A function pointer type that can be used as a callback to call when the return value is ready.

Public Functions

inline bool isComplete() const#

Query is the return value is ready to be used.

Returns: True if the value is ready, otherwise false

inline ValueType get()#

This is the most important function of IFrameworkAsyncResult: it actually gets the return value. If the value is not yet ready (the task is not complete), it will wait for the task completion. Use this immediately when other operations depend on the value. Otherwise, in order to avoid any wait, you can first check isComplete() and only call this function after isComplete() has returned true. If the task may fail, you should call isSuccessful() before using the value to ensure it is what you expect.

Returns: The return value of the operation.

inline bool isSuccessful() const#

Returns true if the operation was successful. An operation that is not complete cannot be successful, so check isComplete to ensure that a return value of false means that the operation actually failed

return: True if the operation is complete and successful, false if the operation failed or has not yet completed

Protected Functions

inline void setTheCallback(Callback completionCallback)#

Set the callback (a function pointer that will be called whenever processing an item is done)

Parameters: completionCallback – The callback to set

inline virtual void executeCallBack(PointerType thisPtr)#

Execute the callback (overridable)

Parameters: thisPtr – The object with which the callback will be executed as a parameter.

inline IFrameworkAsyncResult()#

Protected Attributes

Callback _completionCallback#: The callback that will be called on completion.

std::atomic<bool> _inCallback#: This is a mechanism to query if a function is actually called BY the callback to avoid deadlocking.

bool _successful#: This will / should be set to true when the work is successfully completed.

IFrameworkCleanupObject#

Defined in Threading.h

Inheritance Relationships#

Derived Types#

public pvr::async::IFrameworkAsyncResult< TexturePtr > (IFrameworkAsyncResult)
public pvr::async::IFrameworkAsyncResult< T > (IFrameworkAsyncResult)

Class Documentation#

template<typename T> class IFrameworkCleanupObject#

A wrapper object with explicit clean up semantics that is intended to be used as the return value in functions that may need to wrap multiple items. For example, it might be the return value for a texture upload function that returns both a texture object and the fence to know the operatio is complete, and the cleanup function might wait on the fence and then delete it. to void destroying useful resources, does NOT call cleanup in the destructor by default, but that can (should usually) be added to the destructor of the derived class. Implement the abstract cleanup_ function to clean up the resource, then use this object as the return value_comp from a function needing to return (for example) multiple transient values.

Subclassed by pvr::async::IFrameworkAsyncResult< TexturePtr >, pvr::async::IFrameworkAsyncResult< T >

Public Functions

inline virtual ~IFrameworkCleanupObject()#: Virtual destructor to be overriden if required.

inline void cleanup()#: Call this function when you are done using this object.

Protected Functions

inline IFrameworkCleanupObject()#

Mutex#

Defined in Threading.h

Class Documentation#

class Mutex#

A simple wrapper for a moodcamel Semaphore object used for synchronising multi threaded access.

Public Functions

inline Mutex()#: Constructor.

inline void lock()#: Waits for semaphore completion.

inline void unlock()#: Signals the semaphore as completed.

inline Semaphore &getSemaphore()#

Retrieves the semaphore.

Returns: The semaphore

inline const Semaphore &getSemaphore() const#

Retrieves the semaphore (const)

Returns: The semaphore (const)

TextureAsyncLoader#

Defined in TextureLoadAsync.h

Inheritance Relationships#

Base Type#

public pvr::async::AsyncScheduler< TexturePtr, TextureLoadFuture, &impl::textureLoadAsyncWorker > (AsyncScheduler)

Class Documentation#

class TextureAsyncLoader : public pvr::async::AsyncScheduler<TexturePtr, TextureLoadFuture, &impl::textureLoadAsyncWorker>#

A class that loads Textures in a (single) different thread and provides futures to them. Create an instance of it, and then just call loadTextureAsync foreach texture to load. When each texture has completed loading, a callback may be called, otherwise you can use all the typical functionality of futures, such as querying if loading is comlete, or using a blocking wait to get the result.

Public Functions

inline TextureAsyncLoader()#

inline AsyncResult loadTextureAsync(const std::string &filename, IAssetProvider *loader, TextureFileFormat format, AsyncResult::element_type::Callback callback = NULL)#

This function enqueues a “load texture” on a background thread, and returns an object that can be used to query and wait for the result.

Parameters

filename – The filename of the texture to load
loader – A class that provides a “getAssetStream” function to get a Stream from the filename (usually, the application class itself)
format – The texture format as which to load the texture.
callback – An optional callback to call immediately after texture loading is complete.

Returns

A future to a texture : TextureLoadFuture

hasher_helper#

Defined in CompileTimeHash.h

Class Documentation#

template<uint32_t hashvalue, unsigned char... dummy> class hasher_helper#: A dummy helper.

hasher_helper< hashvalue, first, dummy… >#

Defined in CompileTimeHash.h

Class Documentation#

template<uint32_t hashvalue, unsigned char first, unsigned char... dummy> class hasher_helper<hashvalue, first, dummy...>#

Template specialization for uint32_t values.

Public Static Attributes

static const uint32_t value = hasher_helper<hashvalue * 16777619U ^ first, dummy...>::value#: A hashed value.

hasher_helper< hashvalue, first >#

Defined in CompileTimeHash.h

Class Documentation#

template<uint32_t hashvalue, unsigned char first> class hasher_helper<hashvalue, first>#

Template specialization for uint32_t values.

Public Static Attributes

static const uint32_t value = hashvalue * 16777619U ^ first #: A hashed value.

AxisAlignedBox#

Defined in AxisAlignedBox.h

Class Documentation#

class AxisAlignedBox#

This class provides functionality to handle 3 dimensional Axis Aligned Boxes. Center-halfextent representation.

Public Functions

inline AxisAlignedBox(const glm::vec3 &center = glm::vec3(0.0f), const glm::vec3 &halfExtent = glm::vec3(0.f))#

Constructor center/halfextent.

Parameters

center – The center of the box
halfExtent – A vector containing the half-lengths on each axis

inline AxisAlignedBox(const AxisAlignedBoxMinMax &copyFrom)#

Conversion constructor from AxisAlignedBoxMinMax.

Parameters: copyFrom – An AxisAlignedBoxMinMax to convert from. An invalid AxisAlignedBoxMinMax will result in an empty AxisAlignedBox

inline void clear()#: Sets center and extents to zero.

inline void setMinMax(const glm::vec3 &min, const glm::vec3 &max)#

Sets from min and max. All components of min must be than all components in max.

Parameters

min – Minimum coordinates. Must each be less than the corresponding max coordinate.
max – Maximum coordinates. Must each be greater than the corresponding min coordinate.

inline void set(const glm::vec3 &center, const glm::vec3 &halfExtent)#

Sets from center and half extent.

Parameters

center – The center of the box
halfExtent – A vector containing the half-lengths on each axis

inline void add(const glm::vec3 &point)#

Add a new point to the box. The new box will be the minimum box containing the old box and the new point.

Parameters: point – The point which to add

inline void add(const AxisAlignedBox &aabb)#

Merge two axis aligned boxes. The new box will be the minimum box containing both the old and the new box.

Parameters: aabb – The aabb which to add

inline void add(float x, float y, float z)#

Add a new point to the box. The new box will be the minimum box containing the old box and the new point.

Parameters

x – The x-coord of the point which to add
y – The y-coord of the point which to add
z – The z-coord of the point which to add

inline glm::vec3 getMin() const#

Return a point consisting of the smallest (minimum) coordinate in each axis.

Returns: A point consisting of the smallest (minimum) coordinate in each axis

inline glm::vec3 getMax() const#

Return a point consisting of the largest (maximum) coordinate in each axis.

Returns: A point consisting of the largest (maximum) coordinate in each axis

inline void getMinMax(glm::vec3 &outMin, glm::vec3 &outMax) const#

Return the min and the max.

Parameters

outMin – Output: The min point will be stored here.
outMax – Output: The max point will be stored here.

inline void transform(const glm::mat4 &m, AxisAlignedBox &outAABB) const#

Get the local bounding box transformed by a provided matrix.

Parameters

m – An affine transformation matrix. Skew will be ignored.
outAABB – The transformed AABB will be stored here. Previous contents ignored.

inline glm::vec3 getSize() const#

Get the size (width, height, depth) of the AABB.

Returns: The size of the AABB.

inline glm::vec3 getHalfExtent() const#

Get the half-size (half-width, half-height, half-depth) of the AABB.

Returns: A vector whose coordinates are each half the size of the coresponding axis.

inline glm::vec3 topLeftFar() const#

Get the (-x +y +z) corner of the box.

Returns: A vector containing (min x, max y, max z)

inline glm::vec3 topCenterFar() const#

Get the center of the (+y +z) edge of the box.

Returns: A vector containing (center x, max y, max z)

inline glm::vec3 topRightFar() const#

Get the +x +y +z corner of the box.

Returns: A vector containing (max x, max y, max z)

inline glm::vec3 topLeftNear() const#

Get the -x +y -z corner of the box.

Returns: A vector containing (min x, max y, min z)

inline glm::vec3 topCenterNear() const#

Get the center of the edge with ( +y , -z).

Returns: A vector containing (center of x, max y, min z)

inline glm::vec3 topRightNear() const#

Get the +x +y -z corner of the box.

Returns: A vector containing (max x, max y, min z)

inline glm::vec3 center() const#

Get the center the box.

Returns: A vector containing (center x, center y, center z)

inline glm::vec3 centerLeftNear() const#

Get the center of the (-x -z) edge of the box.

Returns: A vector containing (min x, center y, min z)

inline glm::vec3 centerNear() const#

Get the center of the (-z) face of the box.

Returns: A vector containing (center x, center y, min z)

inline glm::vec3 centerRightNear() const#

Get the center of the (+x -z) edge of the box.

Returns: A vector containing (max x, center y, min z)

inline glm::vec3 centerLeftFar() const#

Get the center of the (-x +z) edge of the box.

Returns: A vector containing (min x, center y, max z)

inline glm::vec3 centerFar() const#

Get the center of the (+z) face of the box.

Returns: A vector containing (center x, center y, max z)

inline glm::vec3 centerRightFar() const#

Get the center of the (+x +z) edge of the box.

Returns: A vector containing (max x, center y, max z)

inline glm::vec3 bottomLeftNear() const#

Get the (-x -y -z) corner of the box.

Returns: A vector containing (min x, min y, min z)

inline glm::vec3 bottomCenterNear() const#

Get the center of the (-x -z) edge of the box.

Returns: A vector containing (center x, min y, min z)

inline glm::vec3 bottomRightNear() const#

Get the (+x -y -z) corner of the box.

Returns: A vector containing (max x, min y, min z)

inline glm::vec3 bottomLeftFar() const#

Get the (-x -y +z) corner of the box.

Returns: A vector containing (min x, min y, max z)

inline glm::vec3 bottomCenterFar() const#

Get the center of the (-y +z) edge of the box.

Returns: A vector containing (center x, min y, max z)

inline glm::vec3 bottomRightFar() const#

Get the (+x -y +z) corner of the box.

Returns: A vector containing (max x, min y, max z)

inline void mergeBox(const AxisAlignedBox &rhs)#

Set this AABB as the minimum AABB that contains itself and the AABB provided.

Parameters: rhs – The AABB to merge with.

inline bool operator==(const AxisAlignedBox &rhs) const#

Equality operator. AABBS are equal when center and size the same (equivalently all vertices coincide)

Parameters: rhs – The right hand side.
Returns: True if the AABBs completely coincide, otherwise false

inline bool operator!=(const AxisAlignedBox &rhs) const#

Inequality operator. AABBS are equal when either center or size are not the same (equivalently at least one vertex does not)

Parameters: rhs – The right hand side.
Returns: True if the AABBs completely coincide, otherwise false

AxisAlignedBoxMinMax#

Defined in AxisAlignedBox.h

Class Documentation#

class AxisAlignedBoxMinMax#

An AABB with a min-max representation. A newly constructed AxisAlignedBoxMinMax is always invalid (min>max), but in such a way that adding any point to it will make it valid.

Public Functions

inline AxisAlignedBoxMinMax()#

Constructor. The created AxisAlignedBoxMinMax has the min set at the highest-valued float number, and the max set at the lowest-valued float number, so but will immediately become valid when the first value is added.

Parameters: copyFrom – An AxisAlignedBox to convert from.

inline explicit AxisAlignedBoxMinMax(const AxisAlignedBox &copyFrom)#

Conversion from AxisAlignedBox.

Parameters: copyFrom – An AxisAlignedBox to convert from.

inline void setMin(const glm::vec3 &min)#

Set the minimum corner.

Parameters: min – The minimum corner

inline void setMax(const glm::vec3 &max)#

Set the maximum corner.

Parameters: max – The maximum corner

inline const glm::vec3 &getMin() const#

Get the minimum corner.

Returns: The minumum corner

inline const glm::vec3 &getMax() const#

Get the maximum corner.

Returns: The maximum corner

inline void add(const glm::vec3 &point)#

Ensure a point is contained in the AABB. If already in the AABB, do nothing. If not in the AABB, expand the AABB to exactly contain it.

Parameters: point – The point to add
Returns: The new point.

CommandLineParser#

Defined in CommandLine.h

Nested Relationships#

Nested Types#

Class Documentation#

class CommandLineParser#

This class parses, abstracts, stores and handles command line options passed on application launch.

Public Functions

inline CommandLineParser()#: Constructor.

inline CommandLineParser(int argc, char **argv)#

Constructor from C++ main arguments.

Parameters

argc – The number of arguments to parse
argv – A list of argc arguments to parse

inline const ParsedCommandLine &getParsedCommandLine() const#

Get a ParsedCommandLine option to inspect and use the command line arguments.

Returns: The processed command line object.

inline void set(const wchar_t *cmdLine)#

Set the command line to a new std::string (wide).

Parameters: cmdLine – The new (wide) std::string to set the command line to

inline void set(int argc, char **argv)#

Set the command line to a new list of arguments.

Parameters

argc – The number of arguments
argv – The list of arguments

inline void set(const char *cmdLine)#

Set the command line from a new std::string.

Parameters: cmdLine – The new std::string to set the command line to

inline void set(const CommandLineParser &cmdLine)#

Set the command line from another command line.

Parameters: cmdLine – Copy the data from another command line

inline void prefix(const wchar_t *cmdLine)#

Prepend data to the command line.

Parameters: cmdLine – A std::string containing the data to prepend to this command line

inline void prefix(int argc, char **argv)#

Prepend a new list of arguments to the command line.

Parameters

argc – The number of arguments
argv – The list of arguments

inline void prefix(const char *cmdLine)#

Prepend data from a std::string to the command line.

Parameters: cmdLine – The std::string whose data to prepend to the command line

inline void prefix(const CommandLineParser &cmdLine)#

Prepend the data from another command line.

Parameters: cmdLine – The command line from which to prepend the data

inline void append(const wchar_t *cmdLine)#

Append data to the command line.

Parameters: cmdLine – A std::string containing the data to append to this command line

inline void append(int argc, char **argv)#

Append a new list of arguments to the command line.

Parameters

argc – The number of arguments
argv – The list of arguments

inline void append(const char *cmdLine)#

Append data from a std::string to the command line.

Parameters: cmdLine – The std::string whose data to append to the command line

inline void append(const CommandLineParser &cmdLine)#

Append data from from another command line.

Parameters: cmdLine – The command line from which to append the data

Protected Functions

inline void parseCmdLine(const char *const cmdLine)#

Parse an entire std::string for command line data.

Parameters: cmdLine – The std::string containing the command line data

inline void parseArgV(char *arg)#

Parse a single argument as passed by the C/C++ style argc/argv command line format.

Parameters: arg – A single element of the “argv” array of char*

class ParsedCommandLine#

This class provides access to the command line arguments of a CommandLineParser. Its lifecycle is tied to the commandLineParser.

Public Types

typedef std::vector<Option> Options#: List of all options passed.

Public Functions

ParsedCommandLine() = default#: Default constructor for a command line parser.

inline ParsedCommandLine(int argc, char **argv)#

Constructor for a command line parser.

Parameters

argc – The number of arguments to parse
argv – A list of argc arguments to parse

inline const Options &getOptionsList() const#

Get all command line options as a list of name/value pairs (c-strings)

Returns: The command line options

inline bool hasOption(const char *name) const#

Query if a specific argument name exists (regardless of the presence of a value or not). For example, if the command line was “myapp.exe -fps”, the query hasOption(“fps”) will return true.

Parameters: name – The argument name to test
Returns: True if the argument name was passed through the command line , otherwise false.

inline bool getStringOption(const char *name, std::string &outValue) const#

Get an argument as a std::string value. Returns false and leaves the value unchanged if the value is not present, allowing very easy use of default arguments.

Parameters

name – The command line argument (e.g. “-captureFrames”)
outValue – The value passed with the argument (verbatim). If the name was not present, it remains unchanged

Returns

True if the argument “name” was present, false otherwise

inline bool getStringOptionList(const char *name, std::vector<std::string> &outValues) const#

Get an argument assuming it is a comma-separated list of string values. Returns false and leaves the value unchanged if the value is not present, allowing easy use of default arguments. Otherwise, tokenizes and adds the values to the provided list of strings.

Parameters

name – The command line argument (e.g. “-captureFrames”)
outValues – A std::vector of strings where all values will be appended/

Returns

True if the argument name was present, false otherwise

inline bool getFloatOption(const char *name, float &outValue) const#

Get an argument’s value as a float value. Returns false and leaves the value unchanged if the value is not present, allowing very easy use of default arguments.

Parameters

name – The command line argument (e.g. “-captureFrames”)
outValue – The value passed with the argument interpreted as a float. If the name was not present, or no value was passed with the name,it remains unchanged. If it was not representing a float, it silently returns zero (0.0).

Returns

True if the argument “name” was present, false otherwise

inline bool getIntOption(const char *name, int32_t &outValue) const#

Get an argument’s value as an integer value. Returns false and leaves the value unchanged if the value is not present, allowing very easy use of default arguments.

Parameters

name – The command line argument (e.g. “-captureFrames”)
outValue – The value passed with the argument interpreted as an integer. If the name was not present, or no value was passed with the name, it remains unchanged. If it was not representing a float, it silently returns zero (0).

Returns

True if the argument “name” was present, false otherwise

inline bool getBoolOptionSetTrueIfPresent(const char *name, bool &outValue) const#

If a specific argument was present, set outValue to True.

Parameters

name – The command line argument (e.g. “-captureFrames”)
outValue – True if the argument “name” was present, otherwise unchanged

Returns

True if the argument “name” was present, false otherwise

inline bool getBoolOptionSetFalseIfPresent(const char *name, bool &outValue) const#

If a specific argument was present, set outValue to False.

Parameters

name – The command line argument (e.g. “-captureFrames”)
outValue – False if the argument “name” was present, otherwise unchanged

Returns

True if the argument “name” was present, false otherwise

struct Option#

A c-style std::string name-value pair that represents command line argument (arg: name, val: value)

Public Functions

inline bool operator==(const Option &rhs) const#

Equality.

Parameters: rhs – Right hand side of the operator
Returns: True if left and right side are equal, otherwise false

inline bool operator==(const char *rhs) const#

Equality to c-string.

Parameters: rhs – Right hand side of the operator
Returns: True if left and right side are equal, otherwise false

Public Members

const char *arg#: Argument name (i.e. -Width)

const char *val#: Argument value (i.e. 640)

CommandLineParser::ParsedCommandLine#

Defined in CommandLine.h

Nested Relationships#

This class is a nested type of CommandLineParser.

Nested Types#

ParsedCommandLine::Option

Class Documentation#

class ParsedCommandLine

This class provides access to the command line arguments of a CommandLineParser. Its lifecycle is tied to the commandLineParser.

Public Types

typedef std::vector<Option> Options: List of all options passed.

Public Functions

ParsedCommandLine() = default: Default constructor for a command line parser.

inline ParsedCommandLine(int argc, char **argv)

Constructor for a command line parser.

Parameters

argc – The number of arguments to parse
argv – A list of argc arguments to parse

inline const Options &getOptionsList() const

Get all command line options as a list of name/value pairs (c-strings)

Returns: The command line options

inline bool hasOption(const char *name) const

Query if a specific argument name exists (regardless of the presence of a value or not). For example, if the command line was “myapp.exe -fps”, the query hasOption(“fps”) will return true.

Parameters: name – The argument name to test
Returns: True if the argument name was passed through the command line , otherwise false.

inline bool getStringOption(const char *name, std::string &outValue) const

Get an argument as a std::string value. Returns false and leaves the value unchanged if the value is not present, allowing very easy use of default arguments.

Parameters

name – The command line argument (e.g. “-captureFrames”)
outValue – The value passed with the argument (verbatim). If the name was not present, it remains unchanged

Returns

True if the argument “name” was present, false otherwise

inline bool getStringOptionList(const char *name, std::vector<std::string> &outValues) const

Parameters

name – The command line argument (e.g. “-captureFrames”)
outValues – A std::vector of strings where all values will be appended/

Returns

True if the argument name was present, false otherwise

inline bool getFloatOption(const char *name, float &outValue) const

Get an argument’s value as a float value. Returns false and leaves the value unchanged if the value is not present, allowing very easy use of default arguments.

Parameters

name – The command line argument (e.g. “-captureFrames”)
outValue – The value passed with the argument interpreted as a float. If the name was not present, or no value was passed with the name,it remains unchanged. If it was not representing a float, it silently returns zero (0.0).

Returns

True if the argument “name” was present, false otherwise

inline bool getIntOption(const char *name, int32_t &outValue) const

Get an argument’s value as an integer value. Returns false and leaves the value unchanged if the value is not present, allowing very easy use of default arguments.

Parameters

name – The command line argument (e.g. “-captureFrames”)
outValue – The value passed with the argument interpreted as an integer. If the name was not present, or no value was passed with the name, it remains unchanged. If it was not representing a float, it silently returns zero (0).

Returns

True if the argument “name” was present, false otherwise

inline bool getBoolOptionSetTrueIfPresent(const char *name, bool &outValue) const

If a specific argument was present, set outValue to True.

Parameters

name – The command line argument (e.g. “-captureFrames”)
outValue – True if the argument “name” was present, otherwise unchanged

Returns

True if the argument “name” was present, false otherwise

inline bool getBoolOptionSetFalseIfPresent(const char *name, bool &outValue) const

If a specific argument was present, set outValue to False.

Parameters

name – The command line argument (e.g. “-captureFrames”)
outValue – False if the argument “name” was present, otherwise unchanged

Returns

True if the argument “name” was present, false otherwise

struct Option

A c-style std::string name-value pair that represents command line argument (arg: name, val: value)

Public Functions

inline bool operator==(const Option &rhs) const

Equality.

Parameters: rhs – Right hand side of the operator
Returns: True if left and right side are equal, otherwise false

inline bool operator==(const char *rhs) const

Equality to c-string.

Parameters: rhs – Right hand side of the operator
Returns: True if left and right side are equal, otherwise false

Public Members

const char *arg: Argument name (i.e. -Width)

const char *val: Argument value (i.e. 640)

MakeFourCC#

Defined in FileDefinesDDS.h

Class Documentation#

template<char C1Name, char C2Name, char C3Name, char C4Name> class MakeFourCC#

Make FourCC template.

Public Static Attributes

static const uint64_t FourCC = ((static_cast<uint32_t>(C1Name)) + (static_cast<uint32_t>(C2Name) << 8) + (static_cast<uint32_t>(C3Name) << 16) + (static_cast<uint32_t>(C4Name) << 24))#: The compile time generated FourCC value constructed using the template parameters.

UnicodeConversionError#

Defined in UnicodeConverter.h

Inheritance Relationships#

Base Type#

public std::runtime_error

Class Documentation#

class UnicodeConversionError : public std::runtime_error#

A simple std::runtime_error wrapper for throwing exceptions when undertaking unicode conversions.

Public Functions

inline UnicodeConversionError(std::string message)#

Constructor.

Parameters: message – The error message to log.

UnicodeConverter#

Defined in UnicodeConverter.h

Class Documentation#

class UnicodeConverter#

Use as a namespace (static functions only). Contains functionality to work with Unicode strings: Conversions between ASCII/UTF8/UTF16/UTF32, parse/count characters in Multibyte systems, validity queries.

Public Static Functions

static uint32_t unicodeCount(const utf8 *unicodeString)#

Count the number of characters in a unicode UTF-8 std::string.

Parameters: unicodeString – A UTF-8 std::string.
Returns: The number of characters unicodeString represents.

static uint32_t unicodeCount(const utf16 *unicodeString)#

Count the number of characters in a unicode UTF-16 std::string.

Parameters: unicodeString – A UTF-16 std::string.
Returns: The number of characters unicodeString represents.

static uint32_t unicodeCount(const utf32 *unicodeString)#

Count the number of characters in a unicode UTF-32 std::string.

Parameters: unicodeString – A UTF-32 std::string.
Returns: The number of characters unicodeString represents.

static void convertAsciiToUnicode(const char *asciiString, std::vector<utf8> &unicodeString)#

Convert an ASCII std::string to a UTF8 std::string.

Parameters

asciiString – An ASCII std::string
unicodeString – The resulting UTF-8 std::string stored as an std::vector<utf8>

static inline void convertAsciiToUnicode(const char *asciiString, std::vector<utf16> &unicodeString)#

Convert an ASCII std::string to a UTF-16 std::string.

Parameters

asciiString – An ASCII std::string
unicodeString – The resulting UTF-16 std::string stored as an std::vector<utf16>

static inline void convertAsciiToUnicode(const char *asciiString, std::vector<utf32> &utf32StringOut)#

Convert an ASCII std::string to a UTF-32 std::string.

Parameters

asciiString – An ASCII std::string
utf32StringOut – The resulting UTF-32 std::string stored as an std::vector<utf32>

static void convertUTF8ToUTF16(const utf8 *utf8String, std::vector<utf16> &utf16StringOut)#

Convert a UTF-8 std::string to a UTF-16 std::string.

Parameters

utf8String – A UTF-8 std::string
utf16StringOut – The resulting UTF-16 std::string stored as an std::vector<utf16>

static void convertUTF8ToUTF32(const utf8 *utf8String, std::vector<utf32> &utf32StringOut)#

Convert a UTF-8 std::string to a UTF-32 std::string.

Parameters

utf8String – A UTF-8 std::string
utf32StringOut – The resulting UTF-32 std::string stored as an std::vector<utf32>

Returns

True for Success or false for error.

static void convertUTF16ToUTF8(const utf16 *utf16String, std::vector<utf8> &utf8StringOut)#

Convert a UTF-16 std::string to a UTF-8 std::string.

Parameters

utf16String – A UTF-16 std::string
utf8StringOut – The resulting UTF-8 std::string stored as an std::vector<utf8>

Returns

True for Success or false for error.

static void convertUTF16ToUTF32(const utf16 *utf16String, std::vector<utf32> &utf32StringOut)#

Convert a UTF-16 std::string to a UTF-32 std::string.

Parameters

utf16String – A UTF-16 std::string
utf32StringOut – The resulting UTF-32 std::string stored as an std::vector<utf32>

Returns

True for Success or false for error.

static void convertUTF32ToUTF8(const utf32 *utf32String, std::vector<utf8> &utf8StringOut)#

Convert a UTF-32 std::string to a UTF-8 std::string.

Parameters

utf32String – A UTF-32 std::string
utf8StringOut – The resulting UTF-8 std::string stored as an std::vector<utf8>

static void convertUTF32ToUTF16(const utf32 *utf32String, std::vector<utf16> &utf16StringOut)#

Convert a UTF-32 std::string to a UTF-16 std::string.

Parameters

utf32String – A UTF-32 std::string
utf16StringOut – The resulting UTF-16 std::string stored as an std::vector<utf16>

static bool isValidUnicode(const utf8 *unicodeString)#

Check if a std::string contains only valid UTF-8 characters.

Parameters: unicodeString – A UTF-8 std::string
Returns: True if the std::string does not contains any characters that are not valid UTF-8, false otherwise

static bool isValidUnicode(const utf16 *unicodeString)#

Check if a std::string contains only valid UTF-16 characters.

Parameters: unicodeString – A UTF-16 std::string
Returns: True if the std::string does not contains any characters that are not valid UTF-16, false otherwise

static bool isValidUnicode(const utf32 *unicodeString)#

Check if a std::string contains only valid UTF-32 characters.

Parameters: unicodeString – A UTF-32 std::string
Returns: True if the std::string does not contains any characters that are not valid UTF-32, false otherwise

static bool isAsciiChar(const char *asciiString)#

Check if a std::string only contains valid Ascii-7 characters.

Parameters: asciiString – A c-style std::string
Returns: True if the std::string only contains values in the range 0..127 (low ascii), False otherwise

static bool isAsciiChar(char asciiChar)#

Check if a character is valid Ascii-7.

Parameters: asciiChar – A character
Returns: True if the std::string only contains values in the range 0..127 (low ascii), False otherwise

AndroidAssetStream#

Defined in AndroidAssetStream.h

Inheritance Relationships#

Base Type#

public pvr::Stream (Stream)

Class Documentation#

class AndroidAssetStream : public pvr::Stream #

A Stream implementation that is used to access resources built in an Android package (apk).

This Stream abstraction allows the user to easily access the Resources embedded in an Android .apk package. This is the default way resources are packed in the Android version of the PowerVR Examples.

Public Functions

inline AndroidAssetStream(AAssetManager *assetManager, const std::string &filename)#

Constructor from Android NDK Asset manager and a filename.

Parameters

assetManager – The Android Asset manager object the app will use
filename – The file (asset) to open

inline ~AndroidAssetStream()#: Destructor. Releases this object.

virtual void _read(size_t size, size_t count, void *const outData, size_t &outElementsRead) const override#

virtual void _write(size_t size, size_t count, const void *data, size_t &dataWritten) override#

virtual void _seek(long offset, SeekOrigin origin) const override#

Override this function to implement a random access stream. After successful call, subsequent operation will happen in the specified point.

Parameters

offset – The offset to seec from “origin”
origin – Beginning of stream, End of stream or Current position

virtual uint64_t _getPosition() const override#

virtual uint64_t _getSize() const override#

void open() const#

void close()#

inline AAssetManager *getAndroidAssetManager()#

Retrieves the current android asset manager.

Returns: The current android asset manager

BufferStream#

Defined in BufferStream.h

Inheritance Relationships#

Base Type#

public pvr::Stream (Stream)

Derived Type#

public pvr::WindowsResourceStream (WindowsResourceStream)

Class Documentation#

class BufferStream : public pvr::Stream #

This class is used to access a block of memory as a Stream.

Subclassed by pvr::WindowsResourceStream

Public Functions

inline BufferStream(const std::string &fileName, void *buffer, size_t bufferSize)#

Create a BufferStream from a writable buffer and associate it with an (arbitrary) filename.

Parameters

fileName – The created stream will have this filename. Arbitrary - not used to access anything.
buffer – Pointer to the memory that this stream will be used to access. Must be kept live from the point the stream is opened until the stream is closed
bufferSize – The size, in bytes, of the buffer

inline BufferStream(const std::string &fileName, const void *buffer, size_t bufferSize)#

Create a BufferStream from a read only buffer and associate it with an (arbitrary) filename. Read only.

Parameters

fileName – The created stream will have this filename. Arbitrary - not used to access anything.
buffer – Pointer to the memory that this stream will be used to access. Must be kept live from the point the stream is opened until the stream is closed
bufferSize – The size, in bytes, of the buffer

Protected Functions

inline explicit BufferStream(const std::string &resourceName)#

Used by resource streams to .

Parameters: resourceName – A resource identifier (conceptually, a “Filename” without a file)

Protected Attributes

const void *_originalData#: The original pointer of the memory this stream accesses.

mutable const void *_currentPointer#: Pointer to the current position in the stream.

mutable size_t _bufferSize#: The size of this stream.

mutable size_t _bufferPosition#: Offset of the current position in the stream.

DisplayAttributes#

Defined in Types.h

Class Documentation#

class DisplayAttributes#

Contains display configuration information (width, height, position, title, bpp etc.).

Public Types

enum [anonymous]#

Unnamed enum for constants.

Values:

enumerator PosDefault#: Sentinel value for Default position.

Public Functions

inline DisplayAttributes()#

inline bool isDisplayPortrait() const#

Checks if the screen is rotated.

Returns: True if the screen is Portrait, otherwise (if landscape) false .

inline bool isFullScreen() const#

Checks if full screen.

Returns: True if full screen, otherwise false.

Public Members

std::string windowTitle#: Title of the application window.

uint32_t width#: Width of the rendering area (default 1280)

uint32_t height#: Height of the rendering (default 800)

uint32_t x#: Horizontal offset of the bottom-left area (default 0)

uint32_t y#: Vertical offset of the bottom-left area (default 0)

uint32_t depthBPP#: Number of bits per pixel in the depth buffer (default 16)

uint32_t stencilBPP#: Number of bits per pixel of the stencil buffer (default 0: no stencil)

uint32_t redBits#: Number of bits of the red channel of the framebuffer (default 8)

uint32_t greenBits#: Number of bits of the green channel of the framebuffer (default 8)

uint32_t blueBits#: Number of bits of the blue channel of the framebuffer (default 8)

uint32_t alphaBits#: Number of bits of the alpha channel of the framebuffer (default 8)

uint32_t aaSamples#: Number of (antialiasing) samples of the framebuffer (default 0)

uint32_t configID#: Deprecated: EGL config id.

VsyncMode vsyncMode#: Type of syncrhonization mode (default On: Vsync)

int32_t contextPriority#: Context priority, if supported (default High)

int32_t swapLength#: Swapchain length, AKA number of framebuffer images (default 0: Minimum required for technique)

bool forceColorBPP#: Require that the color channels of the framebuffer are exactly as requested in redBits/blueBits/greenBits/alphaBits (default false)

bool fullscreen#: If true, application will be fullscreen (if supported). If false, application will be windowed (if supported). (default false)

bool frameBufferSrgb#: If true and supported, attempt to use an sRGB framebuffer format (default false)

FileEOFError#

Defined in Stream.h

Inheritance Relationships#

Base Type#

public pvr::PvrError (PvrError)

Class Documentation#

class FileEOFError : public pvr::PvrError #

A simple std::runtime_error wrapper for throwing exceptions when attempting to read past the End Of File.

Public Functions

inline explicit FileEOFError(const Stream &stream)#

Constructor.

Parameters: stream – The stream being used.

inline FileEOFError(const Stream &stream, std::string message)#

Constructor.

Parameters

stream – The stream being used.
message – A message to log alongside the exception message.

inline explicit FileEOFError(std::string filenameOrMessage)#

Constructor.

Parameters: filenameOrMessage – A message to log alongside the exception message.

inline FileEOFError(std::string filename, std::string message)#

Constructor.

Parameters

filename – The filenae of the file being used.
message – A message to log alongside the exception message.

FileIOError#

Defined in Stream.h

Inheritance Relationships#

Base Type#

public pvr::PvrError (PvrError)

Class Documentation#

class FileIOError : public pvr::PvrError #

A simple std::runtime_error wrapper for throwing exceptions when undertaking File IO operations.

Public Functions

inline explicit FileIOError(const Stream &stream)#

Constructor.

Parameters: stream – The stream being used.

inline FileIOError(const Stream &stream, std::string message)#

Constructor.

Parameters

stream – The stream being used.
message – A message to log alongside the exception message.

inline explicit FileIOError(std::string filenameOrMessage)#

Constructor.

Parameters: filenameOrMessage – A message to log alongside the exception message.

inline FileIOError(std::string filename, std::string message)#

Constructor.

Parameters

filename – The filenae of the file being used.
message – A message to log alongside the exception message.

FileNotFoundError#

Defined in Stream.h

Inheritance Relationships#

Base Type#

public std::runtime_error

Class Documentation#

class FileNotFoundError : public std::runtime_error#

A simple std::runtime_error wrapper for throwing exceptions when file not found errors occur.

Public Functions

inline explicit FileNotFoundError(const Stream &stream)#

Constructor.

Parameters: stream – The stream being used.

inline FileNotFoundError(const Stream &stream, std::string message)#

Constructor.

Parameters

stream – The stream being used.
message – A message to log alongside the exception message.

inline explicit FileNotFoundError(std::string filenameOrMessage)#

Constructor.

Parameters: filenameOrMessage – A message to log alongside the exception message.

inline FileNotFoundError(std::string filename, std::string message)#

Constructor.

Parameters

filename – The filenae of the file being used.
message – A message to log alongside the exception message.

FilePath#

Defined in FilePath.h

Inheritance Relationships#

Base Type#

public std::string

Class Documentation#

class FilePath : public std::string#

Filepath represents a Path + Filename + Extension.

Public Functions

inline FilePath()#: Creates an empty Filepath object.

inline FilePath(const std::string &str)#

Creates an Filepath object from a filename.

Parameters: str – Creates a filepath object of this path.

inline std::string getFileExtension() const#

Get a std::string containing the Extension of the filepath.

Returns: The file extension of the path

inline std::string getDirectory() const#

Get a std::string containing the Directory of the filepath.

Returns: The directory part of the path

inline std::string getFilename() const#

Get a std::string containing the Filename+Extension of the filepath.

Returns: The filename part of the path (including the extension)

inline std::string getFilenameNoExtension() const#

Get a std::string containing the Filename (without extension) of the filepath.

Returns: The filename part of the path (without the extension)

Public Static Functions

static inline char getDirectorySeparator()#

Get the directory separator used by the current platform.

Returns: The platform specific directory separator (usually “\” or “/”

FileStream#

Defined in FileStream.h

Inheritance Relationships#

Base Type#

public pvr::Stream (Stream)

Class Documentation#

class FileStream : public pvr::Stream #

A FileStream is a Stream that is used to access a File in the filesystem of the platform.

Public Functions

inline FileStream(const std::string &filePath, const std::string &flags, bool errorOnFileNotFound = true)#

Create a new filestream of a specified file.

Possible flags: ‘r’:read,’w’:truncate/write, ‘a’:append/write, r+: read/write, w+:truncate/read/write, a+:append/read/write

Parameters

filePath – The path of the file. Can be in any format the operating system understands (absolute, relative etc.)
flags – fopen-style flags.
errorOnFileNotFound – OPTIONAL. Set this to false to avoid an exception when the file is not found. If set to false, always check isReadable() or isWritable before using. Otherwise, a returned stream will always be opened with the correct flags.

inline ~FileStream()#

Public Static Functions

static inline std::unique_ptr<Stream> createFileStream(const char *filename, const char *flags, bool errorOnFileNotFound = true)#

Create a new file stream from a filename.

Flags correspond the C++ standard for fopen r: Read (read from beginning, preserve contents, fail if not exist) w: Write (write from beginning, destroy contents, create if not exist) a: Append (write to end only (regardles of file pointer position), preserve contents, create if not exist) r+: Read+ (read/write from start, preserve contents, fail if not exist) w+: Write+ (read/write from start, destroy contents, create if not exist) a+: Append+ (read/write from end (write only happens to end), preserve contents, create if not exist) b: Additional flag: Do no special handling of line break / form feed characters

Parameters

filename – The filename to create a stream for
flags – The C++ open flags for the file (“r”, “w”, “a”, “r+”, “w+”, “a+” and optionally “b”), see C++ standard.
errorOnFileNotFound – OPTIONAL. Set this to false to avoid an error when the file is not found.

Returns

Return a valid file stream, else Return null if it fails

static inline std::unique_ptr<Stream> createFileStream(const std::string &filename, const char *flags, bool errorOnFileNotFound = true)#

Create a new file stream from a filename.

Parameters

filename – The filename to create a stream for
flags – The C++ open flags for the file (“r”, “w”, “a”, “r+”, “w+”, “a+” and optionally “b”), see C++ standard.
errorOnFileNotFound – OPTIONAL. Set this to false to avoid an error when the file is not found.

Returns

Return a valid file stream, else Return null if it fails

Protected Attributes

mutable FILE *_file#: The underlying C FILE object.

std::string _flags#: The C flags used when opening the file.

bool _errorOnFileNotFound#: True to error when files are not found otherwise False to avoid an exception when the file is not found.

FreeValueView#

Defined in FreeValue.h

Inheritance Relationships#

Derived Types#

public pvr::FreeValue (FreeValue)
public pvr::TypedMem (TypedMem)

Class Documentation#

class FreeValueView#

Represents a runtime-known number of elements of a runtime-known type, with functions to handle and convert them. Very commonly used to dynamically represent data that will eventually need to be used by the GPU, such as uniforms, vectors and matrices. Does not contain methods to actually be populated, as this should be done through subclasses.

Subclassed by pvr::FreeValue, pvr::TypedMem

Public Functions

inline FreeValueView()#: Constructor. Constructs and empty value.

inline GpuDatatypes dataType() const#

Get the datatype of the value contained. “None” means unformatted data, in which case ArraySize represents the number of bytes.

Returns: The datatype of this value.

inline bool isDataCompatible(const FreeValueView &rhs) const#

Check if two free values only differ in value (i.e. they are of the same type and elements).

Parameters: rhs – The value against which to compare
Returns: True if datatype and arrayelements are the same between this and rhs, otherwise false.

inline uint64_t dataSize() const#

Size of the data contained.

Returns: The size of data contained.

inline uint32_t arrayElements() const#

Size of the data contained. For unformatted data (Datatype==None) this is the total bytes contained.

Returns: The size of data contained.

inline void *raw(uint32_t arrayIndex)#

Get a pointer to the raw data value at the specified index.

Parameters: arrayIndex – The array index of which to take the pointer
Returns: Pointer to the raw value.

inline const void *raw(uint32_t arrayIndex) const#

Get a pointer to the raw data value at the specified index.

Parameters: arrayIndex – The array index of which to take the pointer
Returns: Pointer to the raw value.

inline void *raw()#

Get a pointer to the raw data value.

Returns: Pointer to the raw value.

inline const void *raw() const#

Get a pointer to the raw data value.

Returns: Pointer to the raw value.

template<typename Type_> inline Type_ *rawAs()#

Get a pointer to the raw data value as a specified type.

Template Parameters: Type_ – The type as which the data are interpreted
Returns: Pointer to the raw value.

template<typename Type_> inline const Type_ *rawAs() const#

Get a pointer to the data value as a specified type.

Template Parameters: Type_ – The type as which the data are interpreted
Returns: Pointer to the raw value.

inline float *rawFloats()#

Get a pointer to the data value as (an array of) 32 bit floating point numbers.

Returns: Pointer to the data as float*.

inline const float *rawFloats() const#

Get a pointer to the data value as (an array of) 32 bit floating point numbers.

Returns: Pointer to the data as float*.

inline int32_t *rawInts()#

Get a pointer to the data value as (an array of) 32 bit integers.

Returns: Pointer to the data as int*.

inline const int32_t *rawInts() const#

Get a pointer to the data value as (an array of) 32 bit integers.

Returns: Pointer to the data as int*.

inline unsigned char *rawChars()#

Get a pointer to the data value as (an array of) unsigned chars.

Returns: Pointer to the data as unsigned char*.

inline const unsigned char *rawChars() const#

Get a pointer to the data value as (an array of) unsigned chars.

Returns: Pointer to the data as unsigned char*.

template<typename Type_> inline Type_ &interpretValueAs(uint32_t entryIndex = 0)#

Interpret the value as (an array of) a specified type and retrieve the item at a specific position.

Template Parameters: Type_ – The type as which the value is interpreted
Parameters: entryIndex – If an array, which item to retrieve (default 0)
Returns: A value of type Type_ at index entryIndex

template<typename Type_> inline const Type_ &interpretValueAs(uint32_t entryIndex = 0) const#

Interpret the value as (an array of) a specified type and retrieve the item at a specific position.

Template Parameters: Type_ – The type as which the value is interpreted
Parameters: entryIndex – If an array, which item to retrieve (default 0)
Returns: A value of type Type_ at index entryIndex

Protected Attributes

unsigned char *value_#: Dynamically allocated, data is carried here.

uint32_t arrayElements_#: Number of array elements.

GpuDatatypes dataType_#: Semantic data type.

FPSCamera#

Defined in FPSCamera.h

Class Documentation#

class FPSCamera#

A simple first person camera implementation.

Public Functions

inline FPSCamera()#: Constructor.

inline void moveZ(float z)#

Move camera on its local z axis.

Parameters: z – distance to move

inline void moveX(float x)#

Move camera on its local x axis.

Parameters: x – distance to move

inline void set(const glm::vec3 &camPos, float yaw, float pitch)#

Set camera new world position and orientation.

Parameters

camPos – Camera position
yaw – Camera yaw
pitch – Camera pitch

inline void setPosition(const glm::vec3 &camPos)#

Set camera new world position.

Parameters: camPos – Camera position

inline void setOrientation(float yaw, float pitch)#

Set camera new orientation.

Parameters

yaw – Camera yaw
pitch – Camera pitch

inline void yaw(float yaw)#

Set camera new yaw.

Parameters: yaw – Camera yaw

inline void reset(const glm::vec3 &pos, float yaw, float pitch)#

Reset camera position and orientation.

Parameters

pos – Camera position
yaw – Camera yaw
pitch – Camera pitch

inline void pitch(float pitch)#

Set camera orientation.

Parameters: pitch – Camera pitch

inline void orientate(float yaw, float pitch)#

Set camera orientation.

Parameters

yaw – Camera yaw
pitch – Camera pitch

inline const glm::vec3 &getPosition()#

Get camera position.

Returns: Camera position

inline glm::mat4 getViewMatrix() const#

Get camera view matrix.

Returns: Camera view matrix

GeneratePixelType1#

Defined in PixelFormat.h

Class Documentation#

template<char C1Name, uint8_t C1Bits> class GeneratePixelType1#

Use this template class to generate a 1 channel PixelID.

Use this template class to generate a 1 channel PixelID (64-bit identifier for a pixel format used throughout PVR Assets from the channel information. Simply define the template parameters for your class and get the ID member. EXAMPLE USE:

uint64_t myPixelID = GeneratePixelType1<'r',8&gt::ID

Param C1Name: The Name of the 1st channel (poss. values ‘r’,’a’,’l’,0)
Param C1Bits: The number of bits of the 1st channel

Public Static Attributes

static const uint64_t ID = (static_cast<uint64_t>(C1Name) + (static_cast<uint64_t>(0) << 8) + (static_cast<uint64_t>(0) << 16) + (static_cast<uint64_t>(0) << 24) + (static_cast<uint64_t>(C1Bits) << 32) + (static_cast<uint64_t>(0) << 40) + (static_cast<uint64_t>(0) << 48) + (static_cast<uint64_t>(0) << 56))#: A 64 bit integer uniquely representing this pixel type.

GeneratePixelType2#

Defined in PixelFormat.h

Class Documentation#

template<char C1Name, char C2Name, uint8_t C1Bits, uint8_t C2Bits> class GeneratePixelType2#

Use this template class to generate a 2 channel PixelID.

Use this template class to generate a 2 channel PixelID (64-bit identifier for a pixel format used throughout PVR Assets from the channel information. Simply define the template parameters for your class and get the ID member. EXAMPLE USE:

uint64_t myPixelID = GeneratePixelType2<'r','a',8,8&gt::ID

Param C1Name: The Name of the 1st channel (poss. values ‘r’,’g’,’a’,’l’,0)
Param C2Name: The Name of the 2nd channel (poss. values ‘r’,’g’,’a’,’l’,0)
Param C1Bits: The number of bits of the 1st channel
Param C2Bits: The number of bits of the 2nd channel

Public Static Attributes

static const uint64_t ID = (static_cast<uint64_t>(C1Name) + (static_cast<uint64_t>(C2Name) << 8) + (static_cast<uint64_t>(0) << 16) + (static_cast<uint64_t>(0) << 24) + (static_cast<uint64_t>(C1Bits) << 32) + (static_cast<uint64_t>(C2Bits) << 40) + (static_cast<uint64_t>(0) << 48) + (static_cast<uint64_t>(0) << 56))#: A 64 bit integer uniquely representing this pixel type.

GeneratePixelType3#

Defined in PixelFormat.h

Class Documentation#

template<char C1Name, char C2Name, char C3Name, uint8_t C1Bits, uint8_t C2Bits, uint8_t C3Bits> class GeneratePixelType3#

Use this template class to generate a 3 channel PixelID.

Use this template class to generate a 3 channel PixelID (64-bit identifier for a pixel format used throughout PVR Assets from the channel information. Simply define the template parameters for your class and get the ID member. EXAMPLE USE:

uint64_t myPixelID = GeneratePixelType3<'r','g','b',8,8,8&gt::ID

Param C1Name: The Name of the 1st channel (poss. values ‘r’,’g’,’b’,’a’,’l’,0)
Param C2Name: The Name of the 2nd channel (poss. values ‘r’,’g’,’b’,’a’,’l’,0)
Param C3Name: The Name of the 3rd channel (poss. values ‘r’,’g’,’b’,’a’,’l’,0)
Param C1Bits: The number of bits of the 1st channel
Param C2Bits: The number of bits of the 2nd channel
Param C3Bits: The number of bits of the 3rd channel

Public Static Attributes

static const uint64_t ID = (static_cast<uint64_t>(C1Name) + (static_cast<uint64_t>(C2Name) << 8) + (static_cast<uint64_t>(C3Name) << 16) + (static_cast<uint64_t>(0) << 24) + (static_cast<uint64_t>(C1Bits) << 32) + (static_cast<uint64_t>(C2Bits) << 40) + (static_cast<uint64_t>(C3Bits) << 48) + (static_cast<uint64_t>(0) << 56))#: A 64 bit integer uniquely representing this pixel type.

GeneratePixelType4#

Defined in PixelFormat.h

Class Documentation#

template<char C1Name, char C2Name, char C3Name, char C4Name, uint8_t C1Bits, uint8_t C2Bits, uint8_t C3Bits, uint8_t C4Bits> class GeneratePixelType4#

Use this template class to generate a 4 channel PixelID.

Use this template class to generate a 4 channel PixelID (64-bit identifier for a pixel format used throughout PVR Assets from the channel information. Simply define the template parameters for your class and get the ID member. EXAMPLE USE:

uint64_t myPixelID = GeneratePixelType4<'b','g','r','a',8,8,8,8&gt::ID;

Param C1Name: The Name of the 1st channel (poss. values ‘r’,’g’,’b’,’a’,’l’,0)
Param C2Name: The Name of the 2nd channel (poss. values ‘r’,’g’,’b’,’a’,’l’,0)
Param C3Name: The Name of the 3rd channel (poss. values ‘r’,’g’,’b’,’a’,’l’,0)
Param C4Name: The Name of the 4th channel (poss. values ‘r’,’g’,’b’,’a’,’l’,0)
Param C1Bits: The number of bits of the 1st channel
Param C2Bits: The number of bits of the 2nd channel
Param C3Bits: The number of bits of the 3rd channel
Param C4Bits: The number of bits of the 4th channel

Public Static Attributes

static const uint64_t ID = (static_cast<uint64_t>(C1Name) + (static_cast<uint64_t>(C2Name) << 8) + (static_cast<uint64_t>(C3Name) << 16) + (static_cast<uint64_t>(C4Name) << 24) + (static_cast<uint64_t>(C1Bits) << 32) + (static_cast<uint64_t>(C2Bits) << 40) + (static_cast<uint64_t>(C3Bits) << 48) + (static_cast<uint64_t>(C4Bits) << 56))#: A 64 bit integer uniquely representing this pixel type.

HashCompileTime#

Defined in CompileTimeHash.h

Class Documentation#

template<unsigned char... chars> class HashCompileTime#

Template specialization for unsigned char values.

Public Static Attributes

static const uint32_t value = hasher_helper<2166136261U, chars...>::value#: A hashed value.

IndexOutOfRange#

Defined in Errors.h

Inheritance Relationships#

Base Type#

public pvr::PvrError (PvrError)

Class Documentation#

class IndexOutOfRange : public pvr::PvrError #

A simple std::runtime_error wrapper for throwing exceptions when attempting to use index out of range.

Public Functions

inline IndexOutOfRange(std::string message)#

Constructor.

Parameters: message – A message to log.

inline IndexOutOfRange(std::string message, size_t index, size_t maxIndex)#

Constructor.

Parameters

message – A message to log.
index – The index which was out of range.
maxIndex – The maximum index supported.

inline IndexOutOfRange()#: Constructor.

InvalidArgumentError#

Defined in Errors.h

Inheritance Relationships#

Base Type#

public pvr::PvrError (PvrError)

Class Documentation#

class InvalidArgumentError : public pvr::PvrError #

A simple std::runtime_error wrapper for throwing exceptions when invalid arguments are provided.

Public Functions

inline InvalidArgumentError(std::string argument, std::string message)#

Constructor.

Parameters

argument – The invalid argument.
message – A message to log.

inline InvalidArgumentError(std::string argument)#

Constructor.

Parameters: argument – The invalid argument.

InvalidDataError#

Defined in Errors.h

Inheritance Relationships#

Base Type#

public pvr::PvrError (PvrError)

Class Documentation#

class InvalidDataError : public pvr::PvrError #

A simple std::runtime_error wrapper for throwing exceptions when invalid data is provided.

Public Functions

inline InvalidDataError(std::string message)#

Constructor.

Parameters: message – A message to log.

inline InvalidDataError()#: Constructor.

InvalidOperationError#

Defined in Errors.h

Inheritance Relationships#

Base Type#

public pvr::PvrError (PvrError)

Class Documentation#

class InvalidOperationError : public pvr::PvrError #

A simple std::runtime_error wrapper for throwing exceptions when invalid operations are attempted.

Public Functions

inline InvalidOperationError(std::string message)#

Constructor.

Parameters: message – A message to log.

inline InvalidOperationError()#: Constructor.

IAssetProvider#

Defined in IAssetProvider.h

Class Documentation#

class IAssetProvider#

The IAssetProvider interface marks a class that provides the getAssetStream function to load assets in a platform independent way.

Public Functions

virtual std::unique_ptr<Stream> getAssetStream(const std::string &filename, bool logErrorOnNotFound = true) const = 0#

Create a Stream from the provided filename. The actual source of the stream is abstracted (filesystem, resources etc.).

If the file is not found, this function will return a NULL function pointer, and log an error. In cases where file not found is to be expected (for example, testing for different files due to convention), set logErrorOnNotFound to false to avoid cluttering the Log.

Parameters

filename – The name of the asset. May contain a path or not. Platform-specific paths and built-in resources should be searched.
logErrorOnNotFound – OPTIONAL. Set this to false to avoid logging an error when the file is not found.

Returns

A pointer to a Stream. NULL if the asset is not found.

LockedQueue#

Defined in Threading.h

Class Documentation#

template<typename T> class LockedQueue#

A simple adapter for the BlockingConcurrentQueue that simplifies common use cases.

Public Types

typedef moodycamel::ProducerToken ProducerToken#: Producer token.

typedef moodycamel::ConsumerToken ConsumerToken#: Consumer token.

Public Functions

inline LockedQueue()#: Constructor.

inline ConsumerToken getConsumerToken()#

Get a consumer token for this queue.

Returns: A consumer token

inline ProducerToken getProducerToken()#

Get a producer token for this queue.

Returns: A producer token

inline void produce(const T &item)#

Produce: Enqueue an item in the queue.

Parameters: item – The item that will be enqueued. Will be copied into the queue.

inline void produce(ProducerToken &token, const T &item)#

Produce: Enqueue an item in the queue, using a producer token. Will generally be more efficient to use tokens.

Parameters

token – The ProducerToken. May be used to create “private” subqueues to avoid thread contention.
item – The item that will be enqueued. Will be copied into the queue.

template<typename iterator> inline void produceMultiple(iterator items, uint32_t numItems)#

Produce: Enqueue multiple items in the queue. Will be very efficient.

Parameters

items – A type that will act as an iterator. Typically a C-pointer
numItems – The number if items to enqueue from items

Template Parameters

iterator – Type Inferred: The type of the iterator items

template<typename iterator> inline void produceMultiple(ProducerToken &token, iterator items, uint32_t numItems)#

Produce: Enqueue multiple items in the queue. Will be very the most efficient way of enqueueing multiple items.

Parameters

items – A type that will act as an iterator. Typically a C-pointer
numItems – The number if items to enqueue from items
token – The ProducerToken. May be used to create “private” subqueues to avoid thread contention.

Template Parameters

iterator – Type Inferred: The type of the iterator items

inline bool tryUnblockAndReturnTrueIfUnblocked()#

inline bool consume(T &item)#

Blocking consume: Dequeue one item from the queue. If returns false, the queue was finishing.

Parameters: item – Output variable: The item that was dequeued.
Returns: True if an item was dequeued, otherwise false

inline bool consume(ConsumerToken &token, T &item)#

Blocking consume: Dequeue one item from the queue. If returns false, the queue was finishing.

Parameters

item – Output variable: The item that was dequeued.
token – A ConsumerToken. May be used to reduce thread contention.

Returns

True if an item was dequeued, otherwise false

template<typename iterator> inline size_t consumeMultiple(iterator firstItem, uint32_t maxItems)#

Blocking consume multiple: Dequeue multiple items from the queue. Will return at least one item, unless the queue was closing down. If returns 0 items, the queue was finishing.

Parameters

firstItem – Output iterator variable: The items will be dequeued using this iterator. Usually a C-pointer
maxItems – The maximum number of items that will be dequeued

Template Parameters

iterator – Type Inferred: The type of the iterator items

Returns

The number of items dequeued. Will only be 0 if the queue was finishing.

template<typename iterator> inline size_t consumeMultiple(ConsumerToken &token, iterator firstItem, uint32_t maxItems)#

Blocking consume multiple with token: Dequeue multiple items from the queue. Will return at least one item, unless the queue was closing down. If returns 0 items, the queue was finishing.

Parameters

firstItem – Output iterator variable: The items will be dequeued using this iterator. Usually a C-pointer
maxItems – The maximum number of items that will be dequeued
token – A ConsumerToken. May be used to reduce thread contention.

Template Parameters

iterator – Type Inferred: The type of the iterator items

Returns

The number of items dequeued. Will only be 0 if the queue was finishing.

inline void unblockOne()#: Release one consumer from the queue. Used to release waiting threads when shutting down.

inline void unblockMultiple(uint16_t numUnblock)#

Release multiple consumers from the queue. Used to release waiting threads when shutting down.

Parameters: numUnblock – The number of consumers to unblock

inline void reset()#: Only call on an empty, otherwise behaviour is undefined.

inline bool isEmpty()#

Check if the queue is (tentatively) empty - this is an approximation due to multithreading. (To get a precise number the queue should have be blocked for all access and until it was used.)

Returns: True if the thread is empty, otherwise false

inline size_t itemsRemainingApprox()#

Get the number of (tentative) items in the queue - this is an approximation due to multithreading. (To get a precise number the queue should have be blocked for all access and until it was used.)

Returns: The number of produced items

inline void waitUntilEmpty()#: Always call this after you stop enqueueing items. Waits for all consumers to finish consuming, and then signals the queue to finish (unblocks all consumers on an empty queue)

inline void done()#: Immediately signal all consumers to unblock and stop, refusing to enqueue any more items. The queue will be inconsistent afterwards and should be destroyed.

OperationFailedError#

Defined in Errors.h

Inheritance Relationships#

Base Type#

public pvr::PvrError (PvrError)

Class Documentation#

class OperationFailedError : public pvr::PvrError #

A simple std::runtime_error wrapper for throwing exceptions when operations fail.

Public Functions

inline OperationFailedError(std::string message)#

Constructor.

Parameters: message – A message to log.

inline OperationFailedError()#: Constructor.

PaletteExpander#

Defined in PaletteExpander.h

Class Documentation#

class PaletteExpander#

Internally used by some texture readers.

Public Functions

PaletteExpander(const uint8_t *paletteData, uint32_t paletteSize, uint32_t bytesPerEntry)#

Constructor. Initialized with new palette data.

Parameters

paletteData – The palette data
paletteSize – The size of the palete data
bytesPerEntry – The number of bytes each entry takes

void getColorFromIndex(uint32_t index, unsigned char *outputData) const#

Gets a color for the specified index.

Parameters

index – The index of the entry to retrieve. Throws if overruns the palette
outputData – A pointer to the palette color for the specified index is returned here

PixelFormat#

Defined in PixelFormat.h

Nested Relationships#

Nested Types#

Class Documentation#

class PixelFormat#

The PixelFormat class fully defines a Pixel Format (channels, format, compression, bit width etc.).

Public Functions

inline PixelFormat()#: Default Constructor. Creates an empty pixeltype.

inline PixelFormat(uint64_t type)#

Initializes a new pixel type from a 64 bit Integer value.

Parameters: type – Pixel format type
Returns: Return a new PixelFormat

inline PixelFormat(CompressedPixelFormat type)#

Initializes a new pixel type from a CompressedPixelFormat type.

Parameters: type – Compressed Pixel Format type
Returns: Return a new PixelFormat

inline PixelFormat(uint8_t C1Name, uint8_t C2Name, uint8_t C3Name, uint8_t C4Name, uint8_t C1Bits, uint8_t C2Bits, uint8_t C3Bits, uint8_t C4Bits)#

Construct a Pixel format from the given channels which takes up to 4 characters (CnName) and 4 values (CnBits). Any unused channels should be set to 0.

For example: PixelFormat(‘r’,’g’,’b’,0,8,8,8,0)

Parameters

C1Name – channel 1 name
C2Name – channel 2 name
C3Name – channel 3 name
C4Name – channel 4 name
C1Bits – number of bits in channel 1
C2Bits – number of bits in channel 2
C3Bits – number of bits in channel 3
C4Bits – number of bits in channel 4

inline char getChannelContent(uint8_t channel) const#

Returns the “content”, or “name” of a channel, as a character. (normally r,g,b,a,d,s,l,i)

For example, the format d24s8 would return ‘d’ for channel:0, ‘s’ for channel:1, NULL otherwise

Parameters: channel – The zero-indexed channel of the texture(0, 1, 2, 3)
Returns: Return a character describing the channel contents

inline uint8_t getChannelBits(uint8_t channel) const#

Get the width of the specified channel.

Parameters: channel – The zero-indexed channel of the texture(0, 1, 2, 3)
Returns: Return The number of bits the specified channel takes up.

inline uint8_t getNumChannels() const#

Get the number of channels in the format.

Returns: Return the number of channels in the format.

inline bool isCompressedFormat() const#

Returns true if the format is a “normal” compressed format, i.e. the format is not regular (channel type/ bitrate combination), but excludes some special packed formats that are not compressed, such as shared exponent formats.

Returns: True if it is a compressed format, otherwise false

inline uint8_t isIrregularFormat() const#

Returns if the format is some kind of directly supported format that is not regular (i.e. channel type/ channel bitrate combination). I.e. returns true if the format is any of the formats described in the supported “compressed” formats enumeration.

Returns: True if it is a “simple”, “regular” format (i.e. 1-4 channels of some bit width), i.e. neither a “compressed” format nor a “special” format such as shared exponents etc.

inline uint64_t getPixelTypeId() const#

Get the pixel type id.

Returns: Return the pixel type id

inline const uint8_t *getPixelTypeChar() const#

Get a const pointer to the pixel type char.

Returns: Return a const pointer to the pixel type char

inline uint8_t *getPixelTypeChar()#

Get a pointer to the pixel type char.

Returns: Return a pointer to the pixel type char

inline LowHigh getPart() const#

Get the pixel format’s low and high part.

Returns: Return pixel format’s low and high part

inline uint8_t getBitsPerPixel() const#

Get the number of bits per pixel.

Returns: Return the number of bits per pixel

inline bool operator==(const PixelFormat &rhs) const#

operator==, validate if a given pixel format is same as this.

Parameters: rhs – pixel format to compare
Returns: Return true if the given pixel format is same

inline bool operator!=(const PixelFormat &rhs) const#

operator!=, validate if a give pixel format is not same as this.

Parameters: rhs – pixel format to compare
Returns: Return true if the given pixel format is not same

Public Static Functions

static inline const PixelFormat Intensity8()#

Retrieves a pixel format for Intensity 8.

Returns: An 8 bit intensity value

static inline const PixelFormat R_8()#

Retrieves a pixel format for red 8.

Returns: An 8 bit red value

static inline const PixelFormat RG_88()#

Retrieves a pixel format for red and green channels with 8 bits per channel.

Returns: An 8 bit red and green channel

static inline const PixelFormat RGB_888()#

Retrieves a pixel format for red, green and blue channels with 8 bits per channel.

Returns: An 8 bit red, green and blue channel

static inline const PixelFormat RGBA_8888()#

Retrieves a pixel format for red, green, blue and alpha channels with 8 bits per channel.

Returns: An 8 bit red, green, blue and alpha channel

static inline const PixelFormat ABGR_8888()#

Retrieves a pixel format for alpha, blue, green and red channels with 8 bits per channel.

Returns: An 8 bit alpha, blue, green, red channel

static inline const PixelFormat R_16()#

Retrieves a pixel format for red with 16 bits.

Returns: An 16 bit red value

static inline const PixelFormat RG_1616()#

Retrieves a pixel format for red and green channels with 16 bits per channel.

Returns: An 16 bit red and green channel

static inline const PixelFormat R_32()#

Retrieves a pixel format for red with 32 bits.

Returns: An 32 bit red value

static inline const PixelFormat RG_3232()#

Retrieves a pixel format for red and green channels with 32 bits per channel.

Returns: An 32 bit red and green channel

static inline const PixelFormat RGB_323232()#

Retrieves a pixel format for red, green and blue channels with 32 bits per channel.

Returns: An 32 bit red, green and blue channel

static inline const PixelFormat RGBA_32323232()#

Retrieves a pixel format for red, green, blue and alpha channels with 32 bits per channel.

Returns: An 32 bit red, green, blue and alpha channel

static inline const PixelFormat RGB_565()#

Retrieves a pixel format for red, green and blue channels with 5 bits for the red and blue channels and 6 bits for the green channel.

Returns: An red, green and blue pixel format with 5 bits for the red and blue channels and 6 bits for the green channel

static inline const PixelFormat RGBA_4444()#

Retrieves a pixel format for red, green, blue and alpha channels with 4 bits per channel.

Returns: An 4 bit red, green, blue and alpha channel

static inline const PixelFormat RGBA_5551()#

Retrieves a pixel format for red, green, blue and alpha channels with 5 bits per channel for the red, green and blue channels with 1 bit for alpha.

Returns: An 32 bit red, green, blue and alpha channel

static inline const PixelFormat BGR_888()#

Retrieves a pixel format for blue, green and red channels with 8 bits per channel.

Returns: An 8 bit blue, green and red channel pixel format

static inline const PixelFormat BGRA_8888()#

Retrieves a pixel format for blue, green, red and alpha channels with 8 bits per channel.

Returns: An 8 bit blue, green, red and alpha channel pixel format

static inline const PixelFormat Depth8()#

Retrieves a pixel format for depth with 8 bits.

Returns: An 8 bit depth channel pixel format

static inline const PixelFormat Depth16()#

Retrieves a pixel format for depth with 16 bits.

Returns: An 16 bit depth channel pixel format

static inline const PixelFormat Depth24()#

Retrieves a pixel format for depth with 24 bits.

Returns: An 24 bit depth channel pixel format

static inline const PixelFormat Depth32()#

Retrieves a pixel format for depth with 32 bits.

Returns: An 32 bit depth channel pixel format

static inline const PixelFormat Depth16Stencil8()#

Retrieves a pixel format for depth with 16 bits and stencil with 8 bits.

Returns: A 16 bit depth channel with 8 bits for stencil pixel format

static inline const PixelFormat Depth24Stencil8()#

Retrieves a pixel format for depth with 24 bits and stencil with 8 bits.

Returns: A 24 bit depth channel with 8 bits for stencil pixel format

static inline const PixelFormat Depth32Stencil8()#

Retrieves a pixel format for depth with 32 bits and stencil with 8 bits.

Returns: A 32 bit depth channel with 8 bits for stencil pixel format

static inline const PixelFormat Stencil8()#

Retrieves a pixel format for stencil with 8 bits.

Returns: An 8 bit stencil channel pixel format

static inline const PixelFormat L_32()#

Retrieves a pixel format for luminance with 32 bits.

Returns: An 32 bit luminance channel pixel format

static inline const PixelFormat LA_1616()#

Retrieves a pixel format for luminance and alpha channels with 16 bits per channel.

Returns: An 16 bit luminance and alpha channel pixel format

static inline const PixelFormat LA_3232()#

Retrieves a pixel format for luminance and alpha channels with 32 bits per channel.

Returns: An 32 bit luminance and alpha channel pixel format

static inline const PixelFormat RGBA_16161616()#

Retrieves a pixel format for red, green, blue and alpha channels with 16 bits per channel.

Returns: An 16 bit red, green, blue and alpha channel

static inline const PixelFormat RGB_161616()#

Retrieves a pixel format for red, green and blue channels with 16 bits per channel.

Returns: An 16 bit red, green and blue channel

static inline const PixelFormat RGB_111110()#

Retrieves a packed pixel format for blue, green and red channels with 10 bits for the blue and 11 bits for the green and red channel. This pixel format is identical to BGR111110.

Returns: An blue, green and red pixel format with 10 bits for the blue and 11 bits for the green and red channel

static inline const PixelFormat BGR_101111()#

Retrieves a packed pixel format for blue, green and red channels with 10 bits for the blue and 11 bits for the green and red channel. This pixel format is identical to RGB111110.

Returns: An blue, green and red pixel format with 10 bits for the blue and 11 bits for the green and red channel

static inline const PixelFormat Unknown()#

Retrieves an unknown pixel format.

Returns: An unknown pixel format

struct LowHigh#

64 bit Integer representation as 32 lower bits and 32 higher bits

Public Members

uint32_t Low#: Lower 32-bits of the pixel format storage.

uint32_t High#: Higher 32-bits of the pixel format storage.

Plane3d#

Defined in Plane.h

Class Documentation#

class Plane3d#

Uses the plane equation Ax + By + Cz + D = 0, where A B C are plane normal, xyz are position on the plane and D is distance to the plane.

Public Functions

inline Plane3d(const glm::vec3 &normal, float dist)#

Constructs a plane from normal and distance. Distance is the scalar number that is the (unsigned) distance of this plane from (0,0,0).

Parameters

normal – The normal of this plane. MUST BE NORMALISED. If it not normalized, unexpected results may occur.
dist – The signed distance, along the plane’s normal direction, between the coordinate start and (0,0,0). This number is defined as the number that the normal must be multiplied with so that the normal’s coordinates define a point on the plane.

inline Plane3d(const glm::vec3 &normal, const glm::vec3 &pointOnPlane)#

Constructs a plane from normal and a point on this plane.

Parameters

normal – The normal of this plane. If it is not normalized, unexpected results may occur.
pointOnPlane – Any point belonging to this plane

inline Plane3d(const glm::vec3 &point0, const glm::vec3 &point1, const glm::vec3 &point2)#

Constructs a plane from three points.

Parameters

point0 – A point belonging to the plane
point1 – A point belonging to the plane
point2 – A point belonging to the plane

inline void set(const glm::vec3 &normal, float dist)#

Sets a plane from normal and distance. Distance is the scalar number that is the distance of this plane from (0,0,0).

Parameters

normal – The normal of this plane. MUST BE NORMALISED. If it not normalized, unexpected results may occur.
dist – The signed distance, along the plane’s normal direction, between the coordinate start and (0,0,0). This number is defined as the number that the normal must be multiplied with so that the normal’s coordinates define a point on the plane.

inline void set(const glm::vec3 &normal, const glm::vec3 &pointOnPlane)#

Sets a plane from normal and a point on this plane.

Parameters

normal – The normal of this plane. If it is not normalized, unexpected results may occur.
pointOnPlane – Any point belonging to this plane

inline void set(const glm::vec3 &point0, const glm::vec3 &point1, const glm::vec3 &point2)#

Sets a plane from three points.

Parameters

point0 – A point belonging to the plane
point1 – A point belonging to the plane
point2 – A point belonging to the plane

inline float distanceTo(const glm::vec3 &point)#

Find the signed distance between a point and the plane. Positive means distance along the normal, negative means distance opposite to the normal’s direction.

Parameters: point – The point
Returns: The signed distance between the point and this plane.

inline float getDistance() const#

Get the distance of this plane to the coordinate start (0,0,0).

Returns: The distance of this plane to the coordinate start (0,0,0)

inline glm::vec3 getNormal() const#

Get the normal of this plane.

Returns: The normal of this plane.

inline void transform(glm::mat4 &transMtx)#

Transform the plane with a transformation matrix.

Parameters: transMtx – The matrix to transform this plane with.

PvrError#

Defined in Errors.h

Inheritance Relationships#

Base Type#

public std::runtime_error

Derived Types#

public pvr::FileEOFError (FileEOFError)
public pvr::FileIOError (FileIOError)
public pvr::IndexOutOfRange (IndexOutOfRange)
public pvr::InvalidArgumentError (InvalidArgumentError)
public pvr::InvalidDataError (InvalidDataError)
public pvr::InvalidOperationError (InvalidOperationError)
public pvr::OperationFailedError (OperationFailedError)
public pvr::TextureDecompressionError (TextureDecompressionError)
public pvr::UnsupportedOperationError (UnsupportedOperationError)

Class Documentation#

class PvrError : public std::runtime_error#

A simple std::runtime_error wrapper for throwing generic PVR exceptions.

Subclassed by pvr::FileEOFError, pvr::FileIOError, pvr::IndexOutOfRange, pvr::InvalidArgumentError, pvr::InvalidDataError, pvr::InvalidOperationError, pvr::OperationFailedError, pvr::TextureDecompressionError, pvr::UnsupportedOperationError

Public Functions

inline PvrError(std::string message)#

Constructor.

Parameters: message – A message to log.

Stream#

Defined in Stream.h

Inheritance Relationships#

Derived Types#

public pvr::AndroidAssetStream (AndroidAssetStream)
public pvr::BufferStream (BufferStream)
public pvr::FileStream (FileStream)

Class Documentation#

class Stream#

This class is used to abstract streams of data (files, blocks of memory, resources etc.). In general a stream is considered something that can be read or written from. Specializations for many different types of streams are provided by the PowerVR Framework, the most commonly used ones being Files and Memory. The common interface and pointer types allow the Stream to abstract data in a very useful manner.

Subclassed by pvr::AndroidAssetStream, pvr::BufferStream, pvr::FileStream

Public Types

enum SeekOrigin#

When seeking, select if your offset should be considered to be from the Start of the stream, the Current point in the stream or the End of the stream.

Values:

enumerator SeekOriginFromStart#

enumerator SeekOriginFromCurrent#

enumerator SeekOriginFromEnd#

Public Functions

virtual ~Stream() = default#: Destructor (virtual, this class can and should be used polymorphically).

inline bool isReadable() const#

Return true if this stream can be read from.

Returns: True if this stream can be read from.

inline bool isWritable() const#

Return true if this stream can be written from.

Returns: True if this stream can be written to.

inline const std::string &getFileName() const#

Get the filename of the file that this std::string represents, if such exists. Otherwise, empty std::string.

Returns: The filename of the file that this std::string represents, if such exists. Otherwise, empty std::string.

inline void read(size_t elementSize, size_t numElements, void *buffer, size_t &dataRead) const#

Main read function. Read up to a specified amount of items into the provided buffer.

Parameters

elementSize – The size of each element that will be read.
numElements – The maximum number of elements to read.
buffer – The buffer into which to write the data.
dataRead – After returning, will contain the number of items that were actually read

inline void readExact(size_t elementSize, size_t numElements, void *buffer) const#

Main read function. Read exactly a specified amount of items into the provided buffer, otherwise error.

Parameters

elementSize – The size of each element that will be read.
numElements – The maximum number of elements to read.
buffer – The buffer into which to write the data.

inline void write(size_t elementSize, size_t numElements, const void *buffer, size_t &dataWritten)#

Main write function. Write into the stream the specified amount of items from a provided buffer.

Parameters

elementSize – The size of each element that will be written.
numElements – The number of elements to write.
buffer – The buffer from which to read the data. If the buffer is smaller than elementSize * numElements bytes, result is undefined.
dataWritten – After returning, will contain the number of items that were actually written. Will contain numElements unless an error has occured.

inline void writeExact(size_t elementSize, size_t numElements, const void *buffer)#

Main write function. Write into the stream exactly the specified amount of items from a provided buffer, otherwise throw error.

Parameters

elementSize – The size of each element that will be written.
numElements – The number of elements to write.
buffer – The buffer from which to read the data. If the buffer is smaller than elementSize * numElements bytes, result is undefined.

inline void seek(long offset, SeekOrigin origin) const#

If supported, seek a specific point for random access streams. After successful call, subsequent operation will happen in the specified point.

Parameters

offset – The offset to seec from “origin”
origin – Beginning of stream, End of stream or Current position

inline bool isSeekable() const#

Returns true if a stream supports seek, otherwise false.

Returns: True if a stream supports seek, otherwise false

inline bool isRandomAccess() const#

Returns true if a stream supports seek, otherwise false.

Returns: True if a stream supports seek, otherwise false

inline size_t getPosition() const#

If supported, returns the current position in the stream.

Returns: If suppored, returns the current position in the stream. Otherwise, returns 0.

inline uint64_t getPosition64() const#

If supported, returns the current position in the stream.

Returns: If suppored, returns the current position in the stream. Otherwise, returns 0.

inline size_t getSize() const#

If supported, returns the total size of the stream.

Returns: If suppored, returns the total amount of data in the stream. Otherwise, returns 0.

inline uint64_t getSize64() const#

If supported, returns the total size of the stream, always in 64 bit precision.

Returns: If suppored, returns the total amount of data in the stream. Otherwise, returns 0.

template<typename Type_> inline std::vector<Type_> readToEnd() const#

Convenience functions that reads all data in the stream into a contiguous block of memory of a specified element type. Requires random-access stream.

Template Parameters: Type_ – The type of item that will be read into.
Returns: A std::vector of Type_ containing all data from the current point to the end of the stream.

inline void readIntoCharBuffer(std::vector<char> &outString) const#

Convenience function that reads all data in the stream into a raw, contiguous block of memory. Requires random-access stream.

Parameters: outString – A std::vector<char> that will contain all data in the stream.
Returns: true if successful, false otherwise.

template<typename T_> inline void readIntoBuffer(std::vector<T_> &outString) const#

Convenience function that reads all data in the stream into a raw, contiguous block of memory. Requires random-access stream.

Parameters: outString – A std::vector<char> that will contain all data in the stream.
Returns: true if successful, false otherwise.

inline std::vector<char> readChars() const#

Convenience function that reads all data in the stream into a raw, contiguous block of memory. Requires random-access stream.

Returns: A std::vector<char> that will contain all data in the stream.

inline void readIntoString(std::string &outString) const#

Convenience function that reads all data in the stream into a std::string.

Parameters: outString – The string where the stream’s data will all be saved

inline std::string readString() const#

Convenience function that reads all data in the stream into a std::string.

Returns: A string containing the stream’s data

Protected Functions

inline explicit Stream(const std::string &fileName, bool readable, bool writable, bool seekable)#

Constructor. Open a stream to a new filename. Must be overriden as it only sets the filename.

Parameters: fileName – Commmonly the filename, but may be any type of resource identifier (such as Windows Embedded Resource id)

Protected Attributes

bool _isReadable#: True if the stream can be read.

bool _isWritable#: True if the stream can be written.

bool _isRandomAccess#: True if the stream is random read write.

std::string _fileName#: The filename (conceptually, a resource identifier as there may be other sources for the stream)

StridedBuffer#

Defined in Types.h

Inheritance Relationships#

Base Type#

public UInt8Buffer

Class Documentation#

class StridedBuffer : public UInt8Buffer #

Representation of raw data. Used to store raw data that is logically grouped in blocks with a stride.

Public Members

uint16_t stride#: The stride of the buffer.

StringHash#

Defined in StringHash.h

Class Documentation#

class StringHash#

Implementation of a hashed std::string with functionality for fast compares.

In most cases, can be used as a drop-in replacement for std::strings to take advantage of fast hashed comparisons. On debug builds, tests for hash collisions are performed (Assertion + error log if collision found)

Public Functions

inline StringHash(const char *str)#

Constructor. Initialize with c-style std::string, which will be copied. Automatically calculates hash.

Parameters: str – A c-style std::string. Will be copied internaly.

inline StringHash(const std::string &right)#

Constructor. Initialize with c++style std::string, which will be copied. Automatically calculates hash.

Parameters: right – The std::string to initialize with.

inline operator const std::string&() const#

Conversion to std::string reference. No-op.

Returns: A std::string representatation of this hash

inline StringHash()#: Default constructor. Empty std::string.

inline StringHash(const StringHash &other)#

Copy Constructor.

Parameters: other – String hash from which to copy.

inline ~StringHash()#: Dtor.

inline StringHash &operator=(const StringHash other)#

Copy assignment operator.

Parameters: other – String hash from which to copy.
Returns: this object

inline StringHash &append(const char *ptr)#

Appends a std::string to the end of this StringHash, recalculates hash.

Parameters: ptr – A std::string
Returns: this (post the operation)

inline StringHash &append(const std::string &str)#

Appends a std::string.

Parameters: str – A std::string
Returns: this (post the operation)

inline StringHash &assign(const char *ptr)#

Assigns the std::string to the std::string ptr.

Parameters: ptr – A std::string
Returns: this (post the operation)

inline StringHash &assign(const std::string &str)#

Assigns the std::string to the std::string str.

Parameters: str – A std::string
Returns: this (post the operation)

inline size_t size() const#

Return the length of this std::string hash.

Returns: Length of this std::string hash

inline size_t length() const#

Return the length of this std::string hash.

Returns: Length of this std::string hash

inline bool empty() const#

Return if the std::string is empty.

Returns: true if the std::string is emtpy (length=0), false otherwise

inline void clear()#: Clear this std::string hash.

inline bool operator==(const StringHash &str) const#

== Operator. Compares hash values. Extremely fast.

On debug builds, this operation does a deep check for hash collisions. You may also define PVR_STRING_HASH_STRONG_COMPARISONS if you want to force deep checks (in which) case IFF hashes are equal the the strings will be compared char-per-char as well. Only consider this if you think that for some reason you have an extremely high probability of hash collisions.

Parameters: str – A hashed std::string to compare with
Returns: True if the strings have the same hash

inline bool operator==(const char *str) const#

Equality Operator. This function performs a strcmp(), so it is orders of magnitude slower than comparing to another StringHash, but still much faster than creating a temporary StringHash for one comparison.

Parameters: str – A std::string to compare with
Returns: True if they are the same.

inline bool operator==(const std::string &str) const#

Equality Operator. This function performs a std::string comparison so it is orders of magnitude slower than comparing to another StringHash, but still much faster than creating a temporary StringHash for one comparison.

Parameters: str – A std::string to compare with
Returns: True if they are the same.

inline bool operator!=(const StringHash &str) const#

Inequality Operator. Compares hash values. Extremely fast.

Parameters: str – A StringHash to compare with
Returns: True if they don’t match

inline bool operator<(const StringHash &str) const#

Less than Operator. Compares hash values, except on debug builds where it checks for collisions. Extremely fast.

Parameters: str – A StringHash to compare with
Returns: True if this should be considered less than str, otherwise false.

inline bool operator>(const StringHash &str) const#

Greater-than operator.

Parameters: str – Right hand side of the operator (StringHash)
Returns: Return true if left-hand side is greater than right-hand side

inline bool operator<=(const StringHash &str) const#

Less-than or equal operator.

Parameters: str – Right hand side of the operator (StringHash)
Returns: Return true if left-hand side is less than or equal to the right-hand side

inline bool operator>=(const StringHash &str) const#

Greater-than or equal operator.

Parameters: str – Right hand side of the operator (StringHash)
Returns: Return true if left-hand side is greater-than or equal to the right-hand side

inline const std::string &str() const#

Get the base string object used by this StringHash object.

Returns: The base string object contained in this std::string hash.

inline std::size_t getHash() const#

Get the base string object used by this StringHash object.

Returns: The hash value of this StringHash.

inline const char *c_str() const#

Get the base string object used by this StringHash object.

Returns: A c-string representation of the contained std::string.

Texture#

Defined in Texture.h

Inheritance Relationships#

Base Type#

public pvr::TextureHeader (TextureHeader)

Class Documentation#

class Texture : public pvr::TextureHeader #

A 2D Texture asset, together with Information, Metadata and actual Pixel data. Only represents the actual data, not the API objects that may be created from it.

Public Functions

Texture()#: Construct a new empty texture.

Texture(const TextureHeader &sHeader, const unsigned char *pData = NULL)#

Create a texture using the information from a Texture header and copy the actual data from a provided pointer.

Creates a new texture based on a texture header, pre-allocating the correct amount of memory. If data is supplied, it will be copied into memory. If the pointer contains less data than is dictated by the texture header, the behaviour is undefined.

Parameters

sHeader – A texture header describing the texture
pData – Pointer to memory containing the actual data.

void initializeWithHeader(const TextureHeader &sHeader)#

Create a texture using the information from a Texture header and preallocate memory for its data. /summary>

param sHeader: A texture header describing the texture

Creates a new texture based on a texture header, pre-allocating the correct amount of memory.

const unsigned char *getDataPointer(uint32_t mipMapLevel = 0, uint32_t arrayMember = 0, uint32_t face = 0, uint32_t plane = 0) const#

Returns a (const) pointer into the raw texture’s data. Can be offset to a specific array member, face and/or MIP Map levels.

The data is contiguous so that the entire texture (all mips, array members and faces) can always be accessed from any pointer.

Parameters

mipMapLevel – The mip map level to get a pointer to (default 0)
arrayMember – The array member to get a pointer to (default 0)
face – The cube face to get a pointer to (default 0)

Returns

Const raw pointer to a location in the texture.

unsigned char *getDataPointer(uint32_t mipMapLevel = 0, uint32_t arrayMember = 0, uint32_t face = 0, uint32_t plane = 0)#

Returns a pointer into the raw texture’s data. Can be offset to a specific array member, face and/or MIP Map levels.

The data is contiguous so that the entire texture (all mips, array members and faces) can always be accessed from any pointer.

Parameters

mipMapLevel – The mip map level for which to get the data pointer (default 0)
arrayMember – The array member for which to get the data pointer (default 0)
face – The face for which to get the data pointer (default 0)

Returns

Raw pointer to a location in the texture.

inline unsigned char *getPixelPointer(uint32_t x, uint32_t y, uint32_t z = 0, uint32_t mipMapLevel = 0, uint32_t arrayMember = 0, uint32_t face = 0, uint32_t plane = 0)#

Returns a pointer into the raw texture’s data, offset to a specific pixel. Note that this does not work for compressed textures.

The data is contiguous so that the entire texture (all mips, array members and faces) can always be accessed from any pointer. Equivalent to getDataPointer(mipMapLevel, arrayMember, faceNumber) + [char offset of pixel (x,y,z)]

Parameters

x – The x position of the pointer
y – The y position of the pointer
z – The z position of the pointer (default 0)
mipMapLevel – The mip map level for which to get the data pointer (default 0)
arrayMember – The array member for which to get the data pointer (default 0)
face – The face for which to get the data pointer (default 0). The number is equal to the value of the corresponding CubeFace enum.

Returns

Raw pointer to a location in the texture.

inline unsigned char *getPixelPointerByUvw(float u, float v, float w = 0, uint32_t mipMapLevel = 0, uint32_t arrayMember = 0, CubeFace face = (CubeFace)0, uint32_t plane = 0)#

Returns the pointer to the data of the closest texel to the provided uvw coordinates (right/down texel returned if coordinate is on a boundary). Note that this does not work for compressed textures.

The data is contiguous so that the entire texture (all mips, array members and faces) can always be accessed from any pointer.

Parameters

u – The u position [0..1] of the pointer. Clamped to [0..1]
v – The v position [0..1] of the pointer. Clamped to [0..1]
w – Thew position [0..1] of the pointer (default 0). Clamped to [0..1]
mipMapLevel – The mip map level for which to get the data pointer (default 0)
arrayMember – The array member for which to get the data pointer (default 0)
face – The face for which to get the data pointer (default 0)

Returns

Raw pointer to a location in the texture.

inline unsigned char *getCubemapPixel(float x, float y, float z, uint32_t mipMapLevel = 0, uint32_t arrayMember = 0, uint32_t plane = 0)#

Returns the pointer to the data for the direction (x,y,z) provided for the specific mip map level and array layer.

Parameters

x – The x component of the direction
y – The y component of the direction
z – The z component of the direction
mipMapLevel – The mip map level for which to get the data pointer (default 0)
arrayMember – The array member for which to get the data pointer (default 0)
plane – The plane for which to get the data pointer (default 0)

Returns

Raw pointer to the data for the direction specified.

uint8_t getPixelSize() const#

Get the number of bytes size of each pixel in the texture. Not accurate for many compressed textures (e.g. ASTC)

Returns: he number of bytes size of each pixel in the texture. May return zero for some compressed formats. /returns>

inline ImageType getDimension() const#

Return the base dimensioning type of the image (3D, 2D, 1D).

Returns: The base dimensioning type of the image (3D, 2D, 1D).

inline ImageLayersSize getLayersSize() const#

Return the texture’s layer layout (miplevels, arraylevels). Faces are considered array levels, so a cube array has array x face array levels.

Returns: The texture’s layer layout (miplevels, arraylevels)

inline Extent3D getDimensions(uint32_t miplevel = 0) const#

Return the texture’s dimensions as a 3D extent (height, width, depth).

Parameters: miplevel – (Default 0) The mip level for which to get the dimensions
Returns: Return the texture’s dimensions as a 3D extent (height, width, depth)

void addPaddingMetaData(uint32_t alignment)#

This function pads to a boundary value equal to “uiPadding”. For example, setting alignment=8 will align the start of the texture data to an 8 char boundary.

When writing the texture out to a PVR file, it is often desirable to pad the meta data so that the start of the texture data aligns to a given boundary. Note - this should be called immediately before saving (in any case, before adding any metadata) as the value is worked out based on the current meta data size. /remarks>

Parameters: alignment – The final alignment of the metadata

TextureDecompressionError#

Defined in Errors.h

Inheritance Relationships#

Base Type#

public pvr::PvrError (PvrError)

Class Documentation#

class TextureDecompressionError : public pvr::PvrError #

A simple std::runtime_error wrapper for throwing exceptions when invalid operations are attempted.

Public Functions

inline TextureDecompressionError(const std::string &message, const std::string &format)#

Constructor.

Parameters

message – A message to log.
format – The source format of the texture decompression.

inline TextureDecompressionError(const std::string &format)#

Constructor.

Parameters: format – The source format of the texture decompression.

TextureMetaData#

Defined in MetaData.h

Class Documentation#

class TextureMetaData#

The TextureMetaData class contains metadata of a texture. Metadata is any information that a texture could be correctly loaded from file without. In most cases, metadata may still be necessary to actually USE the texture, such as winding orders, paddings, atlas information and others.

Public Types

enum Identifier#

Values for each meta data type that we know about. Texture arrays hinge on each surface being identical in all but content, including meta data. If the meta data varies even slightly then a new texture should be used. It is possible to write your own extension to get around this however.

Values:

enumerator IdentifierTextureAtlasCoords#

enumerator IdentifierBumpData#

enumerator IdentifierCubeMapOrder#

enumerator IdentifierTextureOrientation#

enumerator IdentifierBorderData#

enumerator IdentifierPadding#

enumerator IdentifierPerChannelType#

enumerator IdentifierSupercompressionGlobalData#

enumerator IdentifierMaxRange#

enumerator IdentifierNumMetaDataTypes#

enum Axis#

Axes, used to query orientations.

Values:

enumerator AxisAxisX#

enumerator AxisAxisY#

enumerator AxisAxisZ#

enum AxisOrientation#

Orientations of various axes.

Values:

enumerator AxisOrientationLeft#

enumerator AxisOrientationRight#

enumerator AxisOrientationUp#

enumerator AxisOrientationDown#

enumerator AxisOrientationOut#

enumerator AxisOrientationIn#

Public Functions

inline TextureMetaData()#: Constructor.

inline TextureMetaData(uint32_t fourCC, uint32_t key, uint32_t dataSize, const char *data)#

Constructor.

Parameters

fourCC – FourCC of the metadata
key – Key of the metadata
dataSize – The total size of the payload of the metadata
data – A pointer to the actual data

inline TextureMetaData(const TextureMetaData &rhs)#

Copy Constructor.

Parameters: rhs – Copy from this object

inline TextureMetaData(const TextureMetaData &&rhs)#

Copy Constructor.

Parameters: rhs – Copy from this object

inline ~TextureMetaData()#: Destructor.

inline TextureMetaData &operator=(const TextureMetaData &rhs)#

Copy assignment operator.

Parameters: rhs – Copy from this object
Returns: This object

inline uint32_t getFourCC() const#

Get the 4cc descriptor of the data type’s creator. Values equating to values between ‘P’ ‘V’ ‘R’ 0 and ‘P’ ‘V’ ‘R’ 255 will be used by our headers.

Returns: Return 4cc descriptor of the data type’s creator.

inline uint32_t getDataSize() const#

Get the data size of this meta data.

Returns: Return the size of the meta data

inline uint32_t getKey() const#

Get the enumeration key identifying the data type.

Returns: Return the enumeration key.

inline const unsigned char *getData() const#

Get the data, can be absolutely anything, the loader needs to know how to handle it based on fourCC and key.

Returns: Return the data

inline unsigned char *getData()#

Get the data, can be absolutely anything, the loader needs to know how to handle it based on fourCC and key.

Returns: Return the data

inline uint32_t getTotalSizeInMemory() const#

Get the data total size in memory.

Returns: Return the data total size in memory

Time#

Defined in Time_.h

Class Documentation#

class Time#

This class provides functions for measuring time: current time, elapsed time etc. High performance timers are used if available by the platform.

Public Functions

Time()#

~Time()#

void Reset()#: Sets the current time as a the initial point to measure time from.

uint64_t getElapsedNanoSecs() const#