Elevate Namespace Reference

Namespaces
namespace	Editor
namespace	File
namespace	Files
namespace	Platform
namespace	UI

Classes
class	AddComponentCommand
class	AddGameobjectCommand
class	AkBank
class	Application
struct	ApplicationArguments
class	AppRenderEvent
class	AppTickEvent
class	AppUpdateEvent
class	AudioDistanceProbe
class	BoundingVolume
struct	BufferElement
class	BufferLayout
class	Camera
class	CameraManager
struct	ColorTag
class	Command
class	CommandManager
class	Component
struct	ComponentField
class	ComponentLayout
class	ComponentRegistry
class	Cubemap
struct	DebugLineData
class	DebugRenderer
struct	DebugVertex
class	DefaultShader
class	DeleteGameobjectCommand
class	DesktropFileDialog
class	DirectionalLight
struct	DisplayNameTag
class	EditorCamera
struct	EditorIconTag
struct	EngineDataTypeTrait
struct	EngineDataTypeTrait< bool >
struct	EngineDataTypeTrait< float >
struct	EngineDataTypeTrait< glm::vec2 >
struct	EngineDataTypeTrait< glm::vec3 >
struct	EngineDataTypeTrait< glm::vec4 >
struct	EngineDataTypeTrait< int >
class	Event
class	EventDispatcher
struct	FieldMeta
class	FileDialog
class	FileDialogImpl
struct	FlattenTag
class	Framebuffer
struct	FramebufferColorAttachment
struct	FramebufferDepthAttachment
struct	FramebufferMetadata
struct	FramebufferStencilAttachment
struct	Frustum
class	GameContextEvent
class	GameObject
class	GlfwInput
class	GlfwWindow
class	GraphicsContext
struct	has_super
struct	has_super< T, std::void_t< typename T::Super > >
struct	HideInInspectorTag
class	ImGuiLayer
class	IndexBuffer
class	Input
class	InputBuffer
class	ISerializable
class	ITransformable
	An interface to add all of the methods needed to have a working transform wrapped by getter and setters. More...
class	KeyEvent
class	KeyPressedEvent
class	KeyReleasedEvent
class	KeyTypedEvent
class	Layer
class	LayerStack
class	Light
class	Log
class	LogImpl
class	MacroCommand
	Class to combine multiples commands to execute then or undo them in batches. More...
class	Material
class	MaterialFactory
class	MaterialRegistry
class	Mesh
struct	MeshData
class	Model
class	MouseButtonEvent
class	MouseButtonPressedEvent
class	MouseButtonReleasedEvent
class	MouseMovedEvent
class	MouseScrolledEvent
class	OpenGLContext
class	OpenGLFrameBuffer
class	OpenGLIndexBuffer
class	OpenGLRendererAPI
class	OpenGLShader
class	OpenGLTexture
class	OpenGLVertexArray
class	OpenGLVertexBuffer
struct	ParentFieldsHelper
struct	ParentFieldsHelper< T, true >
class	PathResolver
struct	Plane
class	PointLight
struct	ReadOnlyTag
class	RemoveComponentCommand
class	RenderBucket
struct	RenderCommand
class	RenderCommandQueue
class	Renderer
class	RendererAPI
struct	RenderState
class	Rigidbody
struct	RigidbodyData
class	Scene
class	SceneLayer
	Simple layer thats contains a single scene and take care of all loading/unloading update and rendering. This is a good starting point if your are looking to create your own scene logic. More...
class	SceneLighting
class	SceneManager
class	Shader
class	ShaderManager
class	SoundEngine
class	SphereBoundingVolume
struct	SurfaceMaterial
class	Texture
struct	TextureLoadResult
class	TextureManager
struct	TextureMetadata
struct	TextureMetadataBuilder
class	Time
struct	TooltipTag
class	Transform
struct	UUID
struct	Vertex
class	VertexArray
class	VertexBuffer
class	WAAPIClient
class	Window
class	WindowCloseEvent
struct	WindowData
class	WindowFocusEvent
struct	WindowProps
class	WindowResizeEvent
class	WwiseFileDataSource

