LkEngine 0.1.2
 
Loading...
Searching...
No Matches
Namespaces | Classes | Concepts | Typedefs | Enumerations | Functions | Variables
LkEngine Namespace Reference
Core | Core » Time | Core » String Utility

Namespaces

namespace  LOpenGL_Debug
 
namespace  LOpenGL_Internal
 
namespace  RGBA32
 
namespace  SerializationOp
 
namespace  StringUtils
 String utility. Contains various utility functions for strings.
 
namespace  Time
 Time utility.
 
namespace  TObjectPtr_Internal
 Internal functions used by TObjectPtr for managing live LObject references.
 

Classes

class  AssetEvent
 
struct  AssimpLogStream
 
struct  Box2DWorldComponent
 
struct  ComponentGroup
 
struct  FAABB
 
struct  FApplicationSpecification
 
struct  FArrayTextureSpecification
 
struct  FAssetImporterValidator
 
struct  FAssetMetadata
 
struct  FAssetSerializationInfo
 
struct  FBlendFunction
 
struct  FBoneInfluence
 
struct  FBoneInfo
 
struct  FBuffer
 
struct  FBufferSafe
 
struct  FClassMetadata
 
struct  FConsoleMessage
 
struct  FEditorResources
 
struct  FEditorSettings
 
class  FEditorSettingsSerializer
 
struct  FFontConfiguration
 
struct  FFontEntry
 
struct  FFramebufferAttachmentSpecification
 
struct  FFramebufferSpecification
 
struct  FFramebufferTextureSpecification
 
class  FileStreamReader
 
class  FileStreamWriter
 
struct  FImageSpecification
 
struct  FImageSubresourceRange
 
struct  FIndex
 
struct  FInternalLObjectValidator
 
struct  FKeyData
 
struct  FLineVertex
 
struct  FMaterialSpecification
 
struct  FMeshNode
 
struct  FMouseButtonData
 
struct  FPanelData
 
struct  FPipelineSpecification
 
struct  FPipelineStatistics
 
struct  FProjectConfiguration
 
class  FProjectSerializer
 
struct  FQuadVertex
 
struct  FRay
 
struct  FRayCast
 
struct  FRenderer2DSpecification
 
struct  FRendererCapabilities
 
struct  FRendererSpecification
 
struct  FRenderPassInput
 
struct  FRenderPassInputDeclaration
 
struct  FRenderPassSpecification
 
struct  FRuntimeArguments
 
struct  FSceneRendererFlushData
 
struct  FSceneRendererSpecification
 
struct  FSceneSelectionData
 
class  FScopedPerformanceTimer
 
class  FScopedTimer
 
struct  FShaderProgramSource
 
struct  FTextureLoader
 
struct  FTextureSpecification
 
struct  FThreadData
 
class  FTimerHandle
 
class  FTimestep
 
struct  FTriangle
 
struct  FVertex
 
struct  FVertexBufferElement
 
struct  FVertexBufferLayout
 
struct  FWindowData
 
struct  FWindowSpecification
 
struct  Global
 
struct  GPUMemoryStats
 
struct  HasGetClass
 
struct  HasGetClass< T, std::void_t< decltype(std::declval< T >().GetClass())> >
 
class  IAssetManager
 
class  IAssetSerializer
 
struct  IComponent
 
class  ICrashHandler
 
union  ImageClearValue
 
class  IPanel
 
interface  IPhysicsAPI
 
class  ISerializable
 
class  IThread
 
class  LApplication
 
class  LApplicationSerializer
 
class  LArrayTexture
 
class  LAsset
 
class  LAssetImporter
 
class  LAssetManager
 
class  LAssetRegistry
 
class  LAssimpMeshImporter
 
struct  LBoxCollider2DComponent
 
class  LBulletPhysics
 
class  LCamera
 
struct  LCameraComponent
 
class  LClass
 
class  LCrashHandler
 
class  LEditorAssetManager
 
class  LEditorCamera
 
class  LEditorConsolePanel
 
class  LEditorConsoleSink
 
class  LEditorContext
 
class  LEntity
 
class  LEvent
 
class  LEventDispatcher
 
