#include <platform/core/common/MathTypes.h>
#include <platform/core/common/utils/EnumUtils.h>
#include <array>
#include <cstdint>
#include <limits>
#include <map>
#include <memory>
#include <vector>

Include dependency graph for Types.h:

Classes
struct	core::RenderInput

struct	core::RenderOutput

struct	core::Blob

struct	core::RpcDescription

struct	core::RpcParameterDescription

struct	core::OctreeVector

struct	core::OctreePoint

Namespaces
	core

Typedefs
using	int64 = ::int64_t

using	uint64 = ::uint64_t

using	int32 = ::int32_t

using	uint32 = ::uint32_t

using	int16 = ::int16_t

using	uint16 = ::uint16_t

using	int8 = ::int8_t

using	uint8 = ::uint8_t

using	index_t = ::int64_t

using	strings = std::vector< std::string >

using	floats = std::vector< float >

using	ints = std::vector< int >

using	uints = std::vector< unsigned int >

using	int8_ts = std::vector< int8_t >

using	uint8_ts = std::vector< uint8_t >

using	int16_ts = std::vector< int16_t >

using	uint16_ts = std::vector< uint16_t >

using	int32_ts = std::vector< int32_t >

using	uint32_ts = std::vector< uint32_t >

using	int64_ts = std::vector< int64_t >

using	uint64_ts = std::vector< uint64_t >

using	size_ts = std::vector< size_t >

using	StringMap = std::map< std::string, std::string >

using	Color = core::Vector3d

using	Palette = std::vector< Color >

using	Quaternions = std::vector< core::Quaterniond >

using	bools = std::vector< bool >

using	doubles = std::vector< double >

using	Vector3ds = std::vector< core::Vector3d >

using	Vector3dm = std::map< uint64_t, core::Vector3d >

using	Vector4ds = std::vector< core::Vector4d >

using	Vector2uis = std::vector< core::Vector2ui >

using	Vector3uis = std::vector< core::Vector3ui >

using	uint8_tm = std::map< uint64_t, uint8_t >

using	uint64_tm = std::map< uint64_t, uint64_t >

using	CommandLineArguments = std::map< std::string, std::string >

using	core::ActionInterfacePtr = std::shared_ptr< ActionInterface >

using	core::EnginePtr = std::shared_ptr< Engine >

using	core::ScenePtr = std::shared_ptr< Scene >

using	core::CameraPtr = std::shared_ptr< Camera >

using	core::RendererPtr = std::shared_ptr< Renderer >

using	core::FrameBufferPtr = std::shared_ptr< FrameBuffer >

using	core::ModelPtr = std::unique_ptr< Model >

using	core::ModelMetadata = std::map< std::string, std::string >

using	core::Transformations = std::vector< Transformation >

using	core::ModelDescriptorPtr = std::shared_ptr< ModelDescriptor >

using	core::ModelDescriptors = std::vector< ModelDescriptorPtr >

using	core::ModelInstances = std::vector< ModelInstance >

using	core::MaterialPtr = std::shared_ptr< Material >

using	core::MaterialMap = std::map< size_t, MaterialPtr >

using	core::ClipPlanePtr = std::shared_ptr< ClipPlane >

using	core::ClipPlanes = std::vector< ClipPlanePtr >

using	core::Spheres = std::vector< Sphere >

using	core::SpheresMap = std::map< size_t, Spheres >

using	core::Cylinders = std::vector< Cylinder >

using	core::CylindersMap = std::map< size_t, Cylinders >

using	core::Cones = std::vector< Cone >

using	core::ConesMap = std::map< size_t, Cones >

using	core::TriangleMeshMap = std::map< size_t, TriangleMesh >

using	core::StreamlinesDataMap = std::map< size_t, StreamlinesData >

using	core::Curves = std::vector< Curve >

using	core::CurvesMap = std::map< size_t, Curves >

using	core::FieldPtr = std::shared_ptr< Field >

using	core::FieldsMap = std::map< size_t, FieldPtr >

using	core::VolumePtr = std::shared_ptr< Volume >

using	core::SharedDataVolumePtr = std::shared_ptr< SharedDataVolume >

using	core::BrickedVolumePtr = std::shared_ptr< BrickedVolume >

using	core::VolumesMap = std::map< size_t, VolumePtr >

using	core::Texture2DPtr = std::shared_ptr< Texture2D >

using	core::TexturesMap = std::map< std::string, Texture2DPtr >

using	core::LightPtr = std::shared_ptr< Light >

using	core::Lights = std::vector< LightPtr >

using	core::DirectionalLightPtr = std::shared_ptr< DirectionalLight >

using	core::SphereLightPtr = std::shared_ptr< SphereLight >

using	core::QuadLightPtr = std::shared_ptr< QuadLight >

using	core::SpotLightPtr = std::shared_ptr< SpotLight >

using	core::AbstractSimulationHandlerPtr = std::shared_ptr< AbstractSimulationHandler >

using	core::Plane = std::array< double, 4 >

using	core::Planes = std::vector< Plane >

using	core::TaskPtr = std::shared_ptr< AbstractTask >

using	core::LoaderPtr = std::unique_ptr< Loader >

using	core::OctreeVectors = std::vector< OctreeVector >