Typedefs
using	GameObjectComponentGetter = std::function< Component *(std::weak_ptr< GameObject >)>
using	GameObjectComponentFactory = std::function< Component *(std::weak_ptr< GameObject >)>
using	GameObjectComponentDestructor = std::function< void(std::weak_ptr< GameObject >)>
using	FieldOption = std::variant< HideInInspectorTag, EditorIconTag, FlattenTag, DisplayNameTag, TooltipTag, ReadOnlyTag, ColorTag >
using	EventCallbackFn = std::function< void(Event &)>
typedef EngineDataType	ComponentDataType
typedef EngineDataType	ShaderDataType
using	CameraPtr = std::shared_ptr< Camera >
using	MaterialPtr = std::shared_ptr< Material >
typedef uint32_t	MaterialID
typedef unsigned int	GLenum
using	ScenePtr = std::shared_ptr< Scene >
using	ShaderPtr = std::shared_ptr< Shader >
using	TexturePtr = std::shared_ptr< Texture >

Enumerations
enum class	EngineDataType {   None = 0 , Bool , Int , Int2 ,   Int3 , Int4 , Float , Float2 ,   Float3 , Float4 , Mat3 , Mat4 ,   Mat5 , Sampler2D , Custom , Unknown }
enum	GameContextState {   Initializing , EditorMode , Runtime , Paused ,   Stopped }
enum class	EventType {   None = 0 , GameContextChanged , WindowClose , WindowResize ,   WindowFocus , AppTick , AppUpdate , AppRender ,   KeyPressed , KeyReleased , KeyTyped , MouseButtonPressed ,   MouseButtonReleased , MouseMoved , MouseScrolled }
enum	EventCategory : uint8_t {   None = 0 , EventCategoryApplication = BIT(0) , EventCategoryInput = BIT(1) , EventCategoryKeyboard = BIT(2) ,   EventCategoryMouse = BIT(3) , EventCategoryMouseButton = BIT(4) , EventCategoryGameContext = BIT(5) }
enum	FrustumPlane {   NEAR_PLANE = 0 , FAR_PLANE , TOP_PLANE , BOTTOM_PLANE ,   RIGHT_PLANE , LEFT_PLANE }
enum class	GraphicsContextState { UNINITIALIZED , ACTIVE , TERMINATED }
enum class	PrimitiveType : uint8_t {   Cube , UVSphere , Cubesphere , Icosphere ,   Cylinder , Capsule , Plane , Quad ,   Torus }
enum class	DrawPrimitiveType {   Points , Lines , LineStrip , LineLoop ,   Triangles , TriangleStrip , TriangleFan , Patches }
enum class	TextureSource : uint8_t { File , Generated , RenderTarget }
enum class	TextureFormat : uint8_t {   EMPTY = 0 , GRAYSCALE = 1 , RGB = 3 , RGBA = 4 ,   DEPTH }
enum class	TextureType : uint8_t {   Diffuse , Specular , Normal , Height ,   Cubemap , Ambient , Count }
enum class	TextureState : uint8_t {   Empty , Unloaded = Empty , Loading , Ready ,   Loaded = Ready , Failed }
enum class	TextureFilter : uint8_t { Nearest , Linear }
enum class	TextureWrap : uint8_t { Repeat , MirrorRepeat , ClampToEdge , ClampToBorder }
enum	SceneType { RuntimeScene , EditorScene , DebugScene }

