Acid  0.14.1
A high speed C++17 Vulkan game engine.
Data Structures | Typedefs | Enumerations | Functions | Variables
acid Namespace Reference

Data Structures

class  AnimatedMesh
 Class that represents an animated armature with a skin mesh. More...
 
class  Animation
 Class that represents an animation that can be carried out by an animated entity. It contains the length of the animation in seconds, and a list of Keyframes. More...
 
class  AnimationLoader
 
class  Animator
 Class that contains all the functionality to apply an animation to an animated entity. An Animator instance is associated with just one animated entity. It also keeps track of the running time (in seconds) of the current animation, along with a reference to the currently playing animation for the corresponding entity. More...
 
class  App
 Class that represents a application. More...
 
class  Attachment
 Class that represents an attachment in a renderpass. More...
 
class  Audio
 Module used for loading, managing and playing a variety of different sound types. More...
 
class  AxisInputButton
 InputButton composed of a axis. More...
 
class  BaseFStream
 
class  BestFitConstraint
 Sets the width or height of a rectangle to best fit inside of the parents constraints. More...
 
class  Bitmap
 
class  BitmapFactory
 
class  BitMask
 Wrapper that differentiates combined enumerators from a single enumerator to prevent accidental comparisons between a bitmask and a single enumerator using operator== or operator!=. More...
 
class  BlitFilter
 
class  BlurFilter
 
class  BlurPipeline
 
class  BounceDriver
 A bounce driver that uses a sine wave. More...
 
class  Buffer
 Interface that represents a buffer. More...
 
class  ButtonInputAxis
 InputAxis composed of two buttons. More...
 
class  Camera
 Component that represents a scene camera, this object should be overridden with new behaviour. More...
 
class  CapsuleCollider
 
class  ChangePerSecond
 
class  CircleEmitter
 
class  Collider
 Class that represents a physics shape. More...
 
class  CollisionObject
 Represents a object in a scene effected by physics. More...
 
class  Colour
 Holds a RGBA colour. More...
 
class  CommandBuffer
 Class that represents a command buffer. More...
 
class  CommandPool
 Class that represents a command pool. More...
 
class  Component
 Class that represents a functional component attached to entity. More...
 
class  CompoundInputAxis
 Combines multiple axes inputs into a single axis. More...
 
class  CompoundInputButton
 Combines multiple button inputs into a single button. More...
 
class  ConeCollider
 
class  ConstantDriver
 A driver that has a constant value. More...
 
class  ConvexHullCollider
 
class  CrtFilter
 
class  CubeCollider
 
class  CubeModel
 Resource that represents a cube model. More...
 
class  CylinderCollider
 
class  CylinderModel
 Resource that represents a cylinder model. More...
 
class  DarkenFilter
 
class  DefaultFilter
 
class  DefaultMaterial
 Class that represents the default material shader. More...
 
class  DeferredSubrender
 
class  Delegate
 
class  Delegate< TReturnType(TArgs ...)>
 
class  DelegateValue
 
class  Delta
 
class  Descriptor
 
class  DescriptorSet
 
class  DescriptorsHandler
 Class that handles a descriptor set. More...
 
class  DiskModel
 Resource that represents a disk model. More...
 
class  DngBitmap
 
class  DofFilter
 
class  ElapsedTime
 
class  EmbossFilter
 
class  Emitter
 Component interface that defines a emitter volume. More...
 
struct  EnableBitMaskOperators
 
class  Engine
 Main class for Acid, manages modules and updates. After creating your Engine object call Engine#Run to start. More...
 
class  Entity
 Class that represents a objects that acts as a component container. More...
 
class  EntityPrefab
 Resource that represents a entity prefab. More...
 
class  Enumerator
 Wrapper for an enumerator that provides implicit bool conversion. More...
 
struct  EnumIterator
 
class  ExrBitmap
 
class  Factory
 
class  FadeDriver
 A driver that fades from start to end. More...
 
class  FBuffer
 
class  File
 Class that represents a readable and writable file format using Node as storage. More...
 
class  FileObserver
 Class that can listen to file changes on a path recursively. More...
 
class  Files
 Module used for managing files on engine updates. More...
 
class  FlacSoundBuffer
 
class  Fog
 Component that represents a 3d fog. More...
 
class  FontsSubrender
 
class  FontType
 Resource that is used when creating a font mesh. More...
 
class  Force
 Represents a force that is attached to a Rigidbody. More...
 
class  Framebuffers
 
class  Frustum
 Represents the region of space in the modeled world that may appear on the screen. More...
 
class  FStream
 
class  Ftp
 A very simple FTP client that allows you to communicate with a FTP server. The FTP protocol allows you to manipulate a remote file system (list files, upload, download, create, remove, ...). More...
 
class  FtpDataChannel
 Utility class for exchanging datas with the server on the data channel. More...
 
class  FtpResponse
 Define a FTP response. More...
 
class  FtpResponseDirectory
 Specialization of FTP response returning a directory. More...
 
class  FtpResponseListing
 Specialization of FTP response returning a filename listing. More...
 
class  Future
 Class that holds a future and it's value that will update as future gets new valid values. More...
 
class  FxaaFilter
 
class  GammaRamp
 Class used to describe the gamma ramp for a monitor. More...
 
class  GeometryLoader
 
class  Gizmo
 A instance of a gizmo type. More...
 
class  Gizmos
 Module used for that manages debug gizmos. More...
 
class  GizmosSubrender
 
class  GizmoType
 Resource that represents a gizmo type. More...
 
class  GltfModel
 Resource that represents a GLTF model. More...
 
class  GrainFilter
 
class  Graphics
 Module that manages the Vulkan instance, Surface, Window and the renderpass structure. More...
 
class  GreyFilter
 
class  Gui
 Class that represents a image UI. More...
 
class  GuisSubrender
 
class  HeightfieldCollider
 
class  Http
 A very simple HTTP client that allows you to communicate with a web server. You can retrieve web pages, send data to an interactive resource, download a remote file, etc. The HTTPS protocol is not supported. More...
 
class  HttpRequest
 Defines a HTTP request. More...
 
class  HttpResponse
 Defines a HTTP response. More...
 
class  IFStream
 
class  Image
 A representation of a Vulkan image, sampler, and view. More...
 
class  Image2d
 Resource that represents a 2D image. More...
 
class  Image2dArray
 Resource that represents an array of 2D images. More...
 
class  ImageCube
 Resource that represents a cubemap image. More...
 
class  ImageDepth
 Resource that represents a depth stencil image. More...
 
class  Input
 Module used for managing abstract inputs organized in schemes. More...
 
class  InputAxis
 Interface for an axis based input device. More...
 
class  InputButton
 Interface for a binary input device. More...
 
class  InputDelay
 
class  InputScheme
 
class  Instance
 
class  InstanceBuffer
 
class  Invoker
 
class  Invoker< void, TArgs... >
 
class  IpAddress
 A utility class for manipulating network addresses. It provides a set a implicit constructors and conversion functions to easily build or transform an IP address from/to various representations. More...
 
struct  is_map
 
struct  is_map< T, std::void_t< typename T::key_type, typename T::mapped_type, decltype(std::declval< T & >()[std::declval< const typename T::key_type & >()])> >
 
struct  is_optional
 
struct  is_optional< std::optional< T > >
 
struct  is_pair
 
struct  is_pair< std::pair< T, U > >
 
struct  is_shared_ptr
 
struct  is_shared_ptr< std::shared_ptr< T > >
 
struct  is_unique_ptr
 
struct  is_unique_ptr< std::unique_ptr< T, D > >
 
struct  is_vector
 
struct  is_vector< std::vector< T, A > >
 
struct  is_weak_ptr
 
struct  is_weak_ptr< std::weak_ptr< T > >
 
class  Joint
 Class that represents a joint in a "skeleton". It contains the index of the joint which determines where in the vertex shader uniform array the joint matrix for this joint is loaded up to. It also contains the name of the bone, and a list of all the child joints. More...
 
class  JointTransform
 Class that represents the local bone-space transform of a joint at a certain keyframe during an animation. This includes the position and rotation of the joint, relative to the parent joint (or relative to the model's origin if it's the root joint). The transform is stored as a position vector and a quaternion (rotation) so that these values can be easily interpolated, a functionality that this class also provides. More...
 
class  JoystickHatInput
 InputButton from a joystick. More...
 
class  JoystickInputAxis
 InputAxis input from a joystick input device. More...
 
class  JoystickInputButton
 InputButton input from a joystick input device. More...
 
class  Joysticks
 Module used for the creation, updating and destruction of the joysticks. More...
 
class  JpgBitmap
 
class  Json
 
class  Keyboard
 Module used for managing a virtual keyboard. More...
 
class  KeyboardInputButton
 InputButton input from the keyboard input device. More...
 
class  Keyframe
 Class that represents one keyframe of an animation. This contains the timestamp of the keyframe, which is the time (in seconds) from the start of the animation when this keyframe occurs. More...
 
class  KinematicCharacter
 Represents a kinematic character controller. More...
 
class  LensflareFilter
 
class  Light
 Component that represents a point light. More...
 
class  LinearDriver
 A driver that linearly increases its value. More...
 
class  LineEmitter
 
class  Log
 A logging class used in Acid, will write output to the standard stream and into a file. More...
 
class  Loggable
 
class  LogicalDevice
 
class  Material
 Component that represents a material shader that is used to render a model. The implementation of this object must initialize Material#pipelineMaterial in Material#CreatePipeline(). More...
 
class  MaterialPipeline
 Resource that represents a material pipeline. More...
 
class  MaterialStreamReader
 
class  Maths
 Class that holds many various math functions. More...
 
class  Matrix2
 Holds a row major 2x2 matrix. More...
 
class  Matrix3
 Holds a row major 3x3 matrix. More...
 
class  Matrix4
 Holds a row major 4x4 matrix. More...
 
class  Mesh
 Component that represents a model/mesh. More...
 
class  MeshesSubrender
 
class  Model
 Resource that represents a model vertex and index buffer. More...
 
class  ModelFactory
 
class  Module
 A interface used for defining engine modules. More...
 
class  ModuleFactory
 
class  Monitor
 Class used to represent a monitor. More...
 
class  Mouse
 Module used for managing a virtual mouse. More...
 
class  MouseInputAxis
 InputAxis input from a mouse. More...
 
class  MouseInputButton
 InputButton input from the mouse input device. More...
 
class  Mp3SoundBuffer
 
class  NegativeFilter
 
class  Node
 Class that is used to represent a tree of UFT-8 values, used in serialization. More...
 
class  NodeConstView
 Class that is returned from a Node when getting constant properties. This represents a key tree from a parent, this allows reads of large trees with broken nodes to not need to generate new content. More...
 
class  NodeView
 Class that extends the usage of NodeConstView to mutable nodes. More...
 
class  NonCopyable
 Class that removes the copy constructor and operator from derived classes, while leaving move. More...
 
class  ObjModel
 Resource that represents a OBJ model. More...
 
class  Observer
 
class  OffsetSize
 
class  OFStream
 
class  OggSoundBuffer
 
class  OpusSoundBuffer
 
class  Packet
 Packets provide a safe and easy way to serialize data, in order to send it over the network using sockets (acid::TcpSocket, acid::UdpSocket). More...
 
class  Particle
 A instance of a particle type. More...
 
class  Particles
 A manager that manages particles. More...
 
class  ParticlesSubrender
 
class  ParticleSystem
 A system of particles. More...
 
class  ParticleType
 Resource that represents a particle type. More...
 
class  PatternMesh
 
class  PendingPacket
 TCP is a connected protocol, which means that a TCP socket can only communicate with the host it is connected to. It can't send or receive anything if it is not connected. More...
 
class  PhysicalDevice
 
class  Pipeline
 Class that is used to represent a pipeline. More...
 
class  PipelineCompute
 Class that represents a compute compute pipeline. More...
 
class  PipelineGraphics
 Class that represents a graphics pipeline. More...
 
class  PipelineGraphicsCreate
 
class  PixelConstraint
 Applied away from a vertex of the parent constraint (default: left top). More...
 
class  PixelFilter
 
class  PngBitmap
 
class  PointEmitter
 
class  PostFilter
 Represents a post effect pipeline. More...
 
class  PostPipeline
 Represents a system of post effects. More...
 
class  PushHandler
 Class that handles a pipeline push constant. More...
 
class  Quaternion
 A vector like object of the form w + xi + yj + zk, where w, x, y, z are real numbers and i, j, k are imaginary units. More...
 
class  RatioConstraint
 Sets the width or height of a rectangle to a ratio of the opposite sides value. More...
 
class  Ray
 Class that represents a 3 dimensional ray. More...
 
class  Raycast
 
class  RectangleModel
 Resource that represents a rectangle model. More...
 
class  RelativeConstraint
 Position relative to a vertex of the parent (default: left top), or size as percentage of the parent. More...
 
class  RenderArea
 
class  Renderer
 Class used to manage Subrender objects to create a list of render pass. More...
 
class  Renderpass
 
class  RenderStage
 
class  Resource
 A managed resource object. Implementations contain Create functions that can take a node object or pass parameters to the constructor. More...
 
class  Resources
 Module used for managing resources. Resources are held alive as long as they are in use, a existing resource is queried by node value. More...
 
class  Rigidbody
 Represents a object in a scene effected by physics. More...
 
class  RingBuffer
 A constant-sized non-overwriting circular queue. More...
 
class  Scene
 Class that is used to represent a scene. More...
 
class  ScenePhysics
 
class  Scenes
 Module used for managing game scenes. More...
 
class  SceneStructure
 Class that represents a structure of spatial objects. More...
 
class  SepiaFilter
 
class  Shader
 Class that loads and processes a shader, and provides a reflection. More...
 
class  ShaderIncluder
 
class  ShadowBox
 Represents the 3D area of the world in which engine.shadows will be cast (basically represents the orthographic projection area for the shadow render pass). It can be updated each frame to optimize the area, making it as small as possible (to allow for optimal shadow map resolution) while not being too small to avoid objects not having shadows when they should. This class also provides functionality to test whether an object is inside this shadow box. Everything inside the box will be rendered to the shadow map in the shadow render pass. More...
 
class  ShadowRender
 Component that is used to render a entity as a shadow. More...
 
class  Shadows
 Module used for managing a shadow map. More...
 
class  ShadowsSubrender
 
class  SimpleMesh
 
class  SinewaveDriver
 A driver that uses a sine wave. More...
 
class  SkeletonLoader
 
class  SkinLoader
 
class  SkyboxMaterial
 Class that represents a skybox material shader. More...
 
class  SlideDriver
 A driver that slides to its destination using cosine interpolation. More...
 
class  Socket
 This class mainly defines internal stuff to be used by derived classes. More...
 
class  SocketSelector
 Socket selectors provide a way to wait until some data is available on a set of sockets, instead of just one. This is convenient when you have multiple sockets that may possibly receive data, but you don't know which one will be ready first. In particular, it avoids to use a thread for each socket; with selectors, a single thread can handle all the sockets. More...
 
class  Sound
 Class that represents a playable sound. More...
 
class  SoundBuffer
 Resource that represents a sound buffer. More...
 
class  SoundBufferFactory
 
class  SphereCollider
 
class  SphereEmitter
 
class  SphereModel
 Resource that represents a sphere model. More...
 
class  SsaoFilter
 
class  StorageBuffer
 
class  StorageHandler
 Class that handles a storage buffer. More...
 
class  StreamFactory
 
class  String
 Helper class for C++ strings. More...
 
class  SubpassType
 
class  Subrender
 Represents a render pipeline that is used to render a type of pipeline. More...
 
class  SubrenderHolder
 Class that contains and manages subrenders registered to a render manager. More...
 
class  Surface
 
class  Swapchain
 
class  TcpListener
 A listener socket is a special type of socket that listens to a given port and waits for connections on that port. This is all it can do. More...
 
class  TcpSocket
 Specialized socket using the TCP protocol. More...
 
class  Text
 Class that represents a text in a GUI. More...
 
class  ThreadPool
 A fixed size pool of threads. More...
 
class  TiltshiftFilter
 
class  Time
 Represents a time value stored in microseconds. More...
 
class  Timer
 
class  Timers
 Module used for timed events. More...
 
class  ToneFilter
 
class  Transform
 Holds position, rotation, and scale components. More...
 
class  TypeInfo
 
class  UdpSocket
 A UDP socket is a connectionless socket. Instead of connecting once to a remote host, like TCP sockets, it can send to and receive from any host at any time. More...
 
class  UiAnchor
 
class  UiBooleanInput
 
class  UiButtonInput
 