using	core::OctreePoints = std::vector< OctreePoint >

Enumerations
enum class	core::FrameBufferFormat { core::rgba_i8 , core::bgra_i8 , core::rgb_i8 , core::rgb_f32 , core::none }

enum class	core::AccumulationType { core::linear = 0 , core::ai_denoised = 1 }

enum class	core::GeometryQuality { core::low , core::medium , core::high }

enum class	core::TextureType : uint8_t { core::diffuse = 0 , core::normals , core::bump , core::specular , core::emissive , core::opacity , core::reflection , core::refraction , core::occlusion , core::radiance , core::irradiance , core::brdf_lut , core::volume , core::transfer_function , core::octree_indices , core::octree_values }

enum class	core::MemoryMode { core::shared , core::replicated }

enum class	core::MaterialsColorMap { core::random , core::shades_of_grey , core::gradient , core::pastel }

enum class	core::CameraMode { core::flying , core::inspect }

enum class	core::DataType { core::FLOAT , core::DOUBLE , core::UINT8 , core::UINT16 , core::UINT32 , core::INT8 , core::INT16 , core::INT32 }

enum class	core::Execution { core::sync , core::async }

enum class	core::BVHFlag { core::dynamic , core::compact , core::robust }

Functions
template<>
std::vector< std::pair< std::string, GeometryQuality > >	core::enumMap ()

Typedef Documentation

◆ bools

using bools = std::vector<bool>

Definition at line 61 of file Types.h.

◆ Color

using Color = core::Vector3d

Definition at line 58 of file Types.h.

◆ CommandLineArguments

using CommandLineArguments = std::map<std::string, std::string>

Definition at line 74 of file Types.h.

◆ doubles

using doubles = std::vector<double>

Definition at line 62 of file Types.h.

◆ floats

using floats = std::vector<float>

Definition at line 45 of file Types.h.

◆ index_t

using index_t = ::int64_t

Definition at line 43 of file Types.h.

◆ int16

using int16 = ::int16_t

Definition at line 39 of file Types.h.

◆ int16_ts

using int16_ts = std::vector<int16_t>

Definition at line 50 of file Types.h.

◆ int32

using int32 = ::int32_t

Definition at line 37 of file Types.h.

◆ int32_ts

using int32_ts = std::vector<int32_t>

Definition at line 52 of file Types.h.

◆ int64

using int64 = ::int64_t

Definition at line 35 of file Types.h.

◆ int64_ts

using int64_ts = std::vector<int64_t>

Definition at line 54 of file Types.h.

◆ int8

using int8 = ::int8_t

Definition at line 41 of file Types.h.

◆ int8_ts

using int8_ts = std::vector<int8_t>

Definition at line 48 of file Types.h.

◆ ints

using ints = std::vector<int>

Definition at line 46 of file Types.h.

◆ Palette

using Palette = std::vector<Color>

Definition at line 59 of file Types.h.

◆ Quaternions

using Quaternions = std::vector<core::Quaterniond>

Definition at line 60 of file Types.h.

◆ size_ts

using size_ts = std::vector<size_t>

Definition at line 56 of file Types.h.

◆ StringMap

using StringMap = std::map<std::string, std::string>

Definition at line 57 of file Types.h.

◆ strings

typedef std::vector< std::string > strings

Definition at line 44 of file Types.h.

◆ uint16

using uint16 = ::uint16_t

Definition at line 40 of file Types.h.

◆ uint16_ts

using uint16_ts = std::vector<uint16_t>

Definition at line 51 of file Types.h.

◆ uint32

using uint32 = ::uint32_t

Definition at line 38 of file Types.h.

◆ uint32_ts

typedef std::vector< uint32_t > uint32_ts

Definition at line 53 of file Types.h.

◆ uint64

using uint64 = ::uint64_t

Definition at line 36 of file Types.h.

◆ uint64_tm

using uint64_tm = std::map<uint64_t, uint64_t>

Definition at line 73 of file Types.h.

◆ uint64_ts

typedef std::vector< uint64_t > uint64_ts

Definition at line 55 of file Types.h.

◆ uint8

using uint8 = ::uint8_t

Definition at line 42 of file Types.h.

◆ uint8_tm

using uint8_tm = std::map<uint64_t, uint8_t>

Definition at line 70 of file Types.h.

◆ uint8_ts

typedef std::vector< uint8_t > uint8_ts

Definition at line 49 of file Types.h.

◆ uints

using uints = std::vector<unsigned int>

Definition at line 47 of file Types.h.

◆ Vector2uis

using Vector2uis = std::vector<core::Vector2ui>

Definition at line 67 of file Types.h.

◆ Vector3dm

using Vector3dm = std::map<uint64_t, core::Vector3d>

Definition at line 65 of file Types.h.

◆ Vector3ds

using Vector3ds = std::vector<core::Vector3d>

Definition at line 64 of file Types.h.

◆ Vector3uis

using Vector3uis = std::vector<core::Vector3ui>

Definition at line 68 of file Types.h.

◆ Vector4ds

using Vector4ds = std::vector<core::Vector4d>

Definition at line 66 of file Types.h.

Classes

Namespaces

Typedefs

Enumerations

Functions