Functions
Application *	CreateApplication ()
uint32_t	GetDataTypeCount (EngineDataType type)
uint32_t	GetDataTypeSize (EngineDataType type)
uint32_t	GetDataAPIType (EngineDataType type)
const char *	GetGameContextStateName (GameContextState state)
std::ostream &	operator<< (std::ostream &os, const Event &e)
void	CreateBuffers (int32_t n, uint32_t *ids)
void	NamedBufferData (uint32_t buffer, uint32_t target, size_t size, const void *data, uint32_t usage)
constexpr GLenum	ToInternalFormat (TextureFormat format)
constexpr GLenum	ToOpenGL (TextureFormat format)
constexpr GLenum	ToOpenGLType (TextureFormat format)
constexpr GLenum	ToOpenGL (TextureFilter filter)
constexpr GLenum	ToOpenGL (TextureWrap wrap)
constexpr GLenum	ToOpenGL (TextureType type)
std::unordered_map< uint32_t, std::unique_ptr< entt::registry > > &	GetRegistryMap ()

Variables
const int	ShaderDataTypeCount []
const int	ShaderDataTypeSize []
const unsigned int	ShaderDataAPIType []

Typedef Documentation

CameraPtr

using Elevate::CameraPtr = typedef std::shared_ptr<Camera>

Definition at line 86 of file Camera.h.

ComponentDataType

typedef EngineDataType Elevate::ComponentDataType

Definition at line 12 of file ComponentLayout.h.

EventCallbackFn

using Elevate::EventCallbackFn = typedef std::function<void(Event&)>

Definition at line 9 of file Window.h.

FieldOption

using Elevate::FieldOption = typedef std::variant< HideInInspectorTag, EditorIconTag, FlattenTag, DisplayNameTag, TooltipTag, ReadOnlyTag, ColorTag >

Definition at line 77 of file ComponentRegistry.h.

GameObjectComponentDestructor

using Elevate::GameObjectComponentDestructor = typedef std::function<void(std::weak_ptr<GameObject>)>

Definition at line 22 of file Component.h.

GameObjectComponentFactory

using Elevate::GameObjectComponentFactory = typedef std::function<Component* (std::weak_ptr<GameObject>)>

Definition at line 21 of file Component.h.

GameObjectComponentGetter

using Elevate::GameObjectComponentGetter = typedef std::function<Component* (std::weak_ptr<GameObject>)>

Definition at line 20 of file Component.h.

GLenum

typedef unsigned int Elevate::GLenum

Definition at line 7 of file OpenGLRendererAPI.h.

MaterialID

typedef uint32_t Elevate::MaterialID

Definition at line 26 of file Material.h.

MaterialPtr

using Elevate::MaterialPtr = typedef std::shared_ptr<Material>

Definition at line 24 of file Material.h.

ScenePtr

typedef std::shared_ptr< Scene > Elevate::ScenePtr

Definition at line 12 of file Renderer.h.

ShaderDataType

typedef EngineDataType Elevate::ShaderDataType

Definition at line 11 of file Buffer.h.

ShaderPtr

typedef std::shared_ptr< Shader > Elevate::ShaderPtr

Definition at line 128 of file Shader.h.

TexturePtr

using Elevate::TexturePtr = typedef std::shared_ptr<Texture>

Definition at line 13 of file Texture.h.

Enumeration Type Documentation

DrawPrimitiveType

enum class Elevate::DrawPrimitiveType

strong

Enumerator
Points
Lines
LineStrip
LineLoop
Triangles
TriangleStrip
TriangleFan
Patches

Definition at line 16 of file RendererAPI.h.

    {
        Points,
        Lines,
        LineStrip,
        LineLoop,      // OpenGL only
        Triangles,
        TriangleStrip,
        TriangleFan,   // OpenGL only
        Patches
    };

EngineDataType

enum class Elevate::EngineDataType

strong

Enumerator
None
Bool
Int
Int2
Int3
Int4
Float
Float2
Float3
Float4
Mat3
Mat4
Mat5
Sampler2D
Custom
Unknown

Definition at line 105 of file Data.h.

    {
        None = 0,
        Bool,
        Int, Int2, Int3, Int4,
        Float, Float2, Float3, Float4,
        Mat3, Mat4, Mat5,
        Sampler2D,
        Custom,
        Unknown
    };

EventCategory

enum Elevate::EventCategory : uint8_t