class  UiConstraint
 
class  UiConstraints
 
class  UiDriver
 Represents a driver that changes over time. More...
 
class  UiDropdownInput
 
class  UiGrabberInput
 
class  UiGrabberJoystick
 
class  UiGrabberKeyboard
 
class  UiGrabberMouse
 
class  UiObject
 A representation of a object this is rendered to a screen. This object is contained in a parent and has children. The screen object has a few values that allow for it to be positioned and scaled, along with other variables that are used when rendering. This class can be extended to create a representation for GUI images, fonts, etc. More...
 
class  UiPanel
 
class  UiRadioInput
 
class  UiRadioManager
 
class  Uis
 Module used for managing gui textures in a container. More...
 
class  UiScrollBar
 
class  UiSection
 
class  UiSliderInput
 
class  UiStartLogo
 
class  UiTextInput
 
class  UniformBuffer
 
class  UniformHandler
 Class that handles a uniform buffer. More...
 
class  Vector2
 Holds a 2-tuple vector. More...
 
class  Vector3
 Holds a 3-tuple vector. More...
 
class  Vector4
 Holds a 4-tuple vector. More...
 
class  Version
 
class  Vertex2d
 
class  Vertex3d
 
class  VertexAnimated
 
class  VertexText
 
class  VertexWeights
 
class  VideoMode
 Class used to describe the video mode for a monitor. More...
 
class  Viewport
 
class  VignetteFilter
 
class  WaveSoundBuffer
 
class  Window
 Module used for managing a window. More...
 
class  WobbleFilter
 
class  WriteDescriptorSet
 
class  Xml
 
class  ZipArchive
 The ZipArchive class represents the zip archive file as a whole. It consists of the individual zip entries, which can be both files and folders. It is the main access point into a .zip archive on disk and can be used to create new archives and to open and modify existing archives. More...
 
class  ZipEntry
 
class  ZipEntryMetaData
 
class  ZipException
 
class  ZipExceptionAllocFailed
 
class  ZipExceptionArchiveTooLarge
 
class  ZipExceptionBufferTooSmall
 
class  ZipExceptionCompressionFailed
 
class  ZipExceptionCrcCheckFailed
 
class  ZipExceptionDecompressionFailed
 
class  ZipExceptionFailedFindingCentralDir
 
class  ZipExceptionFileCloseFailed
 
class  ZipExceptionFileCreateFailed
 
class  ZipExceptionFileNotFound
 
class  ZipExceptionFileOpenFailed
 
class  ZipExceptionFileReadFailed
 
class  ZipExceptionFileSeekFailed
 
class  ZipExceptionFileStatFailed
 
class  ZipExceptionFileTooLarge
 
class  ZipExceptionFileWriteFailed
 
class  ZipExceptionInternalError
 
class  ZipExceptionInvalidFilename
 
class  ZipExceptionInvalidHeader
 
class  ZipExceptionInvalidParameter
 
class  ZipExceptionMultidiskUnsupported
 
class  ZipExceptionNotAnArchive
 
class  ZipExceptionTooManyFiles
 
class  ZipExceptionUndefined
 
class  ZipExceptionUnexpectedDecompSize
 
class  ZipExceptionUnsupportedCDirSize
 
class  ZipExceptionUnsupportedEncryption
 
class  ZipExceptionUnsupportedFeature
 
class  ZipExceptionUnsupportedMethod
 
class  ZipExceptionValidationFailed
 
class  ZipExceptionWriteCallbackFailed
 

Typedefs

using JoystickPort = uint8_t
 
using JoystickAxis = uint8_t
 
using JoystickButton = uint8_t
 
using JoystickHat = uint8_t
 
using ZipEntryInfo = mz_zip_archive_file_stat
 
using ZipEntryData = std::vector< std::byte >
 
using JoystickHatInputAxis = JoystickHatInput
 
using JoystickHatInputButton = JoystickHatInput
 
using Vector2f = Vector2< float >
 
using Vector2d = Vector2< double >
 
using Vector2i = Vector2< int32_t >
 
using Vector2ui = Vector2< uint32_t >
 
using Vector2us = Vector2< uint16_t >
 
using Vector3f = Vector3< float >
 
using Vector3d = Vector3< double >
 
using Vector3i = Vector3< int32_t >
 
using Vector3ui = Vector3< uint32_t >
 
using Vector4f = Vector4< float >
 
using Vector4d = Vector4< double >
 
using Vector4i = Vector4< int32_t >
 
using Vector4ui = Vector4< uint32_t >
 
using SocketHandle = int32_t
 
using SocketAddrLength = unsigned int
 
using CollisionPair = std::pair< const btCollisionObject *, const btCollisionObject * >
 
using CollisionPairs = std::set< CollisionPair >
 
using TypeId = std::size_t
 

Enumerations

enum  JoystickHatValue : uint8_t {
  JoystickHatValue::Centered = 0, JoystickHatValue::Up = 1, JoystickHatValue::Right = 2, JoystickHatValue::Down = 4,
  JoystickHatValue::Left = 8
}
 
enum  Key : int16_t {
  Key::Unknown = -1, Key::Space = 32, Key::Apostrophe = 39, Key::Comma = 44,
  Key::Minus = 45, Key::Period = 46, Key::Slash = 47, Key::_0 = 48,
  Key::_1 = 49, Key::_2 = 50, Key::_3 = 51, Key::_4 = 52,
  Key::_5 = 53, Key::_6 = 54, Key::_7 = 55, Key::_8 = 56,
  Key::_9 = 57, Key::Semicolon = 59, Key::Equal = 61, Key::A = 65,
  Key::B = 66, Key::C = 67, Key::D = 68, Key::E = 69,
  Key::F = 70, Key::G = 71, Key::H = 72, Key::I = 73,
  Key::J = 74, Key::K = 75, Key::L = 76, Key::M = 77,
  Key::N = 78, Key::O = 79, Key::P = 80, Key::Q = 81,
  Key::R = 82, Key::S = 83, Key::T = 84, Key::U = 85,
  Key::V = 86, Key::W = 87, Key::X = 88, Key::Y = 89,
  Key::Z = 90, Key::LeftBracket = 91, Key::Backslash = 92, Key::RightBracket = 93,
  Key::GraveAccent = 96, Key::World1 = 161, Key::World2 = 162, Key::Escape = 256,
  Key::Enter = 257, Key::Tab = 258, Key::Backspace = 259, Key::Insert = 260,
  Key::Delete = 261, Key::Right = 262, Key::Left = 263, Key::Down = 264,
  Key::Up = 265, Key::PageUp = 266, Key::PageDown = 267, Key::Home = 268,
  Key::End = 269, Key::CapsLock = 280, Key::ScrollLock = 281, Key::NumLock = 282,
  Key::PrintScreen = 283, Key::Pause = 284, Key::F1 = 290, Key::F2 = 291,
  Key::F3 = 292, Key::F4 = 293, Key::F5 = 294, Key::F6 = 295,
  Key::F7 = 296, Key::F8 = 297, Key::F9 = 298, Key::F10 = 299,
  Key::F11 = 300, Key::F12 = 301, Key::F13 = 302, Key::F14 = 303,
  Key::F15 = 304, Key::F16 = 305, Key::F17 = 306, Key::F18 = 307,
  Key::F19 = 308, Key::F20 = 309, Key::F21 = 310, Key::F22 = 311,
  Key::F23 = 312, Key::F24 = 313, Key::F25 = 314, Key::Numpad0 = 320,
  Key::Numpad1 = 321, Key::Numpad2 = 322, Key::Numpad3 = 323, Key::Numpad4 = 324,
  Key::Numpad5 = 325, Key::Numpad6 = 326, Key::Numpad7 = 327, Key::Numpad8 = 328,
  Key::Numpad9 = 329, Key::NumpadDecimal = 330, Key::NumpadDivide = 331, Key::NumpadMultiply = 332,
  Key::NumpadSubtract = 333, Key::NumpadAdd = 334, Key::NumpadEnter = 335, Key::NumpadEqual = 336,
  Key::ShiftLeft = 340, Key::ControlLeft = 341, Key::AltLeft = 342, Key::SuperLeft = 343,
  Key::ShiftRight = 344, Key::ControlRight = 345, Key::AltRight = 346, Key::SuperRight = 347,
  Key::Menu = 348, Key::First = Space, Key::Last = Menu
}
 
enum  MouseButton : uint8_t {
  MouseButton::_1 = 0, MouseButton::_2 = 1, MouseButton::_3 = 2, MouseButton::_4 = 3,
  MouseButton::_5 = 4, MouseButton::_6 = 5, MouseButton::_7 = 6, MouseButton::_8 = 7,
  MouseButton::Left = _1, MouseButton::Right = _2, MouseButton::Middle = _3, MouseButton::First = _1,
  MouseButton::Last = _8
}
 
enum  CursorHotspot : uint8_t {
  CursorHotspot::UpperLeft, CursorHotspot::UpperRight, CursorHotspot::BottomLeft, CursorHotspot::BottomRight,
  CursorHotspot::Centered
}
 
enum  CursorStandard : uint32_t {
  CursorStandard::Arrow = 0x00036001, CursorStandard::IBeam = 0x00036002, CursorStandard::Crosshair = 0x00036003, CursorStandard::Hand = 0x00036004,
  CursorStandard::ResizeX = 0x00036005, CursorStandard::ResizeY = 0x00036006
}
 
enum  InputAction : int32_t { InputAction::Release = 0, InputAction::Press = 1, InputAction::Repeat = 2 }
 
enum  InputMod : int32_t {
  InputMod::None = 0, InputMod::Shift = 1, InputMod::Control = 2, InputMod::Alt = 4,
  InputMod::Super = 8
}
 
enum  FileMode { FileMode::Read, FileMode::Write, FileMode::Append }
 
enum  UiConstraintType { UiConstraintType::X, UiConstraintType::Y, UiConstraintType::Width, UiConstraintType::Height }
 
enum  UiManipulate { UiManipulate::None = 0, UiManipulate::Resize = 1, UiManipulate::Move = 2, UiManipulate::All = Resize | Move }
 
enum  ScrollBar { ScrollBar::None = 0, ScrollBar::Vertical = 1, ScrollBar::Horizontal = 2, ScrollBar::Both = Vertical | Horizontal }
 

Functions

const Nodeoperator>> (const Node &node, AnimatedMesh &animatedMesh)
 
Nodeoperator<< (Node &node, const AnimatedMesh &animatedMesh)
 
const Nodeoperator>> (const Node &node, Animation &animation)
 
Nodeoperator<< (Node &node, const Animation &animation)
 
const Nodeoperator>> (const Node &node, JointTransform &jointTransform)
 
Nodeoperator<< (Node &node, const JointTransform &jointTransform)
 
const Nodeoperator>> (const Node &node, Keyframe &keyframe)
 
Nodeoperator<< (Node &node, const Keyframe &keyframe)
 
const Nodeoperator>> (const Node &node, Joint &joint)
 
Nodeoperator<< (Node &node, const Joint &joint)
 
const Nodeoperator>> (const Node &node, Sound &sound)
 
Nodeoperator<< (Node &node, const Sound &sound)
 
const Nodeoperator>> (const Node &node, SoundBuffer &soundBuffer)
 
Nodeoperator<< (Node &node, const SoundBuffer &soundBuffer)
 
VKAPI_ATTR VkBool32 VKAPI_CALL CallbackDebug (VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char *pLayerPrefix, const char *pMessage, void *pUserData)
 
void CallbackJoystick (int32_t id, int32_t event)
 
 ENABLE_BITMASK_OPERATORS (JoystickHatValue)
 
void CallbackKey (GLFWwindow *window, int32_t key, int32_t scancode, int32_t action, int32_t mods)
 
void CallbackChar (GLFWwindow *window, uint32_t codepoint)
 
void CallbackMouseButton (GLFWwindow *window, int32_t button, int32_t action, int32_t mods)
 
void CallbackCursorPos (GLFWwindow *window, double xpos, double ypos)
 
void CallbackCursorEnter (GLFWwindow *window, int32_t entered)
 
void CallbackScroll (GLFWwindow *window, double xoffset, double yoffset)
 
void CallbackDrop (GLFWwindow *window, int32_t count, const char **paths)
 
void CallbackError (int32_t error, const char *description)
 
void CallbackMonitor (GLFWmonitor *monitor, int32_t event)
 
void CallbackWindowPosition (GLFWwindow *window, int32_t xpos, int32_t ypos)
 
void CallbackWindowSize (GLFWwindow *window, int32_t width, int32_t height)
 
void CallbackWindowClose (GLFWwindow *window)
 
void CallbackWindowFocus (GLFWwindow *window, int32_t focused)
 
void CallbackWindowIconify (GLFWwindow *window, int32_t iconified)
 
void CallbackFramebufferSize (GLFWwindow *window, int32_t width, int32_t height)
 
int32_t OverlappingArea (Vector2i l1, Vector2i r1, Vector2i l2, Vector2i r2)
 
 ENABLE_BITMASK_OPERATORS (InputAction)
 
 ENABLE_BITMASK_OPERATORS (InputMod)
 
PHYSFS_File * OpenWithMode (const std::filesystem::path &filename, FileMode openMode)
 
const Nodeoperator>> (const Node &node, Node &object)
 
Nodeoperator<< (Node &node, const Node &object)
 
Nodeoperator<< (Node &node, const std::nullptr_t &object)
 
template<typename T , std::enable_if_t< std::is_pointer_v< T >, int > = 0>
Nodeoperator<< (Node &node, const T object)
 
template<typename T >
const Nodeoperator>> (const Node &node, std::unique_ptr< T > &object)
 
template<typename T >
Nodeoperator<< (Node &node, const std::unique_ptr< T > &object)
 
template<typename T >
const Nodeoperator>> (const Node &node, std::shared_ptr< T > &object)
 
template<typename T >
Nodeoperator<< (Node &node, const std::shared_ptr< T > &object)
 
const Nodeoperator>> (const Node &node, bool &object)
 
Nodeoperator<< (Node &node, bool object)
 
template<typename T , std::enable_if_t< std::is_arithmetic_v< T >||std::is_enum_v< T >, int > = 0>
const Nodeoperator>> (const Node &node, T &object)
 
const Nodeoperator>> (const Node &node, char *&string)
 
Nodeoperator<< (Node &node, const char *string)
 
Nodeoperator<< (Node &node, std::string_view string)
 
const Nodeoperator>> (const Node &node, std::string &string)
 
Nodeoperator<< (Node &node, const std::string &string)
 
const Nodeoperator>> (const Node &node, std::filesystem::path &object)
 
Nodeoperator<< (Node &node, const std::filesystem::path &object)
 
template<typename T , typename K >
const Nodeoperator>> (const Node &node, std::pair< T, K > &pair)
 
template<typename T , typename K >
Nodeoperator<< (Node &node, const std::pair< T, K > &pair)
 
template<typename T >
const Nodeoperator>> (const Node &node, std::optional< T > &optional)
 
template<typename T >
Nodeoperator<< (Node &node, const std::optional< T > &optional)
 
template<typename T >
const Nodeoperator>> (const Node &node, std::vector< T > &vector)
 
template<typename T >
Nodeoperator<< (Node &node, const std::vector< T > &vector)
 
template<typename T , typename K >
const Nodeoperator>> (const Node &node, std::map< T, K > &map)
 
template<typename T , typename K >
Nodeoperator<< (Node &node, const std::map< T, K > &map)
 
const Nodeoperator>> (const Node &node, FontType &fontType)
 
Nodeoperator<< (Node &node, const FontType &fontType)
 
const Nodeoperator>> (const Node &node, GizmoType &gizmoType)
 
Nodeoperator<< (Node &node, const GizmoType &gizmoType)
 
const Nodeoperator>> (const Node &node, Image2d &image)
 
Nodeoperator<< (Node &node, const Image2d &image)
 
const Nodeoperator>> (const Node &node, ImageCube &image)
 
Nodeoperator<< (Node &node, const ImageCube &image)
 
EShLanguage GetEshLanguage (VkShaderStageFlags stageFlag)
 
TBuiltInResource GetResources ()
 
const Nodeoperator>> (const Node &node, Shader &shader)
 
Nodeoperator<< (Node &node, const Shader &shader)
 
const Nodeoperator>> (const Node &node, VkVertexInputBindingDescription &bindingDescription)
 
Nodeoperator<< (Node &node, const VkVertexInputBindingDescription &bindingDescription)
 
const Nodeoperator>> (const Node &node, VkVertexInputAttributeDescription &attributeDescription)
 