class  LEventQueue
 
class  LFileSystem
 
class  LFramebuffer
 
class  LGarbageCollector
 
class  LHash
 
struct  LIDComponent
 
class  LImage
 
class  LImage2D
 
class  LIndexBuffer
 
class  LInput
 
class  LKeyboard
 
class  LKeyPressedEvent
 
class  LKeyReleasedEvent
 
class  LLayer
 
class  LLayerStack
 
class  LLog
 
class  LMaterial
 
class  LMaterialAsset
 
class  LMaterialTable
 
class  LMesh
 
struct  LMeshComponent
 
class  LMeshSerializer
 
class  LMeshSource
 
class  LMeshSourceSerializer
 
class  LMetadataRegistry
 
class  LMouse
 
class  LMouseButtonPressedEvent
 
class  LMouseButtonReleasedEvent
 
class  LMouseMovedEvent
 
class  LMouseScrolledEvent
 
class  LObject
 
class  LObjectBase
 
struct  LOpenGL3
 
struct  LOpenGL4
 
class  LOpenGLArrayTexture
 
struct  LOpenGLBase
 
class  LOpenGLContext
 
class  LOpenGLFramebuffer
 
class  LOpenGLImage
 
class  LOpenGLImage2D
 
class  LOpenGLImGuiLayer
 
class  LOpenGLMaterial
 
class  LOpenGLPipeline
 
class  LOpenGLRenderCommandBuffer
 
class  LOpenGLRenderer
 
class  LOpenGLRenderPass
 
class  LOpenGLShader
 
class  LOpenGLTexture2D
 
class  LOpenGLTextureCube
 
class  LOpenGLUniformBuffer
 
class  LOpenGLUniformBufferSet
 
class  LOpenGLVertexBuffer
 
class  LPanelManager
 
class  LPerformanceProfiler
 
class  LPhysicsSystem
 
class  LPipeline
 
class  LProject
 
struct  LRelationshipComponent
 
class  LRenderCommandBuffer
 
class  LRenderCommandQueue
 
class  LRenderContext
 
class  LRenderer
 
class  LRenderer2D
 
class  LRenderer2DAPI
 
class  LRendererAPI
 
class  LRenderPass
 
struct  LRigidBody2DComponent
 
class  LRuntimeAssetManager
 
class  LScene
 
class  LSceneCamera
 
struct  LSceneComponent
 
class  LSceneRenderer
 
class  LSceneSerializer
 
class  LSelectionContext
 
class  LShader
 
class  LShaderLibrary
 
class  LShaderResourceDeclaration
 
struct  LSpriteComponent
 
class  LStaticMesh
 
struct  LStaticMeshComponent
 
class  LStaticMeshSerializer
 
class  LSubmesh
 
class  LSwapChain
 
struct  LTagComponent
 
class  LTestManager
 
class  LTestRunner
 
class  LTexture
 
class  LTexture2D
 
class  LTextureCube
 
class  LThemeManagerPanel
 
class  LThread
 
class  LTimer
 
class  LTimerManager
 
struct  LTransformComponent
 
struct  LType
 
class  LUILayer
 
class  LUniformBuffer
 
class  LUniformBufferSet
 
struct  LUUID
 
class  LVersion
 
class  LVertexBuffer
 
class  LViewport
 
class  LWindow
 
class  LWindowsThread
 
class  OpenGLIndexBuffer
 
class  OpenGLSwapChain
 
class  RendererResource
 
class  SceneCreatedEvent
 
class  SceneDeletedEvent
 
class  ScriptEngine
 
class  ScriptEngineConfig
 
struct  ShaderBuffer
 
struct  ShaderStorageBuffer
 
class  ShaderUniform
 
struct  ShaderUniformBuffer
 
class  StreamReader
 
class  StreamWriter
 
struct  TEnumRange
 
struct  TEventQueueEntry
 
struct  TIsTSubclassOf
 
struct  TIsTSubclassOf< const TSubclassOf< T > >
 
struct  TIsTSubclassOf< const volatile TSubclassOf< T > >
 
struct  TIsTSubclassOf< TSubclassOf< T > >
 