Enumerator
None
EventCategoryApplication
EventCategoryInput
EventCategoryKeyboard
EventCategoryMouse
EventCategoryMouseButton
EventCategoryGameContext

Definition at line 20 of file Event.h.

    {
        None = 0,
        EventCategoryApplication    = BIT(0),
        EventCategoryInput          = BIT(1),
        EventCategoryKeyboard       = BIT(2),
        EventCategoryMouse          = BIT(3),
        EventCategoryMouseButton    = BIT(4),
        EventCategoryGameContext    = BIT(5)
    };

EventType

enum class Elevate::EventType

strong

Enumerator
None
GameContextChanged
WindowClose
WindowResize
WindowFocus
AppTick
AppUpdate
AppRender
KeyPressed
KeyReleased
KeyTyped
MouseButtonPressed
MouseButtonReleased
MouseMoved
MouseScrolled

Definition at line 10 of file Event.h.

    {
        None = 0,
        GameContextChanged,
        WindowClose, WindowResize, WindowFocus,
        AppTick, AppUpdate, AppRender,
        KeyPressed, KeyReleased, KeyTyped,
        MouseButtonPressed, MouseButtonReleased, MouseMoved, MouseScrolled
    };

FrustumPlane

enum Elevate::FrustumPlane

Enumerator
NEAR_PLANE
FAR_PLANE
TOP_PLANE
BOTTOM_PLANE
RIGHT_PLANE
LEFT_PLANE

Definition at line 24 of file Frustum.h.

    {
        NEAR_PLANE = 0,
        FAR_PLANE,
        TOP_PLANE,
        BOTTOM_PLANE,
        RIGHT_PLANE,
        LEFT_PLANE
    };

GameContextState

enum Elevate::GameContextState

Enumerator
Initializing
EditorMode
Runtime
Paused
Stopped

Definition at line 5 of file GameContext.h.

    {
        Initializing,
        EditorMode,
        Runtime,
        Paused,
        Stopped
    };

GraphicsContextState

enum class Elevate::GraphicsContextState

strong

Enumerator
UNINITIALIZED
ACTIVE
TERMINATED

Definition at line 4 of file GraphicsContext.h.

    {
        UNINITIALIZED,
        ACTIVE,
        TERMINATED
    };

PrimitiveType

enum class Elevate::PrimitiveType : uint8_t

strong

Enumerator
Cube
UVSphere
Cubesphere
Icosphere
Cylinder
Capsule
Plane
Quad
Torus

Definition at line 27 of file Mesh.h.

    {
        Cube,
        UVSphere,
        Cubesphere,
        Icosphere,
        Cylinder,
        Capsule,
        Plane,
        Quad,
        Torus,
    };

SceneType

enum Elevate::SceneType

Enumerator
RuntimeScene
EditorScene
DebugScene

Definition at line 28 of file Scene.h.

                   {
        RuntimeScene,
        EditorScene,
        DebugScene,
    };

TextureFilter

enum class Elevate::TextureFilter : uint8_t

strong

Enumerator
Nearest
Linear

Definition at line 49 of file Texture.h.

: uint8_t { Nearest, Linear };

TextureFormat

enum class Elevate::TextureFormat : uint8_t

strong

Enumerator
EMPTY
GRAYSCALE
RGB
RGBA
DEPTH

Definition at line 21 of file Texture.h.

                             : uint8_t {
        EMPTY = 0,
        GRAYSCALE = 1,
        RGB = 3,
        RGBA = 4,
        DEPTH
    };

TextureSource

enum class Elevate::TextureSource : uint8_t

strong

Enumerator
File
Generated
RenderTarget

Definition at line 15 of file Texture.h.

                             : uint8_t {
        File,        // Loaded from disk
        Generated,   // Created from color or procedural
        RenderTarget // Created as framebuffer texture
    };

TextureState

enum class Elevate::TextureState : uint8_t

strong

Enumerator
Empty
Unloaded
Loading
Ready
Loaded
Failed