Nodeoperator<< (Node &node, const VkVertexInputAttributeDescription &attributeDescription)
 
template<typename T >
TypeId GetSubrenderTypeId () noexcept
 
const Nodeoperator>> (const Node &node, ButtonInputAxis &inputAxis)
 
Nodeoperator<< (Node &node, const ButtonInputAxis &inputAxis)
 
const Nodeoperator>> (const Node &node, CompoundInputAxis &inputAxis)
 
Nodeoperator<< (Node &node, const CompoundInputAxis &inputAxis)
 
const Nodeoperator>> (const Node &node, JoystickHatInput &input)
 
Nodeoperator<< (Node &node, const JoystickHatInput &input)
 
const Nodeoperator>> (const Node &node, JoystickInputAxis &inputAxis)
 
Nodeoperator<< (Node &node, const JoystickInputAxis &inputAxis)
 
const Nodeoperator>> (const Node &node, MouseInputAxis &inputAxis)
 
Nodeoperator<< (Node &node, const MouseInputAxis &inputAxis)
 
const Nodeoperator>> (const Node &node, AxisInputButton &inputButton)
 
Nodeoperator<< (Node &node, const AxisInputButton &inputButton)
 
const Nodeoperator>> (const Node &node, CompoundInputButton &inputButton)
 
Nodeoperator<< (Node &node, const CompoundInputButton &inputButton)
 
const Nodeoperator>> (const Node &node, JoystickInputButton &inputButton)
 
Nodeoperator<< (Node &node, const JoystickInputButton &inputButton)
 
const Nodeoperator>> (const Node &node, KeyboardInputButton &inputButton)
 
Nodeoperator<< (Node &node, const KeyboardInputButton &inputButton)
 
const Nodeoperator>> (const Node &node, MouseInputButton &inputButton)
 
Nodeoperator<< (Node &node, const MouseInputButton &inputButton)
 
const Nodeoperator>> (const Node &node, InputScheme &inputScheme)
 
Nodeoperator<< (Node &node, const InputScheme &inputScheme)
 
const Nodeoperator>> (const Node &node, Fog &fog)
 
Nodeoperator<< (Node &node, const Fog &fog)
 
const Nodeoperator>> (const Node &node, Light &light)
 
Nodeoperator<< (Node &node, const Light &light)
 
const Nodeoperator>> (const Node &node, DefaultMaterial &material)
 
Nodeoperator<< (Node &node, const DefaultMaterial &material)
 
const Nodeoperator>> (const Node &node, MaterialPipeline &pipeline)
 
Nodeoperator<< (Node &node, const MaterialPipeline &pipeline)
 
constexpr Colour operator+ (const Colour &lhs, const Colour &rhs)
 
constexpr Colour operator- (const Colour &lhs, const Colour &rhs)
 
constexpr Colour operator* (const Colour &lhs, const Colour &rhs)
 
constexpr Colour operator/ (const Colour &lhs, const Colour &rhs)
 
constexpr Colour operator+ (float lhs, const Colour &rhs)
 
constexpr Colour operator- (float lhs, const Colour &rhs)
 
constexpr Colour operator* (float lhs, const Colour &rhs)
 
constexpr Colour operator/ (float lhs, const Colour &rhs)
 
constexpr Colour operator+ (const Colour &lhs, float rhs)
 
constexpr Colour operator- (const Colour &lhs, float rhs)
 
constexpr Colour operator* (const Colour &lhs, float rhs)
 
constexpr Colour operator/ (const Colour &lhs, float rhs)
 
const Nodeoperator>> (const Node &node, Colour &colour)
 
Nodeoperator<< (Node &node, const Colour &colour)
 
std::ostream & operator<< (std::ostream &stream, const Colour &colour)
 
const Nodeoperator>> (const Node &node, ElapsedTime &elapsedTime)
 
Nodeoperator<< (Node &node, const ElapsedTime &elapsedTime)
 
static std::mt19937 RandomGenerator (RandomDevice())
 
Matrix2 operator+ (const Matrix2 &left, const Matrix2 &right)
 
Matrix2 operator- (const Matrix2 &left, const Matrix2 &right)
 
Matrix2 operator* (const Matrix2 &left, const Matrix2 &right)
 
Matrix2 operator/ (const Matrix2 &left, const Matrix2 &right)
 
Matrix2 operator* (const Vector2f &left, const Matrix2 &right)
 
Matrix2 operator/ (const Vector2f &left, const Matrix2 &right)
 
Matrix2 operator* (const Matrix2 &left, const Vector2f &right)
 
Matrix2 operator/ (const Matrix2 &left, const Vector2f &right)
 
Matrix2 operator* (float left, const Matrix2 &right)
 
Matrix2 operator/ (float left, const Matrix2 &right)
 
Matrix2 operator* (const Matrix2 &left, float right)
 
Matrix2 operator/ (const Matrix2 &left, float right)
 
const Nodeoperator>> (const Node &node, Matrix2 &matrix)
 
Nodeoperator<< (Node &node, const Matrix2 &matrix)
 
std::ostream & operator<< (std::ostream &stream, const Matrix2 &matrix)
 
Matrix3 operator+ (const Matrix3 &left, const Matrix3 &right)
 
Matrix3 operator- (const Matrix3 &left, const Matrix3 &right)
 
Matrix3 operator* (const Matrix3 &left, const Matrix3 &right)
 
Matrix3 operator/ (const Matrix3 &left, const Matrix3 &right)
 
Matrix3 operator* (const Vector3f &left, const Matrix3 &right)
 
Matrix3 operator/ (const Vector3f &left, const Matrix3 &right)
 
Matrix3 operator* (const Matrix3 &left, const Vector3f &right)
 
Matrix3 operator/ (const Matrix3 &left, const Vector3f &right)
 
Matrix3 operator* (float left, const Matrix3 &right)
 
Matrix3 operator/ (float left, const Matrix3 &right)
 
Matrix3 operator* (const Matrix3 &left, float right)
 
Matrix3 operator/ (const Matrix3 &left, float right)
 
const Nodeoperator>> (const Node &node, Matrix3 &matrix)
 
Nodeoperator<< (Node &node, const Matrix3 &matrix)
 
std::ostream & operator<< (std::ostream &stream, const Matrix3 &matrix)
 
Matrix4 operator+ (const Matrix4 &left, const Matrix4 &right)
 
Matrix4 operator- (const Matrix4 &left, const Matrix4 &right)
 
Matrix4 operator* (const Matrix4 &left, const Matrix4 &right)
 
Matrix4 operator/ (const Matrix4 &left, const Matrix4 &right)
 
Matrix4 operator* (const Vector4f &left, const Matrix4 &right)
 
Matrix4 operator/ (const Vector4f &left, const Matrix4 &right)
 
Matrix4 operator* (const Matrix4 &left, const Vector4f &right)
 
Matrix4 operator/ (const Matrix4 &left, const Vector4f &right)
 
Matrix4 operator* (float left, const Matrix4 &right)
 
Matrix4 operator/ (float left, const Matrix4 &right)
 
Matrix4 operator* (const Matrix4 &left, float right)
 
Matrix4 operator/ (const Matrix4 &left, float right)
 
const Nodeoperator>> (const Node &node, Matrix4 &matrix)
 
Nodeoperator<< (Node &node, const Matrix4 &matrix)
 
std::ostream & operator<< (std::ostream &stream, const Matrix4 &matrix)
 
Quaternion operator+ (const Quaternion &lhs, const Quaternion &rhs)
 
Quaternion operator- (const Quaternion &lhs, const Quaternion &rhs)
 
Quaternion operator* (const Quaternion &lhs, const Quaternion &rhs)
 
Vector3f operator* (const Vector3f &lhs, const Quaternion &rhs)
 
Vector3f operator* (const Quaternion &lhs, const Vector3f &rhs)
 
Quaternion operator* (float lhs, const Quaternion &rhs)
 
Quaternion operator* (const Quaternion &lhs, float rhs)
 
const Nodeoperator>> (const Node &node, Quaternion &quaternion)
 
Nodeoperator<< (Node &node, const Quaternion &quaternion)
 
std::ostream & operator<< (std::ostream &stream, const Quaternion &quaternion)
 
constexpr Time operator+ (const Time &lhs, const Time &rhs)
 
constexpr Time operator- (const Time &lhs, const Time &rhs)
 
constexpr Time operator* (const Time &lhs, float rhs)
 
constexpr Time operator* (const Time &lhs, int64_t rhs)
 
constexpr Time operator* (float lhs, const Time &rhs)
 
constexpr Time operator* (int64_t lhs, const Time &rhs)
 
constexpr Time operator/ (const Time &lhs, float rhs)
 
constexpr Time operator/ (const Time &lhs, int64_t rhs)
 
constexpr double operator/ (const Time &lhs, const Time &rhs)
 
const Nodeoperator>> (const Node &node, Time &time)
 
Nodeoperator<< (Node &node, const Time &time)
 
Transform operator* (const Transform &lhs, const Transform &rhs)
 
const Nodeoperator>> (const Node &node, Transform &transform)
 
Nodeoperator<< (Node &node, const Transform &transform)
 
std::ostream & operator<< (std::ostream &stream, const Transform &transform)
 
template<typename K >
const Nodeoperator>> (const Node &node, Vector2< K > &vector)
 
template<typename K >
Nodeoperator<< (Node &node, const Vector2< K > &vector)
 
template<typename K >
std::ostream & operator<< (std::ostream &stream, const Vector2< K > &vector)
 
template<typename K , typename J >
constexpr auto operator+ (const Vector2< K > &left, const Vector2< J > &right)
 
template<typename K , typename J >
constexpr auto operator- (const Vector2< K > &left, const Vector2< J > &right)
 
template<typename K , typename J >
constexpr auto operator* (const Vector2< K > &left, const Vector2< J > &right)
 
template<typename K , typename J >
constexpr auto operator/ (const Vector2< K > &left, const Vector2< J > &right)
 
template<typename K , typename J >
constexpr auto operator+ (const K &left, const Vector2< J > &right)
 
template<typename K , typename J >
constexpr auto operator- (const K &left, const Vector2< J > &right)
 
template<typename K , typename J >
constexpr auto operator* (const K &left, const Vector2< J > &right)
 
template<typename K , typename J >
constexpr auto operator/ (const K &left, const Vector2< J > &right)
 
template<typename K , typename J >
constexpr auto operator+ (const Vector2< K > &left, const J &right)
 
template<typename K , typename J >
constexpr auto operator- (const Vector2< K > &left, const J &right)
 
template<typename K , typename J >
constexpr auto operator* (const Vector2< K > &left, const J &right)
 
template<typename K , typename J >
constexpr auto operator/ (const Vector2< K > &left, const J &right)
 
template<typename K , typename J >
constexpr std::enable_if_t< std::is_integral_v< K > &&std::is_integral_v< J >, Vector2< J > > operator& (const Vector2< K > &left, const Vector2< J > &right)
 
template<typename K , typename J >
constexpr std::enable_if_t< std::is_integral_v< K > &&std::is_integral_v< J >, Vector2< J > > operator| (const Vector2< K > &left, const Vector2< J > &right)
 
template<typename K , typename J >
constexpr std::enable_if_t< std::is_integral_v< K > &&std::is_integral_v< J >, Vector2< J > > operator>> (const Vector2< K > &left, const Vector2< J > &right)
 
template<typename K , typename J >
constexpr std::enable_if_t< std::is_integral_v< K > &&std::is_integral_v< J >, Vector2< J > > operator<< (const Vector2< K > &left, const Vector2< J > &right)
 
template<typename K , typename J >
constexpr std::enable_if_t< std::is_integral_v< K > &&std::is_integral_v< J >, Vector2< J > > operator& (const Vector2< K > &left, const J &right)
 
template<typename K , typename J >
constexpr std::enable_if_t< std::is_integral_v< K > &&std::is_integral_v< J >, Vector2< J > > operator| (const Vector2< K > &left, const J &right)
 
template<typename K , typename J >
constexpr std::enable_if_t< std::is_integral_v< K > &&std::is_integral_v< J >, Vector2< J > > operator>> (const Vector2< K > &left, const J &right)
 
template<typename K , typename J >
constexpr std::enable_if_t< std::is_integral_v< K > &&std::is_integral_v< J >, Vector2< J > > operator<< (const Vector2< K > &left, const J &right)
 
template<typename K >
const Nodeoperator>> (const Node &node, Vector3< K > &vector)
 
template<typename K >
Nodeoperator<< (Node &node, const Vector3< K > &vector)
 
template<typename K >
std::ostream & operator<< (std::ostream &stream, const Vector3< K > &vector)
 
template<typename K , typename J >
constexpr auto operator+ (const Vector3< K > &left, const Vector3< J > &right)
 
template<typename K , typename J >
constexpr auto operator- (const Vector3< K > &left, const Vector3< J > &right)
 
template<typename K , typename J >
constexpr auto operator* (const Vector3< K > &left, const Vector3< J > &right)
 
template<typename K , typename J >
constexpr auto operator/ (const Vector3< K > &left, const Vector3< J > &right)
 
template<typename K , typename J >
constexpr auto operator+ (const K &left, const Vector3< J > &right)
 
template<typename K , typename J >
constexpr auto operator- (const K &left, const Vector3< J > &right)
 
template<typename K , typename J >
constexpr auto operator* (const K &left, const Vector3< J > &right)
 
template<typename K , typename J >
constexpr auto operator/ (const K &left, const Vector3< J > &right)
 
template<typename K , typename J >
constexpr auto operator+ (const Vector3< K > &left, const J &right)
 
template<typename K , typename J >
constexpr auto operator- (const Vector3< K > &left, const J &right)
 
template<typename K , typename J >
constexpr auto operator* (const Vector3< K > &left, const J &right)
 
template<typename K , typename J >
constexpr auto operator/ (const Vector3< K > &left, const J &right)
 
template<typename K , typename J >
constexpr std::enable_if_t< std::is_integral_v< K > &&std::is_integral_v< J >, Vector3< J > > operator& (const Vector3< K > &left, const Vector3< J > &right)
 
template<typename K , typename J >
constexpr std::enable_if_t< std::is_integral_v< K > &&std::is_integral_v< J >, Vector3< J > > operator| (const Vector3< K > &left, const Vector3< J > &right)
 
template<typename K , typename J >
constexpr std::enable_if_t< std::is_integral_v< K > &&std::is_integral_v< J >, Vector3< J > > operator>> (const Vector3< K > &left, const Vector3< J > &right)
 
template<typename K , typename J >
constexpr std::enable_if_t< std::is_integral_v< K > &&std::is_integral_v< J >, Vector3< J > > operator<< (const Vector3< K > &left, const Vector3< J > &right)
 
template<typename K , typename J >
constexpr std::enable_if_t< std::is_integral_v< K > &&std::is_integral_v< J >, Vector3< J > > operator& (const Vector3< K > &left, const J &right)
 
template<typename K , typename J >
constexpr std::enable_if_t< std::is_integral_v< K > &&std::is_integral_v< J >, Vector3< J > > operator| (const Vector3< K > &left, const J &right)
 
template<typename K , typename J >
constexpr std::enable_if_t< std::is_integral_v< K > &&std::is_integral_v< J >, Vector3< J > > operator>> (const Vector3< K > &left, const J &right)
 
template<typename K , typename J >
constexpr std::enable_if_t< std::is_integral_v< K > &&std::is_integral_v< J >, Vector3< J > > operator<< (const Vector3< K > &left, const J &right)
 
template<typename K >
const Nodeoperator>> (const Node &node, Vector4< K > &vector)
 
template<typename K >
Nodeoperator<< (Node &node, const Vector4< K > &vector)
 
template<typename K >
std::ostream & operator<< (std::ostream &stream, const Vector4< K > &vector)
 
template<typename K , typename J >
constexpr auto operator+ (const Vector4< K > &left, const Vector4< J > &right)
 
template<typename K , typename J >
constexpr auto operator- (const Vector4< K > &left, const Vector4< J > &right)
 
template<typename K , typename J >
constexpr auto operator* (const Vector4< K > &left, const Vector4< J > &right)
 
template<typename K , typename J >
constexpr auto operator/ (const Vector4< K > &left, const Vector4< J > &right)
 
template<typename K , typename J >
constexpr auto operator+ (const K &left, const Vector4< J > &right)
 
template<typename K , typename J >
constexpr auto operator- (const K &left, const Vector4< J > &right)
 
template<typename K , typename J >
constexpr auto operator* (const K &left, const Vector4< J > &right)
 
template<typename K , typename J >
constexpr auto operator/ (const K &left, const Vector4< J > &right)
 