struct  TIsTSubclassOf< volatile TSubclassOf< T > >
 
class  TObjectPtr
 
class  TSubclassOf
 
struct  TVector2
 Templated two-component vector. More...
 
struct  TVector3
 
struct  TVector4
 Templated four-component vector. More...
 
class  TWeakPtr
 

Concepts

concept  LObjectCore
 
concept  HasLClassMacro
 

Typedefs

using FAssetHandle = LUUID
 
using byte = uint8_t
 
using llong = long long
 
using LRendererID = uint32_t
 
using FEventCallback = std::function<void(LEvent&)>
 
using FEventHandler = std::function<void(LEvent&)>
 
using LVector2 = TVector2<float>
 
using LVector3 = TVector3<float>
 
using LVector4 = TVector4<float>
 
using LVector = LVector3
 
using FThreadHandle = uint64_t
 
using LOpenGL = LOpenGL4
 
using FResizeCallback = std::function<void(TObjectPtr<LFramebuffer>)>
 
using ResourceDescriptorInfo = void*
 
using ShaderResourceList = std::vector<LShaderResourceDeclaration*>
 
using AllComponents
 
using ESerializationOp = SerializationOp::Type
 

Enumerations

enum class  EAssetFlag : uint16_t { None = LK_BIT(0) , Missing = LK_BIT(1) , Invalid = LK_BIT(2) }
 
enum class  EAssetType : uint16_t {
  None = 0 , Scene , Prefab , Mesh ,
  StaticMesh , MeshSource , Material , Texture ,
  Font , Skeleton , Animation , EnvMap ,
  Audio , COUNT
}
 
enum class  ERendererAPI { None = 0 , OpenGL , Vulkan }
 
enum class  EClassFlag : uint32_t { None = LK_BIT(0) , Abstract = LK_BIT(1) }
 
enum class  EClassType : uint64_t {
  LField = LK_BIT(0) , LEnum = LK_BIT(1) , LStruct = LK_BIT(2) , LClass = LK_BIT(3) ,
  LObject = LK_BIT(4)
}
 
enum class  ELogFormat : uint8_t { Compact = 0 , Verbose }
 
enum class  EShapeType { Null = 0 , Triangle , Quad , Hexagon }
 
enum class  EEventType : uint32_t {
  None = 0 , WindowFocus , WindowLostFocus , WindowMoved ,
  WindowResize , WindowClose , KeyPressed , KeyReleased ,
  MouseButtonPressed , MouseButtonReleased , MouseButtonHeld , MouseMoved ,
  MouseScrolled , COUNT
}
 
enum class  EEventCategory : uint32_t { None = 0 , Input , COUNT }
 
enum class  EHash { None = 0 , FNV }
 
enum class  EChecksum { None = 0 , Crc32 }
 
enum class  EKey : uint16_t {
  None = 0 , Space = 32 , Apostrophe = 39 , Comma = 44 ,
  Minus = 45 , Period = 46 , Slash = 47 , D0 = 48 ,
  D1 = 49 , D2 = 50 , D3 = 51 , D4 = 52 ,
  D5 = 53 , D6 = 54 , D7 = 55 , D8 = 56 ,
  D9 = 57 , Semicolon = 59 , Equal = 61 , A = 65 ,
  B = 66 , C = 67 , D = 68 , E = 69 ,
  F = 70 , G = 71 , H = 72 , I = 73 ,
  J = 74 , K = 75 , L = 76 , M = 77 ,
  N = 78 , O = 79 , P = 80 , Q = 81 ,
  R = 82 , S = 83 , T = 84 , U = 85 ,
  V = 86 , W = 87 , X = 88 , Y = 89 ,
  Z = 90 , LeftBracket = 91 , Backslash = 92 , RightBracket = 93 ,
  GraveAccent = 96 , Escape = 256 , Enter = 257 , Tab = 258 ,
  Backspace = 259 , Insert = 260 , Delete = 261 , Right = 262 ,
  Left = 263 , Down = 264 , Up = 265 , PageUp = 266 ,
  PageDown = 267 , Home = 268 , End = 269 , CapsLock = 280 ,
  ScrollLock = 281 , NumLock = 282 , PrintScreen = 283 , Pause = 284 ,
  F1 = 290 , F2 = 291 , F3 = 292 , F4 = 293 ,
  F5 = 294 , F6 = 295 , F7 = 296 , F8 = 297 ,
  F9 = 298 , LeftShift = 340 , LeftControl = 341 , LeftAlt = 342 ,
  LeftSuper = 343 , RightShift = 344 , RightControl = 345 , RightAlt = 346 ,
  RightSuper = 347 , Menu = 348
}
 