Definition at line 40 of file Texture.h.

                            : uint8_t {
        Empty,
        Unloaded = Empty, // Same as empty but for files
        Loading,
        Ready,
        Loaded = Ready, // Same as ready but for files
        Failed
    };

TextureType

enum class Elevate::TextureType : uint8_t

strong

Enumerator
Diffuse
Specular
Normal
Height
Cubemap
Ambient
Count

Definition at line 29 of file Texture.h.

                           : uint8_t {
        Diffuse,
        Specular,
        Normal,
        Height,
        Cubemap,
        Ambient,
 
        Count
    };

TextureWrap

enum class Elevate::TextureWrap : uint8_t

strong

Enumerator
Repeat
MirrorRepeat
ClampToEdge
ClampToBorder

Definition at line 50 of file Texture.h.

: uint8_t { Repeat, MirrorRepeat, ClampToEdge, ClampToBorder };

Function Documentation

CreateApplication()

Elevate::Application * Elevate::CreateApplication

(

)

CreateBuffers()

void Elevate::CreateBuffers ( int32_t  n, uint32_t *  ids  )

inline

Definition at line 14 of file OpenGLBuffer.cpp.

    {
#ifdef EE_SUPPORTS_DSA
        glCreateBuffers(n, ids);
#else
        glGenBuffers(n, ids);
#endif
    }

GetDataAPIType()

uint32_t Elevate::GetDataAPIType ( EngineDataType  type )

inline

Definition at line 125 of file Data.h.

                                                        {
        return ShaderDataAPIType[static_cast<uint32_t>(type)];
    }

GetDataTypeCount()

uint32_t Elevate::GetDataTypeCount ( EngineDataType  type )

inline

Definition at line 117 of file Data.h.

                                                          {
        return ShaderDataTypeCount[static_cast<uint32_t>(type)];
    }

GetDataTypeSize()

uint32_t Elevate::GetDataTypeSize ( EngineDataType  type )

inline

Definition at line 121 of file Data.h.

                                                         {
        return ShaderDataTypeSize[static_cast<uint32_t>(type)];
    }

GetGameContextStateName()

const char * Elevate::GetGameContextStateName

(

GameContextState

state

)

Definition at line 5 of file GameContext.cpp.

    {
        switch (state)
        {
            case Initializing: return "Initializing";
            case EditorMode: return "EditorMode";
            case Runtime: return "Runtime";
            case Paused: return "Paused";
            case Stopped: return "Stopped";
            default: return "Unknown";
        }
    }

GetRegistryMap()

std::unordered_map< uint32_t, std::unique_ptr< entt::registry > > & Elevate::GetRegistryMap

(

)

Definition at line 6 of file ScenePrivate.cpp.

                                                                              {
        static std::unordered_map<uint32_t, std::unique_ptr<entt::registry>> s_RegistryMap;
        return s_RegistryMap;
    }

NamedBufferData()

void Elevate::NamedBufferData ( uint32_t  buffer, uint32_t  target, size_t  size, const void *  data, uint32_t  usage  )

inline

Definition at line 23 of file OpenGLBuffer.cpp.

                                                                                                                 {
#ifdef EE_SUPPORTS_DSA
        glNamedBufferData(buffer, size, data, usage);
#else
        glBindBuffer(target, buffer);
        glBufferData(target, size, data, usage);
#endif
    }

operator<<()

std::ostream & Elevate::operator<< ( std::ostream &  os, const Event &  e  )

inline

Definition at line 80 of file Event.h.

    {
        return os << e.ToString();
    }

ToInternalFormat()

constexpr GLenum Elevate::ToInternalFormat ( TextureFormat  format )

constexpr

Definition at line 15 of file OpenGLTexture.cpp.

                                                            {
        switch (format) {
        case TextureFormat::GRAYSCALE:   return GL_R8;       // 8-bit single channel
        case TextureFormat::RGB:         return GL_RGB8;     // 8-bit RGB
        case TextureFormat::RGBA:        return GL_RGBA8;    // 8-bit RGBA
        case TextureFormat::DEPTH:       return GL_DEPTH_COMPONENT24;
        default:                         return GL_RGBA8;
        }
    }