template<typename K , typename J >
constexpr auto operator+ (const Vector4< K > &left, const J &right)
 
template<typename K , typename J >
constexpr auto operator- (const Vector4< K > &left, const J &right)
 
template<typename K , typename J >
constexpr auto operator* (const Vector4< K > &left, const J &right)
 
template<typename K , typename J >
constexpr auto operator/ (const Vector4< K > &left, const J &right)
 
template<typename K , typename J >
constexpr std::enable_if_t< std::is_integral_v< K > &&std::is_integral_v< J >, Vector4< J > > operator& (const Vector4< K > &left, const Vector4< J > &right)
 
template<typename K , typename J >
constexpr std::enable_if_t< std::is_integral_v< K > &&std::is_integral_v< J >, Vector4< J > > operator| (const Vector4< K > &left, const Vector4< J > &right)
 
template<typename K , typename J >
constexpr std::enable_if_t< std::is_integral_v< K > &&std::is_integral_v< J >, Vector4< J > > operator>> (const Vector4< K > &left, const Vector4< J > &right)
 
template<typename K , typename J >
constexpr std::enable_if_t< std::is_integral_v< K > &&std::is_integral_v< J >, Vector4< J > > operator<< (const Vector4< K > &left, const Vector4< J > &right)
 
template<typename K , typename J >
constexpr std::enable_if_t< std::is_integral_v< K > &&std::is_integral_v< J >, Vector4< J > > operator& (const Vector4< K > &left, const J &right)
 
template<typename K , typename J >
constexpr std::enable_if_t< std::is_integral_v< K > &&std::is_integral_v< J >, Vector4< J > > operator| (const Vector4< K > &left, const J &right)
 
template<typename K , typename J >
constexpr std::enable_if_t< std::is_integral_v< K > &&std::is_integral_v< J >, Vector4< J > > operator>> (const Vector4< K > &left, const J &right)
 
template<typename K , typename J >
constexpr std::enable_if_t< std::is_integral_v< K > &&std::is_integral_v< J >, Vector4< J > > operator<< (const Vector4< K > &left, const J &right)
 
const Nodeoperator>> (const Node &node, Mesh &mesh)
 
Nodeoperator<< (Node &node, const Mesh &mesh)
 
const Nodeoperator>> (const Node &node, GltfModel &model)
 
Nodeoperator<< (Node &node, const GltfModel &model)
 
const Nodeoperator>> (const Node &node, ObjModel &model)
 
Nodeoperator<< (Node &node, const ObjModel &model)
 
const Nodeoperator>> (const Node &node, CubeModel &model)
 
Nodeoperator<< (Node &node, const CubeModel &model)
 
const Nodeoperator>> (const Node &node, CylinderModel &model)
 
Nodeoperator<< (Node &node, const CylinderModel &model)
 
const Nodeoperator>> (const Node &node, DiskModel &model)
 
Nodeoperator<< (Node &node, const DiskModel &model)
 
const Nodeoperator>> (const Node &node, RectangleModel &model)
 
Nodeoperator<< (Node &node, const RectangleModel &model)
 
const Nodeoperator>> (const Node &node, SphereModel &model)
 
Nodeoperator<< (Node &node, const SphereModel &model)
 
std::ostream & operator<< (std::ostream &stream, const IpAddress &address)
 
std::istream & operator>> (std::istream &stream, IpAddress &address)
 
const Nodeoperator>> (const Node &node, CircleEmitter &emitter)
 
Nodeoperator<< (Node &node, const CircleEmitter &emitter)
 
const Nodeoperator>> (const Node &node, LineEmitter &emitter)
 
Nodeoperator<< (Node &node, const LineEmitter &emitter)
 
const Nodeoperator>> (const Node &node, PointEmitter &emitter)
 
Nodeoperator<< (Node &node, const PointEmitter &emitter)
 
const Nodeoperator>> (const Node &node, SphereEmitter &emitter)
 
Nodeoperator<< (Node &node, const SphereEmitter &emitter)
 
const Nodeoperator>> (const Node &node, ParticleSystem &particleSystem)
 
Nodeoperator<< (Node &node, const ParticleSystem &particleSystem)
 
const Nodeoperator>> (const Node &node, ParticleType &particleType)
 
Nodeoperator<< (Node &node, const ParticleType &particleType)
 
const Nodeoperator>> (const Node &node, CapsuleCollider &collider)
 
Nodeoperator<< (Node &node, const CapsuleCollider &collider)
 
const Nodeoperator>> (const Node &node, ConeCollider &collider)
 
Nodeoperator<< (Node &node, const ConeCollider &collider)
 
const Nodeoperator>> (const Node &node, ConvexHullCollider &collider)
 
Nodeoperator<< (Node &node, const ConvexHullCollider &collider)
 
const Nodeoperator>> (const Node &node, CubeCollider &collider)
 
Nodeoperator<< (Node &node, const CubeCollider &collider)
 
const Nodeoperator>> (const Node &node, CylinderCollider &collider)
 
Nodeoperator<< (Node &node, const CylinderCollider &collider)
 
const Nodeoperator>> (const Node &node, HeightfieldCollider &collider)
 
Nodeoperator<< (Node &node, const HeightfieldCollider &collider)
 
const Nodeoperator>> (const Node &node, SphereCollider &collider)
 
Nodeoperator<< (Node &node, const SphereCollider &collider)
 
const Nodeoperator>> (const Node &node, KinematicCharacter &character)
 
Nodeoperator<< (Node &node, const KinematicCharacter &character)
 
const Nodeoperator>> (const Node &node, Rigidbody &rigidbody)
 
Nodeoperator<< (Node &node, const Rigidbody &rigidbody)
 
const EntityPrefaboperator>> (const EntityPrefab &entityPrefab, Entity &entity)
 
EntityPrefaboperator<< (EntityPrefab &entityPrefab, const Entity &entity)
 
const Nodeoperator>> (const Node &node, EntityPrefab &entityPrefab)
 
Nodeoperator<< (Node &node, const EntityPrefab &entityPrefab)
 
const Nodeoperator>> (const Node &node, ShadowRender &shadowRender)
 
Nodeoperator<< (Node &node, const ShadowRender &shadowRender)
 
const Nodeoperator>> (const Node &node, SkyboxMaterial &material)
 
Nodeoperator<< (Node &node, const SkyboxMaterial &material)
 
static constexpr Vector2i RESIZE_SIZE (16, 16)
 
static constexpr Vector2i PADDING (16, 16)
 
 ENABLE_BITMASK_OPERATORS (UiManipulate)
 
 ENABLE_BITMASK_OPERATORS (ScrollBar)
 
template<typename T >
static T * to_address (T *obj) noexcept
 
template<typename T >
static T * to_address (T &obj) noexcept
 
template<typename T >
static T * to_address (const std::shared_ptr< T > &obj) noexcept
 
template<typename T >
static T * to_address (const std::unique_ptr< T > &obj) noexcept
 
template<typename T >
static const T & to_reference (T &obj) noexcept
 
template<typename T >
static const T & to_reference (T *obj) noexcept
 
template<typename T >
static const T & to_reference (const std::shared_ptr< T > &obj) noexcept
 