enum class  EKeyState { None = -1 , Pressed , Held , Released }
 
enum class  EMouseButton : uint16_t {
  Button0 , Button1 , Button2 , Button3 ,
  Button4 , Button5 , None , Left = Button0 ,
  Right = Button1 , Middle = Button2
}
 
enum class  EMouseButtonState { None = -1 , Pressed , Held , Released }
 
enum class  ECursorMode { Normal = 0 , Hidden = 1 , Locked = 2 }
 
enum class  EMouseScrollDirection { None , Up , Down }
 
enum class  EInitFlag { NoInit = 0 , True }
 
enum class  EObjectFlag : uint32_t {
  None = 0 , NeedInitialization , NeedLoad , BeginDestroy ,
  FinishDestroy , Garbage
}
 
enum class  EAngleUnit { Degree , Radian }
 
enum class  EVectorAxis : uint32_t {
  X = LK_BIT(0) , Y = LK_BIT(1) , Z = LK_BIT(2) , W = LK_BIT(3) ,
  R = X , G = Y , B = Z , A = W
}
 
enum class  ESelectionContext { Global = 0 , Scene , ContentBrowser }
 
enum class  EEditorCameraMode { None = 0 , Flycam , Arcball }
 
enum class  EConsoleVerbosity : int16_t {
  None = -1 , Debug = LK_BIT(0) , Info = LK_BIT(1) , Warning = LK_BIT(2) ,
  Error = LK_BIT(3) , All = Debug | Info | Warning | Error
}
 
enum class  EPanelInitState : uint8_t { Closed = 0 , Open }
 
enum class  EPanelCategory { Edit , View , COUNT }
 
enum class  ETheme { Dark , Light , GruvboxMaterial , COUNT }
 
enum class  EPhysicsAPI { None = 0 , Bullet3 }
 
enum class  EProjectLoadAction : uint8_t { Unload , Load }
 
enum class  ESourceBlendFunction {
  Zero = 0 , One , Color , Alpha ,
  One_Minus_DestinationAlpha
}
 
enum class  EDestinationBlendFunction {
  Zero = 0 , One , Alpha , Color ,
  One_Minus_SourceAlpha
}
 
enum class  EDepthFunction {
  Never = 0 , Less , Equal , LessOrEqual ,
  Greater , NotEqual , GreaterOrEqual , Always
}
 
enum class  ECameraProjection : uint8_t { Perspective , Orthographic }
 
enum class  ECameraType { None = 0 , Scene = 1 , Editor = 2 }
 
enum class  EFramebufferTextureFormat {
  None = 0 , RGBA8 , RED_INTEGER , DEPTH24STENCIL8 ,
  Depth = DEPTH24STENCIL8
}
 
enum class  EFramebufferBlendMode {
  None = 0 , OneZero , SrcAlphaOneMinusSrcAlpha , Additive ,
  Zero_SrcColor
}
 
enum class  EAttachmentLoadOp { Inherit = 0 , Clear = 1 , Load = 2 }
 
enum class  ERenderProfile { Core , Compability }
 
enum class  ERenderTopology { Lines , Triangles }
 
enum class  ERenderPassResourceType : uint16_t {
  None = 0 , UniformBuffer , UniformBufferSet , StorageBuffer ,
  StorageBufferSet , Texture2D , TextureCube , Image2D
}
 
enum class  ERenderPassInputType : uint16_t {
  None = 0 , UniformBuffer , StorageBuffer , ImageSampler1D ,
  ImageSampler2D , ImageSampler3D , StorageImage1D , StorageImage2D ,
  StorageImage3D
}
 