ToOpenGL() [1/4]

constexpr GLenum Elevate::ToOpenGL ( TextureFilter  filter )

constexpr

Definition at line 47 of file OpenGLTexture.cpp.

                                                    {
        switch (filter) {
        case TextureFilter::Nearest: return GL_NEAREST;
        case TextureFilter::Linear:  return GL_LINEAR;
        default:                     return GL_NEAREST;
        }
    }

ToOpenGL() [2/4]

constexpr GLenum Elevate::ToOpenGL ( TextureFormat  format )

constexpr

Definition at line 25 of file OpenGLTexture.cpp.

                                                    {
        switch (format) {
        case TextureFormat::EMPTY:              return GL_NONE;
        case TextureFormat::GRAYSCALE:          return GL_RED;
        case TextureFormat::RGB:                return GL_RGB;
        case TextureFormat::RGBA:               return GL_RGBA;
        case TextureFormat::DEPTH:              return GL_DEPTH_COMPONENT;
            //case TextureFormat::DEPTH16:            return GL_DEPTH_COMPONENT16;
            //case TextureFormat::DEPTH24:            return GL_DEPTH_COMPONENT24;
            //case TextureFormat::DEPTH32F:           return GL_DEPTH_COMPONENT32F;
            //case TextureFormat::DEPTH24_STENCIL8:   return GL_DEPTH24_STENCIL8;
        default:                                return GL_NONE;
        }
    }

ToOpenGL() [3/4]

constexpr GLenum Elevate::ToOpenGL ( TextureType  type )

constexpr

Definition at line 65 of file OpenGLTexture.cpp.

                                                {
        switch (type) {
        case TextureType::Cubemap: return GL_TEXTURE_CUBE_MAP;
        default:                   return GL_TEXTURE_2D;
        }
    }

ToOpenGL() [4/4]

constexpr GLenum Elevate::ToOpenGL ( TextureWrap  wrap )

constexpr

Definition at line 55 of file OpenGLTexture.cpp.

                                                {
        switch (wrap) {
        case TextureWrap::Repeat:       return GL_REPEAT;
        case TextureWrap::MirrorRepeat: return GL_MIRRORED_REPEAT;
        case TextureWrap::ClampToEdge:  return GL_CLAMP_TO_EDGE;
        case TextureWrap::ClampToBorder:return GL_CLAMP_TO_BORDER;
        default:                        return GL_REPEAT;
        }
    }

ToOpenGLType()

constexpr GLenum Elevate::ToOpenGLType ( TextureFormat  format )

constexpr

Definition at line 40 of file OpenGLTexture.cpp.

                                                        {
        switch (format) {
        case TextureFormat::DEPTH:              return GL_FLOAT;
        default:                                return GL_UNSIGNED_BYTE;
        }
    }

Variable Documentation

ShaderDataAPIType

const unsigned int Elevate::ShaderDataAPIType[]

Initial value:

= {
        EE_DATA_TYPE_None,  
        EE_DATA_TYPE_Bool,  
        EE_DATA_TYPE_Int,   
        EE_DATA_TYPE_Int2,  
        EE_DATA_TYPE_Int3,  
        EE_DATA_TYPE_Int4,  
        EE_DATA_TYPE_Float, 
        EE_DATA_TYPE_Float2,
        EE_DATA_TYPE_Float3,
        EE_DATA_TYPE_Float4,
        EE_DATA_TYPE_Mat3,  
        EE_DATA_TYPE_Mat4,  
        EE_DATA_TYPE_Mat5   
    }

