diff --git a/.nojekyll b/.nojekyll new file mode 100644 index 0000000000..e69de29bb2 diff --git a/bc_s.png b/bc_s.png new file mode 100644 index 0000000000..224b29aa98 Binary files /dev/null and b/bc_s.png differ diff --git a/bc_sd.png b/bc_sd.png new file mode 100644 index 0000000000..31ca888dc7 Binary files /dev/null and b/bc_sd.png differ diff --git a/classtz_1_1handle-members.html b/classtz_1_1handle-members.html new file mode 100644 index 0000000000..b1fd52e4f9 --- /dev/null +++ b/classtz_1_1handle-members.html @@ -0,0 +1,110 @@ + + +
+ + + + +
+ Topaz 5.0
+
+ Topaz Game Engine
+ |
+
This is the complete list of members for tz::handle< T >, including all inherited members.
+operator!=(nullhand_t) const | tz::handle< T > | inline |
operator=(hanval value) | tz::handle< T > | inline |
operator==(nullhand_t) const | tz::handle< T > | inline |
peek() const | tz::handle< T > | inline |
+ Topaz 5.0
+
+ Topaz Game Engine
+ |
+
Represents a generic opaque handle. + More...
+ +#include <handle.hpp>
+Public Member Functions | |
+std::underlying_type_t< hanval > | peek () const |
Disregard the concept of "opaqueness" of an opaque handle by peeking at the underlying value. You should avoid the use of this outside of debug tools. | |
+handle & | operator= (hanval value) |
Assign a handle to the null handle, meaning it is now invalid. | |
+bool | operator== (nullhand_t) const |
Compare a handle to the null handle. This comparison will return false if the handle is valid. | |
+bool | operator!= (nullhand_t) const |
Compare a handle to the null handle. This comparison will return true if the handle is valid. | |
Represents a generic opaque handle.
+To create your own opaque handle types, simply create a type alias for a handle<T>
where T
is any unique type identifier.
+ Topaz 5.0
+
+ Topaz Game Engine
+ |
+
+ Topaz 5.0
+
+ Topaz Game Engine
+ |
+
+Files | |
graph.hpp | |
hardware.hpp | |
pass.hpp | |
resource.hpp | |
settings.hpp | |
shader.hpp | |
+ Topaz 5.0
+
+ Topaz Game Engine
+ |
+
+ Topaz 5.0
+
+ Topaz Game Engine
+ |
+
+ Topaz 5.0
+
+ Topaz Game Engine
+ |
+
+ Topaz 5.0
+
+ Topaz Game Engine
+ |
+
+Directories | |
core | |
detail | |
gpu | |
io | |
os | |
ren | |
+Files | |
main.hpp | |
topaz.hpp | |
+ Topaz 5.0
+
+ Topaz Game Engine
+ |
+
+Files | |
error.hpp | |
handle.hpp | |
job.hpp | |
lua.hpp | |
matrix.hpp | |
memory.hpp | |
quaternion.hpp | |
time.hpp | |
trs.hpp | |
vector.hpp | |
+ Topaz 5.0
+
+ Topaz Game Engine
+ |
+
+ Topaz 5.0
+
+ Topaz Game Engine
+ |
+
+ Topaz 5.0
+
+ Topaz Game Engine
+ |
+
+ Topaz 5.0
+
+ Topaz Game Engine
+ |
+
+ Topaz 5.0
+
+ Topaz Game Engine
+ |
+
+ Topaz 5.0
+
+ Topaz Game Engine
+ |
+
+Topics | |
Core Libraries | |
Lowest-level libraries, structs and functionality. Everything is expected to depend on this. | |
OS Libraries | |
Cross-platform API to interact with operating-system level components, such as windowing, hardware input, and machine non-GPU hardware. | |
GPU Library | |
Abstract rendering API for low-level, high-performance 3D desktop graphics. | |
Rendering Library | |
High-level declarative rendering API built upon the GPU Library. | |
IO Library | |
High-level library for wrangling files of various formats. | |
+Classes | |
struct | tz::appinfo |
Contains information about the application being initialised. More... | |
+Macros | |
#define | tz_assert(cond, fmt, ...) |
Assert that the given condition must be true. Cause a tz_error if not. | |
#define | tz_error(fmt, ...) |
Cause a runtime error. If a debugger is present, a breakpoint will occur at the call-site. Otherwise, the program will terminate. | |
#define | tz_must(fnret) |
Cause a runtime error if the expected value is erroneous. If not, the unwrapped expected value is returned. | |
+Functions | |
void | tz::initialise (appinfo info={}) |
Initialise the engine. | |
void | tz::terminate () |
Terminate the engine, cleaning up all resources. | |
#define tz_assert | +( | +cond, | +|
+ | + | fmt, | +|
+ | + | ... ) | +
Assert that the given condition must be true. Cause a tz_error if not.
+cond | Condition which must evaluate to true. |
fmt | Format string, following the fmtlib convention (i.e the n'th instance of {} in the string will be replaced with the n'th variadic parameter). |
... | Additional arguments (size should correspond to the number of occurrences of {} in fmt ) that shall be substituted into the format string. |
#define tz_error | +( | +fmt, | +|
+ | + | ... ) | +
Cause a runtime error. If a debugger is present, a breakpoint will occur at the call-site. Otherwise, the program will terminate.
+fmt | Format string, following the fmtlib convention (i.e the n'th instance of {} in the string will be replaced with the n'th variadic parameter). |
... | Additional arguments (size should correspond to the number of occurrences of {} in fmt ) that shall be substituted into the format string. |
#define tz_must | +( | +fnret | ) | ++ |
Cause a runtime error if the expected value is erroneous. If not, the unwrapped expected value is returned.
+Many API functions in Topaz return some variant of std::expected
. Handling them on an individual basis can be verbose and unnecessary. Surround the call with this macro to instead yield the expected value directly, and emit a runtime error if an error code was returned instead.
Example before:
+std::expected<tz::gpu::resource_handle, tz::error_code> img = tz::gpu::create_image({...});
Example after:
+tz::gpu::resource_handle img = tz_must(tz::gpu::create_image({...}));
void tz::initialise | +( | +appinfo | info = {} | ) | ++ |
Initialise the engine.
+info | Some basic information about your application. If you don't provide this, some placeholder values will be provided for you. |
This function must be the first Topaz API call you make, ideally at the start of your program's runtime.
+You should expect this function to take a significantly long time.
+ +void tz::terminate | +( | +) | ++ |
Terminate the engine, cleaning up all resources.
+This function should be the last Topaz API call you make before the end of your program's runtime.
+You should expect this function to take a significantly long time.
+ +
+ Topaz 5.0
+
+ Topaz Game Engine
+ |
+
Lowest-level libraries, structs and functionality. Everything is expected to depend on this. +More...
++Topics | |
Job System | |
Submit async jobs to an internal threadpool. | |
Lua Scripting | |
Execute lightweight lua code within the engine. | |
Mathematics | |
Basic mathematical geometric types. | |
+Classes | |
class | tz::handle< T > |
Represents a generic opaque handle. More... | |
+Enumerations | |
enum class | tz::error_code { + error_code::success +, error_code::partial_success +, error_code::precondition_failure +, error_code::invalid_value +, + error_code::machine_unsuitable +, error_code::engine_bug +, error_code::driver_hazard +, error_code::unknown_error +, + error_code::oom +, error_code::voom +, error_code::concurrent_usage +, _count + + } |
Error codes for Topaz. More... | |
+Variables | |
constexpr nullhand_t | tz::nullhand |
Lowest-level libraries, structs and functionality. Everything is expected to depend on this.
+
+
|
+ +strong | +
Error codes for Topaz.
+Enumerator | |
---|---|
success | Correct behaviour has occurred. No need to do any sanity checking. + |
partial_success | Nothing erroneous happened, but the process did not complete fully or otherwise provide an ideal result. + |
precondition_failure | An error has occurred because some previously-required setup has not been complete. The most common cause of this is not initialising the engine via tz::initialise. + |
invalid_value | An error has occurred because an illegal/incorrect value has been detected. + |
machine_unsuitable | An error has occurred because the currently running machine does not support the given operation. + |
engine_bug | An error has occurred due to an engine-side logic error, and you should submit a bug report. + |
driver_hazard | An error has occurred due to a serious hazard relating to the driver/hardware. This most likely means a graphics driver crash/hardware-lost. + |
unknown_error | An error has occurred, but it's not clear why. + |
oom | An error has occurred due to lack of CPU memory. + |
voom | An error has occurred due to lack of GPU memory. + |
concurrent_usage | An error has occurred due to an operation being invalid while a given resource is in use by something else. + |
+
|
+ +constexpr | +
Represents the null handle. You can assign any tz::handle<T> to the null handle, meaning it no longer corresponds to something valid. You can also compare any handle to the null handle.
+ +
+ Topaz 5.0
+
+ Topaz Game Engine
+ |
+
Submit async jobs to an internal threadpool. +More...
++Typedefs | |
+using | tz::job_function = std::function<void()> |
Represents a function that will be executed on a job worker via job_execute. | |
+Functions | |
job_handle | tz::job_execute (job_function fn) |
Execute a function as a new job. | |
job_handle | tz::job_execute_on (job_function fn, job_worker worker) |
Execute a function as a new job - but can only be picked up by a specific worker. | |
+void | tz::job_wait (job_handle job) |
Block the current thread until the job specified has been fully completed. | |
+bool | tz::job_complete (job_handle job) |
Query as to whether the specific job has been fully completed or not. | |
std::size_t | tz::job_count () |
Estimate the total number of jobs that have been created but not yet completed. | |
std::size_t | tz::job_worker_count () |
Retrieve the number of worker threads. | |
Submit async jobs to an internal threadpool.
+std::size_t tz::job_count | +( | +) | ++ |
Estimate the total number of jobs that have been created but not yet completed.
+You should assume the returned value to be an estimate – a lower bound on the real number. It is also absolutely possible that many jobs are completed between the time of you calling this function and inspecting the result.
+ +job_handle tz::job_execute | +( | +job_function | fn | ) | ++ |
Execute a function as a new job.
+This creates a new job which will be picked up by any worker thread as soon as possible. You can query the job's progress via job_complete, or block the wait for it to finish via job_wait.
+There is no guarantee or hint as to which worker thread ultimately picks up your work. If you need that, consider job_execute_on. There is also no safety mechanism in place for avoiding deadlocks – there is nothing stopping you from writing race conditions, nor does some hidden feature exist to protect you from them.
+job_handle tz::job_execute_on | +( | +job_function | fn, | +
+ | + | job_worker | worker ) | +
Execute a function as a new job - but can only be picked up by a specific worker.
+At any given time, there are a set of worker threads available for use (number of worker threads is equal to job_worker_count). Unlike job_execute, the job created by this function is tailored to only a single worker thread. Aside from this, the behaviour of this function exactly matches that of job_execute.
+You might want to do this for a couple of reasons:
std::size_t tz::job_worker_count | +( | +) | ++ |
Retrieve the number of worker threads.
+The returned value is unaffected by whether these worker threads are currently carrying out work/are idle. You can assume this number will never change throughout your application's runtime.
+ +
+ Topaz 5.0
+
+ Topaz Game Engine
+ |
+
Execute lightweight lua code within the engine. +More...
++Typedefs | |
using | tz::lua_fn = int(*)() |
Represents the signature for a function that can be called from lua. | |
+Functions | |
tz::error_code | tz::lua_execute_file (std::filesystem::path path) |
Attempt to execute a local lua file on the current thread. | |
tz::error_code | tz::lua_execute (std::string_view lua_src) |
Attempt to execute some lua code on the current thread. | |
tz::error_code | tz::lua_set_nil (std::string_view varname) |
Set a variable in lua to be nil. | |
tz::error_code | tz::lua_set_emptytable (std::string_view varname) |
Set a variable in lua to be the empty table "{}". | |
tz::error_code | tz::lua_set_bool (std::string_view varname, bool v) |
Set a variable in lua to a new bool value. | |
tz::error_code | tz::lua_set_int (std::string_view varname, std::int64_t v) |
Set a variable in lua to a new int value. | |
tz::error_code | tz::lua_set_number (std::string_view varname, double v) |
Set a variable in lua to a new number value. | |
tz::error_code | tz::lua_set_string (std::string_view varname, std::string str) |
Set a variable in lua to a new string value. | |
tz::error_code | tz::lua_define_function (std::string_view varname, lua_fn fn) |
Define a new function in lua. | |
std::expected< bool, tz::error_code > | tz::lua_get_bool (std::string_view varname) |
Retrieve the value of a bool variable. | |
std::expected< std::int64_t, tz::error_code > | tz::lua_get_int (std::string_view varname) |
Retrieve the value of a int variable. | |
std::expected< double, tz::error_code > | tz::lua_get_number (std::string_view varname) |
Retrieve the value of a number variable. | |
std::expected< std::string, tz::error_code > | tz::lua_get_string (std::string_view varname) |
Retrieve the value of a string variable. | |
std::expected< bool, tz::error_code > | tz::lua_stack_get_bool (std::size_t id) |
Retrieve a bool from the stack at the given index. | |
std::expected< std::int64_t, tz::error_code > | tz::lua_stack_get_int (std::size_t id) |
Retrieve a int from the stack at the given index. | |
std::expected< double, tz::error_code > | tz::lua_stack_get_number (std::size_t id) |
Retrieve a number from the stack at the given index. | |
std::expected< std::string, tz::error_code > | tz::lua_stack_get_string (std::size_t id) |
Retrieve a string from the stack at the given index. | |
+void | tz::lua_push_nil () |
Push a nil value onto the stack. | |
+void | tz::lua_push_bool (bool v) |
Push a bool value onto the stack. | |
+void | tz::lua_push_int (std::int64_t v) |
Push an int value onto the stack. | |
+void | tz::lua_push_number (double v) |
Push a number value onto the stack. | |
+void | tz::lua_push_string (std::string v) |
Push a string value onto the stack. | |
+std::size_t | tz::lua_stack_size () |
Retrieve the number of values on the stack currently. | |
std::string | tz::lua_debug_callstack () |
Retreieve a string describing the lua callstack right now. | |
std::string | tz::lua_debug_stack () |
Retreieve a string describing the entire lua stack right now. | |
template<typename... Ts> | |
std::tuple< Ts... > | tz::lua_parse_args () |
Retreve a set of arguments from the stack. | |
Execute lightweight lua code within the engine.
+using tz::lua_fn = int(*)() | +
Represents the signature for a function that can be called from lua.
+You might be expecting int(lua_State*)
if you're used to using Lua directly. However, lua headers are not available to you, so this is the only signature you will worry about. Like in default lua, the return value of any lua function represents how many values you have returned (put onto the stack). To retrieve an argument in a lua function, you can either:
Example: C function callable in lua:
In your lua code:
std::string tz::lua_debug_callstack | +( | +) | ++ |
Retreieve a string describing the lua callstack right now.
+This might be useful for debugging purposes.
+ +std::string tz::lua_debug_stack | +( | +) | ++ |
Retreieve a string describing the entire lua stack right now.
+This might be useful for debugging purposes.
+ +tz::error_code tz::lua_define_function | +( | +std::string_view | varname, | +
+ | + | lua_fn | fn ) | +
Define a new function in lua.
+varname | Name of the function when called in lua code. |
fn | Pointer to an existing function to expose to lua. |
tz::error_code tz::lua_execute | +( | +std::string_view | lua_src | ) | ++ |
Attempt to execute some lua code on the current thread.
+lua_src | String containing lua code to execute. |
tz::error_code tz::lua_execute_file | +( | +std::filesystem::path | path | ) | ++ |
Attempt to execute a local lua file on the current thread.
+path | Path to a local file containing lua code. |
std::expected< bool, tz::error_code > tz::lua_get_bool | +( | +std::string_view | varname | ) | ++ |
Retrieve the value of a bool variable.
+varname | Name of the variable to retrieve. |
std::expected< std::int64_t, tz::error_code > tz::lua_get_int | +( | +std::string_view | varname | ) | ++ |
Retrieve the value of a int variable.
+varname | Name of the variable to retrieve. |
std::expected< double, tz::error_code > tz::lua_get_number | +( | +std::string_view | varname | ) | ++ |
Retrieve the value of a number variable.
+varname | Name of the variable to retrieve. |
std::expected< std::string, tz::error_code > tz::lua_get_string | +( | +std::string_view | varname | ) | ++ |
Retrieve the value of a string variable.
+varname | Name of the variable to retrieve. |
std::tuple< Ts... > tz::lua_parse_args | +( | +) | ++ |
Retreve a set of arguments from the stack.
+tz::error_code tz::lua_set_bool | +( | +std::string_view | varname, | +
+ | + | bool | v ) | +
Set a variable in lua to a new bool value.
+varname | Name of the variable to set. |
v | Value to set |
tz::error_code tz::lua_set_emptytable | +( | +std::string_view | varname | ) | ++ |
Set a variable in lua to be the empty table "{}".
+varname | Name of the variable to set. |
tz::error_code tz::lua_set_int | +( | +std::string_view | varname, | +
+ | + | std::int64_t | v ) | +
Set a variable in lua to a new int value.
+varname | Name of the variable to set. |
v | Value to set |
tz::error_code tz::lua_set_nil | +( | +std::string_view | varname | ) | ++ |
Set a variable in lua to be nil.
+varname | Name of the variable to set. |
tz::error_code tz::lua_set_number | +( | +std::string_view | varname, | +
+ | + | double | v ) | +
Set a variable in lua to a new number value.
+varname | Name of the variable to set. |
v | Value to set |
tz::error_code tz::lua_set_string | +( | +std::string_view | varname, | +
+ | + | std::string | str ) | +
Set a variable in lua to a new string value.
+varname | Name of the variable to set. |
str | Value to set |
std::expected< bool, tz::error_code > tz::lua_stack_get_bool | +( | +std::size_t | id | ) | ++ |
Retrieve a bool from the stack at the given index.
+id | Position on the stack to retrieve. |
std::expected< std::int64_t, tz::error_code > tz::lua_stack_get_int | +( | +std::size_t | id | ) | ++ |
Retrieve a int from the stack at the given index.
+id | Position on the stack to retrieve. |
std::expected< double, tz::error_code > tz::lua_stack_get_number | +( | +std::size_t | id | ) | ++ |
Retrieve a number from the stack at the given index.
+id | Position on the stack to retrieve. |
std::expected< std::string, tz::error_code > tz::lua_stack_get_string | +( | +std::size_t | id | ) | ++ |
Retrieve a string from the stack at the given index.
+id | Position on the stack to retrieve. |
+ Topaz 5.0
+
+ Topaz Game Engine
+ |
+
Basic mathematical geometric types. +More...
++Classes | |
struct | tz::vector< T, N > |
Represents the generic vector. More... | |
+Typedefs | |
+using | tz::v2i = vector<int, 2> |
2d integer vector. | |
+using | tz::v3i = vector<int, 3> |
3d integer vector. | |
+using | tz::v4i = vector<int, 4> |
4d integer vector. | |
+using | tz::v2u = vector<unsigned int, 2> |
2d unsigned integer vector. | |
+using | tz::v3u = vector<unsigned int, 3> |
3d unsigned integer vector. | |
+using | tz::v4u = vector<unsigned int, 4> |
4d unsigned integer vector. | |
+using | tz::v2f = vector<float, 2> |
2d single-precision floating-point vector. | |
+using | tz::v3f = vector<float, 3> |
3d single-precision floating-point vector. | |
+using | tz::v4f = vector<float, 4> |
4d single-precision floating-point vector. | |
+using | tz::v2d = vector<double, 2> |
2d double-precision floating-point vector. | |
+using | tz::v3d = vector<double, 3> |
3d double-precision floating-point vector. | |
+using | tz::v4d = vector<double, 4> |
4d double-precision floating-point vector. | |
Basic mathematical geometric types.
+
+ Topaz 5.0
+
+ Topaz Game Engine
+ |
+
Abstract rendering API for low-level, high-performance 3D desktop graphics. +More...
++Topics | |
Graphs | |
Documentation for render graphs - describes the execution of Passes. | |
Hardware | |
Documentation specialised for iterating over rendering hardware and selecting one to be used for rendering. | |
Passes | |
Documentation for render/compute passes - each a single node within Graphs. | |
Resources | |
Create/edit/destroy resources (images and buffers). | |
Settings | |
Global settings that affect all passes and graphs. The kind of stuff you'd expect to see in a game's video options. | |
Shaders | |
Create shaders to carry out programmable GPU work. | |
Abstract rendering API for low-level, high-performance 3D desktop graphics.
+This library provides a API to interact with a single desktop GPU, agnostic of whichever graphics API runs under-the-hood (e.g Vulkan/OpenGL/D3D12). When you use this library, the implementation will use one of these graphics APIs (which one is used depends on your platform and is configurable at compile-time) automatically with minimal overhead.
+If you intend to do 3D graphics in Topaz, you should first consult the Rendering Library incase a high-level implementation of what you want to achieve already exists. It is unlikely that the Rendering Library contains all the rendering components you need for a modern game, especially if your game has some more bespoke graphical features or its own unique style. In which case, you should use this library to build your feature from the ground-up.
+The GPU Library works as follows:
An example graph could be comprised of:
The timeline of GPU execution of this graph could look as follows:
+ Topaz 5.0
+
+ Topaz Game Engine
+ |
+
Documentation for render graphs - describes the execution of Passes. +More...
++Classes | |
struct | tz::gpu::graph_info |
Specifies creation flags for a new graph. More... | |
struct | tz::gpu::graph_builder |
Helper struct for creating a new graph. Follows the builder pattern. More... | |
+Functions | |
std::expected< graph_handle, tz::error_code > | tz::gpu::create_graph (graph_info graph) |
Create a new graph, which can be used for rendering a frame. | |
+void | tz::gpu::execute (graph_handle) |
Execute the graph - invoking all passes contained a single time. | |
Documentation for render graphs - describes the execution of Passes.
+std::expected< graph_handle, tz::error_code > tz::gpu::create_graph | +( | +graph_info | graph | ) | ++ |
Create a new graph, which can be used for rendering a frame.
+
+ Topaz 5.0
+
+ Topaz Game Engine
+ |
+
Documentation specialised for iterating over rendering hardware and selecting one to be used for rendering. +More...
++Classes | |
struct | tz::gpu::hardware |
Contains some basic information about a particular piece of hardware on the machine that the driver thinks could do GPU work. More... | |
+Enumerations | |
enum class | tz::gpu::hardware_type { hardware_type::gpu +, hardware_type::integrated_gpu +, hardware_type::cpu +, hardware_type::unknown + } |
Describes a specific type of rendering hardware. More... | |
enum class | tz::gpu::hardware_capabilities { hardware_capabilities::graphics_compute +, hardware_capabilities::graphics_only +, hardware_capabilities::compute_only +, hardware_capabilities::neither + } |
Describes what kind of GPU operations a rendering hardware can carry out when used. More... | |
enum class | tz::gpu::hardware_feature_coverage { hardware_feature_coverage::ideal +, hardware_feature_coverage::insufficient +, hardware_feature_coverage::poor +, _count + } |
Describes to what extent the rendering hardware supports all the features that Topaz requires. More... | |
+Functions | |
error_code | tz::gpu::iterate_hardware (std::span< hardware > hardwares, std::size_t *hardware_count=nullptr) |
Retrieve information about all detected rendering hardware currently available on the machine. | |
hardware | tz::gpu::find_best_hardware () |
Retrieve the "best" hardware hardware on your machine. | |
error_code | tz::gpu::use_hardware (hardware hw) |
Select a piece of hardware to use for future graphical operations. | |
hardware | tz::gpu::get_used_hardware () |
Retrieve the hardware that's currently being used. | |
Documentation specialised for iterating over rendering hardware and selecting one to be used for rendering.
+
+
|
+ +strong | +
Describes what kind of GPU operations a rendering hardware can carry out when used.
+
+
|
+ +strong | +
Describes to what extent the rendering hardware supports all the features that Topaz requires.
+Enumerator | |
---|---|
ideal | The hardware supports everything Topaz needs to do to support all GPU Library features. + |
insufficient | The hardware does not support all features, and as such could crash. + |
poor | The hardware does not come close to supporting all required features, and as such should not be attempted to be used. + |
+
|
+ +strong | +
Describes a specific type of rendering hardware.
+hardware tz::gpu::find_best_hardware | +( | +) | ++ |
Retrieve the "best" hardware hardware on your machine.
+This function prefers desktop GPUs that handle compute/graphics/transfer on the same queue.
+If you want more control over which hardware is used, or you don't trust Topaz's opinion, consider calling iterate_hardware and choosing one yourself.
+Unlike iterate_hardware, any error that the driver reports is considered fatal and will emit a tz_error.
+ +hardware tz::gpu::get_used_hardware | +( | +) | ++ |
Retrieve the hardware that's currently being used.
+
+
This will return the hardware selected in a previous call to use_hardware. If you have never selected a hardware component by calling this previous function, this function will emit a tz_error.
+ +error_code tz::gpu::iterate_hardware | +( | +std::span< hardware > | hardwares, | +
+ | + | std::size_t * | hardware_count = nullptr ) | +
Retrieve information about all detected rendering hardware currently available on the machine.
+hardwares | A region of memory through which hardware information shall be written to. As many hardware components as possible will be written, until all hardware has been listed or the region does not have enough available space. |
hardware_count | A pointer to a value which (if not-null) will be updated with the total number of rendering hardware components available on the machine. |
If you aren't interested in choosing a hardware yourself, and are happy to let Topaz figure out the best for you, use find_best_hardware instead of this.
+You should use this function if you:
error_code tz::gpu::use_hardware | +( | +hardware | hw | ) | ++ |
Select a piece of hardware to use for future graphical operations.
+hw | A hardware component of your choice that you wish to use to perform some GPU work. |
You must select a piece of hardware using this API call before attempting to submit any GPU work. There is no default hardware selection.
+
+ Topaz 5.0
+
+ Topaz Game Engine
+ |
+
Documentation for render/compute passes - each a single node within Graphs. +More...
++Classes | |
struct | tz::gpu::pass_graphics_state |
Specifies creation flags for a new graphics pass. More... | |
struct | tz::gpu::pass_compute_state |
Specifies creation flags for a new compute pass. More... | |
struct | tz::gpu::pass_info |
Specifies creation flags for a new pass. More... | |
+Typedefs | |
+using | tz::gpu::pass_handle = tz::handle<pass_info> |
Corresponds to a previously-created pass. | |
+Enumerations | |
enum class | tz::gpu::pass_type { pass_type::render +, pass_type::compute + } |
Describes what kind of GPU work a pass will involve. More... | |
enum | tz::gpu::graphics_flag { tz::gpu::dont_clear = 0b0001 +, tz::gpu::no_depth_test = 0b0010 +, tz::gpu::no_depth_write = 0b0100 + } |
Specifies optional behaviours for a graphics pass. More... | |
enum class | tz::gpu::cull { cull::both +, cull::front +, cull::back +, cull::none + } |
Specifies face culling behaviour of a graphics pass. More... | |
+Functions | |
std::expected< pass_handle, tz::error_code > | tz::gpu::create_pass (pass_info) |
Create a new pass. | |
void | tz::gpu::pass_set_triangle_count (pass_handle graphics_pass, std::size_t triangle_count) |
Set the triangle count of an existing graphics pass. | |
void | tz::gpu::pass_set_kernel (pass_handle compute_pass, tz::v3u kernel) |
Set the compute kernel of an existing compute pass. | |
tz::error_code | tz::gpu::pass_add_image_resource (pass_handle pass, resource_handle res) |
Add a new image resource to be used in the pass. | |
void | tz::gpu::destroy_pass (pass_handle) |
Manually destroy a pass. | |
Documentation for render/compute passes - each a single node within Graphs.
+
+
|
+ +strong | +
enum tz::gpu::graphics_flag | +
Specifies optional behaviours for a graphics pass.
+Enumerator | |
---|---|
dont_clear | Do not clear the colour target images prior to rendering - whatever data they held previously will be loaded prior to rendering. + |
no_depth_test | Disable depth testing - i.e fragments that are behind another may still draw over it. + |
no_depth_write | Disable depth writes - i.e when a depth test is passed by a fragment, the old depth value is not overwritten, but stays as it was before. +
|
+
|
+ +strong | +
std::expected< pass_handle, tz::error_code > tz::gpu::create_pass | +( | +pass_info | ) | ++ |
Create a new pass.
+Once you successfully create a pass, you can add it to a TODO: write docs on timelines
+Once you're done with a pass, you can manually destroy it using destroy_pass.
void tz::gpu::destroy_pass | +( | +pass_handle | ) | ++ |
Manually destroy a pass.
+Passes can be quite heavy in the context of both CPU and GPU memory. This is due to internal components such as recorded command buffers, synchronisation primitives and compiled shader code.
+Because of this, it might sometimes be necessary to manually destroy a pass once you are certain you have no further use of it. This will free up a bunch of CPU/GPU memory.
+tz::error_code tz::gpu::pass_add_image_resource | +( | +pass_handle | pass, | +
+ | + | resource_handle | res ) | +
Add a new image resource to be used in the pass.
+This will permanently increase the number of resources used in the pass. It is not possible to change the shader used by a pass, so the shader associated with the pass is expected to conditionally use the new image id anyway.
+All other resources used by the pass are unchanged. The index of this new image to be used in the shader will be equal to the previous number of images.
+ +void tz::gpu::pass_set_kernel | +( | +pass_handle | compute_pass, | +
+ | + | tz::v3u | kernel ) | +
Set the compute kernel of an existing compute pass.
+compute_pass | Compute pass to target. If you provide a graphics pass, nothing interesting happens. |
kernel | New workgroup dimensions to be dispatched every frame. |
When you created a compute pass, you set an initial kernel size via pass_compute_state::kernel. This function will override those dimensions, meaning the next time a pass submits GPU work, the new workgroup dimensions will be dispatched.
+There are no GPU-sync considerations involved when calling this function.
void tz::gpu::pass_set_triangle_count | +( | +pass_handle | graphics_pass, | +
+ | + | std::size_t | triangle_count ) | +
Set the triangle count of an existing graphics pass.
+graphics_pass | Graphics pass to target. If you provide a compute pass, nothing interesting happens. |
triangle_count | New number of triangles to render every frame. |
When you created a graphics pass, you set an initial triangle count via pass_graphics_state::triangle_count. This function will override that count, meaning the next time a pass submits GPU work, the new number of triangles will be rendered.
+There are no GPU-sync considerations involved when calling this function.
+ Topaz 5.0
+
+ Topaz Game Engine
+ |
+
Create/edit/destroy resources (images and buffers). +More...
++Classes | |
struct | tz::gpu::buffer_info |
Specifies creation flags for a buffer. More... | |
struct | tz::gpu::image_info |
Specifies creation flags for an image. More... | |
+Typedefs | |
+using | tz::gpu::resource_handle = tz::handle<buffer_info> |
Corresponds to a previously-created resource (buffer or image). | |
+Enumerations | |
enum | tz::gpu::buffer_flag { tz::gpu::index = 0b0001 +, tz::gpu::draw = 0b0010 +, tz::gpu::dynamic_access = 0b0100 + } |
Specifies optional behaviours for a buffer. More... | |
enum class | tz::gpu::image_type { image_type::rgba +, image_type::depth +, image_type::floats + } |
Describes the internal format of an image's data. More... | |
enum | tz::gpu::image_flag { tz::gpu::colour_target = 0b0001 +, tz::gpu::depth_target = 0b0010 + } |
Specifies optional behaviours for a buffer. More... | |
+Functions | |
std::expected< resource_handle, tz::error_code > | tz::gpu::create_buffer (buffer_info) |
Create a new buffer. | |
std::expected< resource_handle, tz::error_code > | tz::gpu::create_image (image_info) |
Create a new image. | |
tz::error_code | tz::gpu::destroy_resource (resource_handle res) |
Manually destroy a resource. | |
tz::error_code | tz::gpu::resource_write (resource_handle res, std::span< const std::byte > new_data, std::size_t offset=0) |
Write some new data to a resource. The thread will block until the changes are resident GPU-side. | |
std::span< const std::byte > | tz::gpu::resource_read (resource_handle res) |
Retrieves the current data within a resource. | |
tz::error_code | tz::gpu::index_buffer_write (resource_handle index_buffer, std::span< const index_t > indices) |
Write indices into a buffer resource. | |
tz::error_code | tz::gpu::draw_buffer_write (resource_handle draw_buffer, std::uint32_t count, std::span< const draw_t > draws) |
Write draw-indirect-count + commands into a buffer resource. | |
tz::error_code | tz::gpu::draw_buffer_indexed_write (resource_handle draw_buffer, std::uint32_t count, std::span< const draw_indexed_t > draws) |
Write draw-indirect-count + indexed commands into a buffer resource. | |
Create/edit/destroy resources (images and buffers).
+enum tz::gpu::buffer_flag | +
Specifies optional behaviours for a buffer.
+enum tz::gpu::image_flag | +
+
|
+ +strong | +
Describes the internal format of an image's data.
+You are not able to choose a specific sized format.
+std::expected< resource_handle, tz::error_code > tz::gpu::create_buffer | +( | +buffer_info | ) | ++ |
Create a new buffer.
+Once you successfully create a resource, you can use the returned resource_handle to create a new renderer that uses that resource.
+Once you're done with a resource, you can destroy it using destroy_resource.
std::expected< resource_handle, tz::error_code > tz::gpu::create_image | +( | +image_info | ) | ++ |
Create a new image.
+Once you successfully create a resource, you can use the returned resource_handle to create a new renderer that uses that resource.
+Once you're done with a resource, you can destroy it using destroy_resource.
tz::error_code tz::gpu::destroy_resource | +( | +resource_handle | res | ) | ++ |
Manually destroy a resource.
+If you know a resource uses alot of memory, or you're sure you're not going to use it anymore, you can destroy it here, causing all of its memory to be available for reuse.
+tz::error_code tz::gpu::draw_buffer_indexed_write | +( | +resource_handle | draw_buffer, | +
+ | + | std::uint32_t | count, | +
+ | + | std::span< const draw_indexed_t > | draws ) | +
Write draw-indirect-count + indexed commands into a buffer resource.
+This is a helper function which will call resource_write under-the-hood.
+ +tz::error_code tz::gpu::draw_buffer_write | +( | +resource_handle | draw_buffer, | +
+ | + | std::uint32_t | count, | +
+ | + | std::span< const draw_t > | draws ) | +
Write draw-indirect-count + commands into a buffer resource.
+This is a helper function which will call resource_write under-the-hood.
+ +tz::error_code tz::gpu::index_buffer_write | +( | +resource_handle | index_buffer, | +
+ | + | std::span< const index_t > | indices ) | +
Write indices into a buffer resource.
+This is a helper function which will call resource_write under-the-hood.
+ +std::span< const std::byte > tz::gpu::resource_read | +( | +resource_handle | res | ) | ++ |
Retrieves the current data within a resource.
+You aren't allowed to read from tz::gpu::window_resource.
+ +tz::error_code tz::gpu::resource_write | +( | +resource_handle | res, | +
+ | + | std::span< const std::byte > | new_data, | +
+ | + | std::size_t | offset = 0 ) | +
Write some new data to a resource. The thread will block until the changes are resident GPU-side.
+res | Resource whose data should be changed. |
new_data | Region containing new memory for the provided resource. |
If the region of new data is smaller than the total size of the resource's underlying data, then all bytes beyond the new data region will be unchanged and keep their previous state.
+Regarding buffer resources:
+ Topaz 5.0
+
+ Topaz Game Engine
+ |
+
Global settings that affect all passes and graphs. The kind of stuff you'd expect to see in a game's video options. +More...
++Functions | |
bool | tz::gpu::settings_get_vsync () |
Query as to whether vsync is enabled. | |
void | tz::gpu::settings_set_vsync (bool enabled) |
Enable/disable vsync. | |
Global settings that affect all passes and graphs. The kind of stuff you'd expect to see in a game's video options.
+bool tz::gpu::settings_get_vsync | +( | +) | ++ |
Query as to whether vsync is enabled.
+By default, vsync is disabled.
+ +void tz::gpu::settings_set_vsync | +( | +bool | enabled | ) | ++ |
Enable/disable vsync.
+By default, vsync is disabled. You should assume that this function will take a significantly long time.
+ +
+ Topaz 5.0
+
+ Topaz Game Engine
+ |
+
Create shaders to carry out programmable GPU work. +More...
++Macros | |
#define | ImportedShaderHeader(shader_name, shader_type) |
#define | ImportedShaderSource(shader_name, shader_type) |
+Typedefs | |
+using | tz::gpu::shader_handle = tz::handle<shader_tag_t> |
Corresponds to a previously-created shader program (for graphics or compute). | |
+Functions | |
std::expected< shader_handle, tz::error_code > | tz::gpu::create_graphics_shader (std::string_view vertex_source, std::string_view fragment_source) |
Create a new shader intended for graphics GPU work, comprised of a vertex and fragment shader. | |
std::expected< shader_handle, tz::error_code > | tz::gpu::create_compute_shader (std::string_view compute_source) |
Create a new shader intended for compute GPU work, comprised of a single compute shader. | |
void | tz::gpu::destroy_shader (shader_handle) |
Manually destroy a previously-created shader. | |
Create shaders to carry out programmable GPU work.
+#define ImportedShaderHeader | +( | +shader_name, | +|
+ | + | shader_type ) | +
Retrieves a file path which is intended to be #included in a application's main source file. Once included, the imported shader's source code can be retrieved as a constexpr string_view via ImportedShaderSource
+ +#define ImportedShaderSource | +( | +shader_name, | +|
+ | + | shader_type ) | +
Retrieves a token representing a std::string_view
which contains the shader's compiled results. On Vulkan, this will be SPIRV, and GLSL source code for OpenGL. You can only retrieve an imported shader's source if the imported header has been included via ImportedShaderHeader
std::expected< shader_handle, tz::error_code > tz::gpu::create_compute_shader | +( | +std::string_view | compute_source | ) | ++ |
Create a new shader intended for compute GPU work, comprised of a single compute shader.
+compute_source | Code for the compute shader, in SPIRV. |
std::expected< shader_handle, tz::error_code > tz::gpu::create_graphics_shader | +( | +std::string_view | vertex_source, | +
+ | + | std::string_view | fragment_source ) | +
Create a new shader intended for graphics GPU work, comprised of a vertex and fragment shader.
+vertex_source | Code for the vertex shader, in SPIRV. |
fragment_source | Code for the fragment shader, in SPIRV. |
void tz::gpu::destroy_shader | +( | +shader_handle | ) | ++ |
Manually destroy a previously-created shader.
+If you are certain that you are done with a shader program, you can destroy it here, causing all of its memory to be available for reuse.
+
+ Topaz 5.0
+
+ Topaz Game Engine
+ |
+
High-level library for wrangling files of various formats. +More...
++Classes | |
struct | tz::io::image_header |
Describes basic information about an image. More... | |
+Functions | |
std::expected< image_header, tz::error_code > | tz::io::image_info (std::span< const std::byte > img_file_data) |
Retrieve info about an image loaded in memory. | |
tz::error_code | tz::io::parse_image (std::span< const std::byte > img_file_data, std::span< std::byte > buffer) |
Load an image from file data resident in memory. | |
High-level library for wrangling files of various formats.
+This library contains support for a handful of common file formats, allowing you to import them without having to implement a parser yourself.
+std::expected< image_header, tz::error_code > tz::io::image_info | +( | +std::span< const std::byte > | img_file_data | ) | ++ |
Retrieve info about an image loaded in memory.
+img_file_data | Data read directly from an image file. See below for the list of supported image file formats. |
The image file formats guaranteed are:
Other file formats that aren't listed here might still work, but you should consider anything not on this list an implementation detail that could lose support suddenly in a new release.
+ +tz::error_code tz::io::parse_image | +( | +std::span< const std::byte > | img_file_data, | +
+ | + | std::span< std::byte > | buffer ) | +
Load an image from file data resident in memory.
+img_file_data | Data read directly from an image file. See the detailsof image_info for a list of supported image file formats. |
buffer | A buffer of memory into which decoded image data will be written. It is your responsibility to provide a buffer that is of sufficient size. To decipher the size needed, see image_info. |
+ Topaz 5.0
+
+ Topaz Game Engine
+ |
+
Cross-platform API to interact with operating-system level components, such as windowing, hardware input, and machine non-GPU hardware. +More...
++Topics | |
Input System | |
Retrieve keyboard/mouse input. | |
Window System | |
Creating, modifying and destroying OS windows. | |
Cross-platform API to interact with operating-system level components, such as windowing, hardware input, and machine non-GPU hardware.
+
+ Topaz 5.0
+
+ Topaz Game Engine
+ |
+
Retrieve keyboard/mouse input. +More...
++Enumerations | |
enum class | tz::os::key |
+Functions | |
tz::error_code | tz::os::install_char_typed_callback (char_type_callback callback) |
Install a callback which will be invoked whenever the user types a character on the keyboard. | |
bool | tz::os::is_key_pressed (key k) |
Query as to whether a specific key is pressed right now. | |
std::pair< unsigned int, unsigned int > | tz::os::get_mouse_position () |
Retrieve the mouse cursor's current position, in pixels, relative to the top-left of the window. | |
Retrieve keyboard/mouse input.
+
+
|
+ +strong | +
Represents a key on your keyboard.
+ +std::pair< unsigned int, unsigned int > tz::os::get_mouse_position | +( | +) | ++ |
Retrieve the mouse cursor's current position, in pixels, relative to the top-left of the window.
+If for whatever reason the cursor pos cannot be retrieved, {-1, -1} is returned. Some reasons could include:
tz::error_code tz::os::install_char_typed_callback | +( | +char_type_callback | callback | ) | ++ |
Install a callback which will be invoked whenever the user types a character on the keyboard.
+callback | Pointer to a function which will be called whenever a character is typed. If you pass nullptr, the callback will safely be ignored. |
bool tz::os::is_key_pressed | +( | +key | k | ) | ++ |
Query as to whether a specific key is pressed right now.
+k | Keyboard key to query |
+ Topaz 5.0
+
+ Topaz Game Engine
+ |
+
Creating, modifying and destroying OS windows. +More...
++Classes | |
struct | tz::os::window_info |
Basic customisation of a newly-opened window. More... | |
+Enumerations | |
enum | tz::os::window_flags { } |
Optional behaviours/attributes when opening windows. More... | |
+Functions | |
tz::error_code | tz::os::open_window (window_info winfo) |
Open a new window. | |
tz::error_code | tz::os::close_window () |
Close a previously-opened window. | |
bool | tz::os::window_is_open () |
Query as to whether a window has been opened that has not yet been closed. | |
void | tz::os::window_update () |
Poll updates for a window, advancing input events etc. | |
window_handle | tz::os::get_window_handle () |
Retrieve a opaque handle corresponding to the underlying window native. | |
unsigned int | tz::os::window_get_width () |
Retrieve the width of the window, in pixels. | |
unsigned int | tz::os::window_get_height () |
Retrieve the height of the window, in pixels. | |
void | tz::os::window_set_dimensions (unsigned int width, unsigned int height) |
Set a new width and height for the open window. | |
std::string | tz::os::window_get_title () |
Retrieve the title of the window. | |
void | tz::os::window_set_title (std::string_view title) |
Set a new title for the open window. | |
void | tz::os::window_maximise () |
Maximise the window, causing it to cover the whole screen. | |
void | tz::os::window_minimise () |
Minimise the window, causing it to no longer be visible until maximised/shown. | |
void | tz::os::window_show () |
Show the window as normal, even if it is currently maximised/minimised/fullscreen. | |
void | tz::os::window_fullscreen () |
Display the window in proper fullscreen. | |
Creating, modifying and destroying OS windows.
+enum tz::os::window_flags | +
Optional behaviours/attributes when opening windows.
+Enumerator | |
---|---|
centered_window | Ignore the x and y coordinates provided within window_info and position the window approximately in the middle of the screen instead. + |
maximised | Ignore the width and height provided within window_info and set set the window as maximised instead. + |
transparent | When a pixel of the window's framebuffer is never drawn to, instead of being a clamped colour it is instead fully transparent. Your mileage may vary, depending on your platform. + |
invisible | When the window is "opened", it is completely invisible to the user. They won't see the window, nor will it be visible in the OS' taskbar. + |
tz::error_code tz::os::close_window | +( | +) | ++ |
Close a previously-opened window.
+Only one window can be open at a time - If you have called this function before but have not since closed the previous window, it will automatically be closed.
+ +window_handle tz::os::get_window_handle | +( | +) | ++ |
Retrieve a opaque handle corresponding to the underlying window native.
+HWND
via (HWND)(uintptr_t)handle.peek()
tz::error_code tz::os::open_window | +( | +window_info | winfo | ) | ++ |
Open a new window.
+Only one window can be open at a time - If you have called this function before but have not since closed the previous window, it will automatically be closed.
+ +void tz::os::window_fullscreen | +( | +) | ++ |
Display the window in proper fullscreen.
+unsigned int tz::os::window_get_height | +( | +) | ++ |
Retrieve the height of the window, in pixels.
+See window_set_dimensions to programatically resize the window.
+ +std::string tz::os::window_get_title | +( | +) | ++ |
Retrieve the title of the window.
+unsigned int tz::os::window_get_width | +( | +) | ++ |
Retrieve the width of the window, in pixels.
+See window_set_dimensions to programatically resize the window.
+ +bool tz::os::window_is_open | +( | +) | ++ |
Query as to whether a window has been opened that has not yet been closed.
+void tz::os::window_maximise | +( | +) | ++ |
Maximise the window, causing it to cover the whole screen.
+void tz::os::window_minimise | +( | +) | ++ |
Minimise the window, causing it to no longer be visible until maximised/shown.
+void tz::os::window_set_dimensions | +( | +unsigned int | width, | +
+ | + | unsigned int | height ) | +
Set a new width and height for the open window.
+void tz::os::window_set_title | +( | +std::string_view | title | ) | ++ |
Set a new title for the open window.
+void tz::os::window_show | +( | +) | ++ |
Show the window as normal, even if it is currently maximised/minimised/fullscreen.
+void tz::os::window_update | +( | +) | ++ |
Poll updates for a window, advancing input events etc.
+If an open window does not exist, this function safely does nothing.
+ +
+ Topaz 5.0
+
+ Topaz Game Engine
+ |
+
High-level declarative rendering API built upon the GPU Library. +
+High-level declarative rendering API built upon the GPU Library.
+This library contains some pre-created high-level rendering systems used for common tasks, such as rendering 3D models, or user interface. These components are intended to be used in most Topaz games, with the goal of not needing to reinvent the wheel in every single game using the Rendering Library.
+
+ Topaz 5.0
+
+ Topaz Game Engine
+ |
+
+ Topaz 5.0
+
+ Topaz Game Engine
+ |
+
+ Topaz 5.0
+
+ Topaz Game Engine
+ |
+
+ Topaz 5.0
+
+ Topaz Game Engine
+ |
+
Topaz is a 3D graphics engine.
Topaz 4.2.0 is the most recent release of the Topaz Engine. The next version is Topaz 5.0, currently in early development on the master branch.
+The Topaz project has been ongoing since it began as a school project in 2015.
+Each major version is a total rewrite and thus completely different from the previous. Each minor version typically consists of API-breaking feature changes. Patch versions are not formally shipped unless they contain emergency bugfixes for a flawed release.
Topaz Version | Release Date | Branch | Documentation |
---|---|---|---|
5.0 | TBD | master | harrand.github.io |
4.2.0 | Apr 23, 2024 | Topaz4.2 | Branch: gh-pages-tz4.2 |
4.1.0 | Dec 1, 2023 | Topaz4.1 | Branch: gh-pages-tz4.1 |
4.0.0 | July 9, 2023 | Topaz4.0 | Branch: gh-pages-tz4.0 |
3.6.1 | Dec 10, 2022 | Topaz3.6 | Branch: gh-pages-tz3.6 |
3.6.0 | Dec 8, 2022 | Topaz3.6 | Branch: gh-pages-tz3.6 |
3.5.0 | Sep 22, 2022 | Topaz3.5 | Branch: gh-pages-tz3.5 |
3.4.0 | Aug 3, 2022 | Topaz3.4 | Branch: gh-pages-tz3.4 |
3.3.0 | Jun 12, 2022 | Topaz3.3 | Branch: gh-pages-tz3.3 |
3.2.0 | Apr 23, 2022 | Topaz3.2 | Branch: gh-pages-tz3.2 |
3.1.0 | Feb 13, 2022 | Topaz3.1 | Branch: gh-pages-tz3.1 |
3.0.0 | Sep 17, 2021 | Topaz3.0 | Branch: gh-pages-tz3 |
2.0.0 | May 9, 2021 | Topaz2.0 | Branch: gh-pages-tz2 |
1.0.0 | Sep 25, 2020 | Topaz1.0 | Branch: gh-pages-tz1 |
Topaz Version | Release Date | Release |
---|---|---|
0.7.0 | Apr 10, 2019 | Raycasts, Octrees & Improved Utility |
0.6.0 | Jul 18, 2018 | Shadow Mapping & Physics |
0.5.1 | Dec 12, 2017 | Refactoring 1 |
0.5.0 | Oct 8, 2017 | Physics & Collision |
0.4.0 | Sep 25, 2017 | Displacement Maps & Skyboxes |
0.3.0 | Sep 21, 2017 | GUI & Flexible |
0.2.0 | Jun 5, 2017 | Prettier, faster and more features |
0.1.6 | Apr 16, 2017 | Skybox & Audio |
0.1.5 | Apr 11, 2017 | Dynamic Lighting |
0.1.4 | Apr 9, 2017 | Audio |
0.1.3 | Mar 29, 2017 | World Construction |
0.1.2 | Mar 25, 2017 | Hightail House Construction |
0.1.1 | Mar 24, 2017 | Parallax Displacement Mapping |
0.1.0 | Mar 21, 2017 | Dev Test |
Configure CMake. It is recommended you use a preset.
+Example: cmake --preset host_vulkan_debug
topaz
target to build the engine. Run the tztest
target to build and run all unit-tests.The table below shows all the engine's dependencies.
+Dependency | Render API | Build Config | Dependency Type |
---|---|---|---|
Vulkan SDK | Vulkan | All | Needs pre-installation |
The following requirements apply for all possible build configurations:
+ Topaz 5.0
+
+ Topaz Game Engine
+ |
+
+ Topaz 5.0
+
+ Topaz Game Engine
+ |
+