enum class  EShaderType { None = -1 , Vertex , Fragment }
 
enum class  EUniformVarType {
  None = 0 , Bool , Float , Vec3 ,
  Sampler2D , Sampler2DArray
}
 
enum class  ShaderUniformType {
  None = 0 , Bool , Int , UInt ,
  Float , Vec2 , Vec3 , Vec4 ,
  Mat3 , Mat4 , IVec2 , IVec3 ,
  IVec4
}
 
enum class  EImageFormat {
  None = 0 , RED8UN , RED8UI , RED16UI ,
  RED32UI , RED32F , RG8 , RG16F ,
  RG32F , RGB , RGBA , RGB8 ,
  RGBA8 , RGBA16F , RGBA32F , B10R11G11UF ,
  SRGB , SRGBA , DEPTH32FSTENCIL8UINT , DEPTH32F ,
  DEPTH24STENCIL8 , Depth = DEPTH24STENCIL8
}
 
enum class  EImageUsage { None = 0 , Texture , Attachment , Storage }
 
enum class  ETextureWrap { None = 0 , Clamp , Repeat }
 
enum class  ETextureFilter { None = 0 , Linear , Nearest }
 
enum class  ETextureType { None = 0 , Texture2D , TextureCube }
 
enum class  ETextureAnistropicFiltering { None = 0 , Bilnear , Trilnear }
 
enum class  ETextureUniformType : uint8_t {
  Diffuse = 0 , Specular , Normal , Height ,
  Emissive , DiffuseRoughness
}
 
enum class  EArrayTextureDimension {
  Dim_200x200 , Dim_512x512 , Dim_1024x1024 , Dim_2048x2048 ,
  Dim_4096x4096
}
 
enum class  EPrimitiveTopology {
  None = 0 , Points , Lines , Triangles ,
  LineStrip , TriangleStrip , TriangleFan
}
 
enum class  EDepthCompareOperator {
  None = 0 , Never , NotEqual , Less ,
  LessOrEqual , Greater , GreaterOrEqual , Equal ,
  Always
}
 
enum class  EFontSize {
  Regular = 0 , Smaller , Small , Large ,
  Larger , Title , Header
}
 
enum class  EFont { Default = 0 , SourceSansPro , Roboto }
 
enum class  EMessageBoxFlag : uint32_t { OkButton = LK_BIT(0) , CancelButton = LK_BIT(1) , UserFunction = LK_BIT(2) , AutoSize = LK_BIT(3) }
 
enum class  EVertexBufferUsage { None = 0 , Static = 1 , Dynamic = 2 }
 
enum class  EShaderDataType : uint8_t {
  Null = 0 , Float , Float2 , Float3 ,
  Float4 , Int , Int2 , Int3 ,
  Int4 , Mat3 , Mat4 , Bool
}
 
enum class  EShaderDataMember { Null = 0 , Position , Color }
 
enum class  ERigidBodyType { None = -1 , Static , Dynamic , Kinematic }
 
enum class  ESceneType { Normal = 0 , Editor }
 
enum class  ESceneState { Edit = 0 , Play , Pause , Simulate }
 
enum class  ESerializeFormat : uint8_t { None = 0 , Yaml }
 

Functions

 LK_ENUM_CLASS (EAssetFlag)
 
 LK_ENUM_RANGE_BY_FIRST_AND_LAST (EAssetType, EAssetType::None, EAssetType::COUNT)
 
 LK_DECLARE_MULTICAST_DELEGATE (FOnEngineShutdown)
 
 LK_ENUM_CLASS (ERendererAPI)
 
 LK_ENUM_RANGE_BY_FIRST_AND_LAST (ERendererAPI, ERendererAPI::None, ERendererAPI::Vulkan)
 
 LK_ENUM_CLASS (EClassFlag)
 
 LK_ENUM_CLASS (EClassType)
 
template<typename To , typename From >
To * Cast (From *Source)
 Static cast.
 
 LK_ENUM_CLASS (EEventType)
 
 LK_ENUM_RANGE_BY_COUNT (EEventType, EEventType::COUNT)
 
 LK_ENUM_CLASS (EEventCategory)
 
 LK_ENUM_RANGE_BY_COUNT (EEventCategory, EEventCategory::COUNT)
 
