Skip to content

Namespace atlas

Namespace List > atlas

More...

Namespaces

Type Name
namespace event
namespace filesystem
namespace physics
Handles error handling with in jolt.
namespace sync_update
namespace ui
namespace vk

Classes

Type Name
class application
struct application_settings
struct box_collider3d
class camera
class console_log_manager
class entity_t
class graphics_context
class interpolation
struct light
TODO: Make this better (when we do lighting)
struct material
struct math_generic <typename T>
struct matrix2 <typename T>
struct matrix3 <typename T>
struct matrix4 <typename T>
class mesh
struct reload
Actually might do a query for this along with rendertarget3d.
class render_context
class renderer
struct rigidbody3d
class scene_object
class scene_scope
class serializer
class system_registry
struct tag
class thread
class timer
struct transform
struct transform_physics
struct vector2 <typename T>
struct vector2< glm::highp_vec2 > <>
struct vector3 <typename T>
struct vector3< JPH::Vec3 > <>
struct vector3< glm::highp_vec3 > <>
struct vector4 <typename T>
struct vector4< glm::highp_vec4 > <>
class window
struct window_settings
Specific settings to the window configuration.
class world_scope
Lets rethink how world_scope gets created.

Public Types

Type Name
enum CameraMovement
enum api
typedef vector2< glm::highp_vec2 > highp_vec2
typedef vector3< glm::highp_vec3 > highp_vec3
typedef vector4< glm::highp_vec4 > highp_vec4
typedef math_generic< glm::mat< C, R, T > > mat
typedef matrix2< glm::mat2 > mat2
typedef matrix3< glm::mat3 > mat3
typedef matrix4< glm::mat4 > mat4
typedef std::shared_ptr< T > ref
typedef std::unique_ptr< T > scope
typedef math_generic< glm::vec< Size, T > > vec
typedef vector2< glm::vec2 > vec2
typedef vector3< glm::vec3 > vec3
typedef vector4< glm::vec4 > vec4
typedef std::weak_ptr< T > weak_ptr

Public Functions

Type Name
void attach (UObject * p_instance, const UCallable & p_callable)
constexpr ref< T > create_ref (Args &&... args)
constexpr scope< T > create_scope (Args &&... args)
constexpr weak_ptr< T > create_weak_ptr (Args &&... args)
ref< window > create_window (const window_settings & p_settings)
uint32_t get_thread_count ()
void hash_combine (size_t & seed, const T & v, const Rest &... rest)
ref< application > initialize_application ()
ref< graphics_context > initialize_context (const std::string & p_tag)
scope< render_context > initialize_renderer (const vk::vk_swapchain & p_swapchain, const std::string & p_tag)
void post (UObject * p_instance, const UCallable & p_callable)
void sync (UObject * p_instance, const UCallable & p_callable)
void sync_physics (UObject * p_instance, const UCallable & p_callable)
weak_ptr< T > to_weak_ptr (const U & p_value)

Public Static Functions

Type Name
void core_assert (bool x, T &&... args)

Detailed Description

Note:

This is just a class abstraction idea

class swapchain { public: virtual ~swapchain();

uint32_t read_acquired_next_image();

private: virtual uint32_t swapchain_read_acquried_image() = 0; };

Here are responsibilities I want the renderer/vk_renderer to have Task graph for command buffer submission/execution API's are going to be using defer_submit API's are potentially (with ???) using immediate_submit

Public Types Documentation

enum CameraMovement

enum atlas::CameraMovement {
    forward,
    backward,
    left,
    right,
    up,
    down
};

enum api

enum atlas::api {
    vulkan,
    dx11,
    fx12,
    undefined
};

typedef highp_vec2

using atlas::highp_vec2 = typedef vector2<glm::highp_vec2>;

typedef highp_vec3

using atlas::highp_vec3 = typedef vector3<glm::highp_vec3>;

typedef highp_vec4

using atlas::highp_vec4 = typedef vector4<glm::highp_vec4>;

typedef mat

using atlas::mat = typedef math_generic<glm::mat<C, R, T> >;

typedef mat2

using atlas::mat2 = typedef matrix2<glm::mat2>;

typedef mat3

using atlas::mat3 = typedef matrix3<glm::mat3>;

typedef mat4

using atlas::mat4 = typedef matrix4<glm::mat4>;

typedef ref

using atlas::ref = typedef std::shared_ptr<T>;

Note:

Some aliases for the smart pointers

typedef scope

using atlas::scope = typedef std::unique_ptr<T>;

typedef vec

using atlas::vec = typedef math_generic<glm::vec<Size, T> >;

Note:

By default we use glm

typedef vec2

using atlas::vec2 = typedef vector2<glm::vec2>;

typedef vec3

using atlas::vec3 = typedef vector3<glm::vec3>;

typedef vec4

using atlas::vec4 = typedef vector4<glm::vec4>;

typedef weak_ptr

using atlas::weak_ptr = typedef std::weak_ptr<T>;

Public Functions Documentation

function attach

template<typename UObject, typename UCallable>
void atlas::attach (
    UObject * p_instance,
    const UCallable & p_callable
)

function create_ref

template<typename T, typename... Args>
constexpr ref < T > atlas::create_ref (
    Args &&... args
)

function create_scope

template<typename T, typename... Args>
constexpr scope< T > atlas::create_scope (
    Args &&... args
)

function create_weak_ptr

template<typename T, typename... Args>
constexpr weak_ptr< T > atlas::create_weak_ptr (
    Args &&... args
)

function create_window

ref < window > atlas::create_window (
    const window_settings & p_settings
)

function get_thread_count

uint32_t atlas::get_thread_count ()

function hash_combine

template<typename T, typename... Rest>
void atlas::hash_combine (
    size_t & seed,
    const T & v,
    const Rest &... rest
)

function initialize_application

ref < application > atlas::initialize_application ()

function initialize_context

ref < graphics_context > atlas::initialize_context (
    const std::string & p_tag
)

function initialize_renderer

scope< render_context > atlas::initialize_renderer (
    const vk::vk_swapchain & p_swapchain,
    const std::string & p_tag
)

function post

template<typename UObject, typename UCallable>
void atlas::post (
    UObject * p_instance,
    const UCallable & p_callable
)

function sync

template<typename UObject, typename UCallable>
void atlas::sync (
    UObject * p_instance,
    const UCallable & p_callable
)

Note:

These are public functions that users can utilize

Note:

If users are using anything within the sync_update namespace. They shouldn't

function sync_physics

template<typename UObject, typename UCallable>
void atlas::sync_physics (
    UObject * p_instance,
    const UCallable & p_callable
)

function to_weak_ptr

template<typename T, typename U>
weak_ptr< T > atlas::to_weak_ptr (
    const U & p_value
)

Public Static Functions Documentation

function core_assert

template<typename... T>
static void atlas::core_assert (
    bool x,
    T &&... args
)

The documentation for this class was generated from the following file TheAtlasEngine/atlas/components/transform.hpp