Definition at line 89 of file Data.h.

                                             {
        EE_DATA_TYPE_None,  // None
        EE_DATA_TYPE_Bool,  // Bool
        EE_DATA_TYPE_Int,   // Int
        EE_DATA_TYPE_Int2,  // Int2
        EE_DATA_TYPE_Int3,  // Int3
        EE_DATA_TYPE_Int4,  // Int4
        EE_DATA_TYPE_Float, // Float
        EE_DATA_TYPE_Float2,// Float2
        EE_DATA_TYPE_Float3,// Float3
        EE_DATA_TYPE_Float4,// Float4
        EE_DATA_TYPE_Mat3,  // Mat3
        EE_DATA_TYPE_Mat4,  // Mat4
        EE_DATA_TYPE_Mat5   // Mat5
    };

ShaderDataTypeCount

const int Elevate::ShaderDataTypeCount[]

Initial value:

= {
        EE_DATA_COUNT_None,  
        EE_DATA_COUNT_Bool,  
        EE_DATA_COUNT_Int,   
        EE_DATA_COUNT_Int2,  
        EE_DATA_COUNT_Int3,  
        EE_DATA_COUNT_Int4,  
        EE_DATA_COUNT_Float, 
        EE_DATA_COUNT_Float2,
        EE_DATA_COUNT_Float3,
        EE_DATA_COUNT_Float4,
        EE_DATA_COUNT_Mat3,  
        EE_DATA_COUNT_Mat4,  
        EE_DATA_COUNT_Mat5   
    }

Definition at line 54 of file Data.h.

                                      {
        EE_DATA_COUNT_None,  // None
        EE_DATA_COUNT_Bool,  // Bool
        EE_DATA_COUNT_Int,   // Int
        EE_DATA_COUNT_Int2,  // Int2
        EE_DATA_COUNT_Int3,  // Int3
        EE_DATA_COUNT_Int4,  // Int4
        EE_DATA_COUNT_Float, // Float
        EE_DATA_COUNT_Float2,// Float2
        EE_DATA_COUNT_Float3,// Float3
        EE_DATA_COUNT_Float4,// Float4
        EE_DATA_COUNT_Mat3,  // Mat3
        EE_DATA_COUNT_Mat4,  // Mat4
        EE_DATA_COUNT_Mat5   // Mat5
    };

ShaderDataTypeSize

const int Elevate::ShaderDataTypeSize[]

Initial value:

= {
        EE_DATA_SIZE_None,  
        EE_DATA_SIZE_Bool,  
        EE_DATA_SIZE_Int,   
        EE_DATA_SIZE_Int2,  
        EE_DATA_SIZE_Int3,  
        EE_DATA_SIZE_Int4,  
        EE_DATA_SIZE_Float, 
        EE_DATA_SIZE_Float2,
        EE_DATA_SIZE_Float3,
        EE_DATA_SIZE_Float4,
        EE_DATA_SIZE_Mat3,  
        EE_DATA_SIZE_Mat4,  
        EE_DATA_SIZE_Mat5,  
        EE_DATA_SIZE_None,  
        EE_DATA_SIZE_None,  
        EE_DATA_SIZE_None   
    }

Definition at line 70 of file Data.h.

                                     {
        EE_DATA_SIZE_None,  // None
        EE_DATA_SIZE_Bool,  // Bool
        EE_DATA_SIZE_Int,   // Int
        EE_DATA_SIZE_Int2,  // Int2
        EE_DATA_SIZE_Int3,  // Int3
        EE_DATA_SIZE_Int4,  // Int4
        EE_DATA_SIZE_Float, // Float
        EE_DATA_SIZE_Float2,// Float2
        EE_DATA_SIZE_Float3,// Float3
        EE_DATA_SIZE_Float4,// Float4
        EE_DATA_SIZE_Mat3,  // Mat3
        EE_DATA_SIZE_Mat4,  // Mat4
        EE_DATA_SIZE_Mat5,  // Mat5
        EE_DATA_SIZE_None,  // Sampler2D
        EE_DATA_SIZE_None,  // Custom
        EE_DATA_SIZE_None   // Unknown
    };