std::ostream & operator<< (std::ostream &OStream, const LEvent &InEvent)
 
template<>
constexpr uint32_t LHash::Generate< EHash::FNV > (std::string_view String)
 Generate hash.
 
template<>
constexpr uint32_t LHash::GenerateChecksum< EChecksum::Crc32 > (std::string_view String)
 Generate a checksum based on a string input.
 
 LK_ENUM_CLASS (EObjectFlag)
 
template<typename... TArgs>
 if (TagDetails.Enabled &&TagDetails.Filter<=Level)
 
template<typename... TArgs>
 if (TagDetails.Enabled &&(TagDetails.Filter<=Level))
 
 LK_ENUM_CLASS (EVectorAxis)
 
 LK_DECLARE_MULTICAST_DELEGATE (FOnWindowMaximized, const bool)
 
 LK_ENUM_CLASS (EEditorCameraMode)
 
 LK_ENUM_CLASS (EConsoleVerbosity)
 
 LK_DECLARE_MULTICAST_DELEGATE (FEditorOnSelectionChanged, const LObject &)
 
 LK_ENUM_RANGE_BY_COUNT (ETheme, ETheme::COUNT)
 
YAML::Emitter & operator<< (YAML::Emitter &Out, const ImVec2 &InVec2)
 
YAML::Emitter & operator<< (YAML::Emitter &Out, const ImVec4 &InVec4)
 
 LK_ENUM_CLASS (EMessageBoxFlag)
 
 LK_ENUM_RANGE_FLAGS_BY_FIRST_AND_LAST (EMessageBoxFlag, EMessageBoxFlag::OkButton, EMessageBoxFlag::AutoSize)
 
 LK_DECLARE_MULTICAST_DELEGATE (FOnSetPanelOpen, const char *, const bool)
 
 LK_DECLARE_DELEGATE_RET (FIsPanelOpen, bool, const char *)
 
 LK_DECLARE_MULTICAST_DELEGATE (FOnSceneSetActive, const TObjectPtr< LScene > &)
 
 LK_DECLARE_MULTICAST_DELEGATE (FOnSceneCreated, const TObjectPtr< LScene > &)
 
 LK_DECLARE_MULTICAST_DELEGATE (FOnSceneSelectionUpdated, const std::vector< FSceneSelectionData > &)
 
YAML::Emitter & operator<< (YAML::Emitter &Out, const glm::vec2 &InVec2)
 
YAML::Emitter & operator<< (YAML::Emitter &Out, const glm::vec3 &InVec3)
 
YAML::Emitter & operator<< (YAML::Emitter &Out, const glm::vec4 &InVec4)
 
YAML::Emitter & operator<< (YAML::Emitter &Out, const std::vector< uint32_t > &Value)
 
 LK_DECLARE_DELEGATE (FTimerDelegate)
 

Variables

template<typename TChar >
constexpr TChar TPathSeparator = '/'
 
constexpr LK_TCHAR PathSeparator = TPathSeparator<LK_TCHAR>
 
std::unordered_map< FObjectHandle, TObjectPtr< LObject > > GLiveObjectMap {}
 
FOnSetPanelOpen OnSetPanelOpen
 
FIsPanelOpen IsPanelOpen
 
const std::unordered_map< EFontSize, float > FontSizeMap
 
FOnSceneSetActive GOnSceneSetActive {}
 
FOnSceneCreated GOnSceneCreated {}
 
enum class  ELogLevel {
  Trace , Debug , Info , Warning ,
  Error , Fatal
}
 
enum class  ELoggerType { Core = 0 , Client , EditorConsole , TestRunner }
 
using LogLevelColorConfig = std::pair<ELogLevel, uint16_t>
 
enum class  ECameraAction : uint16_t { None = 0 , Pan = LK_BIT(0) , Rotate = LK_BIT(1) , Zoom = LK_BIT(2) }
 