template<typename T >
static const T & to_reference (const std::unique_ptr< T > &obj) noexcept
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, BitMask< T > > MakeBitMask (const T &t)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, BitMask< T > > MakeBitMask (const std::underlying_type_t< T > &t)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, Enumerator< T > > operator& (const T &lhs, const T &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, Enumerator< T > > operator& (const Enumerator< T > &lhs, const Enumerator< T > &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, BitMask< T > > operator& (const BitMask< T > &lhs, const BitMask< T > &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, Enumerator< T > > operator& (const BitMask< T > &lhs, const T &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, Enumerator< T > > operator& (const T &lhs, const BitMask< T > &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, Enumerator< T > > operator& (const BitMask< T > &lhs, const Enumerator< T > &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, Enumerator< T > > operator& (const Enumerator< T > &lhs, const BitMask< T > &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, Enumerator< T > > operator& (const T &lhs, const Enumerator< T > &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, Enumerator< T > > operator& (const Enumerator< T > &lhs, const T &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, BitMask< T > > operator| (const T &lhs, const T &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, BitMask< T > > operator| (const Enumerator< T > &lhs, const Enumerator< T > &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, BitMask< T > > operator| (const BitMask< T > &lhs, const BitMask< T > &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, BitMask< T > > operator| (const BitMask< T > &lhs, const T &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, BitMask< T > > operator| (const T &lhs, const BitMask< T > &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, BitMask< T > > operator| (const BitMask< T > &lhs, const Enumerator< T > &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, BitMask< T > > operator| (const Enumerator< T > &lhs, const BitMask< T > &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, BitMask< T > > operator| (const Enumerator< T > &lhs, const T &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, BitMask< T > > operator| (const T &lhs, const Enumerator< T > &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, BitMask< T > > operator^ (const T &lhs, const T &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, BitMask< T > > operator^ (const Enumerator< T > &lhs, const Enumerator< T > &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, BitMask< T > > operator^ (const BitMask< T > &lhs, const BitMask< T > &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, BitMask< T > > operator^ (const BitMask< T > &lhs, const T &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, BitMask< T > > operator^ (const T &lhs, const BitMask< T > &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, BitMask< T > > operator^ (const BitMask< T > &lhs, const Enumerator< T > &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, BitMask< T > > operator^ (const Enumerator< T > &lhs, const BitMask< T > &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, BitMask< T > > operator^ (const Enumerator< T > &lhs, const T &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, BitMask< T > > operator^ (const T &lhs, const Enumerator< T > &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, BitMask< T > > operator~ (const T &value)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, BitMask< T > > operator~ (const Enumerator< T > &lhs)
 
template<typename T >
constexpr std::enable_if< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, BitMask< T > > operator~ (const BitMask< T > &lhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, BitMask< T > & > operator&= (BitMask< T > &lhs, const T &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, BitMask< T > & > operator&= (BitMask< T > &lhs, const Enumerator< T > &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, BitMask< T > & > operator&= (BitMask< T > &lhs, const BitMask< T > &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, BitMask< T > & > operator|= (BitMask< T > &lhs, const T &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, BitMask< T > & > operator|= (BitMask< T > &lhs, const Enumerator< T > &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, BitMask< T > & > operator|= (BitMask< T > &lhs, const BitMask< T > &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, BitMask< T > & > operator^= (BitMask< T > &lhs, const T &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, BitMask< T > & > operator^= (BitMask< T > &lhs, const Enumerator< T > &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, BitMask< T > & > operator^= (BitMask< T > &lhs, const BitMask< T > &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, bool > operator== (const T &lhs, const T &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, bool > operator== (const Enumerator< T > &lhs, const Enumerator< T > &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, bool > operator== (const BitMask< T > &lhs, const BitMask< T > &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, bool > operator== (const Enumerator< T > &lhs, const T &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, bool > operator== (const T &lhs, const Enumerator< T > &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, bool > operator== (const BitMask< T > &lhs, const T &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, bool > operator== (const T &lhs, const BitMask< T > &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, bool > operator== (const BitMask< T > &lhs, const Enumerator< T > &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, bool > operator== (const Enumerator< T > &lhs, const BitMask< T > &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, bool > operator!= (const T &lhs, const T &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, bool > operator!= (const Enumerator< T > &lhs, const Enumerator< T > &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, bool > operator!= (const BitMask< T > &lhs, const BitMask< T > &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, bool > operator!= (const Enumerator< T > &lhs, const T &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, bool > operator!= (const T &lhs, const Enumerator< T > &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, bool > operator!= (const BitMask< T > &lhs, const T &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, bool > operator!= (const T &lhs, const BitMask< T > &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, bool > operator!= (const BitMask< T > &lhs, const Enumerator< T > &rhs)
 
template<typename T >
constexpr std::enable_if_t< std::is_enum_v< T > &&EnableBitMaskOperatorsV< T >, bool > operator!= (const Enumerator< T > &lhs, const BitMask< T > &rhs)
 
template<typename T , typename TIter = decltype(std::begin(std::declval<T>())), typename = decltype(std::end(std::declval<T>()))>
constexpr auto Enumerate (T &&iterable)
 
constexpr std::uint32_t operator""_hash (const char *s, std::size_t count)
 

Variables

static const std::vector< VkSampleCountFlagBits > STAGE_FLAG_BITS
 
static const Node NullNode = Node("null", Node::Type::Null)
 
static const std::wstring_view NEHE = L" \t\r\nABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890\"!`?'.,;:()[]{}<>|/@\\^$-%+=#_&~*"
 
static const uint32_t MAX_INSTANCES = 512
 
static constexpr float ANISOTROPY = 16.0f
 
static const std::vector< VkFormat > TRY_FORMATS
 
const std::vector< VkDynamicState > DYNAMIC_STATES = {VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR, VK_DYNAMIC_STATE_LINE_WIDTH}
 
static const std::vector< VkCompositeAlphaFlagBitsKHR > COMPOSITE_ALPHA_FLAGS
 
template class ACID_EXPORT TypeInfo< Subrender >
 
static const std::vector< Vertex2dVERTICES
 
static const std::vector< uint32_t > INDICES
 
static std::random_device RandomDevice
 
const int32_t flags = 0
 
static const uint32_t MAX_DATAGRAM_SIZE = 65507
 
static constexpr float FADE_TIME = 1.0f
 
static const uint32_t MAX_INSTANCES = 1024
 
static const float FRUSTUM_BUFFER = 1.4f
 
static const uint32_t MAX_LIGHTS = 32
 
static const uint32_t SSAO_NOISE_DIM = 4
 
static const uint32_t SSAO_KERNEL_SIZE = 64
 
static const float SSAO_RADIUS = 0.5f
 
template<typename T >
constexpr bool is_optional_v = is_optional<T>::value
 
template<typename T >
constexpr bool is_pair_v = is_pair<T>::value
 
template<typename T >
constexpr bool is_vector_v = is_vector<T>::value
 
template<typename T >
constexpr bool is_map_v = is_map<T>::value
 
template<typename T >
constexpr bool is_unique_ptr_v = is_unique_ptr<T>::value
 
template<typename T >
constexpr bool is_shared_ptr_v = is_shared_ptr<T>::value
 
template<typename T >
constexpr bool is_weak_ptr_v = is_weak_ptr<T>::value
 
template<typename T >
constexpr bool is_ptr_access_v = std::is_pointer_v<T> || is_unique_ptr_v<T> || is_shared_ptr_v<T> || is_weak_ptr_v<T>
 
template<typename Enum >
constexpr bool EnableBitMaskOperatorsV = EnableBitMaskOperators<Enum>::value
 
template<typename T >
EnumIterator< T >::Iterator begin (EnumIterator< T >)
 
template<typename T >
EnumIterator< T >::Iterator end (EnumIterator< T >)
 
std::wstring_convert< std::codecvt_utf8_utf16< wchar_t >, wchar_t > UTF8_TO_UTF16_CONVERTER
 

Detailed Description

https://github.com/troldal/Zippy

MIT License

Copyright (c) 2019 Kenneth Troldal Balslev

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Typedef Documentation

◆ CollisionPair

using acid::CollisionPair = typedef std::pair<const btCollisionObject *, const btCollisionObject *>

◆ CollisionPairs

using acid::CollisionPairs = typedef std::set<CollisionPair>

◆ JoystickAxis

using acid::JoystickAxis = typedef uint8_t

◆ JoystickButton

using acid::JoystickButton = typedef uint8_t

◆ JoystickHat

using acid::JoystickHat = typedef uint8_t

◆ JoystickHatInputAxis

◆ JoystickHatInputButton

◆ JoystickPort

using acid::JoystickPort = typedef uint8_t

◆ SocketAddrLength

using acid::SocketAddrLength = typedef unsigned int

◆ SocketHandle

using acid::SocketHandle = typedef int32_t

◆ TypeId

using acid::TypeId = typedef std::size_t

◆ Vector2d

using acid::Vector2d = typedef Vector2<double>

◆ Vector2f

using acid::Vector2f = typedef Vector2<float>

◆ Vector2i

using acid::Vector2i = typedef Vector2<int32_t>

◆ Vector2ui

using acid::Vector2ui = typedef Vector2<uint32_t>

◆ Vector2us

using acid::Vector2us = typedef Vector2<uint16_t>

◆ Vector3d

using acid::Vector3d = typedef Vector3<double>

◆ Vector3f

using acid::Vector3f = typedef Vector3<float>

◆ Vector3i

using acid::Vector3i = typedef Vector3<int32_t>

◆ Vector3ui

using acid::Vector3ui = typedef Vector3<uint32_t>

◆ Vector4d

using acid::Vector4d = typedef Vector4<double>

◆ Vector4f

using acid::Vector4f = typedef Vector4<float>

◆ Vector4i

using acid::Vector4i = typedef Vector4<int32_t>

◆ Vector4ui

using acid::Vector4ui = typedef Vector4<uint32_t>

◆ ZipEntryData

using acid::ZipEntryData = typedef std::vector<std::byte>

◆ ZipEntryInfo

using acid::ZipEntryInfo = typedef mz_zip_archive_file_stat

Enumeration Type Documentation

◆ CursorHotspot

enum acid::CursorHotspot : uint8_t
strong
Enumerator
UpperLeft 
UpperRight 
BottomLeft 
BottomRight 
Centered 

◆ CursorStandard

enum acid::CursorStandard : uint32_t
strong
Enumerator
Arrow 
IBeam 
Crosshair 
Hand 
ResizeX 
ResizeY 

◆ FileMode

enum acid::FileMode
strong
Enumerator
Read 
Write 
Append 

◆ InputAction

enum acid::InputAction : int32_t
strong
Enumerator
Release 
Press 
Repeat 

◆ InputMod

enum acid::InputMod : int32_t
strong
Enumerator
None 
Shift 
Control 
Alt 
Super 

◆ JoystickHatValue

enum acid::JoystickHatValue : uint8_t
strong
Enumerator
Centered 
Up 
Right 
Down 
Left 

◆ Key

enum acid::Key : int16_t
strong
Enumerator
Unknown 
Space 
Apostrophe 
Comma 
Minus 
Period 
Slash 
_0 
_1 
_2 
_3 
_4 
_5 
_6 
_7 
_8 
_9 
Semicolon 
Equal 
LeftBracket 
Backslash 
RightBracket 
GraveAccent 
World1 
World2 
Escape 
Enter 
Tab 
Backspace 
Insert 
Delete 
Right 
Left 
Down 
Up 
PageUp 
PageDown 
Home 
End 
CapsLock 
ScrollLock 
NumLock 
PrintScreen 
Pause 
F1 
F2 
F3 
F4 
F5 
F6 
F7 
F8 
F9 
F10 
F11 
F12 
F13 
F14 
F15 
F16 
F17 
F18 
F19 
F20 
F21 
F22 
F23 
F24 
F25 
Numpad0 
Numpad1 
Numpad2 
Numpad3 
Numpad4 
Numpad5 
Numpad6 
Numpad7 
Numpad8 
Numpad9 
NumpadDecimal 
NumpadDivide 
NumpadMultiply 
NumpadSubtract 
NumpadAdd 
NumpadEnter 
NumpadEqual 
ShiftLeft 
ControlLeft 
AltLeft 
SuperLeft 
ShiftRight 
ControlRight 
AltRight 
SuperRight 
Menu 
First 
Last 

◆ MouseButton

enum acid::MouseButton : uint8_t
strong
Enumerator
_1 
_2 
_3 
_4 
_5 
_6 
_7 
_8 
Left 
Right 
Middle 
First 
Last 

◆ ScrollBar

enum acid::ScrollBar
strong
Enumerator
None 
Vertical 
Horizontal 
Both 

◆ UiConstraintType

Enumerator
Width 
Height 

◆ UiManipulate

enum acid::UiManipulate
strong
Enumerator
None 
Resize 
Move 
All 

Function Documentation

◆ CallbackChar()

void acid::CallbackChar ( GLFWwindow *  window,
uint32_t  codepoint 
)

◆ CallbackCursorEnter()

void acid::CallbackCursorEnter ( GLFWwindow *  window,
int32_t  entered 
)

◆ CallbackCursorPos()

void acid::CallbackCursorPos ( GLFWwindow *  window,
double  xpos,
double  ypos 
)

◆ CallbackDebug()

VKAPI_ATTR VkBool32 VKAPI_CALL acid::CallbackDebug ( VkDebugReportFlagsEXT  flags,
VkDebugReportObjectTypeEXT  objectType,
uint64_t  object,
size_t  location,
int32_t  messageCode,
const char *  pLayerPrefix,
const char *  pMessage,
void *  pUserData 
)

◆ CallbackDrop()

void acid::CallbackDrop ( GLFWwindow *  window,
int32_t  count,
const char **  paths 
)

◆ CallbackError()

void acid::CallbackError ( int32_t  error,
const char *  description 
)

◆ CallbackFramebufferSize()

void acid::CallbackFramebufferSize ( GLFWwindow *  window,
int32_t  width,
int32_t  height 
)

◆ CallbackJoystick()

void acid::CallbackJoystick ( int32_t  id,
int32_t  event 
)

◆ CallbackKey()

void acid::CallbackKey ( GLFWwindow *  window,
int32_t  key,
int32_t  scancode,
int32_t  action,
int32_t  mods 
)

◆ CallbackMonitor()

void acid::CallbackMonitor ( GLFWmonitor *  monitor,
int32_t  event 
)

◆ CallbackMouseButton()

void acid::CallbackMouseButton ( GLFWwindow *  window,
int32_t  button,
int32_t  action,
int32_t  mods 
)

◆ CallbackScroll()

void acid::CallbackScroll ( GLFWwindow *  window,
double  xoffset,
double  yoffset 
)

◆ CallbackWindowClose()

void acid::CallbackWindowClose ( GLFWwindow *  window)

◆ CallbackWindowFocus()

void acid::CallbackWindowFocus ( GLFWwindow *  window,
int32_t  focused 
)

◆ CallbackWindowIconify()

void acid::CallbackWindowIconify ( GLFWwindow *  window,
int32_t  iconified 
)

◆ CallbackWindowPosition()

void acid::CallbackWindowPosition ( GLFWwindow *  window,
int32_t  xpos,
int32_t  ypos 
)

◆ CallbackWindowSize()

void acid::CallbackWindowSize ( GLFWwindow *  window,
int32_t  width,
int32_t  height 
)

◆ ENABLE_BITMASK_OPERATORS() [1/5]

acid::ENABLE_BITMASK_OPERATORS ( InputAction  )

◆ ENABLE_BITMASK_OPERATORS() [2/5]

acid::ENABLE_BITMASK_OPERATORS ( InputMod  )

◆ ENABLE_BITMASK_OPERATORS() [3/5]

acid::ENABLE_BITMASK_OPERATORS ( JoystickHatValue  )

◆ ENABLE_BITMASK_OPERATORS() [4/5]

acid::ENABLE_BITMASK_OPERATORS ( ScrollBar  )

◆ ENABLE_BITMASK_OPERATORS() [5/5]

acid::ENABLE_BITMASK_OPERATORS ( UiManipulate  )

◆ Enumerate()

template<typename T , typename TIter = decltype(std::begin(std::declval<T>())), typename = decltype(std::end(std::declval<T>()))>
constexpr auto acid::Enumerate ( T &&  iterable)
constexpr

◆ GetEshLanguage()

EShLanguage acid::GetEshLanguage ( VkShaderStageFlags  stageFlag)

◆ GetResources()

TBuiltInResource acid::GetResources ( )

◆ GetSubrenderTypeId()

template<typename T >
TypeId acid::GetSubrenderTypeId ( )
noexcept

Gets the Type ID for the Subrender.

Template Parameters
TThe Subrender type.
Returns
The Type ID.

◆ MakeBitMask() [1/2]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, BitMask<T> > acid::MakeBitMask ( const std::underlying_type_t< T > &  t)
constexpr

◆ MakeBitMask() [2/2]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, BitMask<T> > acid::MakeBitMask ( const T &  t)
constexpr

◆ OpenWithMode()

PHYSFS_File* acid::OpenWithMode ( const std::filesystem::path &  filename,
FileMode  openMode 
)

◆ operator!=() [1/9]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, bool> acid::operator!= ( const BitMask< T > &  lhs,
const BitMask< T > &  rhs 
)
constexpr

operator!=(BitMask<T>, BitMask<T>)

◆ operator!=() [2/9]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, bool> acid::operator!= ( const BitMask< T > &  lhs,
const Enumerator< T > &  rhs 
)
constexpr

operator!=(BitMask<T>, Enumerator<T>)

◆ operator!=() [3/9]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, bool> acid::operator!= ( const BitMask< T > &  lhs,
const T &  rhs 
)
constexpr

operator!=(BitMask<T>, T)

◆ operator!=() [4/9]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, bool> acid::operator!= ( const Enumerator< T > &  lhs,
const BitMask< T > &  rhs 
)
constexpr

operator!=(Enumerator<T>, BitMask<T>)

◆ operator!=() [5/9]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, bool> acid::operator!= ( const Enumerator< T > &  lhs,
const Enumerator< T > &  rhs 
)
constexpr

operator!=(Enumerator<T>, Enumerator<T>)

◆ operator!=() [6/9]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, bool> acid::operator!= ( const Enumerator< T > &  lhs,
const T &  rhs 
)
constexpr

operator!=(Enumerator<T>, T)

◆ operator!=() [7/9]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, bool> acid::operator!= ( const T &  lhs,
const BitMask< T > &  rhs 
)
constexpr

operator!=(T, BitMask<T>)

◆ operator!=() [8/9]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, bool> acid::operator!= ( const T &  lhs,
const Enumerator< T > &  rhs 
)
constexpr

operator!=(T, Enumerator<T>)

◆ operator!=() [9/9]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, bool> acid::operator!= ( const T &  lhs,
const T &  rhs 
)
constexpr

operator!=(T, T)

◆ operator""_hash()

constexpr std::uint32_t acid::operator""_hash ( const char *  s,
std::size_t  count 
)
constexpr

◆ operator&() [1/15]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, BitMask<T> > acid::operator& ( const BitMask< T > &  lhs,
const BitMask< T > &  rhs 
)
constexpr

operator&(BitMask<T>, BitMask<T>)

◆ operator&() [2/15]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, Enumerator<T> > acid::operator& ( const BitMask< T > &  lhs,
const Enumerator< T > &  rhs 
)
constexpr

operator&(BitMask<T>, Enumerator<T>)

◆ operator&() [3/15]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, Enumerator<T> > acid::operator& ( const BitMask< T > &  lhs,
const T &  rhs 
)
constexpr

operator&(BitMask<T>, T)

◆ operator&() [4/15]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, Enumerator<T> > acid::operator& ( const Enumerator< T > &  lhs,
const BitMask< T > &  rhs 
)
constexpr

operator&(Enumerator<T>, BitMask<T>)

◆ operator&() [5/15]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, Enumerator<T> > acid::operator& ( const Enumerator< T > &  lhs,
const Enumerator< T > &  rhs 
)
constexpr

operator&(Enumerator<T>, Enumerator<T>)

◆ operator&() [6/15]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, Enumerator<T> > acid::operator& ( const Enumerator< T > &  lhs,
const T &  rhs 
)
constexpr

operator&(Enumerator<T>, T)

◆ operator&() [7/15]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, Enumerator<T> > acid::operator& ( const T &  lhs,
const BitMask< T > &  rhs 
)
constexpr

operator&(T, BitMask<T>)

◆ operator&() [8/15]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, Enumerator<T> > acid::operator& ( const T &  lhs,
const Enumerator< T > &  rhs 
)
constexpr

operator&(T, Enumerator<T>)

◆ operator&() [9/15]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, Enumerator<T> > acid::operator& ( const T &  lhs,
const T &  rhs 
)
constexpr

operator&(T, T)

◆ operator&() [10/15]

template<typename K , typename J >
constexpr std::enable_if_t<std::is_integral_v<K> && std::is_integral_v<J>, Vector2<J> > acid::operator& ( const Vector2< K > &  left,
const J &  right 
)
constexpr

◆ operator&() [11/15]

template<typename K , typename J >
constexpr std::enable_if_t<std::is_integral_v<K> && std::is_integral_v<J>, Vector2<J> > acid::operator& ( const Vector2< K > &  left,
const Vector2< J > &  right 
)
constexpr

◆ operator&() [12/15]

template<typename K , typename J >
constexpr std::enable_if_t<std::is_integral_v<K> && std::is_integral_v<J>, Vector3<J> > acid::operator& ( const Vector3< K > &  left,
const J &  right 
)
constexpr

◆ operator&() [13/15]

template<typename K , typename J >
constexpr std::enable_if_t<std::is_integral_v<K> && std::is_integral_v<J>, Vector3<J> > acid::operator& ( const Vector3< K > &  left,
const Vector3< J > &  right 
)
constexpr

◆ operator&() [14/15]

template<typename K , typename J >
constexpr std::enable_if_t<std::is_integral_v<K> && std::is_integral_v<J>, Vector4<J> > acid::operator& ( const Vector4< K > &  left,
const J &  right 
)
constexpr

◆ operator&() [15/15]

template<typename K , typename J >
constexpr std::enable_if_t<std::is_integral_v<K> && std::is_integral_v<J>, Vector4<J> > acid::operator& ( const Vector4< K > &  left,
const Vector4< J > &  right 
)
constexpr

◆ operator&=() [1/3]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, BitMask<T> &> acid::operator&= ( BitMask< T > &  lhs,
const BitMask< T > &  rhs 
)
constexpr

operator&=(BitMask<T>, BitMask<T>)

◆ operator&=() [2/3]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, BitMask<T> &> acid::operator&= ( BitMask< T > &  lhs,
const Enumerator< T > &  rhs 
)
constexpr

operator&=(BitMask<T>, Enumerator<T>)

◆ operator&=() [3/3]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, BitMask<T> &> acid::operator&= ( BitMask< T > &  lhs,
const T &  rhs 
)
constexpr

operator&=(BitMask<T>, T)

◆ operator*() [1/37]

constexpr Colour acid::operator* ( const Colour lhs,
const Colour rhs 
)
constexpr

◆ operator*() [2/37]

constexpr Colour acid::operator* ( const Colour lhs,
float  rhs 
)
constexpr

◆ operator*() [3/37]

template<typename K , typename J >
constexpr auto acid::operator* ( const K &  left,
const Vector2< J > &  right 
)
constexpr

◆ operator*() [4/37]

template<typename K , typename J >
constexpr auto acid::operator* ( const K &  left,
const Vector3< J > &  right 
)
constexpr

◆ operator*() [5/37]

template<typename K , typename J >
constexpr auto acid::operator* ( const K &  left,
const Vector4< J > &  right 
)
constexpr

◆ operator*() [6/37]

Matrix2 acid::operator* ( const Matrix2 left,
const Matrix2 right 
)

◆ operator*() [7/37]

Matrix2 acid::operator* ( const Matrix2 left,
const Vector2f right 
)

◆ operator*() [8/37]

Matrix2 acid::operator* ( const Matrix2 left,
float  right 
)

◆ operator*() [9/37]

Matrix3 acid::operator* ( const Matrix3 left,
const Matrix3 right 
)

◆ operator*() [10/37]

Matrix3 acid::operator* ( const Matrix3 left,
const Vector3f right 
)

◆ operator*() [11/37]

Matrix3 acid::operator* ( const Matrix3 left,
float  right 
)

◆ operator*() [12/37]

Matrix4 acid::operator* ( const Matrix4 left,
const Matrix4 right 
)

◆ operator*() [13/37]

Matrix4 acid::operator* ( const Matrix4 left,
const Vector4f right 
)

◆ operator*() [14/37]

Matrix4 acid::operator* ( const Matrix4 left,
float  right 
)

◆ operator*() [15/37]

Quaternion acid::operator* ( const Quaternion lhs,
const Quaternion rhs 
)

◆ operator*() [16/37]

Vector3f acid::operator* ( const Quaternion lhs,
const Vector3f rhs 
)

◆ operator*() [17/37]

Quaternion acid::operator* ( const Quaternion lhs,
float  rhs 
)

◆ operator*() [18/37]

constexpr Time acid::operator* ( const Time lhs,
float  rhs 
)
constexpr

◆ operator*() [19/37]

constexpr Time acid::operator* ( const Time lhs,
int64_t  rhs 
)
constexpr

◆ operator*() [20/37]

Transform acid::operator* ( const Transform lhs,
const Transform rhs 
)

◆ operator*() [21/37]

template<typename K , typename J >
constexpr auto acid::operator* ( const Vector2< K > &  left,
const J &  right 
)
constexpr

◆ operator*() [22/37]

template<typename K , typename J >
constexpr auto acid::operator* ( const Vector2< K > &  left,
const Vector2< J > &  right 
)
constexpr

◆ operator*() [23/37]

Matrix2 acid::operator* ( const Vector2f left,
const Matrix2 right 
)

◆ operator*() [24/37]

template<typename K , typename J >
constexpr auto acid::operator* ( const Vector3< K > &  left,
const J &  right 
)
constexpr

◆ operator*() [25/37]

template<typename K , typename J >
constexpr auto acid::operator* ( const Vector3< K > &  left,
const Vector3< J > &  right 
)
constexpr

◆ operator*() [26/37]

Matrix3 acid::operator* ( const Vector3f left,
const Matrix3 right 
)

◆ operator*() [27/37]

Vector3f acid::operator* ( const Vector3f lhs,
const Quaternion rhs 
)

◆ operator*() [28/37]

template<typename K , typename J >
constexpr auto acid::operator* ( const Vector4< K > &  left,
const J &  right 
)
constexpr

◆ operator*() [29/37]

template<typename K , typename J >
constexpr auto acid::operator* ( const Vector4< K > &  left,
const Vector4< J > &  right 
)
constexpr

◆ operator*() [30/37]

Matrix4 acid::operator* ( const Vector4f left,
const Matrix4 right 
)

◆ operator*() [31/37]

Matrix2 acid::operator* ( float  left,
const Matrix2 right 
)

◆ operator*() [32/37]

Matrix3 acid::operator* ( float  left,
const Matrix3 right 
)

◆ operator*() [33/37]

Matrix4 acid::operator* ( float  left,
const Matrix4 right 
)

◆ operator*() [34/37]

constexpr Colour acid::operator* ( float  lhs,
const Colour rhs 
)
constexpr

◆ operator*() [35/37]

Quaternion acid::operator* ( float  lhs,
const Quaternion rhs 
)

◆ operator*() [36/37]

constexpr Time acid::operator* ( float  lhs,
const Time rhs 
)
constexpr

◆ operator*() [37/37]

constexpr Time acid::operator* ( int64_t  lhs,
const Time rhs 
)
constexpr

◆ operator+() [1/17]

constexpr Colour acid::operator+ ( const Colour lhs,
const Colour rhs 
)
constexpr

◆ operator+() [2/17]

constexpr Colour acid::operator+ ( const Colour lhs,
float  rhs 
)
constexpr

◆ operator+() [3/17]

template<typename K , typename J >
constexpr auto acid::operator+ ( const K &  left,
const Vector2< J > &  right 
)
constexpr

◆ operator+() [4/17]

template<typename K , typename J >
constexpr auto acid::operator+ ( const K &  left,
const Vector3< J > &  right 
)
constexpr

◆ operator+() [5/17]

template<typename K , typename J >
constexpr auto acid::operator+ ( const K &  left,
const Vector4< J > &  right 
)
constexpr

◆ operator+() [6/17]

Matrix2 acid::operator+ ( const Matrix2 left,
const Matrix2 right 
)

◆ operator+() [7/17]

Matrix3 acid::operator+ ( const Matrix3 left,
const Matrix3 right 
)

◆ operator+() [8/17]

Matrix4 acid::operator+ ( const Matrix4 left,
const Matrix4 right 
)

◆ operator+() [9/17]

Quaternion acid::operator+ ( const Quaternion lhs,
const Quaternion rhs 
)

◆ operator+() [10/17]

constexpr Time acid::operator+ ( const Time lhs,
const Time rhs 
)
constexpr

◆ operator+() [11/17]

template<typename K , typename J >
constexpr auto acid::operator+ ( const Vector2< K > &  left,
const J &  right 
)
constexpr

◆ operator+() [12/17]

template<typename K , typename J >
constexpr auto acid::operator+ ( const Vector2< K > &  left,
const Vector2< J > &  right 
)
constexpr

◆ operator+() [13/17]

template<typename K , typename J >
constexpr auto acid::operator+ ( const Vector3< K > &  left,
const J &  right 
)
constexpr

◆ operator+() [14/17]

template<typename K , typename J >
constexpr auto acid::operator+ ( const Vector3< K > &  left,
const Vector3< J > &  right 
)
constexpr

◆ operator+() [15/17]

template<typename K , typename J >
constexpr auto acid::operator+ ( const Vector4< K > &  left,
const J &  right 
)
constexpr

◆ operator+() [16/17]

template<typename K , typename J >
constexpr auto acid::operator+ ( const Vector4< K > &  left,
const Vector4< J > &  right 
)
constexpr

◆ operator+() [17/17]

constexpr Colour acid::operator+ ( float  lhs,
const Colour rhs 
)
constexpr

◆ operator-() [1/17]

constexpr Colour acid::operator- ( const Colour lhs,
const Colour rhs 
)
constexpr

◆ operator-() [2/17]

constexpr Colour acid::operator- ( const Colour lhs,
float  rhs 
)
constexpr

◆ operator-() [3/17]

template<typename K , typename J >
constexpr auto acid::operator- ( const K &  left,
const Vector2< J > &  right 
)
constexpr

◆ operator-() [4/17]

template<typename K , typename J >
constexpr auto acid::operator- ( const K &  left,
const Vector3< J > &  right 
)
constexpr

◆ operator-() [5/17]

template<typename K , typename J >
constexpr auto acid::operator- ( const K &  left,
const Vector4< J > &  right 
)
constexpr

◆ operator-() [6/17]

Matrix2 acid::operator- ( const Matrix2 left,
const Matrix2 right 
)

◆ operator-() [7/17]

Matrix3 acid::operator- ( const Matrix3 left,
const Matrix3 right 
)

◆ operator-() [8/17]

Matrix4 acid::operator- ( const Matrix4 left,
const Matrix4 right 
)

◆ operator-() [9/17]

Quaternion acid::operator- ( const Quaternion lhs,
const Quaternion rhs 
)

◆ operator-() [10/17]

constexpr Time acid::operator- ( const Time lhs,
const Time rhs 
)
constexpr

◆ operator-() [11/17]

template<typename K , typename J >
constexpr auto acid::operator- ( const Vector2< K > &  left,
const J &  right 
)
constexpr

◆ operator-() [12/17]

template<typename K , typename J >
constexpr auto acid::operator- ( const Vector2< K > &  left,
const Vector2< J > &  right 
)
constexpr

◆ operator-() [13/17]

template<typename K , typename J >
constexpr auto acid::operator- ( const Vector3< K > &  left,
const J &  right 
)
constexpr

◆ operator-() [14/17]

template<typename K , typename J >
constexpr auto acid::operator- ( const Vector3< K > &  left,
const Vector3< J > &  right 
)
constexpr

◆ operator-() [15/17]

template<typename K , typename J >
constexpr auto acid::operator- ( const Vector4< K > &  left,
const J &  right 
)
constexpr

◆ operator-() [16/17]

template<typename K , typename J >
constexpr auto acid::operator- ( const Vector4< K > &  left,
const Vector4< J > &  right 
)
constexpr

◆ operator-() [17/17]

constexpr Colour acid::operator- ( float  lhs,
const Colour rhs 
)
constexpr

◆ operator/() [1/30]

constexpr Colour acid::operator/ ( const Colour lhs,
const Colour rhs 
)
constexpr

◆ operator/() [2/30]

constexpr Colour acid::operator/ ( const Colour lhs,
float  rhs 
)
constexpr

◆ operator/() [3/30]

template<typename K , typename J >
constexpr auto acid::operator/ ( const K &  left,
const Vector2< J > &  right 
)
constexpr

◆ operator/() [4/30]

template<typename K , typename J >
constexpr auto acid::operator/ ( const K &  left,
const Vector3< J > &  right 
)
constexpr

◆ operator/() [5/30]

template<typename K , typename J >
constexpr auto acid::operator/ ( const K &  left,
const Vector4< J > &  right 
)
constexpr

◆ operator/() [6/30]

Matrix2 acid::operator/ ( const Matrix2 left,
const Matrix2 right 
)

◆ operator/() [7/30]

Matrix2 acid::operator/ ( const Matrix2 left,
const Vector2f right 
)

◆ operator/() [8/30]

Matrix2 acid::operator/ ( const Matrix2 left,
float  right 
)

◆ operator/() [9/30]

Matrix3 acid::operator/ ( const Matrix3 left,
const Matrix3 right 
)

◆ operator/() [10/30]

Matrix3 acid::operator/ ( const Matrix3 left,
const Vector3f right 
)

◆ operator/() [11/30]

Matrix3 acid::operator/ ( const Matrix3 left,
float  right 
)

◆ operator/() [12/30]

Matrix4 acid::operator/ ( const Matrix4 left,
const Matrix4 right 
)

◆ operator/() [13/30]

Matrix4 acid::operator/ ( const Matrix4 left,
const Vector4f right 
)

◆ operator/() [14/30]

Matrix4 acid::operator/ ( const Matrix4 left,
float  right 
)

◆ operator/() [15/30]

constexpr double acid::operator/ ( const Time lhs,
const Time rhs 
)
constexpr

◆ operator/() [16/30]

constexpr Time acid::operator/ ( const Time lhs,
float  rhs 
)
constexpr

◆ operator/() [17/30]

constexpr Time acid::operator/ ( const Time lhs,
int64_t  rhs 
)
constexpr

◆ operator/() [18/30]

template<typename K , typename J >
constexpr auto acid::operator/ ( const Vector2< K > &  left,
const J &  right 
)
constexpr

◆ operator/() [19/30]

template<typename K , typename J >
constexpr auto acid::operator/ ( const Vector2< K > &  left,
const Vector2< J > &  right 
)
constexpr

◆ operator/() [20/30]

Matrix2 acid::operator/ ( const Vector2f left,
const Matrix2 right 
)

◆ operator/() [21/30]

template<typename K , typename J >
constexpr auto acid::operator/ ( const Vector3< K > &  left,
const J &  right 
)
constexpr

◆ operator/() [22/30]

template<typename K , typename J >
constexpr auto acid::operator/ ( const Vector3< K > &  left,
const Vector3< J > &  right 
)
constexpr

◆ operator/() [23/30]

Matrix3 acid::operator/ ( const Vector3f left,
const Matrix3 right 
)

◆ operator/() [24/30]

template<typename K , typename J >
constexpr auto acid::operator/ ( const Vector4< K > &  left,
const J &  right 
)
constexpr

◆ operator/() [25/30]

template<typename K , typename J >
constexpr auto acid::operator/ ( const Vector4< K > &  left,
const Vector4< J > &  right 
)
constexpr

◆ operator/() [26/30]

Matrix4 acid::operator/ ( const Vector4f left,
const Matrix4 right 
)

◆ operator/() [27/30]

Matrix2 acid::operator/ ( float  left,
const Matrix2 right 
)

◆ operator/() [28/30]

Matrix3 acid::operator/ ( float  left,
const Matrix3 right 
)

◆ operator/() [29/30]

Matrix4 acid::operator/ ( float  left,
const Matrix4 right 
)

◆ operator/() [30/30]

constexpr Colour acid::operator/ ( float  lhs,
const Colour rhs 
)
constexpr

◆ operator<<() [1/97]

template<typename K , typename J >
constexpr std::enable_if_t<std::is_integral_v<K> && std::is_integral_v<J>, Vector2<J> > acid::operator<< ( const Vector2< K > &  left,
const J &  right 
)
constexpr

◆ operator<<() [2/97]

template<typename K , typename J >
constexpr std::enable_if_t<std::is_integral_v<K> && std::is_integral_v<J>, Vector2<J> > acid::operator<< ( const Vector2< K > &  left,
const Vector2< J > &  right 
)
constexpr

◆ operator<<() [3/97]

template<typename K , typename J >
constexpr std::enable_if_t<std::is_integral_v<K> && std::is_integral_v<J>, Vector3<J> > acid::operator<< ( const Vector3< K > &  left,
const J &  right 
)
constexpr

◆ operator<<() [4/97]

template<typename K , typename J >
constexpr std::enable_if_t<std::is_integral_v<K> && std::is_integral_v<J>, Vector3<J> > acid::operator<< ( const Vector3< K > &  left,
const Vector3< J > &  right 
)
constexpr

◆ operator<<() [5/97]

template<typename K , typename J >
constexpr std::enable_if_t<std::is_integral_v<K> && std::is_integral_v<J>, Vector4<J> > acid::operator<< ( const Vector4< K > &  left,
const J &  right 
)
constexpr

◆ operator<<() [6/97]

template<typename K , typename J >
constexpr std::enable_if_t<std::is_integral_v<K> && std::is_integral_v<J>, Vector4<J> > acid::operator<< ( const Vector4< K > &  left,
const Vector4< J > &  right 
)
constexpr

◆ operator<<() [7/97]

EntityPrefab& acid::operator<< ( EntityPrefab entityPrefab,
const Entity entity 
)

◆ operator<<() [8/97]

Node& acid::operator<< ( Node node,
bool  object 
)
inline

◆ operator<<() [9/97]

Node& acid::operator<< ( Node node,
const AnimatedMesh animatedMesh 
)

◆ operator<<() [10/97]

Node& acid::operator<< ( Node node,
const Animation animation 
)

◆ operator<<() [11/97]

Node& acid::operator<< ( Node node,
const AxisInputButton inputButton 
)

◆ operator<<() [12/97]

Node& acid::operator<< ( Node node,
const ButtonInputAxis inputAxis 
)

◆ operator<<() [13/97]

Node& acid::operator<< ( Node node,
const CapsuleCollider collider 
)

◆ operator<<() [14/97]

Node& acid::operator<< ( Node node,
const char *  string 
)
inline

◆ operator<<() [15/97]

Node& acid::operator<< ( Node node,
const CircleEmitter emitter 
)

◆ operator<<() [16/97]

Node& acid::operator<< ( Node node,
const Colour colour 
)
inline

◆ operator<<() [17/97]

Node& acid::operator<< ( Node node,
const CompoundInputAxis inputAxis 
)

◆ operator<<() [18/97]

Node& acid::operator<< ( Node node,
const CompoundInputButton inputButton 
)

◆ operator<<() [19/97]

Node& acid::operator<< ( Node node,
const ConeCollider collider 
)

◆ operator<<() [20/97]

Node& acid::operator<< ( Node node,
const ConvexHullCollider collider 
)

◆ operator<<() [21/97]

Node& acid::operator<< ( Node node,
const CubeCollider collider 
)

◆ operator<<() [22/97]

Node& acid::operator<< ( Node node,
const CubeModel model 
)

◆ operator<<() [23/97]

Node& acid::operator<< ( Node node,
const CylinderCollider collider 
)

◆ operator<<() [24/97]

Node& acid::operator<< ( Node node,
const CylinderModel model 
)

◆ operator<<() [25/97]

Node& acid::operator<< ( Node node,
const DefaultMaterial material 
)

◆ operator<<() [26/97]

Node& acid::operator<< ( Node node,
const DiskModel model 
)

◆ operator<<() [27/97]

Node& acid::operator<< ( Node node,
const ElapsedTime elapsedTime 
)

◆ operator<<() [28/97]

Node& acid::operator<< ( Node node,
const EntityPrefab entityPrefab 
)

◆ operator<<() [29/97]

Node& acid::operator<< ( Node node,
const Fog fog 
)

◆ operator<<() [30/97]

Node& acid::operator<< ( Node node,
const FontType fontType 
)

◆ operator<<() [31/97]

Node& acid::operator<< ( Node node,
const GizmoType gizmoType 
)

◆ operator<<() [32/97]

Node& acid::operator<< ( Node node,
const GltfModel model 
)

◆ operator<<() [33/97]

Node& acid::operator<< ( Node node,
const HeightfieldCollider collider 
)

◆ operator<<() [34/97]

Node& acid::operator<< ( Node node,
const Image2d image 
)

◆ operator<<() [35/97]

Node& acid::operator<< ( Node node,
const ImageCube image 
)

◆ operator<<() [36/97]

Node& acid::operator<< ( Node node,
const InputScheme inputScheme 
)

◆ operator<<() [37/97]

Node& acid::operator<< ( Node node,
const Joint joint 
)

◆ operator<<() [38/97]

Node& acid::operator<< ( Node node,
const JointTransform jointTransform 
)

◆ operator<<() [39/97]

Node& acid::operator<< ( Node node,
const JoystickHatInput input 
)

◆ operator<<() [40/97]

Node& acid::operator<< ( Node node,
const JoystickInputAxis inputAxis 
)

◆ operator<<() [41/97]

Node& acid::operator<< ( Node node,
const JoystickInputButton inputButton 
)

◆ operator<<() [42/97]

Node& acid::operator<< ( Node node,
const KeyboardInputButton inputButton 
)

◆ operator<<() [43/97]

Node& acid::operator<< ( Node node,
const Keyframe keyframe 
)

◆ operator<<() [44/97]

Node& acid::operator<< ( Node node,
const KinematicCharacter character 
)

◆ operator<<() [45/97]

Node& acid::operator<< ( Node node,
const Light light 
)

◆ operator<<() [46/97]

Node& acid::operator<< ( Node node,
const LineEmitter emitter 
)

◆ operator<<() [47/97]

Node& acid::operator<< ( Node node,
const MaterialPipeline pipeline 
)

◆ operator<<() [48/97]

Node& acid::operator<< ( Node node,
const Matrix2 matrix 
)

◆ operator<<() [49/97]

Node& acid::operator<< ( Node node,
const Matrix3 matrix 
)

◆ operator<<() [50/97]

Node& acid::operator<< ( Node node,
const Matrix4 matrix 
)

◆ operator<<() [51/97]

Node& acid::operator<< ( Node node,
const Mesh mesh 
)

◆ operator<<() [52/97]

Node& acid::operator<< ( Node node,
const MouseInputAxis inputAxis 
)

◆ operator<<() [53/97]

Node& acid::operator<< ( Node node,
const MouseInputButton inputButton 
)

◆ operator<<() [54/97]

Node& acid::operator<< ( Node node,
const Node object 
)
inline

◆ operator<<() [55/97]

Node& acid::operator<< ( Node node,
const ObjModel model 
)

◆ operator<<() [56/97]

Node& acid::operator<< ( Node node,
const ParticleSystem particleSystem 
)

◆ operator<<() [57/97]

Node& acid::operator<< ( Node node,
const ParticleType particleType 
)

◆ operator<<() [58/97]

Node& acid::operator<< ( Node node,
const PointEmitter emitter 
)

◆ operator<<() [59/97]

Node& acid::operator<< ( Node node,
const Quaternion quaternion 
)

◆ operator<<() [60/97]

Node& acid::operator<< ( Node node,
const RectangleModel model 
)

◆ operator<<() [61/97]

Node& acid::operator<< ( Node node,
const Rigidbody rigidbody 
)

◆ operator<<() [62/97]

Node& acid::operator<< ( Node node,
const Shader shader 
)

◆ operator<<() [63/97]

Node& acid::operator<< ( Node node,
const ShadowRender shadowRender 
)

◆ operator<<() [64/97]

Node& acid::operator<< ( Node node,
const SkyboxMaterial material 
)

◆ operator<<() [65/97]

Node& acid::operator<< ( Node node,
const Sound sound 
)

◆ operator<<() [66/97]

Node& acid::operator<< ( Node node,
const SoundBuffer soundBuffer 
)

◆ operator<<() [67/97]

Node& acid::operator<< ( Node node,
const SphereCollider collider 
)

◆ operator<<() [68/97]

Node& acid::operator<< ( Node node,
const SphereEmitter emitter 
)

◆ operator<<() [69/97]

Node& acid::operator<< ( Node node,
const SphereModel model 
)

◆ operator<<() [70/97]

Node& acid::operator<< ( Node node,
const std::filesystem::path &  object 
)
inline

◆ operator<<() [71/97]

template<typename T , typename K >
Node& acid::operator<< ( Node node,
const std::map< T, K > &  map 
)

◆ operator<<() [72/97]

Node& acid::operator<< ( Node node,
const std::nullptr_t &  object 
)
inline

◆ operator<<() [73/97]

template<typename T >
Node& acid::operator<< ( Node node,
const std::optional< T > &  optional 
)

◆ operator<<() [74/97]

template<typename T , typename K >
Node& acid::operator<< ( Node node,
const std::pair< T, K > &  pair 
)

◆ operator<<() [75/97]

template<typename T >
Node& acid::operator<< ( Node node,
const std::shared_ptr< T > &  object 
)

◆ operator<<() [76/97]

Node& acid::operator<< ( Node node,
const std::string &  string 
)
inline

◆ operator<<() [77/97]

template<typename T >
Node& acid::operator<< ( Node node,
const std::unique_ptr< T > &  object 
)

◆ operator<<() [78/97]

template<typename T >
Node& acid::operator<< ( Node node,
const std::vector< T > &  vector 
)

◆ operator<<() [79/97]

template<typename T , std::enable_if_t< std::is_pointer_v< T >, int > = 0>
Node & acid::operator<< ( Node node,
const T  object 
)

◆ operator<<() [80/97]

Node& acid::operator<< ( Node node,
const Time time 
)
inline

◆ operator<<() [81/97]

Node& acid::operator<< ( Node node,
const Transform transform 
)

◆ operator<<() [82/97]

template<typename K >
Node& acid::operator<< ( Node node,
const Vector2< K > &  vector 
)

◆ operator<<() [83/97]

template<typename K >
Node& acid::operator<< ( Node node,
const Vector3< K > &  vector 
)

◆ operator<<() [84/97]

template<typename K >
Node& acid::operator<< ( Node node,
const Vector4< K > &  vector 
)

◆ operator<<() [85/97]

Node& acid::operator<< ( Node node,
const VkVertexInputAttributeDescription &  attributeDescription 
)
inline

◆ operator<<() [86/97]

Node& acid::operator<< ( Node node,
const VkVertexInputBindingDescription &  bindingDescription 
)
inline

◆ operator<<() [87/97]

Node& acid::operator<< ( Node node,
std::string_view  string 
)
inline

◆ operator<<() [88/97]

std::ostream& acid::operator<< ( std::ostream &  stream,
const Colour colour 
)
inline

◆ operator<<() [89/97]

std::ostream& acid::operator<< ( std::ostream &  stream,
const IpAddress address 
)

◆ operator<<() [90/97]

std::ostream& acid::operator<< ( std::ostream &  stream,
const Matrix2 matrix 
)

◆ operator<<() [91/97]

std::ostream& acid::operator<< ( std::ostream &  stream,
const Matrix3 matrix 
)

◆ operator<<() [92/97]

std::ostream& acid::operator<< ( std::ostream &  stream,
const Matrix4 matrix 
)

◆ operator<<() [93/97]

std::ostream& acid::operator<< ( std::ostream &  stream,
const Quaternion quaternion 
)

◆ operator<<() [94/97]

std::ostream& acid::operator<< ( std::ostream &  stream,
const Transform transform 
)

◆ operator<<() [95/97]

template<typename K >
std::ostream& acid::operator<< ( std::ostream &  stream,
const Vector2< K > &  vector 
)

◆ operator<<() [96/97]

template<typename K >
std::ostream& acid::operator<< ( std::ostream &  stream,
const Vector3< K > &  vector 
)

◆ operator<<() [97/97]

template<typename K >
std::ostream& acid::operator<< ( std::ostream &  stream,
const Vector4< K > &  vector 
)

◆ operator==() [1/9]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, bool> acid::operator== ( const BitMask< T > &  lhs,
const BitMask< T > &  rhs 
)
constexpr

operator==(BitMask<T>, BitMask<T>)

◆ operator==() [2/9]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, bool> acid::operator== ( const BitMask< T > &  lhs,
const Enumerator< T > &  rhs 
)
constexpr

operator==(BitMask<T>, Enumerator<T>)

◆ operator==() [3/9]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, bool> acid::operator== ( const BitMask< T > &  lhs,
const T &  rhs 
)
constexpr

operator==(BitMask<T>, T)

◆ operator==() [4/9]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, bool> acid::operator== ( const Enumerator< T > &  lhs,
const BitMask< T > &  rhs 
)
constexpr

operator==(Enumerator<T>, BitMask<T>)

◆ operator==() [5/9]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, bool> acid::operator== ( const Enumerator< T > &  lhs,
const Enumerator< T > &  rhs 
)
constexpr

operator==(Enumerator<T>, Enumerator<T>)

◆ operator==() [6/9]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, bool> acid::operator== ( const Enumerator< T > &  lhs,
const T &  rhs 
)
constexpr

operator==(Enumerator<T>, T)

◆ operator==() [7/9]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, bool> acid::operator== ( const T &  lhs,
const BitMask< T > &  rhs 
)
constexpr

operator==(T, BitMask<T>)

◆ operator==() [8/9]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, bool> acid::operator== ( const T &  lhs,
const Enumerator< T > &  rhs 
)
constexpr

operator==(T, Enumerator<T>)

◆ operator==() [9/9]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, bool> acid::operator== ( const T &  lhs,
const T &  rhs 
)
constexpr

operator==(T, T)

◆ operator>>() [1/86]

const EntityPrefab& acid::operator>> ( const EntityPrefab entityPrefab,
Entity entity 
)

◆ operator>>() [2/86]

const Node& acid::operator>> ( const Node node,
AnimatedMesh animatedMesh 
)

◆ operator>>() [3/86]

const Node& acid::operator>> ( const Node node,
Animation animation 
)

◆ operator>>() [4/86]

const Node& acid::operator>> ( const Node node,
AxisInputButton inputButton 
)

◆ operator>>() [5/86]

const Node& acid::operator>> ( const Node node,
bool &  object 
)
inline

◆ operator>>() [6/86]

const Node& acid::operator>> ( const Node node,
ButtonInputAxis inputAxis 
)

◆ operator>>() [7/86]

const Node& acid::operator>> ( const Node node,
CapsuleCollider collider 
)

◆ operator>>() [8/86]

const Node& acid::operator>> ( const Node node,
char *&  string 
)
inline

◆ operator>>() [9/86]

const Node& acid::operator>> ( const Node node,
CircleEmitter emitter 
)

◆ operator>>() [10/86]

const Node& acid::operator>> ( const Node node,
Colour colour 
)
inline

◆ operator>>() [11/86]

const Node& acid::operator>> ( const Node node,
CompoundInputAxis inputAxis 
)

◆ operator>>() [12/86]

const Node& acid::operator>> ( const Node node,
CompoundInputButton inputButton 
)

◆ operator>>() [13/86]

const Node& acid::operator>> ( const Node node,
ConeCollider collider 
)

◆ operator>>() [14/86]

const Node& acid::operator>> ( const Node node,
ConvexHullCollider collider 
)

◆ operator>>() [15/86]

const Node& acid::operator>> ( const Node node,
CubeCollider collider 
)

◆ operator>>() [16/86]

const Node& acid::operator>> ( const Node node,
CubeModel model 
)

◆ operator>>() [17/86]

const Node& acid::operator>> ( const Node node,
CylinderCollider collider 
)

◆ operator>>() [18/86]

const Node& acid::operator>> ( const Node node,
CylinderModel model 
)

◆ operator>>() [19/86]

const Node& acid::operator>> ( const Node node,
DefaultMaterial material 
)

◆ operator>>() [20/86]

const Node& acid::operator>> ( const Node node,
DiskModel model 
)

◆ operator>>() [21/86]

const Node& acid::operator>> ( const Node node,
ElapsedTime elapsedTime 
)

◆ operator>>() [22/86]

const Node& acid::operator>> ( const Node node,
EntityPrefab entityPrefab 
)

◆ operator>>() [23/86]

const Node& acid::operator>> ( const Node node,
Fog fog 
)

◆ operator>>() [24/86]

const Node& acid::operator>> ( const Node node,
FontType fontType 
)

◆ operator>>() [25/86]

const Node& acid::operator>> ( const Node node,
GizmoType gizmoType 
)

◆ operator>>() [26/86]

const Node& acid::operator>> ( const Node node,
GltfModel model 
)

◆ operator>>() [27/86]

const Node& acid::operator>> ( const Node node,
HeightfieldCollider collider 
)

◆ operator>>() [28/86]

const Node& acid::operator>> ( const Node node,
Image2d image 
)

◆ operator>>() [29/86]

const Node& acid::operator>> ( const Node node,
ImageCube image 
)

◆ operator>>() [30/86]

const Node& acid::operator>> ( const Node node,
InputScheme inputScheme 
)

◆ operator>>() [31/86]

const Node& acid::operator>> ( const Node node,
Joint joint 
)

◆ operator>>() [32/86]

const Node& acid::operator>> ( const Node node,
JointTransform jointTransform 
)

◆ operator>>() [33/86]

const Node& acid::operator>> ( const Node node,
JoystickHatInput input 
)

◆ operator>>() [34/86]

const Node& acid::operator>> ( const Node node,
JoystickInputAxis inputAxis 
)

◆ operator>>() [35/86]

const Node& acid::operator>> ( const Node node,
JoystickInputButton inputButton 
)

◆ operator>>() [36/86]

const Node& acid::operator>> ( const Node node,
KeyboardInputButton inputButton 
)

◆ operator>>() [37/86]

const Node& acid::operator>> ( const Node node,
Keyframe keyframe 
)

◆ operator>>() [38/86]

const Node& acid::operator>> ( const Node node,
KinematicCharacter character 
)

◆ operator>>() [39/86]

const Node& acid::operator>> ( const Node node,
Light light 
)

◆ operator>>() [40/86]

const Node& acid::operator>> ( const Node node,
LineEmitter emitter 
)

◆ operator>>() [41/86]

const Node& acid::operator>> ( const Node node,
MaterialPipeline pipeline 
)

◆ operator>>() [42/86]

const Node& acid::operator>> ( const Node node,
Matrix2 matrix 
)

◆ operator>>() [43/86]

const Node& acid::operator>> ( const Node node,
Matrix3 matrix 
)

◆ operator>>() [44/86]

const Node& acid::operator>> ( const Node node,
Matrix4 matrix 
)

◆ operator>>() [45/86]

const Node& acid::operator>> ( const Node node,
Mesh mesh 
)

◆ operator>>() [46/86]

const Node& acid::operator>> ( const Node node,
MouseInputAxis inputAxis 
)

◆ operator>>() [47/86]

const Node& acid::operator>> ( const Node node,
MouseInputButton inputButton 
)

◆ operator>>() [48/86]

const Node& acid::operator>> ( const Node node,
Node object 
)
inline

◆ operator>>() [49/86]

const Node& acid::operator>> ( const Node node,
ObjModel model 
)

◆ operator>>() [50/86]

const Node& acid::operator>> ( const Node node,
ParticleSystem particleSystem 
)

◆ operator>>() [51/86]

const Node& acid::operator>> ( const Node node,
ParticleType particleType 
)

◆ operator>>() [52/86]

const Node& acid::operator>> ( const Node node,
PointEmitter emitter 
)

◆ operator>>() [53/86]

const Node& acid::operator>> ( const Node node,
Quaternion quaternion 
)

◆ operator>>() [54/86]

const Node& acid::operator>> ( const Node node,
RectangleModel model 
)

◆ operator>>() [55/86]

const Node& acid::operator>> ( const Node node,
Rigidbody rigidbody 
)

◆ operator>>() [56/86]

const Node& acid::operator>> ( const Node node,
Shader shader 
)

◆ operator>>() [57/86]

const Node& acid::operator>> ( const Node node,
ShadowRender shadowRender 
)

◆ operator>>() [58/86]

const Node& acid::operator>> ( const Node node,
SkyboxMaterial material 
)

◆ operator>>() [59/86]

const Node& acid::operator>> ( const Node node,
Sound sound 
)

◆ operator>>() [60/86]

const Node& acid::operator>> ( const Node node,
SoundBuffer soundBuffer 
)

◆ operator>>() [61/86]

const Node& acid::operator>> ( const Node node,
SphereCollider collider 
)

◆ operator>>() [62/86]

const Node& acid::operator>> ( const Node node,
SphereEmitter emitter 
)

◆ operator>>() [63/86]

const Node& acid::operator>> ( const Node node,
SphereModel model 
)

◆ operator>>() [64/86]

const Node& acid::operator>> ( const Node node,
std::filesystem::path &  object 
)
inline

◆ operator>>() [65/86]

template<typename T , typename K >
const Node& acid::operator>> ( const Node node,
std::map< T, K > &  map 
)

◆ operator>>() [66/86]

template<typename T >
const Node& acid::operator>> ( const Node node,
std::optional< T > &  optional 
)

◆ operator>>() [67/86]

template<typename T , typename K >
const Node& acid::operator>> ( const Node node,
std::pair< T, K > &  pair 
)

◆ operator>>() [68/86]

template<typename T >
const Node& acid::operator>> ( const Node node,
std::shared_ptr< T > &  object 
)

◆ operator>>() [69/86]

const Node& acid::operator>> ( const Node node,
std::string &  string 
)
inline

◆ operator>>() [70/86]

template<typename T >
const Node& acid::operator>> ( const Node node,
std::unique_ptr< T > &  object 
)

◆ operator>>() [71/86]

template<typename T >
const Node& acid::operator>> ( const Node node,
std::vector< T > &  vector 
)

◆ operator>>() [72/86]

template<typename T , std::enable_if_t< std::is_arithmetic_v< T >||std::is_enum_v< T >, int > = 0>
const Node& acid::operator>> ( const Node node,
T &  object 
)

◆ operator>>() [73/86]

const Node& acid::operator>> ( const Node node,
Time time 
)
inline

◆ operator>>() [74/86]

const Node& acid::operator>> ( const Node node,
Transform transform 
)

◆ operator>>() [75/86]

template<typename K >
const Node& acid::operator>> ( const Node node,
Vector2< K > &  vector 
)

◆ operator>>() [76/86]

template<typename K >
const Node& acid::operator>> ( const Node node,
Vector3< K > &  vector 
)

◆ operator>>() [77/86]

template<typename K >
const Node& acid::operator>> ( const Node node,
Vector4< K > &  vector 
)

◆ operator>>() [78/86]

const Node& acid::operator>> ( const Node node,
VkVertexInputAttributeDescription &  attributeDescription 
)
inline

◆ operator>>() [79/86]

const Node& acid::operator>> ( const Node node,
VkVertexInputBindingDescription &  bindingDescription 
)
inline

◆ operator>>() [80/86]

template<typename K , typename J >
constexpr std::enable_if_t<std::is_integral_v<K> && std::is_integral_v<J>, Vector2<J> > acid::operator>> ( const Vector2< K > &  left,
const J &  right 
)
constexpr

◆ operator>>() [81/86]

template<typename K , typename J >
constexpr std::enable_if_t<std::is_integral_v<K> && std::is_integral_v<J>, Vector2<J> > acid::operator>> ( const Vector2< K > &  left,
const Vector2< J > &  right 
)
constexpr

◆ operator>>() [82/86]

template<typename K , typename J >
constexpr std::enable_if_t<std::is_integral_v<K> && std::is_integral_v<J>, Vector3<J> > acid::operator>> ( const Vector3< K > &  left,
const J &  right 
)
constexpr

◆ operator>>() [83/86]

template<typename K , typename J >
constexpr std::enable_if_t<std::is_integral_v<K> && std::is_integral_v<J>, Vector3<J> > acid::operator>> ( const Vector3< K > &  left,
const Vector3< J > &  right 
)
constexpr

◆ operator>>() [84/86]

template<typename K , typename J >
constexpr std::enable_if_t<std::is_integral_v<K> && std::is_integral_v<J>, Vector4<J> > acid::operator>> ( const Vector4< K > &  left,
const J &  right 
)
constexpr

◆ operator>>() [85/86]

template<typename K , typename J >
constexpr std::enable_if_t<std::is_integral_v<K> && std::is_integral_v<J>, Vector4<J> > acid::operator>> ( const Vector4< K > &  left,
const Vector4< J > &  right 
)
constexpr

◆ operator>>() [86/86]

std::istream& acid::operator>> ( std::istream &  stream,
IpAddress address 
)

◆ operator^() [1/9]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, BitMask<T> > acid::operator^ ( const BitMask< T > &  lhs,
const BitMask< T > &  rhs 
)
constexpr

operator^(BitMask<T>, BitMask<T>)

◆ operator^() [2/9]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, BitMask<T> > acid::operator^ ( const BitMask< T > &  lhs,
const Enumerator< T > &  rhs 
)
constexpr

operator^(BitMask<T>, Enumerator<T>)

◆ operator^() [3/9]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, BitMask<T> > acid::operator^ ( const BitMask< T > &  lhs,
const T &  rhs 
)
constexpr

operator^(BitMask<T>, T)

◆ operator^() [4/9]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, BitMask<T> > acid::operator^ ( const Enumerator< T > &  lhs,
const BitMask< T > &  rhs 
)
constexpr

operator^(Enumerator<T>, BitMask<T>)

◆ operator^() [5/9]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, BitMask<T> > acid::operator^ ( const Enumerator< T > &  lhs,
const Enumerator< T > &  rhs 
)
constexpr

operator^(Enumerator<T>, Enumerator<T>)

◆ operator^() [6/9]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, BitMask<T> > acid::operator^ ( const Enumerator< T > &  lhs,
const T &  rhs 
)
constexpr

operator^(Enumerator<T>, T)

◆ operator^() [7/9]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, BitMask<T> > acid::operator^ ( const T &  lhs,
const BitMask< T > &  rhs 
)
constexpr

operator^(T, BitMask<T>)

◆ operator^() [8/9]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, BitMask<T> > acid::operator^ ( const T &  lhs,
const Enumerator< T > &  rhs 
)
constexpr

operator^(T, Enumerator<T>)

◆ operator^() [9/9]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, BitMask<T> > acid::operator^ ( const T &  lhs,
const T &  rhs 
)
constexpr

operator^(T, T)

◆ operator^=() [1/3]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, BitMask<T> &> acid::operator^= ( BitMask< T > &  lhs,
const BitMask< T > &  rhs 
)
constexpr

operator^=(BitMask<T>, BitMask<T>)

◆ operator^=() [2/3]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, BitMask<T> &> acid::operator^= ( BitMask< T > &  lhs,
const Enumerator< T > &  rhs 
)
constexpr

operator^=(BitMask<T>, Enumerator<T>)

◆ operator^=() [3/3]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, BitMask<T> &> acid::operator^= ( BitMask< T > &  lhs,
const T &  rhs 
)
constexpr

operator^=(BitMask<T>, T)

◆ operator|() [1/15]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, BitMask<T> > acid::operator| ( const BitMask< T > &  lhs,
const BitMask< T > &  rhs 
)
constexpr

operator|(BitMask<T>, BitMask<T>)

◆ operator|() [2/15]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, BitMask<T> > acid::operator| ( const BitMask< T > &  lhs,
const Enumerator< T > &  rhs 
)
constexpr

operator|(BitMask<T>, Enumerator<T>)

◆ operator|() [3/15]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, BitMask<T> > acid::operator| ( const BitMask< T > &  lhs,
const T &  rhs 
)
constexpr

operator|(BitMask<T>, T)

◆ operator|() [4/15]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, BitMask<T> > acid::operator| ( const Enumerator< T > &  lhs,
const BitMask< T > &  rhs 
)
constexpr

operator|(Enumerator<T>, BitMask<T>)

◆ operator|() [5/15]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, BitMask<T> > acid::operator| ( const Enumerator< T > &  lhs,
const Enumerator< T > &  rhs 
)
constexpr

operator|(Enumerator<T>, Enumerator<T>)

◆ operator|() [6/15]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, BitMask<T> > acid::operator| ( const Enumerator< T > &  lhs,
const T &  rhs 
)
constexpr

operator|(Enumerator<T>, T)

◆ operator|() [7/15]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, BitMask<T> > acid::operator| ( const T &  lhs,
const BitMask< T > &  rhs 
)
constexpr

operator|(T, BitMask<T>)

◆ operator|() [8/15]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, BitMask<T> > acid::operator| ( const T &  lhs,
const Enumerator< T > &  rhs 
)
constexpr

operator|(T, Enumerator<T>)

◆ operator|() [9/15]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, BitMask<T> > acid::operator| ( const T &  lhs,
const T &  rhs 
)
constexpr

operator|(T, T)

◆ operator|() [10/15]

template<typename K , typename J >
constexpr std::enable_if_t<std::is_integral_v<K> && std::is_integral_v<J>, Vector2<J> > acid::operator| ( const Vector2< K > &  left,
const J &  right 
)
constexpr

◆ operator|() [11/15]

template<typename K , typename J >
constexpr std::enable_if_t<std::is_integral_v<K> && std::is_integral_v<J>, Vector2<J> > acid::operator| ( const Vector2< K > &  left,
const Vector2< J > &  right 
)
constexpr

◆ operator|() [12/15]

template<typename K , typename J >
constexpr std::enable_if_t<std::is_integral_v<K> && std::is_integral_v<J>, Vector3<J> > acid::operator| ( const Vector3< K > &  left,
const J &  right 
)
constexpr

◆ operator|() [13/15]

template<typename K , typename J >
constexpr std::enable_if_t<std::is_integral_v<K> && std::is_integral_v<J>, Vector3<J> > acid::operator| ( const Vector3< K > &  left,
const Vector3< J > &  right 
)
constexpr

◆ operator|() [14/15]

template<typename K , typename J >
constexpr std::enable_if_t<std::is_integral_v<K> && std::is_integral_v<J>, Vector4<J> > acid::operator| ( const Vector4< K > &  left,
const J &  right 
)
constexpr

◆ operator|() [15/15]

template<typename K , typename J >
constexpr std::enable_if_t<std::is_integral_v<K> && std::is_integral_v<J>, Vector4<J> > acid::operator| ( const Vector4< K > &  left,
const Vector4< J > &  right 
)
constexpr

◆ operator|=() [1/3]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, BitMask<T> &> acid::operator|= ( BitMask< T > &  lhs,
const BitMask< T > &  rhs 
)
constexpr

operator|=(BitMask<T>, BitMask<T>)

◆ operator|=() [2/3]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, BitMask<T> &> acid::operator|= ( BitMask< T > &  lhs,
const Enumerator< T > &  rhs 
)
constexpr

operator|=(BitMask<T>, Enumerator<T>)

◆ operator|=() [3/3]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, BitMask<T> &> acid::operator|= ( BitMask< T > &  lhs,
const T &  rhs 
)
constexpr

operator|=(BitMask<T>, T)

◆ operator~() [1/3]

template<typename T >
constexpr std::enable_if<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, BitMask<T> > acid::operator~ ( const BitMask< T > &  lhs)
constexpr

operator~(BitMask<T>)

◆ operator~() [2/3]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, BitMask<T> > acid::operator~ ( const Enumerator< T > &  lhs)
constexpr

operator~(Enumerator<T>)

◆ operator~() [3/3]

template<typename T >
constexpr std::enable_if_t<std::is_enum_v<T> && EnableBitMaskOperatorsV<T>, BitMask<T> > acid::operator~ ( const T &  value)
constexpr

operator~(T)

◆ OverlappingArea()

int32_t acid::OverlappingArea ( Vector2i  l1,
Vector2i  r1,
Vector2i  l2,
Vector2i  r2 
)

◆ PADDING()

static constexpr Vector2i acid::PADDING ( 16  ,
16   
)
staticconstexpr

◆ RandomGenerator()

static std::mt19937 acid::RandomGenerator ( RandomDevice()  )
static

◆ RESIZE_SIZE()

static constexpr Vector2i acid::RESIZE_SIZE ( 16  ,
16   
)
staticconstexpr

◆ to_address() [1/4]

template<typename T >
static T* acid::to_address ( const std::shared_ptr< T > &  obj)
staticnoexcept

◆ to_address() [2/4]

template<typename T >
static T* acid::to_address ( const std::unique_ptr< T > &  obj)
staticnoexcept

◆ to_address() [3/4]

template<typename T >
static T* acid::to_address ( T &  obj)
staticnoexcept

◆ to_address() [4/4]

template<typename T >
static T* acid::to_address ( T *  obj)
staticnoexcept

◆ to_reference() [1/4]

template<typename T >
static const T& acid::to_reference ( const std::shared_ptr< T > &  obj)
staticnoexcept

◆ to_reference() [2/4]

template<typename T >
static const T& acid::to_reference ( const std::unique_ptr< T > &  obj)
staticnoexcept

◆ to_reference() [3/4]

template<typename T >
static const T& acid::to_reference ( T &  obj)
staticnoexcept

◆ to_reference() [4/4]

template<typename T >
static const T& acid::to_reference ( T *  obj)
staticnoexcept

Variable Documentation

◆ ANISOTROPY

constexpr float acid::ANISOTROPY = 16.0f
staticconstexpr

◆ begin

template<typename T >
EnumIterator<T>::Iterator acid::begin(EnumIterator< T >)

◆ COMPOSITE_ALPHA_FLAGS

const std::vector<VkCompositeAlphaFlagBitsKHR> acid::COMPOSITE_ALPHA_FLAGS
static
Initial value:
= {
VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR, VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR,
VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR, VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR,
}

◆ DYNAMIC_STATES

const std::vector<VkDynamicState> acid::DYNAMIC_STATES = {VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR, VK_DYNAMIC_STATE_LINE_WIDTH}

◆ EnableBitMaskOperatorsV

template<typename Enum >
constexpr bool acid::EnableBitMaskOperatorsV = EnableBitMaskOperators<Enum>::value
inlineconstexpr

◆ end

template<typename T >
EnumIterator<T>::Iterator acid::end(EnumIterator< T >)

◆ FADE_TIME

constexpr float acid::FADE_TIME = 1.0f
staticconstexpr

◆ flags

const int32_t acid::flags = 0

◆ FRUSTUM_BUFFER

const float acid::FRUSTUM_BUFFER = 1.4f
static

◆ INDICES

const std::vector<uint32_t> acid::INDICES
static
Initial value:
= {
0, 1, 2,
2, 3, 0
}

◆ is_map_v

template<typename T >
constexpr bool acid::is_map_v = is_map<T>::value
inlineconstexpr

◆ is_optional_v

template<typename T >
constexpr bool acid::is_optional_v = is_optional<T>::value
inlineconstexpr

◆ is_pair_v

template<typename T >
constexpr bool acid::is_pair_v = is_pair<T>::value
inlineconstexpr

◆ is_ptr_access_v

template<typename T >
constexpr bool acid::is_ptr_access_v = std::is_pointer_v<T> || is_unique_ptr_v<T> || is_shared_ptr_v<T> || is_weak_ptr_v<T>
inlineconstexpr

◆ is_shared_ptr_v

template<typename T >
constexpr bool acid::is_shared_ptr_v = is_shared_ptr<T>::value
inlineconstexpr

◆ is_unique_ptr_v

template<typename T >
constexpr bool acid::is_unique_ptr_v = is_unique_ptr<T>::value
inlineconstexpr

◆ is_vector_v

template<typename T >
constexpr bool acid::is_vector_v = is_vector<T>::value
inlineconstexpr

◆ is_weak_ptr_v

template<typename T >
constexpr bool acid::is_weak_ptr_v = is_weak_ptr<T>::value
inlineconstexpr

◆ MAX_DATAGRAM_SIZE

const uint32_t acid::MAX_DATAGRAM_SIZE = 65507
static

◆ MAX_INSTANCES [1/2]

const uint32_t acid::MAX_INSTANCES = 512
static

◆ MAX_INSTANCES [2/2]

const uint32_t acid::MAX_INSTANCES = 1024
static

◆ MAX_LIGHTS

const uint32_t acid::MAX_LIGHTS = 32
static

◆ NEHE

const std::wstring_view acid::NEHE = L" \t\r\nABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890\"!`?'.,;:()[]{}<>|/@\\^$-%+=#_&~*"
static

◆ NullNode

const Node acid::NullNode = Node("null", Node::Type::Null)
static

◆ RandomDevice

std::random_device acid::RandomDevice
static

◆ SSAO_KERNEL_SIZE

const uint32_t acid::SSAO_KERNEL_SIZE = 64
static

◆ SSAO_NOISE_DIM

const uint32_t acid::SSAO_NOISE_DIM = 4
static

◆ SSAO_RADIUS

const float acid::SSAO_RADIUS = 0.5f
static

◆ STAGE_FLAG_BITS

const std::vector<VkSampleCountFlagBits> acid::STAGE_FLAG_BITS
static
Initial value:
= {
VK_SAMPLE_COUNT_64_BIT, VK_SAMPLE_COUNT_32_BIT, VK_SAMPLE_COUNT_16_BIT, VK_SAMPLE_COUNT_8_BIT,
VK_SAMPLE_COUNT_4_BIT, VK_SAMPLE_COUNT_2_BIT
}

◆ TRY_FORMATS

const std::vector<VkFormat> acid::TRY_FORMATS
static
Initial value:
= {
VK_FORMAT_D32_SFLOAT_S8_UINT, VK_FORMAT_D32_SFLOAT, VK_FORMAT_D24_UNORM_S8_UINT, VK_FORMAT_D16_UNORM_S8_UINT,
VK_FORMAT_D16_UNORM
}

◆ TypeInfo< Subrender >

template class ACID_EXPORT acid::TypeInfo< Subrender >

◆ UTF8_TO_UTF16_CONVERTER

std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>, wchar_t> acid::UTF8_TO_UTF16_CONVERTER

◆ VERTICES

const std::vector<Vertex2d> acid::VERTICES
static
Initial value:
= {
{{0.0f, 0.0f}, {0.0f, 0.0f}},
{{1.0f, 0.0f}, {1.0f, 0.0f}},
{{1.0f, 1.0f}, {1.0f, 1.0f}},
{{0.0f, 1.0f}, {0.0f, 1.0f}}
}