enum class  ECameraModifier : int32_t {
  None = 0 , MouseEnabled = LK_BIT(1) , KeyboardEnabled = LK_BIT(2) , PitchLocked = LK_BIT(3) ,
  YawLocked = LK_BIT(4) , Damping = LK_BIT(5)
}
 
 LK_ENUM_CLASS (ECameraAction)
 
 LK_ENUM_RANGE_FLAGS_BY_FIRST_AND_LAST (ECameraAction, ECameraAction::None, ECameraAction::Zoom)
 
 LK_ENUM_CLASS (ECameraModifier)
 
template<>
float LCamera::GetPerspectiveFov< EAngleUnit::Degree > () const
 
template<>
float LCamera::GetPerspectiveFov< EAngleUnit::Radian > () const
 
template<>
float LCamera::GetPerspectiveVerticalFov< EAngleUnit::Degree > () const
 
template<>
float LCamera::GetPerspectiveVerticalFov< EAngleUnit::Radian > () const
 
using FObjectHandle = LUUID
 
template<typename TObject >
constexpr bool IsBaseOfObject = std::is_base_of<LObject, std::decay_t<TObject>>::value
 
FORCEINLINE bool IsValid (const LObject *Object)
 
FORCEINLINE bool IsValid (const LObject &Object)
 

Detailed Description

@fixme: FIXME

|////////////////////////////////////////////////////// LWindowsThread

|//////////////////////////////////////////////////////

Wrap raw OpenGL functions with LK_OpenGL_Verify to reduce clutter in the code by having to do it for every GL call.

Typedef Documentation

◆ AllComponents

using LkEngine::AllComponents
Initial value:
ComponentGroup<
LIDComponent,
LTagComponent,
LTransformComponent,
LSpriteComponent,
LCameraComponent,
LRigidBody2DComponent,
LBoxCollider2DComponent,
LMeshComponent,
LStaticMeshComponent,
LSceneComponent
>

Enumeration Type Documentation

◆ EAssetFlag

enum class LkEngine::EAssetFlag : uint16_t
strong

EAssetFlag

◆ EAssetType

enum class LkEngine::EAssetType : uint16_t
strong

EAssetType

Type of asset.

◆ EClassType

enum class LkEngine::EClassType : uint64_t
strong

Bitflags for different object types.

Todo
: Should be renamed to something else that doesn't contain the word 'Class'.

◆ ECursorMode

enum class LkEngine::ECursorMode
strong

ECursorMode

◆ EEventCategory

enum class LkEngine::EEventCategory : uint32_t
strong

EEventCategory

Category for different type of events.

◆ EEventType

enum class LkEngine::EEventType : uint32_t
strong

EEventType

Type of event.

◆ EKey

enum class LkEngine::EKey : uint16_t
strong

EKey

Key code.

◆ EKeyState

enum class LkEngine::EKeyState
strong

EKeyState

State of a key.

◆ ELogFormat

enum class LkEngine::ELogFormat : uint8_t
strong

Format used on a log message.

◆ EMouseButton

enum class LkEngine::EMouseButton : uint16_t
strong

EMouseButton

◆ EMouseButtonState

enum class LkEngine::EMouseButtonState
strong

EMouseButtonState

◆ EMouseScrollDirection

enum class LkEngine::EMouseScrollDirection
strong

EMouseScrollDirection

◆ ERigidBodyType

enum class LkEngine::ERigidBodyType
strong

ERigidBodyType

◆ ESelectionContext

enum class LkEngine::ESelectionContext
strong

ESelectionContext

Used a way to sort selections depending on where they are performed.

◆ EShaderDataMember

enum class LkEngine::EShaderDataMember
strong

EShaderDataMember

◆ EShaderDataType

enum class LkEngine::EShaderDataType : uint8_t
strong

EShaderDataType

◆ EShaderType

enum class LkEngine::EShaderType
strong

Type of shader, used on parsing of files during shader setup.

◆ ETheme

enum class LkEngine::ETheme
strong

ETheme

Type of theme.

◆ EUniformVarType

enum class LkEngine::EUniformVarType
strong

EUniformVarType

The type of an uniform variable in a glsl shader.

◆ EVertexBufferUsage

enum class LkEngine::EVertexBufferUsage
strong

EVertexBufferUsage