`ice_engine`¶

namespace ice_engine

Typedefs

typedef unsigned char byte

typedef signed char sbyte

typedef uint8_t uint8

typedef int8_t int8

typedef int8_t sint8

typedef uint16_t uint16

typedef int16_t int16

typedef int16_t sint16

typedef uint32_t uint

typedef uint32_t uint32

typedef int32_t sint

typedef int32_t sint32

typedef int32_t int32

typedef float float32

typedef double float64

typedef uint64_t uint64

typedef int64_t sint64

typedef int64_t int64

Functions

void animateSkeleton(std::vector<glm::mat4> &transformations, const glm::mat4 &globalInverseTransformation, const std::unordered_map<std::string, AnimatedBoneNode> &animatedBoneNodes, const BoneNode &rootBoneNode, const BoneData &boneData, std::chrono::duration<float32> duration, float32 ticksPerSecond, std::chrono::duration<float32> runningTime)

void animateSkeleton(std::vector<glm::mat4> &transformations, const glm::mat4 &globalInverseTransformation, const std::unordered_map<std::string, AnimatedBoneNode> &animatedBoneNodes, const BoneNode &rootBoneNode, const BoneData &boneData, std::chrono::duration<float32> duration, float32 ticksPerSecond, std::chrono::duration<float32> runningTime, uint32 startFrame, uint32 endFrame)

void animateSkeleton(std::vector<glm::mat4> &transformations, const glm::mat4 &globalInverseTransformation, const std::unordered_map<std::string, AnimatedBoneNode> &animatedBoneNodes, const BoneNode &rootBoneNode, const BoneData &boneData, std::chrono::duration<float32> duration, float32 ticksPerSecond, std::chrono::duration<float32> runningTime, std::vector<uint32> &indexCache)

void animateSkeleton(std::vector<glm::mat4> &transformations, const glm::mat4 &globalInverseTransformation, const std::unordered_map<std::string, AnimatedBoneNode> &animatedBoneNodes, const BoneNode &rootBoneNode, const BoneData &boneData, std::chrono::duration<float32> duration, float32 ticksPerSecond, std::chrono::duration<float32> runningTime, std::vector<uint32> &indexCache, uint32 startFrame, uint32 endFrame)

template<typename T> std::function<std::string(void*)> scriptingEngineDebuggerToStringCallback()

template<class T> static void DefaultConstructor(T *memory)

template<class T, typename ...Args> static void InitConstructorNoForward(T *memory, Args... args)

template<class T> static void CopyConstructor(T *memory, const T &other)

template<class T> static void DefaultDestructor(T *memory)

template<class T> static T &defaultAssignmentOperator(const T &other, T *v)

template<typename V> void registerVectorBindings(scripting::IScriptingEngine *scriptingEngine, const std::string &name, const std::string &type, asEObjTypeFlags objectTypeFlags = asOBJ_APP_CLASS_ALLINTS): Register our vector bindings.

template<typename K, typename V> void registerUnorderedMapBindings(scripting::IScriptingEngine *scriptingEngine, const std::string &name, const std::string &keyType, const std::string &valueType, asEObjTypeFlags objectTypeFlags = asOBJ_APP_CLASS_ALLINTS): Register our map bindings.

template<typename V> void registerFutureBindings(scripting::IScriptingEngine *scriptingEngine, const std::string &name, const std::string &type, asEObjTypeFlags objectTypeFlags = asOBJ_APP_CLASS_ALLINTS): Register our future bindings.

template<typename V> void registerSharedFutureBindings(scripting::IScriptingEngine *scriptingEngine, const std::string &name, const std::string &type, asEObjTypeFlags objectTypeFlags = asOBJ_APP_CLASS_ALLINTS): Register our shared_future bindings.

template<typename VariantBase, typename T> void registerVariantBindingsRecursive(scripting::IScriptingEngine *scriptingEngine, const std::string &name, std::list<std::string> types, asEObjTypeFlags objectTypeFlags = asOBJ_APP_CLASS_ALLINTS): Register our variant bindings.

template<typename VariantBase, typename T, typename Value, typename ...V> void registerVariantBindingsRecursive(scripting::IScriptingEngine *scriptingEngine, const std::string &name, std::list<std::string> types, asEObjTypeFlags objectTypeFlags = asOBJ_APP_CLASS_ALLINTS): Register our variant bindings.

template<typename ...V> void registerVariantBindings(scripting::IScriptingEngine *scriptingEngine, const std::string &name, const std::list<std::string> &types, asEObjTypeFlags objectTypeFlags = asOBJ_APP_CLASS_ALLINTS): Register our variant bindings.

template<typename T> void registerHandleBindings(scripting::IScriptingEngine *scriptingEngine, const std::string &name): Register our Handle bindings.

template<typename T> void registerPointerHandleBindings(scripting::IScriptingEngine *scriptingEngine, const std::string &name): Register our Pointer Handle bindings.

template<typename T> void registerPointerHandleBindings(scripting::IScriptingEngine *scriptingEngine, const std::string &name, const std::string &scriptTypeName): Register our Pointer Handle bindings.

template<class A, class B> B *refCast(A *a)

template<class A, class B> B valueCast(A &a)

template<class C> void registerComponentBehaviours(ice_engine::scripting::IScriptingEngine *scriptingEngine, const std::string &name)

template<class C> void registerComponentMethods(ice_engine::scripting::IScriptingEngine *scriptingEngine, const std::string &name)

template<class C> void registerComponentHandle(ice_engine::scripting::IScriptingEngine *scriptingEngine, const std::string &name)

template<class C, typename ...Args> void registerEntityComponentAssignMethod(ice_engine::scripting::IScriptingEngine *scriptingEngine, const std::string &name, const std::string &params = std::string())

template<class C, typename ...Args> static entityx::ComponentHandle<C> assignNoForward(ecs::Entity &entity, Args... args)

template<class C, typename ...Args> void registerEntityComponentAssignMethodNoForward(ice_engine::scripting::IScriptingEngine *scriptingEngine, const std::string &name, const std::string &params = std::string())

template<class C> static const entityx::ComponentHandle<const C, const entityx::EntityManager> component(ecs::Entity &entity)

template<class C, typename ...Args> void registerEntityComponentMethods(ice_engine::scripting::IScriptingEngine *scriptingEngine, const std::string &name, const std::string &params = std::string())

template<class C, typename ...Args> void registerComponent(ice_engine::scripting::IScriptingEngine *scriptingEngine, const std::string &name, const std::vector<std::pair<std::string, int32>> &memberVariables, const std::string &params)

template<class C, typename ...Args> void registerComponent(ice_engine::scripting::IScriptingEngine *scriptingEngine, const std::string &name, const std::vector<std::pair<std::string, int32>> &memberVariables)

traced stacktrace()

scripting::ScriptObjectHandle createScriptObjectHandle(void *object)

static void InitConstructorImage(Image *memory, const std::vector<byte> &data, const uint32 width, const uint32 height, const IImage::Format format)

static void InitConstructorPbrMaterial(PbrMaterial *memory, IImage *albedo, IImage *normal, IImage *metalness, IImage *roughness, IImage *ambientOcclusion)

static void InitConstructorHeightMap(HeightMap *memory, const IImage &image)

static void InitConstructorHeightMap(HeightMap *memory, const std::vector<uint8> &imageData, const uint32 width, const uint32 height)

static void InitConstructorSplatMap(SplatMap *memory, std::vector<PbrMaterial> materialMap, IImage *terrainMap)

static void InitConstructorHeightfield(Heightfield *memory, const IImage &image)

static void InitConstructorPathfindingTerrain(PathfindingTerrain *memory, const HeightMap &heightMap)

static void InitConstructorMesh(Mesh *memory, std::string name, std::vector<glm::vec3> vertices, std::vector<uint32> indices, std::vector<glm::vec4> colors, std::vector<glm::vec3> normals, std::vector<glm::vec2> textureCoordinates, VertexBoneData vertexBoneData = VertexBoneData(), BoneData boneData = BoneData())

static void InitConstructorTexture(Texture *memory, std::string name, IImage *image)

void testFunction(const pathfinding::AgentParams &ap)

void testFunction2(const pathfinding::AgentParams ap)

void testFunction3(pathfinding::AgentParams ap)

template<typename T> void registerUniquePtrBindings(scripting::IScriptingEngine *scriptingEngine, const std::string &name, const std::string &scriptTypeName): Register our unique_ptr bindings.

template<typename T = std::nullptr_t> void registerTemplateTypeBindings(scripting::IScriptingEngine *scriptingEngine, const std::string &name, const std::string &scriptTypeName, const asDWORD objectTypeFlags = asOBJ_REF | asOBJ_NOCOUNT, const asEObjTypeFlags objectTypeTraitsFlag = asOBJ_APP_CLASS_ALLINTS): Register our template type bindings.

template<typename T = std::nullptr_t> void registerTemplateTypeSpecializationBindings(scripting::IScriptingEngine *scriptingEngine, const std::string &name, const std::string &scriptTypeName, const asDWORD objectTypeFlags = asOBJ_REF | asOBJ_NOCOUNT, const asEObjTypeFlags objectTypeTraitsFlag = asOBJ_APP_CLASS_ALLINTS): Register our template type specialization bindings.

void registerEngineResourceManagerTemplateTypeBindings(scripting::IScriptingEngine *scriptingEngine): Register our EngineResourceManager template type bindings.

template<typename T> void registerEngineResourceManagerTemplateTypeSpecializationBindings(scripting::IScriptingEngine *scriptingEngine, const std::string &name): Register our EngineResourceManager template type specialization bindings.

void mrtest(int *a, std::string *errs)

const std::vector<byte> &iImageDataProxy(const IImage *image)

uint32 iImageWidthProxy(const IImage *image)

uint32 iImageHeightProxy(const IImage *image)

template<class T> void proxyFunctionSetPosition(const uint32 x, const uint32 y, T *t)

template<class T> glm::ivec2 proxyFunctionGetPosition(T *t)

template<class T> void proxyFunctionSetDimensions(const uint32 x, const uint32 y, T *t)

template<class T> glm::ivec2 proxyFunctionGetDimensions(T *t)

template<class T> bool proxyFunctionVisible(T *t)

template<class T> void proxyFunctionSetVisible(const bool visible, T *t)

template<class T> bool proxyFunctionDisabled(T *t)

template<class T> void proxyFunctionSetDisabled(const bool disabled, T *t)

template<class T> void proxyFunctionSetStyle(const graphics::gui::Style &style, T *t)

template<class T> const graphics::gui::Style &proxyFunctionGetStyle(T *t)

template<class T> const void proxyFunctionAddComponent(graphics::gui::IComponent *component, T *t)

template<class T> const void proxyFunctionRemoveComponent(graphics::gui::IComponent *component, T *t)

template<class T> const void proxyFunctionRemoveAllComponents(T *t)

template<class T> graphics::gui::ILabel *proxyFunctionCreateLabel(const std::string label, T *t)

template<class T> graphics::gui::ILabel *proxyFunctionCreateLabel(const uint32 x, const uint32 y, const uint32 width, const uint32 height, const std::string label, T *t)

template<class T> graphics::gui::IButton *proxyFunctionCreateButton(const std::string label, T *t)

template<class T> graphics::gui::IButton *proxyFunctionCreateButton(const uint32 x, const uint32 y, const uint32 width, const uint32 height, const std::string label, T *t)

template<class T> graphics::gui::ITextField *proxyFunctionCreateTextField(const std::string label, T *t)

template<class T> graphics::gui::ITextField *proxyFunctionCreateTextField(const uint32 x, const uint32 y, const uint32 width, const uint32 height, const std::string label, T *t)

template<class T> graphics::gui::ITextArea *proxyFunctionCreateTextArea(const std::string label, T *t)

template<class T> graphics::gui::ITextArea *proxyFunctionCreateTextArea(const uint32 x, const uint32 y, const uint32 width, const uint32 height, const std::string label, T *t)

template<class T> graphics::gui::IComboBox *proxyFunctionCreateComboBox(T *t)

template<class T> graphics::gui::ITreeView *proxyFunctionCreateTreeView(T *t)

template<class T> void proxyFunctionDestroyLabel(const graphics::gui::ILabel *label, T *t)

template<class T> void proxyFunctionDestroyButton(const graphics::gui::IButton *button, T *t)

template<class T> void proxyFunctionDestroyTextField(const graphics::gui::ITextField *textField, T *t)

template<class T> void proxyFunctionDestroyTextArea(const graphics::gui::ITextArea *textArea, T *t)

template<class T> void proxyFunctionDestroyComboBox(const graphics::gui::IComboBox *comboBox, T *t)

template<class T> void proxyFunctionDestroyTreeView(const graphics::gui::ITreeView *treeView, T *t)

static void InitConstructorGraphicsColor(graphics::Color *memory, const uint32 color)

static void InitConstructorGraphicsColor(graphics::Color *memory, const uint8 r, const uint8 g, const uint8 b, const uint8 a)

template<class T> auto import(const std::string &path, const std::string &name, boost::dll::load_mode::type mode)

void normalizeHandles(ecs::EntityComponentSystem &entityComponentSystem, const std::unordered_map<physics::CollisionShapeHandle, physics::CollisionShapeHandle> &normalizedMap, logger::ILogger *logger)

void normalizeHandles(ecs::EntityComponentSystem &entityComponentSystem, const std::unordered_map<graphics::MeshHandle, graphics::MeshHandle> &normalizedMeshHandleMap, const std::unordered_map<graphics::TextureHandle, graphics::TextureHandle> &normalizedTextureHandleMap, logger::ILogger *logger)

void normalizeHandles(ecs::EntityComponentSystem &entityComponentSystem, const std::unordered_map<SkeletonHandle, SkeletonHandle> &normalizedSkeletonHandleMap, logger::ILogger *logger)

void normalizeHandles(ecs::EntityComponentSystem &entityComponentSystem, const std::unordered_map<AnimationHandle, AnimationHandle> &normalizedAnimationHandleMap, logger::ILogger *logger)

void normalizeHandles(ecs::EntityComponentSystem &entityComponentSystem, const std::unordered_map<graphics::TerrainHandle, graphics::TerrainHandle> &normalizedMap, logger::ILogger *logger)

void normalizeHandles(ecs::EntityComponentSystem &entityComponentSystem, const std::unordered_map<pathfinding::CrowdHandle, pathfinding::CrowdHandle> &normalizedMap, logger::ILogger *logger)

void normalizeHandles(ecs::EntityComponentSystem &entityComponentSystem, const std::unordered_map<pathfinding::NavigationMeshHandle, pathfinding::NavigationMeshHandle> &normalizedMap, std::unordered_map<pathfinding::CrowdHandle, pathfinding::CrowdHandle> &crowdHandleMap, logger::ILogger *logger)

void normalizeParentComponentEntities(ecs::EntityComponentSystem &entityComponentSystem, logger::ILogger *logger)

void normalizeParentComponents(ecs::EntityComponentSystem &entityComponentSystem, logger::ILogger *logger)

void normalizeChildrenComponentEntities(ecs::EntityComponentSystem &entityComponentSystem, logger::ILogger *logger)

void normalizeChildrenComponents(ecs::EntityComponentSystem &entityComponentSystem, logger::ILogger *logger)

void normalizeHandles(ecs::EntityComponentSystem &entityComponentSystem, scripting::IScriptingEngine *scriptingEngine, scripting::ModuleHandle moduleHandle, scripting::ExecutionContextHandle executionContextHandle, const std::unordered_map<scripting::ScriptObjectHandle, std::string> &scriptObjectHandleMap, logger::ILogger *logger)

uint64 sceneGetNumEntitiesProxy(const Scene *scene)

void ScriptFunctionHandleWrapperDeleter(std::pair<scripting::IScriptingEngine*, scripting::ScriptFunctionHandle> *data)

void saveImageToFile(fs::IFile *file, const Image &image)

void saveAlphaImageToFile(fs::IFile *file, const Image &image)

Variables

std::vector<graphics::model::BoneData> boneData

std::vector<graphics::model::Animation> animations

graphics::model::BoneNode rootBoneNode

glm::mat4 globalInverseTransformation = glm::mat4(1.0f)

graphics::SkeletonHandle skeletonHandle

template<typename T, typename Crtp> class AbstractEngineResourceManager : public ice_engine::BaseEngineResourceManager

#include <AbstractEngineResourceManager.hpp>

Public Functions

AbstractEngineResourceManager(const AbstractEngineResourceManager&) = delete

AbstractEngineResourceManager &operator=(const AbstractEngineResourceManager&) = delete

AbstractEngineResourceManager(AbstractEngineResourceManager&&) = default

AbstractEngineResourceManager &operator=(AbstractEngineResourceManager&&) noexcept = default

template<typename ...Args> inline const T &create(const std::string &name, const Args&... args)

inline void destroy(const std::string &name)

inline void destroy(const T &resource)

inline void destroyAll()

inline bool exists(const std::string &name) const

inline const T &get(const std::string &name) const

struct AnimatedBoneNode

#include <Animation.hpp>

Public Functions

AnimatedBoneNode() = default

inline AnimatedBoneNode(std::string name, std::vector<KeyFrame<glm::vec3>> positionKeyFrames, std::vector<KeyFrame<glm::quat>> rotationKeyFrames, std::vector<KeyFrame<glm::vec3>> scalingKeyFrames)

Public Members

std::string name

std::vector<KeyFrame<glm::vec3>> positionKeyFrames

std::vector<KeyFrame<glm::quat>> rotationKeyFrames

std::vector<KeyFrame<glm::vec3>> scalingKeyFrames

class Animation

#include <Animation.hpp>

Public Functions

Animation() = default

inline Animation(std::string name, std::chrono::duration<float32> duration, float32 ticksPerSecond, std::unordered_map<std::string, AnimatedBoneNode> animatedBoneNodes)

inline Animation(const std::string &name, const std::string &filename, const aiAnimation *animation, logger::ILogger *logger, fs::IFileSystem *fileSystem)

~Animation() = default

inline const std::string &name() const

inline std::chrono::duration<float32> duration() const

inline float32 ticksPerSecond() const

inline const std::unordered_map<std::string, AnimatedBoneNode> &animatedBoneNodes() const

class AnimationHandle : public ice_engine::handles::Handle<AnimationHandle>: #include <AnimationHandle.hpp>

class Audio : public ice_engine::audio::IAudio

#include <Audio.hpp>

Public Functions

inline Audio(const std::vector<uint8> &data)

Will load the provided audio data into a proper audio.

Parameters: data – The audio data to load.

inline Audio(std::istream &inputStream)

Will load the provided audio data into a proper audio.

Parameters: inputStream – Stream from which we will load our audio data.

~Audio() override = default

inline virtual const std::vector<uint8> &data() const override

inline virtual uint32 length() const override

inline virtual uint32 frequency() const override

inline virtual uint8 channels() const override

inline virtual uint16 bitsPerSample() const override

inline virtual int32 format() const override

class AudioEngineBindingDelegate

#include <AudioEngineBindingDelegate.hpp>

Public Functions

AudioEngineBindingDelegate(logger::ILogger *logger, scripting::IScriptingEngine *scriptingEngine, GameEngine *gameEngine, audio::IAudioEngine *audioEngine)

~AudioEngineBindingDelegate() = default

void bind()

class BaseEngineResourceManager

#include <BaseEngineResourceManager.hpp>

Public Functions

virtual ~BaseEngineResourceManager() = default

BaseEngineResourceManager(const BaseEngineResourceManager&) = delete

BaseEngineResourceManager &operator=(const BaseEngineResourceManager&) = delete

BaseEngineResourceManager(BaseEngineResourceManager&&) = default

BaseEngineResourceManager &operator=(BaseEngineResourceManager&&) noexcept = default

struct BaseException : public virtual exception, public virtual std::exception: #include <Exception.hpp>
Subclassed by ice_engine::Exception

class BaseResourceManager

#include <BaseResourceManager.hpp>

Subclassed by ice_engine::ResourceManager< T >

Public Functions

virtual ~BaseResourceManager() = default

BaseResourceManager(const BaseResourceManager&) = delete

BaseResourceManager &operator=(const BaseResourceManager&) = delete

BaseResourceManager(BaseResourceManager&&) = default

BaseResourceManager &operator=(BaseResourceManager&&) noexcept = default

class BindingDelegate

#include <BindingDelegate.hpp>

Public Functions

BindingDelegate(logger::ILogger *logger, scripting::IScriptingEngine *scriptingEngine, GameEngine *gameEngine, graphics::IGraphicsEngine *graphicsEngine, audio::IAudioEngine *audioEngine, networking::INetworkingEngine *networkingEngine, physics::IPhysicsEngine *physicsEngine, pathfinding::IPathfindingEngine *pathfindingEngine)

void bind()

struct Bone

#include <Mesh.hpp>

Public Members

std::string name

glm::mat4 inverseModelSpacePoseTransform = glm::mat4(1.0f): Describes the model space transformation from the original pose position back to the origin.

struct BoneData

#include <Mesh.hpp>

Public Members

std::string name

std::unordered_map<std::string, uint32> boneIndexMap

std::vector<Bone> boneTransform

struct BoneNode

#include <Skeleton.hpp>

Public Members

std::string name

glm::mat4 transformation = glm::mat4(1.0f)

std::vector<BoneNode> children

class Camera

#include <Camera.hpp>

Public Functions

Camera()

virtual ~Camera()

bool isActive()

void moveForward()

void moveBack()

void moveLeft()

void moveRight()

void rotate(const float32 &degrees, const glm::vec3 &axis)

void tick(float32 time)

class Constants

#include <Constants.hpp>

Public Static Attributes

static const std::string GAME_NAME = std::string(~~"Dark Horizon"~~)

static const std::string GAME_VERSION = std::string(~~"0.0.1 Pre-Alpha"~~)

static const std::string MODELS_DIRECTORY

class CPreProcessor : public default_preprocessing_hooks

#include <CPreProcessor.hpp>

This class is a generic pre processor for C like code.

Subclassed by ice_engine::scripting::angel_script::AngelscriptCPreProcessor

Public Functions

CPreProcessor(fs::IFileSystem *fileSystem, logger::ILogger *logger, const std::unordered_map<std::string, std::string> &includeOverrides = {})

std::string process(std::string source, const std::unordered_map<std::string, std::string> &defineMap = {}, const bool autoIncludeGuard = false, const bool preserveLineNumbers = false)

Processess the source code.

Parameters: defineMap – this is an optional map that can contain any extra/special #defines that have been defined.

template<typename ContextT, typename ContainerT> bool found_unknown_directive(ContextT const &ctx, ContainerT const &line, ContainerT &pending)

template<typename ContextT, typename ContainerT> bool emit_line_directive(ContextT const &ctx, ContainerT &pending, typename ContextT::token_type const &act_token)

template<typename ContextT> bool locate_include_file(ContextT &ctx, std::string &file_path, bool is_system, char const *current_name, std::string &dir_path, std::string &native_name)

template<typename ContextT> void opened_include_file(ContextT const &ctx, std::string const &relname, std::string const &filename, bool is_system_include)

template<typename ContextT> void returning_from_include_file(ContextT const &ctx)

template<typename ContextT> bool found_include_directive(ContextT const &ctx, std::string const &filename, bool include_next)

template<typename ContextT, typename TokenT> void skipped_token(ContextT const &ctx, TokenT const &token)

template<typename ContextT, typename TokenT> TokenT const &generated_token(ContextT const &ctx, TokenT const &token)

template<typename ContextT, typename TokenT, typename ContainerT> bool evaluated_conditional_expression(ContextT const &ctx, TokenT const &directive, ContainerT const &expression, bool expression_value)

template<typename ContextT, typename TokenT> bool found_directive(ContextT const &ctx, TokenT const &directive)

template<typename IterContextT> class inner

#include <CPreProcessor.hpp>

Inner class to do the loading of a file.

Public Static Functions

template<typename PositionT> static inline void init_iterators(IterContextT &iter_ctx, PositionT const &act_pos, wave::language_support language)

class DebugRenderer : public ice_engine::IDebugRenderer

#include <DebugRenderer.hpp>

Public Functions

inline DebugRenderer(graphics::IGraphicsEngine *graphicsEngine)

~DebugRenderer() override = default

inline virtual void pushLine(const glm::vec3 &from, const glm::vec3 &to, const glm::vec3 &color) override

inline virtual void pushLines(const std::vector<std::tuple<glm::vec3, glm::vec3, glm::vec3>> &lineData) override

inline virtual void render() override

class DisplacementMap : public ice_engine::graphics::IDisplacementMap

#include <DisplacementMap.hpp>

Public Functions

~DisplacementMap() override = default

template<typename T> class EngineResourceManager : public ice_engine::AbstractEngineResourceManager<T, EngineResourceManager<T>>

#include <EngineResourceManager.hpp>

Public Functions

EngineResourceManager(const EngineResourceManager&) = delete

EngineResourceManager &operator=(const EngineResourceManager&) = delete

EngineResourceManager(EngineResourceManager&&) = default

EngineResourceManager &operator=(EngineResourceManager&&) noexcept = default

template<> MeshHandle > : public ice_engine::AbstractEngineResourceManager< graphics::MeshHandle, EngineResourceManager< graphics::MeshHandle > > , private ice_engine::GraphicsEngineResourceManager< graphics::MeshHandle >

#include <EngineResourceManager.MeshHandle.hpp>

Public Functions

~EngineResourceManager() override = default¶

Friends

friend class AbstractEngineResourceManager< graphics::MeshHandle, EngineResourceManager< graphics::MeshHandle > >

template<> TextureHandle > : public ice_engine::AbstractEngineResourceManager< graphics::TextureHandle, EngineResourceManager< graphics::TextureHandle > > , private ice_engine::GraphicsEngineResourceManager< graphics::TextureHandle >

#include <EngineResourceManager.TextureHandle.hpp>

Public Functions

~EngineResourceManager() override = default

Friends

friend class AbstractEngineResourceManager< graphics::TextureHandle, EngineResourceManager< graphics::TextureHandle > >

template<> VertexShaderHandle > : public ice_engine::AbstractEngineResourceManager< graphics::VertexShaderHandle, EngineResourceManager< graphics::VertexShaderHandle > > , private ice_engine::GraphicsEngineResourceManager< graphics::VertexShaderHandle >

#include <EngineResourceManager.VertexShaderHandle.hpp>

Public Functions

~EngineResourceManager() override = default

Friends

friend class AbstractEngineResourceManager< graphics::VertexShaderHandle, EngineResourceManager< graphics::VertexShaderHandle > >

struct EngineStatistics

#include <EngineStatistics.hpp>

Public Members

float32 fps

std::chrono::duration<float32> renderTime

class EntityBindingDelegate

#include <EntityBindingDelegate.hpp>

Public Functions

EntityBindingDelegate(logger::ILogger *logger, scripting::IScriptingEngine *scriptingEngine, GameEngine *gameEngine)

~EntityBindingDelegate() = default

void bind()

class EntityComponentSystemEventListener : public entityx::Receiver<EntityComponentSystemEventListener>

#include <EntityComponentSystemEventListener.hpp>

Public Functions

EntityComponentSystemEventListener(Scene &scene, ecs::EntityComponentSystem &entityComponentSystem)

void receive(const entityx::EntityCreatedEvent &event)

void receive(const entityx::EntityDestroyedEvent &event)

void receive(const entityx::ComponentAddedEvent<ecs::GraphicsComponent> &event)

void receive(const entityx::ComponentRemovedEvent<ecs::GraphicsComponent> &event)

void receive(const entityx::ComponentRemovedEvent<ecs::AnimationComponent> &event)

void receive(const entityx::ComponentRemovedEvent<ecs::RigidBodyObjectComponent> &event)

void receive(const entityx::ComponentRemovedEvent<ecs::GhostObjectComponent> &event)

void receive(const entityx::ComponentRemovedEvent<ecs::PathfindingCrowdComponent> &event)

void receive(const entityx::ComponentRemovedEvent<ecs::PathfindingAgentComponent> &event)

void receive(const entityx::ComponentRemovedEvent<ecs::PathfindingObstacleComponent> &event)

void receive(const entityx::ComponentRemovedEvent<ecs::ParentComponent> &event)

void receive(const entityx::ComponentRemovedEvent<ecs::ChildrenComponent> &event)

void receive(const entityx::ComponentRemovedEvent<ecs::ParentBoneAttachmentComponent> &event)

struct Exception : public virtual ice_engine::BaseException

#include <Exception.hpp>

Subclassed by ice_engine::FileNotFoundException, ice_engine::graphics::GraphicsException, ice_engine::InvalidArgumentException, ice_engine::InvalidOperationException, ice_engine::RuntimeException

Public Functions

Exception(const std::string &error = std::string())

Exception(const std::exception &e)

inline const char *what() const noexcept

struct FileNotFoundException : public virtual ice_engine::Exception: #include <FileNotFoundException.hpp>

template<typename T, typename V> class FutureRegisterHelper

#include <BindingDelegateUtilities.hpp>

Public Static Functions

static inline void DefaultConstructor(T *memory)

static inline void DefaultDestructor(T *memory)

static inline T &assignmentOperator(const T &other, T *v)

static inline V get(T *v)

static inline bool valid(T *v)

static inline void wait(T *v)

static inline std::future_status wait_for(const std::chrono::seconds &s, T *v)

class GameEngine : public ice_engine::graphics::IEventListener, public ice_engine::networking::IEventListener, public ice_engine::scripting::IDebugEventListener

#include <GameEngine.hpp>

Public Functions

GameEngine(std::unique_ptr<utilities::Properties> properties, std::unique_ptr<fs::IFileSystem> fileSystem, std::unique_ptr<ice_engine::IPluginManager> pluginManager, std::unique_ptr<ice_engine::logger::ILogger> logger)

GameEngine(std::unique_ptr<utilities::Properties> properties, std::unique_ptr<fs::IFileSystem> fileSystem, std::unique_ptr<ice_engine::logger::ILogger> logger, std::unique_ptr<ice_engine::IPluginManager> pluginManager, std::unique_ptr<graphics::IGraphicsEngineFactory> graphicsEngineFactory, std::unique_ptr<ITerrainFactory> terrainFactory)

virtual ~GameEngine()

void run()

const EngineStatistics &getEngineStatistics() const

void setIGameInstance(void *object)

void setBootstrapScript(const std::string &filename)

audio::IAudioEngine *audioEngine() const

graphics::IGraphicsEngine *graphicsEngine() const

physics::IPhysicsEngine *physicsEngine() const

scripting::IScriptingEngine *scriptingEngine() const

IDebugRenderer *debugRenderer() const

pathfinding::IPathfindingEngine *pathfindingEngine() const

IThreadPool *backgroundThreadPool() const

IThreadPool *foregroundThreadPool() const

IOpenGlLoader *openGlLoader() const

inline IOpenGlLoader *foregroundGraphicsThreadPool() const

logger::ILogger *logger() const

fs::IFileSystem *fileSystem() const

inline ResourceCache &resourceCache()

inline ResourceHandleCache &resourceHandleCache()

template<typename T> inline ResourceManager<T> &resourceManager()

template<typename T> inline EngineResourceManager<T> &engineResourceManager()

graphics::gui::IGui *createGui(const std::string &name)

void destroyGui(const graphics::gui::IGui *gui)

void setCallback(graphics::gui::IButton *button, void *object)

void setOnChangeCallback(graphics::gui::ITextField *textField, void *object)

void setOnChangeCallback(graphics::gui::ITextArea *textArea, void *object)

void setCallback(graphics::gui::IMenuItem *menuItem, void *object)

void setCallback(graphics::gui::IComboBox *comboBox, void *object)

void setCallback(graphics::gui::ITreeView *treeView, void *object)

Audio *loadAudio(const std::string &name, const std::string &filename)

std::shared_future<Audio*> loadAudioAsync(const std::string &name, const std::string &filename)

inline IImage *createImage(const std::string &name, const std::vector<byte> &data, const uint32 width, const uint32 height, const IImage::Format format)

IImage *loadImage(const std::string &name, const std::string &filename)

std::shared_future<IImage*> loadImageAsync(const std::string &name, const std::string &filename)

Model *loadModel(const std::string &name, const std::string &filename)

std::shared_future<Model*> loadModelAsync(const std::string &name, const std::string &filename)

Model *importModel(const std::string &name, const std::string &filename)

std::shared_future<Model*> importModelAsync(const std::string &name, const std::string &filename)

void unloadAudio(const std::string &name)

void unloadImage(const std::string &name)

void unloadModel(const std::string &name)

Audio *getAudio(const std::string &name) const

IImage *getImage(const std::string &name) const

Model *getModel(const std::string &name) const

ModelHandle loadStaticModel(const Model *model)

std::shared_future<ModelHandle> loadStaticModelAsync(const Model *model)

graphics::RenderableHandle createRenderable(const graphics::RenderSceneHandle &renderSceneHandle, const ModelHandle &modelHandle, const glm::vec3 &position, const glm::quat &orientation, const glm::vec3 &scale = glm::vec3(1.0f))

graphics::RenderableHandle createRenderable(const graphics::RenderSceneHandle &renderSceneHandle, const graphics::MeshHandle &meshHandle, const graphics::TextureHandle &textureHandle, const glm::vec3 &position, const glm::quat &orientation, const glm::vec3 &scale = glm::vec3(1.0f))

graphics::VertexShaderHandle createVertexShader(const std::string &name, const std::string &filename)

std::shared_future<graphics::VertexShaderHandle> createVertexShaderAsync(const std::string &name, const std::string &filename)

graphics::VertexShaderHandle createVertexShaderFromSource(const std::string &name, const std::string &data)

std::shared_future<graphics::VertexShaderHandle> createVertexShaderFromSourceAsync(const std::string &name, const std::string &data)

graphics::FragmentShaderHandle createFragmentShader(const std::string &name, const std::string &filename)

std::shared_future<graphics::FragmentShaderHandle> createFragmentShaderAsync(const std::string &name, const std::string &filename)

graphics::FragmentShaderHandle createFragmentShaderFromSource(const std::string &name, const std::string &data)

std::shared_future<graphics::FragmentShaderHandle> createFragmentShaderFromSourceAsync(const std::string &name, const std::string &data)

graphics::VertexShaderHandle getVertexShader(const std::string &name) const

graphics::FragmentShaderHandle getFragmentShader(const std::string &name) const

void destroyShader(const std::string &name)

void destroyShader(const graphics::VertexShaderHandle &shaderHandle)

void destroyShader(const graphics::FragmentShaderHandle &shaderHandle)

graphics::ShaderProgramHandle createShaderProgram(const std::string &name, const graphics::VertexShaderHandle &vertexShaderHandle, const graphics::FragmentShaderHandle &fragmentShaderHandle)

std::shared_future<graphics::ShaderProgramHandle> createShaderProgramAsync(const std::string &name, const graphics::VertexShaderHandle &vertexShaderHandle, const graphics::FragmentShaderHandle &fragmentShaderHandle)

graphics::ShaderProgramHandle getShaderProgram(const std::string &name) const

void destroyShaderProgram(const std::string &name)

void destroyShaderProgram(const graphics::ShaderProgramHandle &shaderProgramHandle)

Scene *createScene(const std::string &name, const std::vector<std::string> &scriptData = {}, const std::string &initializationFunctionName = "")

Scene *createScene(const std::string &name, const scripting::ModuleHandle, const std::string &initializationFunctionName = "")

void destroyScene(const std::string &name)

void destroyScene(const Scene *scene)

Scene *getScene(const std::string &name) const

std::vector<Scene*> getAllScenes() const

inline void addPreSerializeCallback(std::function<void(serialization::TextOutArchive&, ecs::EntityComponentSystem&, const unsigned int)> callback)

inline void addPostSerializeCallback(std::function<void(serialization::TextOutArchive&, ecs::EntityComponentSystem&, const unsigned int)> callback)

inline void addPreDeserializeCallback(std::function<void(serialization::TextInArchive&, ecs::EntityComponentSystem&, const unsigned int)> callback)

inline void addPostDeserializeCallback(std::function<void(serialization::TextInArchive&, ecs::EntityComponentSystem&, const std::unordered_map<physics::CollisionShapeHandle, physics::CollisionShapeHandle>&, const std::unordered_map<ModelHandle, ModelHandle>&, const std::unordered_map<graphics::MeshHandle, graphics::MeshHandle>&, const std::unordered_map<graphics::TextureHandle, graphics::TextureHandle>&, const std::unordered_map<SkeletonHandle, SkeletonHandle>&, const std::unordered_map<AnimationHandle, AnimationHandle>&, const std::unordered_map<graphics::TerrainHandle, graphics::TerrainHandle>&, const std::unordered_map<std::string, pathfinding::PolygonMeshHandle>&, const std::unordered_map<pathfinding::NavigationMeshHandle, pathfinding::NavigationMeshHandle>&, const std::unordered_map<scripting::ScriptObjectHandle, std::string>&, const std::unordered_map<pathfinding::CrowdHandle, pathfinding::CrowdHandle>&, const unsigned int)> callback)

void testSerialize()

void addWindowEventListener(IWindowEventListener *windowEventListener)

void addKeyboardEventListener(IKeyboardEventListener *keyboardEventListener)

void addTextInputEventListener(ITextInputEventListener *textInputEventListener)

void addMouseMotionEventListener(IMouseMotionEventListener *mouseMotionEventListener)

void addMouseButtonEventListener(IMouseButtonEventListener *mouseButtonEventListener)

void addMouseWheelEventListener(IMouseWheelEventListener *mouseWheelEventListener)

void removeWindowEventListener(IWindowEventListener *windowEventListener)

void removeKeyboardEventListener(IKeyboardEventListener *keyboardEventListener)

void removeTextInputEventListener(ITextInputEventListener *textInputEventListener)

void removeMouseMotionEventListener(IMouseMotionEventListener *mouseMotionEventListener)

void removeMouseButtonEventListener(IMouseButtonEventListener *mouseButtonEventListener)

void removeMouseWheelEventListener(IMouseWheelEventListener *mouseWheelEventListener)

void addWindowEventListener(void *windowEventListener)

void addKeyboardEventListener(void *keyboardEventListener)

void addTextInputEventListener(void *textInputEventListener)

void addMouseMotionEventListener(void *mouseMotionEventListener)

void addMouseButtonEventListener(void *mouseButtonEventListener)

void addMouseWheelEventListener(void *mouseWheelEventListener)

void removeWindowEventListener(void *windowEventListener)

void removeKeyboardEventListener(void *keyboardEventListener)

void removeTextInputEventListener(void *textInputEventListener)

void removeMouseMotionEventListener(void *mouseMotionEventListener)

void removeMouseButtonEventListener(void *mouseButtonEventListener)

void removeMouseWheelEventListener(void *mouseWheelEventListener)

void addConnectEventListener(IConnectEventListener *connectEventListener)

void addDisconnectEventListener(IDisconnectEventListener *disconnectEventListener)

void addMessageEventListener(IMessageEventListener *messageEventListener)

void removeConnectEventListener(IConnectEventListener *connectEventListener)

void removeDisconnectEventListener(IDisconnectEventListener *disconnectEventListener)

void removeMessageEventListener(IMessageEventListener *messageEventListener)

void addConnectEventListener(void *connectEventListener)

void addDisconnectEventListener(void *disconnectEventListener)

void addMessageEventListener(void *messageEventListener)

void removeConnectEventListener(void *connectEventListener)

void removeDisconnectEventListener(void *disconnectEventListener)

void removeMessageEventListener(void *messageEventListener)

void addScriptingEngineDebugHandler(IScriptingEngineDebugHandler *handler)

void removeScriptingEngineDebugHandler(const IScriptingEngineDebugHandler *handler)

void addScriptingEngineDebugHandler(void *object)

void removeScriptingEngineDebugHandler(const void *object)

std::shared_future<void> postWorkToBackgroundThreadPool(void *object)

std::shared_future<void> postWorkToForegroundThreadPool(void *object)

std::shared_future<void> postWorkToOpenGlWorker(void *object)

virtual bool processEvent(const graphics::Event &event) override

virtual bool processEvent(const networking::ConnectEvent &event) override

virtual bool processEvent(const networking::DisconnectEvent &event) override

virtual bool processEvent(const networking::MessageEvent &event) override

inline physics::CollisionShapeHandle createStaticBoxShape(const std::string &name, const glm::vec3 &dimensions)

template<typename ...Args> inline physics::CollisionShapeHandle createStaticBoxShape(const std::string &name, const Args... args)

inline physics::CollisionShapeHandle createStaticSphereShape(const std::string &name, const float32 radius)

template<typename ...Args> inline physics::CollisionShapeHandle createStaticSphereShape(const std::string &name, const Args... args)

inline physics::CollisionShapeHandle createStaticPlaneShape(const std::string &name, const glm::vec3 &planeNormal, const float32 planeConstant)

template<typename ...Args> inline physics::CollisionShapeHandle createStaticPlaneShape(const std::string &name, const Args... args)

template<typename ...Args> inline physics::CollisionShapeHandle createStaticTerrainShape(const std::string &name, const Args... args)

inline physics::CollisionShapeHandle createStaticTerrainShape(const std::string &name, const Heightfield &heightfield)

inline void destroyStaticShape(const std::string &name)

inline void destroyAllStaticShapes()

inline physics::CollisionShapeHandle getStaticShape(const std::string &name) const

inline ModelHandle createStaticModel(const std::string &name, const Model &model)

inline void destroyStaticModel(const std::string &name)

inline void destroyAllStaticModels()

inline ModelHandle getStaticModel(const std::string &name) const

inline SkeletonHandle createSkeleton(const std::string &name, const Skeleton &skeleton)

void animateSkeleton(std::vector<glm::mat4> &transformations, const std::chrono::duration<float32> runningTime, const graphics::MeshHandle &meshHandle, const AnimationHandle &animationHandle, const SkeletonHandle &skeletonHandle)

void animateSkeleton(std::vector<glm::mat4> &transformations, const std::chrono::duration<float32> runningTime, const uint32 startFrame, const uint32 endFrame, const graphics::MeshHandle &meshHandle, const AnimationHandle &animationHandle, const SkeletonHandle &skeletonHandle)

inline void destroySkeleton(const std::string &name)

inline void destroyAllSkeletons()

inline SkeletonHandle getSkeleton(const std::string &name) const

inline void createSkeleton(const graphics::MeshHandle &meshHandle, const graphics::ISkeleton &skeleton)

inline AnimationHandle createAnimation(const std::string &name, const Animation &animation)

inline void destroyAnimation(const std::string &name)

inline void destroyAllAnimations()

inline AnimationHandle getAnimation(const std::string &name) const

inline graphics::MeshHandle createStaticMesh(const std::string &name, const Mesh &mesh)

inline void destroyStaticMesh(const std::string &name)

inline void destroyAllStaticMeshes()

inline graphics::MeshHandle getStaticMesh(const std::string &name) const

inline uint32 getBoneId(const graphics::MeshHandle meshHandle, const std::string &name) const

inline graphics::TextureHandle createTexture(const std::string &name, const Texture &texture)

inline void destroyTexture(const std::string &name)

inline void destroyAllTextures()

inline graphics::TextureHandle getTexture(const std::string &name) const

inline graphics::TerrainHandle createStaticTerrain(const std::string &name, const HeightMap &heightMap, const SplatMap &splatMap, const DisplacementMap &displacementMap)

inline void destroyStaticTerrain(const std::string &name)

inline void destroyAllStaticTerrains()

inline graphics::TerrainHandle getStaticTerrain(const std::string &name) const

inline graphics::SkyboxHandle createStaticSkybox(const std::string &name, const IImage &back, const IImage &down, const IImage &front, const IImage &left, const IImage &right, const IImage &up)

inline void destroyStaticSkybox(const std::string &name)

inline void destroyAllStaticSkyboxes()

inline graphics::SkyboxHandle getStaticSkybox(const std::string &name) const

inline audio::SoundHandle createSound(const std::string &name, const Audio &audio)

inline void destroySound(const std::string &name)

inline void destroyAllSound()

inline audio::SoundHandle getSound(const std::string &name) const

template<typename ...Args> inline pathfinding::PolygonMeshHandle createPolygonMesh(const std::string &name, const Args... args)

inline pathfinding::PolygonMeshHandle createPolygonMesh(const std::string &name, const PathfindingTerrain &pathfindingTerrain, const pathfinding::PolygonMeshConfig &polygonMeshConfig)

inline void destroyPolygonMesh(const std::string &name)

inline pathfinding::PolygonMeshHandle getPolygonMesh(const std::string &name) const

inline pathfinding::NavigationMeshHandle createNavigationMesh(const std::string &name, const pathfinding::PolygonMeshHandle &polygonMeshHandle, const pathfinding::NavigationMeshConfig &navigationMeshConfig)

template<typename ...Args> inline pathfinding::NavigationMeshHandle createNavigationMesh(const std::string &name, const Args... args)

inline void destroyNavigationMesh(const std::string &name)

inline pathfinding::NavigationMeshHandle getNavigationMesh(const std::string &name) const

class GameFactory

#include <GameFactory.hpp>

Public Static Functions

static std::unique_ptr<GameEngine> createGameEngine(std::unique_ptr<utilities::Properties> properties, std::unique_ptr<fs::IFileSystem> fileSystem, std::unique_ptr<ice_engine::IPluginManager> pluginManager, std::unique_ptr<ice_engine::logger::ILogger> logger)

class GraphicsEngineBindingDelegate

#include <GraphicsEngineBindingDelegate.hpp>

Public Functions

GraphicsEngineBindingDelegate(logger::ILogger *logger, scripting::IScriptingEngine *scriptingEngine, GameEngine *gameEngine, graphics::IGraphicsEngine *graphicsEngine)

~GraphicsEngineBindingDelegate() = default

void bind()

template<typename T> class GraphicsEngineResourceManager

#include <GraphicsEngineResourceManager.hpp>

Public Functions

inline explicit GraphicsEngineResourceManager(graphics::IGraphicsEngine *graphicsEngine)

GraphicsEngineResourceManager(const GraphicsEngineResourceManager&) = delete

GraphicsEngineResourceManager &operator=(const GraphicsEngineResourceManager&) = delete

GraphicsEngineResourceManager(GraphicsEngineResourceManager&&) = default

GraphicsEngineResourceManager &operator=(GraphicsEngineResourceManager&&) noexcept = default

template<typename T> class HandleRegisterHelper

#include <BindingDelegateUtilities.hpp>

Public Static Functions

static inline void DefaultConstructor(T *memory)

static inline void InitConstructor(T *memory, const uint64 id)

static inline void CopyConstructor(T *memory, const T &other)

static inline void DefaultDestructor(T *memory)

class Heightfield : public ice_engine::physics::IHeightfield

#include <Heightfield.hpp>

Public Functions

Heightfield() = default

inline Heightfield(const IImage &image)

virtual ~Heightfield() override = default

inline virtual const std::vector<byte> &data() const override

inline virtual uint32 width() const override

inline virtual uint32 length() const override

inline virtual uint32 height() const override

class HeightMap : public ice_engine::graphics::IHeightMap

#include <HeightMap.hpp>

Public Functions

HeightMap() = default

inline HeightMap(const std::vector<byte> &data, const uint32 width, const uint32 height)

inline HeightMap(const IImage &image)

inline HeightMap(const HeightMap &other)

~HeightMap() override = default

inline HeightMap &operator=(const HeightMap &other)

inline byte height(uint32 x, uint32 z) const

inline IImage *image()

inline virtual const graphics::IImage *image() const override

class IAudioPlugin : public virtual ice_engine::IPlugin

#include <IAudioPlugin.hpp>

Public Functions

inline virtual ~IAudioPlugin()

virtual std::unique_ptr<audio::IAudioEngineFactory> createFactory() const = 0

class IceEngineMotionChangeListener : public ice_engine::physics::IMotionChangeListener

#include <IceEngineMotionChangeListener.hpp>

Public Functions

IceEngineMotionChangeListener(ecs::Entity entity, Scene *scene)

virtual ~IceEngineMotionChangeListener()

virtual void update(const glm::vec3 &position, const glm::quat &orientation) override

class IceEnginePathfindingAgentMotionChangeListener : public ice_engine::pathfinding::IAgentMotionChangeListener

#include <IceEnginePathfindingAgentMotionChangeListener.hpp>

Public Functions

IceEnginePathfindingAgentMotionChangeListener(ecs::Entity entity, Scene *scene)

virtual ~IceEnginePathfindingAgentMotionChangeListener()

virtual void update(const glm::vec3 &position) override

class IceEnginePathfindingAgentStateChangeListener : public ice_engine::pathfinding::IAgentStateChangeListener

#include <IceEnginePathfindingAgentStateChangeListener.hpp>

Public Functions

IceEnginePathfindingAgentStateChangeListener(ecs::Entity entity)

virtual ~IceEnginePathfindingAgentStateChangeListener()

virtual void update(const pathfinding::AgentState &agentState) override

class IceEnginePathfindingMovementRequestStateChangeListener : public ice_engine::pathfinding::IMovementRequestStateChangeListener

#include <IceEnginePathfindingMovementRequestStateChangeListener.hpp>

Public Functions

IceEnginePathfindingMovementRequestStateChangeListener(ecs::Entity entity)

virtual ~IceEnginePathfindingMovementRequestStateChangeListener()

virtual void update(const pathfinding::MovementRequestState &movementRequestState) override

class IConnectEventListener

#include <IConnectEventListener.hpp>

Public Functions

inline virtual ~IConnectEventListener()

virtual bool processEvent(const networking::ConnectEvent &event) = 0

class IDebugRenderer : public virtual ice_engine::physics::IPhysicsDebugRenderer, public virtual ice_engine::pathfinding::IPathfindingDebugRenderer

#include <IDebugRenderer.hpp>

Subclassed by ice_engine::DebugRenderer

Public Functions

~IDebugRenderer() override = default

virtual void pushLine(const glm::vec3 &from, const glm::vec3 &to, const glm::vec3 &color) = 0

virtual void pushLines(const std::vector<std::tuple<glm::vec3, glm::vec3, glm::vec3>> &lineData) = 0

virtual void render() = 0

class IDisconnectEventListener

#include <IDisconnectEventListener.hpp>

Public Functions

inline virtual ~IDisconnectEventListener()

virtual bool processEvent(const networking::DisconnectEvent &event) = 0

class IFileSerializable

#include <IFileSerializable.hpp>

Public Functions

inline virtual ~IFileSerializable()

virtual void serialize(const std::string &filename) = 0

virtual void deserialize(const std::string &filename) = 0

virtual void serialize(std::ofstream &stream) = 0

virtual void deserialize(std::ifstream &stream) = 0

class IGraphicsPlugin : public virtual ice_engine::IPlugin

#include <IGraphicsPlugin.hpp>

Public Functions

virtual ~IGraphicsPlugin() = default

virtual std::unique_ptr<graphics::IGraphicsEngineFactory> createFactory() const = 0

class IGuiPlugin : public ice_engine::IPlugin

#include <IGuiPlugin.hpp>

Public Functions

virtual ~IGuiPlugin() = default

virtual std::unique_ptr<graphics::gui::IGuiFactory> createFactory() const = 0

class IImage : public ice_engine::graphics::IImage, public ice_engine::physics::IImage

#include <IImage.hpp>

Subclassed by ice_engine::Image

Public Types

enum Format

Values:

enumerator FORMAT_UNKNOWN

enumerator FORMAT_RGB

enumerator FORMAT_RGBA

Public Functions

virtual ~IImage() override = default

virtual const std::vector<byte> &data() const override = 0

virtual uint32 width() const override = 0

virtual uint32 height() const override = 0

virtual int32 format() const override = 0

class IKeyboardEventListener

#include <IKeyboardEventListener.hpp>

Public Functions

virtual ~IKeyboardEventListener() = default

virtual bool processEvent(const graphics::KeyboardEvent &event) = 0

class Image : public ice_engine::IImage

#include <Image.hpp>

Public Functions

Image() = default

inline Image(std::vector<byte> data, int width, int height, IImage::Format format)

Will load the provided image data into a proper image.

Parameters

data – The image data to load.
hasAlpha – Whether the image has an alpha channel or not.

inline Image(fs::IFile &file, bool hasAlpha = true)

Will load the provided image data into a proper image.

Parameters

file – The file to load.
hasAlpha – Whether the image has an alpha channel or not.

inline Image(std::istream &inputStream, bool hasAlpha = true)

Will load the provided image data into a proper image.

Parameters

inputStream – Stream from which we will load our image data.
hasAlpha – Whether the image has an alpha channel or not.

inline Image(const Image &image)

~Image() override = default

inline virtual const std::vector<byte> &data() const override

inline virtual uint32 width() const override

inline virtual uint32 height() const override

inline virtual int32 format() const override

class IMessageEventListener

#include <IMessageEventListener.hpp>

Public Functions

inline virtual ~IMessageEventListener()

virtual bool processEvent(const networking::MessageEvent &event) = 0

class IModule

#include <IModule.hpp>

Public Functions

inline virtual ~IModule()

virtual void tick(const float32 delta) = 0

class IModuleFactory

#include <IModuleFactory.hpp>

Public Functions

inline virtual ~IModuleFactory()

virtual std::unique_ptr<IModule> create(utilities::Properties *properties, fs::IFileSystem *fileSystem, logger::ILogger *logger, graphics::IGraphicsEngine *graphicsEngine, pathfinding::IPathfindingEngine *pathfindingEngine, scripting::IScriptingEngine *scriptingEngine, audio::IAudioEngine *audioEngine, networking::INetworkingEngine *networkingEngine) = 0

class IModulePlugin : public ice_engine::IPlugin

#include <IModulePlugin.hpp>

Public Functions

inline virtual ~IModulePlugin()

virtual std::unique_ptr<IModuleFactory> createFactory() const = 0

class IMouseButtonEventListener

#include <IMouseButtonEventListener.hpp>

Public Functions

inline virtual ~IMouseButtonEventListener()

virtual bool processEvent(const graphics::MouseButtonEvent &event) = 0

class IMouseMotionEventListener

#include <IMouseMotionEventListener.hpp>

Public Functions

inline virtual ~IMouseMotionEventListener()

virtual bool processEvent(const graphics::MouseMotionEvent &event) = 0

class IMouseWheelEventListener

#include <IMouseWheelEventListener.hpp>

Public Functions

inline virtual ~IMouseWheelEventListener()

virtual bool processEvent(const graphics::MouseWheelEvent &event) = 0

class INetworkingPlugin : public virtual ice_engine::IPlugin

#include <INetworkingPlugin.hpp>

Public Functions

inline virtual ~INetworkingPlugin()

virtual std::unique_ptr<networking::INetworkingEngineFactory> createFactory() const = 0

struct InvalidArgumentException : public virtual ice_engine::Exception: #include <InvalidArgumentException.hpp>

struct InvalidOperationException : public virtual ice_engine::Exception: #include <InvalidOperationException.hpp>

class IOpenGlLoader

#include <IOpenGlLoader.hpp>

Subclassed by ice_engine::OpenGlLoader

Public Functions

inline virtual ~IOpenGlLoader()

virtual std::future<void> postWork(const std::function<void()> &work) = 0

virtual std::future<void> postWork(std::function<void()> &&work) = 0

virtual void waitAll() = 0

virtual uint32 getWorkQueueCount() const = 0

virtual void tick() = 0

virtual void block() = 0

virtual void unblock() = 0

class IPathfindingPlugin : public virtual ice_engine::IPlugin

#include <IPathfindingPlugin.hpp>

Public Functions

inline virtual ~IPathfindingPlugin()

virtual std::unique_ptr<pathfinding::IPathfindingEngineFactory> createFactory() const = 0

class IPhysicsPlugin : public virtual ice_engine::IPlugin

#include <IPhysicsPlugin.hpp>

Public Functions

inline virtual ~IPhysicsPlugin()

virtual std::unique_ptr<physics::IPhysicsEngineFactory> createFactory() const = 0

class IPlugin

#include <IPlugin.hpp>

Subclassed by ice_engine::IAudioPlugin, ice_engine::IGraphicsPlugin, ice_engine::IGuiPlugin, ice_engine::IModulePlugin, ice_engine::INetworkingPlugin, ice_engine::IPathfindingPlugin, ice_engine::IPhysicsPlugin, ice_engine::IResourceImporterPlugin< T >, ice_engine::IScriptingEngineBindingPlugin

Public Functions

inline virtual ~IPlugin()

virtual std::string getName() const = 0

class IPluginManager

#include <IPluginManager.hpp>

Subclassed by ice_engine::PluginManager

Public Functions

virtual ~IPluginManager() = default

virtual const std::vector<std::shared_ptr<IResourceImporterPlugin<Image>>> &getImageResourceImporterPlugins() const = 0

virtual const std::vector<std::shared_ptr<IGuiPlugin>> &getGuiPlugins() const = 0

virtual std::shared_ptr<IGraphicsPlugin> getGraphicsPlugin() const = 0

virtual std::shared_ptr<IAudioPlugin> getAudioPlugin() const = 0

virtual std::shared_ptr<IPathfindingPlugin> getPathfindingPlugin() const = 0

virtual std::shared_ptr<IPhysicsPlugin> getPhysicsPlugin() const = 0

virtual std::shared_ptr<INetworkingPlugin> getNetworkingPlugin() const = 0

virtual const std::vector<std::shared_ptr<IModulePlugin>> &getModulePlugins() const = 0

virtual const std::vector<std::shared_ptr<IScriptingEngineBindingPlugin>> &scriptingEngineBindingPlugins() const = 0

class IResourceCache

#include <IResourceCache.hpp>

Subclassed by ice_engine::ResourceCache

Public Functions

virtual ~IResourceCache() = default

virtual void addAudio(const std::string &name, std::unique_ptr<Audio> audio) = 0

virtual void addImage(const std::string &name, std::unique_ptr<Image> image) = 0

virtual void addModel(const std::string &name, std::unique_ptr<Model> model) = 0

virtual void removeAudio(const std::string &name) = 0

virtual void removeImage(const std::string &name) = 0

virtual void removeModel(const std::string &name) = 0

virtual Audio *getAudio(const std::string &name) const = 0

virtual Image *getImage(const std::string &name) const = 0

virtual Model *getModel(const std::string &name) const = 0

template<typename T> class IResourceImporter

#include <IResourceImporter.hpp>

Public Functions

virtual ~IResourceImporter() = default

virtual std::unique_ptr<T> import(const std::string &name, const std::string &filename) const = 0

virtual bool supports(const std::string &filename) const = 0

template<> class IResourceImporter<Image>

#include <IResourceImporter.Image.hpp>

Public Functions

virtual ~IResourceImporter() = default

virtual std::unique_ptr<Image> import(const std::string &name, const std::string &filename) const = 0

virtual bool supported(const std::string &filename) const = 0

template<typename T> class IResourceImporterFactory

#include <IResourceImporterFactory.hpp>

Public Functions

virtual ~IResourceImporterFactory() = default

virtual std::unique_ptr<IResourceImporter<T>> create(utilities::Properties *properties, fs::IFileSystem *fileSystem, logger::ILogger *logger) const = 0

template<typename T> class IResourceImporterPlugin : public ice_engine::IPlugin

#include <IResourceImporterPlugin.hpp>

Public Functions

virtual ~IResourceImporterPlugin() = default

virtual std::unique_ptr<IResourceImporterFactory<T>> createFactory() const = 0

class IScriptingEngineBinding

#include <IScriptingEngineBinding.hpp>

Public Functions

virtual ~IScriptingEngineBinding() = default

virtual void bind() = 0

class IScriptingEngineBindingFactory

#include <IScriptingEngineBindingFactory.hpp>

Public Functions

virtual ~IScriptingEngineBindingFactory() = default

virtual std::unique_ptr<IScriptingEngineBinding> create(utilities::Properties *properties, fs::IFileSystem *fileSystem, logger::ILogger *logger, graphics::IGraphicsEngine *graphicsEngine, pathfinding::IPathfindingEngine *pathfindingEngine, physics::IPhysicsEngine *physicsEngine, scripting::IScriptingEngine *scriptingEngine, audio::IAudioEngine *audioEngine, networking::INetworkingEngine *networkingEngine, GameEngine *gameEngine) = 0

class IScriptingEngineBindingPlugin : public ice_engine::IPlugin

#include <IScriptingEngineBindingPlugin.hpp>

Public Functions

inline virtual ~IScriptingEngineBindingPlugin()

virtual std::unique_ptr<IScriptingEngineBindingFactory> createFactory() const = 0

class IScriptingEngineDebugHandler

#include <IScriptingEngineDebugHandler.hpp>

Public Functions

virtual ~IScriptingEngineDebugHandler() = default

virtual void tick(const float32 delta) = 0

class ITerrain

#include <ITerrain.hpp>

Subclassed by ice_engine::Terrain

Public Functions

inline virtual ~ITerrain()

virtual void tick(const float32 delta) = 0

virtual const std::vector<pathfinding::CrowdHandle> &crowds() const = 0

class ITerrainFactory

#include <ITerrainFactory.hpp>

Subclassed by ice_engine::TerrainFactory

Public Functions

inline virtual ~ITerrainFactory()

virtual std::unique_ptr<ITerrain> create(utilities::Properties *properties, fs::IFileSystem *fileSystem, logger::ILogger *logger, Scene *scene, HeightMap heightMap, SplatMap splatMap, DisplacementMap displacementMap, physics::CollisionShapeHandle collisionShapeHandle, pathfinding::PolygonMeshHandle polygonMeshHandle, pathfinding::NavigationMeshHandle navigationMeshHandle, graphics::IGraphicsEngine *graphicsEngine, pathfinding::IPathfindingEngine *pathfindingEngine, physics::IPhysicsEngine *physicsEngine, audio::IAudioEngine *audioEngine, audio::AudioSceneHandle audioSceneHandle, graphics::RenderSceneHandle renderSceneHandle, physics::PhysicsSceneHandle physicsSceneHandle, pathfinding::PathfindingSceneHandle pathfindingSceneHandle) = 0

class ITextInputEventListener

#include <ITextInputEventListener.hpp>

Public Functions

inline virtual ~ITextInputEventListener()

virtual bool processEvent(const graphics::TextInputEvent &event) = 0

class IThreadPool

#include <IThreadPool.hpp>

Subclassed by ice_engine::ThreadPool

Public Functions

virtual ~IThreadPool() = default

virtual std::future<void> postWork(const std::function<void()> &work) = 0

virtual std::future<void> postWork(std::function<void()> &&work) = 0

virtual void waitAll() = 0

virtual void joinAll() = 0

virtual uint32 getActiveWorkerCount() const = 0

virtual uint32 getInactiveWorkerCount() const = 0

virtual uint32 getWorkQueueCount() const = 0

virtual uint32 getWorkQueueSize() const = 0

virtual void increaseWorkerCountBy(uint32 n) = 0

virtual void decreaseWorkerCountBy(uint32 n) = 0

class IWindowEventListener

#include <IWindowEventListener.hpp>

Public Functions

inline virtual ~IWindowEventListener()

virtual bool processEvent(const graphics::WindowEvent &event) = 0

template<typename T> struct KeyFrame

#include <Animation.hpp>

Public Functions

KeyFrame() = default

inline KeyFrame(std::chrono::duration<float32> time, T transformation)

Public Members

std::chrono::duration<float32> time = {0.0f}

T transformation

class Mesh : public ice_engine::graphics::IMesh

#include <Mesh.hpp>

Public Functions

Mesh() = default

inline Mesh(std::string name, std::vector<glm::vec3> vertices, std::vector<uint32> indices, std::vector<glm::vec4> colors, std::vector<glm::vec3> normals, std::vector<glm::vec2> textureCoordinates, VertexBoneData vertexBoneData = VertexBoneData(), BoneData boneData = BoneData())

inline Mesh(const std::string &name, const std::string &filename, const uint32 index, const aiMesh *mesh, logger::ILogger *logger, fs::IFileSystem *fileSystem)

~Mesh() override = default

inline virtual const std::string &name() const override

inline const VertexBoneData &vertexBoneData() const

inline const BoneData &boneData() const

inline virtual const std::vector<glm::vec3> &vertices() const override

inline virtual const std::vector<uint32> &indices() const override

inline virtual const std::vector<glm::vec4> &colors() const override

inline virtual const std::vector<glm::vec3> &normals() const override

inline virtual const std::vector<glm::vec2> &textureCoordinates() const override

class Model

#include <Model.hpp>

Public Functions

Model() = default

inline Model(std::string name, std::vector<Mesh> meshes, std::vector<Texture> textures, Skeleton skeleton, std::unordered_map<std::string, Animation> animations)

inline Model(const std::string &filename, IResourceCache *resourceCache, logger::ILogger *logger, fs::IFileSystem *fileSystem)

inline const std::string &name() const

inline const std::vector<Mesh> &meshes() const

inline const std::vector<Texture> &textures() const

inline const Skeleton &skeleton() const

inline const std::unordered_map<std::string, Animation> &animations() const

class ModelHandle : public ice_engine::handles::Handle<ModelHandle>: #include <ModelHandle.hpp>

class NetworkingEngineBindingDelegate

#include <NetworkingEngineBindingDelegate.hpp>

Public Functions

NetworkingEngineBindingDelegate(logger::ILogger *logger, scripting::IScriptingEngine *scriptingEngine, GameEngine *gameEngine, networking::INetworkingEngine *networkingEngine)

~NetworkingEngineBindingDelegate() = default

void bind()

class OpenGlLoader : public ice_engine::IOpenGlLoader

#include <OpenGlLoader.hpp>

Public Functions

OpenGlLoader()

virtual ~OpenGlLoader()

virtual std::future<void> postWork(const std::function<void()> &work) override

virtual std::future<void> postWork(std::function<void()> &&work) override

virtual void waitAll() override

virtual uint32 getWorkQueueCount() const override

virtual void tick() override

virtual void block() override

virtual void unblock() override

class PathfindingEngineBindingDelegate

#include <PathfindingEngineBindingDelegate.hpp>

Public Functions

PathfindingEngineBindingDelegate(logger::ILogger *logger, scripting::IScriptingEngine *scriptingEngine, GameEngine *gameEngine, pathfinding::IPathfindingEngine *pathfindingEngine)

~PathfindingEngineBindingDelegate() = default

void bind()

class PathfindingTerrain : public ice_engine::pathfinding::ITerrain

#include <PathfindingTerrain.hpp>

Public Functions

PathfindingTerrain() = default

inline PathfindingTerrain(const HeightMap &heightMap)

~PathfindingTerrain() override = default

inline virtual const std::vector<glm::vec3> &vertices() const override

inline virtual const std::vector<uint32> &indices() const override

class PbrMaterial : public ice_engine::graphics::IPbrMaterial

#include <PbrMaterial.hpp>

Public Functions

inline PbrMaterial(IImage *albedo = nullptr, IImage *normal = nullptr, IImage *metalness = nullptr, IImage *roughness = nullptr, IImage *ambientOcclusion = nullptr)

~PbrMaterial() override = default

inline virtual const graphics::IImage *albedo() const override

inline virtual const graphics::IImage *normal() const override

inline virtual const graphics::IImage *metalness() const override

inline virtual const graphics::IImage *roughness() const override

inline virtual const graphics::IImage *ambientOcclusion() const override

class PhysicsEngineBindingDelegate

#include <PhysicsEngineBindingDelegate.hpp>

Public Functions

PhysicsEngineBindingDelegate(logger::ILogger *logger, scripting::IScriptingEngine *scriptingEngine, GameEngine *gameEngine, physics::IPhysicsEngine *physicsEngine)

~PhysicsEngineBindingDelegate() = default

void bind()

class PluginManager : public ice_engine::IPluginManager

#include <PluginManager.hpp>

Public Functions

PluginManager(utilities::Properties *properties, fs::IFileSystem *fileSystem, logger::ILogger *logger)

~PluginManager() override = default

virtual const std::vector<std::shared_ptr<IResourceImporterPlugin<Image>>> &getImageResourceImporterPlugins() const override

virtual const std::vector<std::shared_ptr<IGuiPlugin>> &getGuiPlugins() const override

virtual std::shared_ptr<IGraphicsPlugin> getGraphicsPlugin() const override

virtual std::shared_ptr<IAudioPlugin> getAudioPlugin() const override

virtual std::shared_ptr<IPathfindingPlugin> getPathfindingPlugin() const override

virtual std::shared_ptr<IPhysicsPlugin> getPhysicsPlugin() const override

virtual std::shared_ptr<INetworkingPlugin> getNetworkingPlugin() const override

virtual const std::vector<std::shared_ptr<IModulePlugin>> &getModulePlugins() const override

virtual const std::vector<std::shared_ptr<IScriptingEngineBindingPlugin>> &scriptingEngineBindingPlugins() const override

template<typename T> class PointerHandleRegisterHelper

#include <BindingDelegateUtilities.hpp>

Public Static Functions

static inline void DefaultConstructor(T *memory)

static inline void InitConstructor(T *memory, void *object)

static inline void CopyConstructor(T *memory, const T &other)

static inline void DefaultDestructor(T *memory)

class Raycast

#include <Raycast.hpp>

Public Functions

Raycast() = default

inline Raycast(const ray::Ray &ray)

inline const ray::Ray &ray() const

inline void setRay(const ray::Ray &ray)

inline const glm::vec3 &hitPointWorld() const

inline void setHitPointWorld(const glm::vec3 &hitPointWorld)

inline const glm::vec3 &hitNormalWorld() const

inline void setHitNormalWorld(const glm::vec3 &hitNormalWorld)

inline ecs::Entity entity() const

inline void setEntity(const ecs::Entity &entity)

class ResourceCache : public ice_engine::IResourceCache

#include <ResourceCache.hpp>

Public Functions

~ResourceCache() override = default

virtual void addAudio(const std::string &name, std::unique_ptr<Audio> audio) override

virtual void addImage(const std::string &name, std::unique_ptr<Image> image) override

virtual void addModel(const std::string &name, std::unique_ptr<Model> model) override

virtual void removeAudio(const std::string &name) override

virtual void removeImage(const std::string &name) override

virtual void removeModel(const std::string &name) override

virtual Audio *getAudio(const std::string &name) const override

virtual Image *getImage(const std::string &name) const override

virtual Model *getModel(const std::string &name) const override

class ResourceHandleCache

#include <ResourceHandleCache.hpp>

Public Functions

inline void addCollisionShapeHandle(const std::string &name, const physics::CollisionShapeHandle &handle)

inline void removeCollisionShapeHandle(const std::string &name)

inline void removeAllCollisionShapeHandles()

inline physics::CollisionShapeHandle getCollisionShapeHandle(const std::string &name) const

inline void addModelHandle(const std::string &name, const ModelHandle &handle)

inline void removeModelHandle(const std::string &name)

inline void removeAllModelHandles()

inline ModelHandle getModelHandle(const std::string &name) const

inline void addSkeletonHandle(const std::string &name, const SkeletonHandle &handle)

inline void removeSkeletonHandle(const std::string &name)

inline void removeAllSkeletonHandles()

inline SkeletonHandle getSkeletonHandle(const std::string &name) const

inline void addAnimationHandle(const std::string &name, const AnimationHandle &handle)

inline void removeAnimationHandle(const std::string &name)

inline void removeAllAnimationHandles()

inline AnimationHandle getAnimationHandle(const std::string &name) const

inline void addMeshHandle(const std::string &name, const graphics::MeshHandle &handle)

inline void removeMeshHandle(const std::string &name)

inline void removeAllMeshHandles()

inline graphics::MeshHandle getMeshHandle(const std::string &name) const

inline void addTextureHandle(const std::string &name, const graphics::TextureHandle &handle)

inline void removeTextureHandle(const std::string &name)

inline void removeAllTextureHandles()

inline graphics::TextureHandle getTextureHandle(const std::string &name) const

inline void addTerrainHandle(const std::string &name, const graphics::TerrainHandle &handle)

inline void removeTerrainHandle(const std::string &name)

inline void removeAllTerrainHandles()

inline graphics::TerrainHandle getTerrainHandle(const std::string &name) const

inline void addSkyboxHandle(const std::string &name, const graphics::SkyboxHandle &handle)

inline void removeSkyboxHandle(const std::string &name)

inline void removeAllSkyboxHandles()

inline graphics::SkyboxHandle getSkyboxHandle(const std::string &name) const

inline void addSoundHandle(const std::string &name, const audio::SoundHandle &handle)

inline void removeSoundHandle(const std::string &name)

inline void removeAllSoundHandles()

inline audio::SoundHandle getSoundHandle(const std::string &name) const

inline void addPolygonMeshHandle(const std::string &name, const pathfinding::PolygonMeshHandle &handle)

inline void removePolygonMeshHandle(const std::string &name)

inline void removeAllPolygonMeshHandles()

inline pathfinding::PolygonMeshHandle getPolygonMeshHandle(const std::string &name) const

inline void addNavigationMeshHandle(const std::string &name, const pathfinding::NavigationMeshHandle &handle)

inline void removeNavigationMeshHandle(const std::string &name)

inline void removeAllNavigationMeshHandles()

inline pathfinding::NavigationMeshHandle getNavigationMeshHandle(const std::string &name) const

inline std::unordered_map<std::string, physics::CollisionShapeHandle> collisionShapeHandleMap()

inline std::unordered_map<std::string, ModelHandle> modelHandleMap()

inline std::unordered_map<std::string, SkeletonHandle> skeletonHandleMap()

inline std::unordered_map<std::string, AnimationHandle> animationHandleMap()

inline std::unordered_map<std::string, graphics::MeshHandle> meshHandleMap()

inline std::unordered_map<std::string, graphics::TextureHandle> textureHandleMap()

inline std::unordered_map<std::string, graphics::TerrainHandle> terrainHandleMap()

inline std::unordered_map<std::string, graphics::SkyboxHandle> skyboxHandleMap()

inline std::unordered_map<std::string, audio::SoundHandle> soundHandleMap()

inline std::unordered_map<std::string, pathfinding::PolygonMeshHandle> polygonMeshHandleMap()

inline std::unordered_map<std::string, pathfinding::NavigationMeshHandle> navigationMeshHandleMap()

template<typename T> class ResourceManager : public ice_engine::BaseResourceManager

#include <ResourceManager.hpp>

Public Functions

inline ResourceManager(std::unordered_map<std::string, std::unique_ptr<IResourceImporter<T>>> importers)

~ResourceManager() override = default

ResourceManager(const ResourceManager&) = delete

ResourceManager &operator=(const ResourceManager&) = delete

ResourceManager(ResourceManager&&) = default

ResourceManager &operator=(ResourceManager&&) noexcept = default

inline T *import(const std::string &name, const std::string &filename, const std::string &importer = "")

inline void destroy(const std::string &name)

inline void destroy(const T *resource)

inline void destroyAll()

inline bool exists(const std::string &name) const

inline T *get(const std::string &name) const

class RuntimeException : public ice_engine::Exception: #include <RuntimeException.hpp>

class Scene : private ice_engine::serialization::ISerializable

#include <Scene.hpp>

Public Functions

Scene(const std::string &name, const std::vector<std::string> &scriptData, const std::string &initializationFunctionName, GameEngine *gameEngine, ITerrainFactory *terrainFactory, utilities::Properties *properties, fs::IFileSystem *fileSystem, logger::ILogger *logger)

Scene(const std::string &name, const scripting::ModuleHandle moduleHandle, const std::string &initializationFunctionName, GameEngine *gameEngine, ITerrainFactory *terrainFactory, utilities::Properties *properties, fs::IFileSystem *fileSystem, logger::ILogger *logger)

~Scene()

void tick(const float32 delta)

void render()

void setSceneThingyInstance(void *object)

void setDebugRendering(const bool enabled)

bool debugRendering() const

void createResources(const ecs::Entity &entity)

void destroyResources(const ecs::Entity &entity)

pathfinding::CrowdHandle createCrowd(const pathfinding::NavigationMeshHandle &navigationMeshHandle, const pathfinding::CrowdConfig &crowdConfig)

void destroy(const pathfinding::CrowdHandle &crowdHandle)

pathfinding::AgentHandle createAgent(const pathfinding::CrowdHandle &crowdHandle, const glm::vec3 &position, const pathfinding::AgentParams &agentParams = pathfinding::AgentParams())

void destroy(const pathfinding::CrowdHandle &crowdHandle, const pathfinding::AgentHandle &agentHandle)

void requestMoveTarget(const pathfinding::CrowdHandle &crowdHandle, const pathfinding::AgentHandle &agentHandle, const glm::vec3 &position)

inline void resetMoveTarget(const pathfinding::CrowdHandle &crowdHandle, const pathfinding::AgentHandle &agentHandle)

void requestMoveVelocity(const pathfinding::CrowdHandle &crowdHandle, const pathfinding::AgentHandle &agentHandle, const glm::vec3 &velocity)

physics::RigidBodyObjectHandle createRigidBodyObject(const physics::CollisionShapeHandle &collisionShapeHandle)

physics::RigidBodyObjectHandle createRigidBodyObject(const physics::CollisionShapeHandle &collisionShapeHandle, const float32 mass, const float32 friction, const float32 restitution)

physics::RigidBodyObjectHandle createRigidBodyObject(const physics::CollisionShapeHandle &collisionShapeHandle, const glm::vec3 &position, const glm::quat &orientation, const float32 mass = 1.0f, const float32 friction = 1.0f, const float32 restitution = 1.0f)

void destroy(const physics::RigidBodyObjectHandle &rigidBodyObjectHandle)

physics::GhostObjectHandle createGhostObject(const physics::CollisionShapeHandle &collisionShapeHandle)

physics::GhostObjectHandle createGhostObject(const physics::CollisionShapeHandle &collisionShapeHandle, const glm::vec3 &position, const glm::quat &orientation)

void destroy(const physics::GhostObjectHandle &ghostObjectHandle)

graphics::RenderableHandle createRenderable(const ModelHandle &modelHandle, const glm::vec3 &position, const glm::quat &orientation, const glm::vec3 &scale = glm::vec3(1.0f))

graphics::RenderableHandle createRenderable(const graphics::MeshHandle &meshHandle, const graphics::TextureHandle &textureHandle, const glm::vec3 &position, const glm::quat &orientation, const glm::vec3 &scale = glm::vec3(1.0f))

void destroy(const graphics::RenderableHandle &renderableHandle)

audio::SoundSourceHandle play(const audio::SoundHandle &soundHandle, const glm::vec3 &position)

graphics::PointLightHandle createPointLight(const glm::vec3 &position)

void destroy(const graphics::PointLightHandle &pointLightHandle)

inline graphics::BonesHandle createBones(const uint32 maxNumberOfBones)

inline void destroy(const graphics::BonesHandle &bonesHandle)

inline void attach(const graphics::RenderableHandle &renderableHandle, const graphics::BonesHandle &bonesHandle)

inline void detach(const graphics::RenderableHandle &renderableHandle, const graphics::BonesHandle &bonesHandle)

inline void attachBoneAttachment(const graphics::RenderableHandle &renderableHandle, const graphics::BonesHandle &bonesHandle, const glm::ivec4 &boneIds, const glm::vec4 &boneWeights)

inline void attachBoneAttachment(const graphics::RenderableHandle &renderableHandle, const graphics::BonesHandle &bonesHandle, const graphics::MeshHandle meshHandle, const std::string &boneName, const glm::ivec4 &boneIds, const glm::vec4 &boneWeights)

inline void detachBoneAttachment(const graphics::RenderableHandle &renderableHandle)

inline graphics::TerrainRenderableHandle createTerrainRenderable(const graphics::TerrainHandle terrainHandle)

inline void destroy(const graphics::TerrainRenderableHandle &terrainRenderableHandle)

inline ITerrain *testCreateTerrain(HeightMap heightMap, SplatMap splatMap, DisplacementMap displacementMap, physics::CollisionShapeHandle collisionShapeHandle, pathfinding::PolygonMeshHandle polygonMeshHandle, pathfinding::NavigationMeshHandle navigationMeshHandle)

inline graphics::SkyboxRenderableHandle createSkyboxRenderable(const graphics::SkyboxHandle skyboxHandle)

inline void destroy(const graphics::SkyboxRenderableHandle &skyboxRenderableHandle)

inline pathfinding::IPathfindingEngine &pathfindingEngine() const

template<typename ...C> inline void entitiesWithComponents(void *object)

template<typename ...C> inline void entitiesWithComponents(void *object) const

virtual void serialize(const std::string &filename) override

Serialize the object to the provided filename.

Not Thread Safe: This method is not safe to call in a multi-threaded environment. When you are calling this method, no other threads should be accessing this object.

virtual void deserialize(const std::string &filename) override

Deserializes the object from the provided filename.

Not Thread Safe: This method is not safe to call in a multi-threaded environment. When you are calling this method, no other threads should be accessing this object.

inline void addPreSerializeCallback(std::function<void(serialization::TextOutArchive&, ecs::EntityComponentSystem&, const unsigned int)> callback)

inline void addPostSerializeCallback(std::function<void(serialization::TextOutArchive&, ecs::EntityComponentSystem&, const unsigned int)> callback)

inline void addPreDeserializeCallback(std::function<void(serialization::TextInArchive&, ecs::EntityComponentSystem&, const unsigned int)> callback)

inline void addPostDeserializeCallback(std::function<void(serialization::TextInArchive&, ecs::EntityComponentSystem&, const std::unordered_map<physics::CollisionShapeHandle, physics::CollisionShapeHandle>&, const std::unordered_map<ModelHandle, ModelHandle>&, const std::unordered_map<graphics::MeshHandle, graphics::MeshHandle>&, const std::unordered_map<graphics::TextureHandle, graphics::TextureHandle>&, const std::unordered_map<SkeletonHandle, SkeletonHandle>&, const std::unordered_map<AnimationHandle, AnimationHandle>&, const std::unordered_map<graphics::TerrainHandle, graphics::TerrainHandle>&, const std::unordered_map<std::string, pathfinding::PolygonMeshHandle>&, const std::unordered_map<pathfinding::NavigationMeshHandle, pathfinding::NavigationMeshHandle>&, const std::unordered_map<scripting::ScriptObjectHandle, std::string>&, const std::unordered_map<pathfinding::CrowdHandle, pathfinding::CrowdHandle>&, const unsigned int)> callback)

inline void addPreSerializeCallback(void *object)

inline void addPostSerializeCallback(void *object)

inline void addPreDeserializeCallback(void *object)

inline void addPostDeserializeCallback(void *object)

const std::string &name() const

void setVisible(const bool visible)

bool visible() const

void setActive(const bool active)

bool active() const

const SceneStatistics &getSceneStatistics() const

ecs::Entity createEntity()

std::shared_future<ecs::Entity> createEntityAsync()

void destroy(ecs::Entity &entity)

void destroyAsync(ecs::Entity &entity)

size_t getNumEntities() const

Raycast raycast(const ray::Ray &ray)

std::vector<ecs::Entity> query(const glm::vec3 &origin, const std::vector<glm::vec3> &points)

std::vector<ecs::Entity> query(const glm::vec3 &origin, const float32 radius)

Friends

friend class boost::serialization::access

class SceneBindingDelegate

#include <SceneBindingDelegate.hpp>

Public Functions

SceneBindingDelegate(logger::ILogger *logger, scripting::IScriptingEngine *scriptingEngine, GameEngine *gameEngine, graphics::IGraphicsEngine *graphicsEngine, audio::IAudioEngine *audioEngine, networking::INetworkingEngine *networkingEngine, physics::IPhysicsEngine *physicsEngine, pathfinding::IPathfindingEngine *pathfindingEngine)

void bind()

struct SceneStatistics

#include <SceneStatistics.hpp>

Public Members

float32 physicsTime

float32 renderTime

class ScriptFunctionHandleWrapper

#include <ScriptFunctionHandleWrapper.hpp>

Public Functions

ScriptFunctionHandleWrapper(scripting::IScriptingEngine *scriptingEngine, scripting::ScriptFunctionHandle scriptFunctionHandle)

virtual ~ScriptFunctionHandleWrapper()

scripting::ScriptFunctionHandle get() const

class ScriptingEngineBindingDelegate

#include <ScriptingEngineBindingDelegate.hpp>

Public Functions

ScriptingEngineBindingDelegate(logger::ILogger *logger, scripting::IScriptingEngine *scriptingEngine)

virtual ~ScriptingEngineBindingDelegate()

void bind()

template<typename T, typename V> class SharedFutureRegisterHelper

#include <BindingDelegateUtilities.hpp>

Public Static Functions

static inline void DefaultConstructor(T *memory)

static inline void CopyConstructor(const T &other, T *memory)

static inline void DefaultDestructor(T *memory)

static inline T &assignmentOperator(const T &other, T *v)

template<typename V1 = V> static inline std::enable_if<std::is_void<V1>::value, void>::type get(const T *v)

template<typename V1 = V> static inline const std::enable_if<std::is_pointer<V1>::value, V1>::type get(const T *v)

template<typename V1 = V> static inline const std::enable_if<!std::is_void<V1>::value && !std::is_pointer<V1>::value, V1>::type &get(const T *v)

static inline bool valid(T *v)

static inline void wait(T *v)

template<typename Duration> static inline std::future_status wait_for(const Duration &d, T *v)

class Skeleton

#include <Skeleton.hpp>

Public Functions

Skeleton() = default

inline Skeleton(std::string name, BoneNode rootBoneNode, glm::mat4 globalInverseTransformation)

inline Skeleton(const std::string &name, const std::string &filename, const aiScene *scene, logger::ILogger *logger, fs::IFileSystem *fileSystem)

inline const std::string &name() const

inline const BoneNode &rootBoneNode() const

inline const glm::mat4 &globalInverseTransformation() const

class SkeletonHandle : public ice_engine::handles::Handle<SkeletonHandle>: #include <SkeletonHandle.hpp>

class SplatMap : public ice_engine::graphics::ISplatMap

#include <SplatMap.hpp>

Public Functions

SplatMap() = default

inline SplatMap(std::vector<PbrMaterial> materialMap, IImage *terrainMap)

inline SplatMap(const SplatMap &other)

inline SplatMap &operator=(const SplatMap &other)

~SplatMap() override = default

inline virtual const std::vector<graphics::IPbrMaterial*> &materialMap() const override

inline virtual const graphics::IImage *terrainMap() const override

template<typename T> class TemplateTypeRegisterHelper

Public Static Functions

static inline void DefaultConstructor(T *memory)

static inline void InitConstructor(T *memory, const uint64 id)

static inline void CopyConstructor(T *memory, const T &other)

static inline void DefaultDestructor(T *memory)

class Terrain : public ice_engine::ITerrain

#include <Terrain.hpp>

Public Functions

Terrain(utilities::Properties *properties, fs::IFileSystem *fileSystem, logger::ILogger *logger, Scene *scene, HeightMap heightMap, SplatMap splatMap, DisplacementMap displacementMap, physics::CollisionShapeHandle collisionShapeHandle, pathfinding::PolygonMeshHandle polygonMeshHandle, pathfinding::NavigationMeshHandle navigationMeshHandle, graphics::IGraphicsEngine *graphicsEngine, pathfinding::IPathfindingEngine *pathfindingEngine, physics::IPhysicsEngine *physicsEngine, audio::IAudioEngine *audioEngine, audio::AudioSceneHandle audioSceneHandle, graphics::RenderSceneHandle renderSceneHandle, physics::PhysicsSceneHandle physicsSceneHandle, pathfinding::PathfindingSceneHandle pathfindingSceneHandle)

virtual ~Terrain()

virtual void tick(const float32 delta) override

virtual const std::vector<pathfinding::CrowdHandle> &crowds() const override

class TerrainFactory : public ice_engine::ITerrainFactory

#include <TerrainFactory.hpp>

Public Functions

TerrainFactory() = default

virtual ~TerrainFactory() = default

virtual std::unique_ptr<ITerrain> create(utilities::Properties *properties, fs::IFileSystem *fileSystem, logger::ILogger *logger, Scene *scene, HeightMap heightMap, SplatMap splatMap, DisplacementMap displacementMap, physics::CollisionShapeHandle collisionShapeHandle, pathfinding::PolygonMeshHandle polygonMeshHandle, pathfinding::NavigationMeshHandle navigationMeshHandle, graphics::IGraphicsEngine *graphicsEngine, pathfinding::IPathfindingEngine *pathfindingEngine, physics::IPhysicsEngine *physicsEngine, audio::IAudioEngine *audioEngine, audio::AudioSceneHandle audioSceneHandle, graphics::RenderSceneHandle renderSceneHandle, physics::PhysicsSceneHandle physicsSceneHandle, pathfinding::PathfindingSceneHandle pathfindingSceneHandle) override

class Texture : public ice_engine::graphics::ITexture

#include <Texture.hpp>

Public Functions

Texture() = default

inline Texture(std::string name, IImage *image)

inline Texture(const std::string &name, const std::string &filename, const uint32 index, const aiMaterial *material, IResourceCache *resourceCache, logger::ILogger *logger, fs::IFileSystem *fileSystem)

~Texture() override = default

inline virtual const std::string &name() const override

inline IImage *image()

inline virtual const graphics::IImage *image() const override

class ThreadPool : public ice_engine::IThreadPool

#include <ThreadPool.hpp>

Public Functions

ThreadPool()

ThreadPool(uint32 numThreads)

~ThreadPool() override

virtual std::future<void> postWork(const std::function<void()> &work) override

virtual std::future<void> postWork(std::function<void()> &&work) override

virtual void waitAll() override

virtual void joinAll() override

virtual uint32 getActiveWorkerCount() const override

virtual uint32 getInactiveWorkerCount() const override

virtual uint32 getWorkQueueCount() const override

virtual uint32 getWorkQueueSize() const override

virtual void increaseWorkerCountBy(uint32 n) override

virtual void decreaseWorkerCountBy(uint32 n) override

template<typename T, typename V> class UniquePtrRegisterHelper

Public Static Functions

static inline void DefaultConstructor(T *memory)

static inline void InitConstructor(T *memory, const uint64 id)

static inline void CopyConstructor(T *memory, const T &other)

static inline void DefaultDestructor(T *memory)

static inline V *get(T *u)

template<typename T, typename K, typename V> class UnorderedMapRegisterHelper

#include <BindingDelegateUtilities.hpp>

Public Static Functions

static inline void DefaultConstructor(T *memory)

static inline void CopyConstructor(const T &other, T *memory)

static inline void DefaultDestructor(T *memory)

static inline T &assignmentOperator(const T &other, T *m)

static inline uint64 size(T *m)

static inline V &at(const K &k, T *m)

static inline V &index(const K &k, T *m)

static inline void clear(T *m)

static inline bool empty(T *m)

static inline uint64 max_size(T *m)

template<typename T, typename ...V> class VariantRegisterHelper

#include <BindingDelegateUtilities.hpp>

Public Static Functions

static inline void DefaultConstructor(T *memory)

static inline void CopyConstructor(const T &other, T *memory)

static inline void DefaultDestructor(T *memory)

static inline T &assignmentOperator(const T &other, T *v)

template<typename Value> static inline T &assignmentOperatorValue(const Value &value, T *v)

static inline int which(T *v)

template<typename Value> static inline Value &get(T &v)

template<typename T, typename V> class VectorRegisterHelper

#include <BindingDelegateUtilities.hpp>

Public Static Functions

static inline void DefaultConstructor(T *memory)

static inline void CopyConstructor(const T &other, T *memory)

static inline void InitConstructor(uint64 size, T *memory)

static inline void DefaultDestructor(T *memory)

static inline T &assignmentOperator(const T &other, T *v)

static inline void assign(uint64 count, const V &value, T *v)

static inline uint64 size(T *v)

static inline void resize(uint64 size, T *v)

static inline V &at(uint64 i, T *v)

static inline V &index(uint64 i, T *v)

static inline V &front(T *v)

static inline V &back(T *v)

static inline void push_back(const V &value, T *v)

static inline void pop_back(T *v)

static inline void erase(uint64 i, T *v)

static inline void insert(uint64 i, const V &value, T *v)

static inline void clear(T *v)

static inline bool empty(T *v)

static inline uint64 max_size(T *v)

static inline void reserve(uint64 size, T *v)

static inline uint64 capacity(T *v)

class VertexBoneData : public ice_engine::graphics::ISkeleton

#include <Mesh.hpp>

Public Functions

VertexBoneData() = default

inline VertexBoneData(std::vector<glm::ivec4> boneIds, std::vector<glm::vec4> boneWeights)

inline VertexBoneData(const std::string &name, const std::string &filename, const uint32 index, const aiMesh *mesh, const BoneData &boneData, const uint32 numberOfVertices, logger::ILogger *logger, fs::IFileSystem *fileSystem)

VertexBoneData(const VertexBoneData&) = default

VertexBoneData(VertexBoneData&&) = default

~VertexBoneData() override = default

VertexBoneData &operator=(const VertexBoneData&) = default

VertexBoneData &operator=(VertexBoneData&&) = default

inline virtual const std::string &name() const override

inline virtual const std::vector<glm::ivec4> &boneIds() const override

inline virtual const std::vector<glm::vec4> &boneWeights() const override

namespace audio

class AudioFactory

#include <AudioFactory.hpp>

Public Static Functions

static std::unique_ptr<IAudioEngine> createAudioEngine(utilities::Properties *properties, fs::IFileSystem *fileSystem, logger::ILogger *logger)

class AudioSceneHandle : public ice_engine::handles::Handle<AudioSceneHandle>: #include <AudioSceneHandle.hpp>

class IAudio

#include <IAudio.hpp>

Subclassed by ice_engine::Audio

Public Types

enum Format

Values:

enumerator FORMAT_UNKNOWN

enumerator FORMAT_AUDIO_S8

enumerator FORMAT_AUDIO_U8

enumerator FORMAT_AUDIO_S16LSB

enumerator FORMAT_AUDIO_S16MSB

enumerator FORMAT_AUDIO_S16SYS

enumerator FORMAT_AUDIO_S16

enumerator FORMAT_AUDIO_U16LSB

enumerator FORMAT_AUDIO_U16MSB

enumerator FORMAT_AUDIO_U16SYS

enumerator FORMAT_AUDIO_U16

enumerator FORMAT_AUDIO_S32LSB

enumerator FORMAT_AUDIO_S32MSB

enumerator FORMAT_AUDIO_S32SYS

enumerator FORMAT_AUDIO_S32

enumerator FORMAT_AUDIO_F32LSB

enumerator FORMAT_AUDIO_F32MSB

enumerator FORMAT_AUDIO_F32SYS

enumerator FORMAT_AUDIO_F32

Public Functions

virtual ~IAudio() = default

virtual const std::vector<uint8> &data() const = 0

virtual uint32 length() const = 0

virtual uint32 frequency() const = 0

virtual uint8 channels() const = 0

virtual uint16 bitsPerSample() const = 0

virtual int32 format() const = 0

class IAudioEngine

#include <IAudioEngine.hpp>

Public Functions

virtual ~IAudioEngine() = default

virtual AudioSceneHandle createAudioScene() = 0

virtual void destroyAudioScene(const AudioSceneHandle &audioSceneHandle) = 0

virtual void tick(const AudioSceneHandle audioSceneHandle, const float32 delta) = 0

virtual void beginRender() = 0

virtual void render(const AudioSceneHandle &audioSceneHandle) = 0

virtual void endRender() = 0

virtual SoundSourceHandle play(const AudioSceneHandle &audioSceneHandle, const SoundHandle &soundHandle, const glm::vec3 &position) = 0

virtual void stop(const AudioSceneHandle &audioSceneHandle, const SoundSourceHandle &soundSourceHandle) = 0

virtual void stopAll(const AudioSceneHandle &audioSceneHandle) = 0

virtual SoundHandle createSound(const IAudio &audio) = 0

virtual void destroy(const SoundHandle soundHandle) = 0

virtual ListenerHandle createListener(const AudioSceneHandle &audioSceneHandle, const glm::vec3 &position) = 0

virtual void setPosition(const AudioSceneHandle &audioSceneHandle, const SoundSourceHandle &soundSourceHandle, const float32 x, const float32 y, const float32 z) = 0

virtual void setPosition(const AudioSceneHandle &audioSceneHandle, const SoundSourceHandle &soundSourceHandle, const glm::vec3 &position) = 0

virtual glm::vec3 position(const AudioSceneHandle &audioSceneHandle, const SoundSourceHandle &soundSourceHandle) const = 0

virtual void setPosition(const AudioSceneHandle &audioSceneHandle, const ListenerHandle &listenerHandle, const float32 x, const float32 y, const float32 z) = 0

virtual void setPosition(const AudioSceneHandle &audioSceneHandle, const ListenerHandle &listenerHandle, const glm::vec3 &position) = 0

virtual glm::vec3 position(const AudioSceneHandle &audioSceneHandle, const ListenerHandle &listenerHandle) const = 0

class IAudioEngineFactory

#include <IAudioEngineFactory.hpp>

Public Functions

inline virtual ~IAudioEngineFactory()

virtual std::unique_ptr<IAudioEngine> create(utilities::Properties *properties, fs::IFileSystem *fileSystem, logger::ILogger *logger) = 0

class ListenerHandle : public ice_engine::handles::Handle<ListenerHandle>: #include <ListenerHandle.hpp>

class SoundHandle : public ice_engine::handles::Handle<SoundHandle>: #include <SoundHandle.hpp>

class SoundSourceHandle : public ice_engine::handles::Handle<SoundSourceHandle>: #include <SoundSourceHandle.hpp>

namespace detail

Functions

inline glm::vec2 toGlm(const aiVector2D &v)

inline glm::vec3 toGlm(const aiVector3D &v)

inline glm::vec4 toGlm(const aiColor4D &c)

inline glm::mat4 toGlm(const aiMatrix4x4 &m)

inline glm::quat toGlm(const aiQuaternion &q)

inline boost::format &formatFunctionRecursive(boost::format &format)

template<typename Arg, typename ...Args> inline boost::format &formatFunctionRecursive(boost::format &format, const Arg &arg, const Args&... args)

template<typename ...Args> inline std::string formatFunction(boost::format &format, const Args&... args)

template<typename ...Args> inline std::string format(const std::string &format, const Args&... args)

inline std::tuple<std::vector<glm::vec3>, std::vector<uint32>> generateCube(const float32 size = 1.0f)

inline std::tuple<std::vector<glm::vec3>, std::vector<uint32>> generateGrid(const uint32 width = 64, const uint32 height = 64, const glm::vec2 &offset = glm::vec2(), const uint32 resolution = 1)

template<typename V, typename H, typename = typename std::enable_if<std::is_pointer<V>::value, V>::type, typename = typename std::enable_if<std::is_base_of<handles::Handle<H>, H>::value, H>::type> inline void checkHandleValidity(V validator, const H handle)

template<typename V, typename H, typename = typename std::enable_if<!std::is_pointer<V>::value, V>::type, typename = typename std::enable_if<std::is_base_of<handles::Handle<H>, H>::value, H>::type> inline void checkHandleValidity(const V &validator, const H handle)

namespace ecs

Typedefs

using ViewIteratorDelegateIterator = typename entityx::EntityManager::BaseView<All>::Iterator

using ViewIteratorIterator = entityx::EntityManager::ViewIterator<ViewIteratorDelegateIterator<All>, All>

Enums

enum DirtyFlags

Values:

enumerator DIRTY_SOURCE_SCRIPT

enumerator DIRTY_SOURCE_PHYSICS

enumerator DIRTY_SOURCE_PATHFINDING

enumerator DIRTY_ALL

enumerator DIRTY_POSITION

enumerator DIRTY_ORIENTATION

enumerator DIRTY_RIGID_BODY_OBJECT

enumerator DIRTY_GHOST_OBJECT

enumerator DIRTY_PATHFINDING_AGENT

enumerator DIRTY_AGENT_STATE

enumerator DIRTY_MOVEMENT_REQUEST_STATE

Functions

template<> entityx::ComponentHandle<ChildrenComponent> assign<ChildrenComponent, std::vector<Entity>>(std::vector<Entity> &&children)

template<> entityx::ComponentHandle<ChildrenComponent> assign<ChildrenComponent, std::vector<Entity>&&>(std::vector<Entity> &&children)

template<> entityx::ComponentHandle<ChildrenComponent> assign<ChildrenComponent, std::vector<Entity>&>(std::vector<Entity> &children)

template<> entityx::ComponentHandle<ChildrenComponent> assign<ChildrenComponent, const std::vector<Entity>&>(const std::vector<Entity> &children)

template<> entityx::ComponentHandle<ParentBoneAttachmentComponent> assign<ParentBoneAttachmentComponent, std::string, glm::ivec4, glm::vec4>(std::string &&boneName, glm::ivec4 &&boneIds, glm::vec4 &&boneWeights)

template<> entityx::ComponentHandle<ParentBoneAttachmentComponent> assign<ParentBoneAttachmentComponent, std::string&, glm::ivec4&, glm::vec4&>(std::string &boneName, glm::ivec4 &boneIds, glm::vec4 &boneWeights)

template<> entityx::ComponentHandle<ParentBoneAttachmentComponent> assign<ParentBoneAttachmentComponent, const std::string&, const glm::ivec4&, const glm::vec4&>(const std::string &boneName, const glm::ivec4 &boneIds, const glm::vec4 &boneWeights)

template<> entityx::ComponentHandle<ParentBoneAttachmentComponent> assign<ParentBoneAttachmentComponent, std::string&&, glm::ivec4&&, glm::vec4&&>(std::string &&boneName, glm::ivec4 &&boneIds, glm::vec4 &&boneWeights)

template<> entityx::ComponentHandle<ParentBoneAttachmentComponent> assign<ParentBoneAttachmentComponent, std::string>(std::string &&boneName)

template<> entityx::ComponentHandle<ParentBoneAttachmentComponent> assign<ParentBoneAttachmentComponent, std::string&&>(std::string &&boneName)

template<> entityx::ComponentHandle<ParentBoneAttachmentComponent> assign<ParentBoneAttachmentComponent, std::string&>(std::string &boneName)

template<> entityx::ComponentHandle<ParentBoneAttachmentComponent> assign<ParentBoneAttachmentComponent, const std::string&>(const std::string &boneName)

struct AnimationComponent

#include <AnimationComponent.hpp>

Public Functions

AnimationComponent() = default

inline AnimationComponent(AnimationHandle animationHandle)

inline AnimationComponent(AnimationHandle animationHandle, uint32 startFrame, uint32 endFrame)

Public Members

AnimationHandle animationHandle

graphics::BonesHandle bonesHandle

std::chrono::duration<float32> runningTime = std::chrono::duration<float32>(0.0f)

float32 speed = 1.0f

uint32 startFrame = 0

uint32 endFrame = 0

std::vector<glm::mat4> transformations

Public Static Functions

static inline uint8 id()

struct ChildrenComponent

#include <ChildrenComponent.hpp>

Public Functions

ChildrenComponent() = default

inline ChildrenComponent(std::vector<Entity> children)

Public Members

std::vector<Entity> children

Public Static Functions

static inline uint8 id()

struct DirtyComponent

#include <DirtyComponent.hpp>

Public Functions

DirtyComponent() = default

inline DirtyComponent(uint16 dirty)

Public Members

uint16 dirty = 0

template<bool All = false> class EcsView

#include <EntityComponentSystem.hpp>

Public Functions

inline EcsView(Scene *scene, entityx::EntityManager::BaseView<All> baseView)

~EcsView() = default

inline Iterator begin()

inline Iterator end()

inline const Iterator begin() const

inline const Iterator end() const

class Iterator : public ice_engine::ecs::ViewIterator<All>¶

#include <EntityComponentSystem.hpp>

Public Functions

inline Iterator(Scene *scene, ViewIteratorIterator<All> viewIterator)¶

class Entity

#include <Entity.hpp>

Public Functions

Entity() = default

inline Entity(entityx::Entity::Id id)

inline Entity(Scene *scene, entityx::Entity entity)

Entity(const Entity &other) = default

Entity &operator=(const Entity &other) = default

inline operator bool() const

inline bool operator==(const Entity &other) const

inline bool operator!=(const Entity &other) const

inline bool operator<(const Entity &other) const

inline bool valid() const

inline void invalidate()

inline Scene *scene() const

inline entityx::Entity::Id id() const

template<typename C> std::enable_if<std::is_same<entityx::ComponentHandle<C>, entityx::ComponentHandle<ParentComponent>>::value, entityx::ComponentHandle<C>>::type assign(const ParentComponent &parentComponent)

template<typename C, typename ...Args> inline std::enable_if<!std::is_same<entityx::ComponentHandle<C>, entityx::ComponentHandle<GraphicsComponent>>::value && !std::is_same<entityx::ComponentHandle<C>, entityx::ComponentHandle<AnimationComponent>>::value && !std::is_same<entityx::ComponentHandle<C>, entityx::ComponentHandle<PointLightComponent>>::value && !std::is_same<entityx::ComponentHandle<C>, entityx::ComponentHandle<GraphicsTerrainComponent>>::value && !std::is_same<entityx::ComponentHandle<C>, entityx::ComponentHandle<GraphicsSkyboxComponent>>::value && !std::is_same<entityx::ComponentHandle<C>, entityx::ComponentHandle<RigidBodyObjectComponent>>::value && !std::is_same<entityx::ComponentHandle<C>, entityx::ComponentHandle<GhostObjectComponent>>::value && !std::is_same<entityx::ComponentHandle<C>, entityx::ComponentHandle<PathfindingCrowdComponent>>::value && !std::is_same<entityx::ComponentHandle<C>, entityx::ComponentHandle<PathfindingAgentComponent>>::value && !std::is_same<entityx::ComponentHandle<C>, entityx::ComponentHandle<PathfindingObstacleComponent>>::value && !std::is_same<entityx::ComponentHandle<C>, entityx::ComponentHandle<ParentComponent>>::value && !std::is_same<entityx::ComponentHandle<C>, entityx::ComponentHandle<ChildrenComponent>>::value && !std::is_same<entityx::ComponentHandle<C>, entityx::ComponentHandle<ParentBoneAttachmentComponent>>::value, entityx::ComponentHandle<C>>::type assign(Args&&... args)

template<typename C, typename ...Args> std::enable_if<std::is_same<entityx::ComponentHandle<C>, entityx::ComponentHandle<ParentComponent>>::value, entityx::ComponentHandle<C>>::type assign(Args&&... args)

template<typename C, typename ...Args> std::enable_if<std::is_same<entityx::ComponentHandle<C>, entityx::ComponentHandle<ChildrenComponent>>::value, entityx::ComponentHandle<C>>::type assign(Args&&... args)

template<typename C, typename ...Args> std::enable_if<std::is_same<entityx::ComponentHandle<C>, entityx::ComponentHandle<ParentBoneAttachmentComponent>>::value, entityx::ComponentHandle<C>>::type assign(Args&&... args)

template<typename C, typename ...Args> inline std::enable_if<std::is_same<entityx::ComponentHandle<C>, entityx::ComponentHandle<GraphicsComponent>>::value, entityx::ComponentHandle<C>>::type assign(Args&&... args)

template<typename C, typename ...Args> inline std::enable_if<std::is_same<entityx::ComponentHandle<C>, entityx::ComponentHandle<AnimationComponent>>::value, entityx::ComponentHandle<C>>::type assign(Args&&... args)

template<typename C, typename ...Args> inline std::enable_if<std::is_same<entityx::ComponentHandle<C>, entityx::ComponentHandle<PointLightComponent>>::value, entityx::ComponentHandle<C>>::type assign(Args&&... args)

template<typename C, typename ...Args> inline std::enable_if<std::is_same<entityx::ComponentHandle<C>, entityx::ComponentHandle<GraphicsTerrainComponent>>::value, entityx::ComponentHandle<C>>::type assign(Args&&... args)

template<typename C, typename ...Args> inline std::enable_if<std::is_same<entityx::ComponentHandle<C>, entityx::ComponentHandle<GraphicsSkyboxComponent>>::value, entityx::ComponentHandle<C>>::type assign(Args&&... args)

template<typename C, typename ...Args> inline std::enable_if<std::is_same<entityx::ComponentHandle<C>, entityx::ComponentHandle<RigidBodyObjectComponent>>::value, entityx::ComponentHandle<C>>::type assign(Args&&... args)

template<typename C, typename ...Args> inline std::enable_if<std::is_same<entityx::ComponentHandle<C>, entityx::ComponentHandle<GhostObjectComponent>>::value, entityx::ComponentHandle<C>>::type assign(Args&&... args)

template<typename C, typename ...Args> inline std::enable_if<std::is_same<entityx::ComponentHandle<C>, entityx::ComponentHandle<PathfindingCrowdComponent>>::value, entityx::ComponentHandle<C>>::type assign(Args&&... args)

template<typename C, typename ...Args> inline std::enable_if<std::is_same<entityx::ComponentHandle<C>, entityx::ComponentHandle<PathfindingAgentComponent>>::value, entityx::ComponentHandle<C>>::type assign(Args&&... args)

template<typename C, typename ...Args> inline std::enable_if<std::is_same<entityx::ComponentHandle<C>, entityx::ComponentHandle<PathfindingObstacleComponent>>::value, entityx::ComponentHandle<C>>::type assign(Args&&... args)

template<typename C> inline entityx::ComponentHandle<C> assignFromCopy(const C &component)

template<typename C, typename ...Args> inline entityx::ComponentHandle<C> replace(Args&&... args)

template<typename C> inline void remove()

template<typename C, typename = typename std::enable_if<!std::is_const<C>::value>::type> inline entityx::ComponentHandle<C> component()

template<typename C, typename = typename std::enable_if<std::is_const<C>::value>::type> inline const entityx::ComponentHandle<C, const entityx::EntityManager> component() const

template<typename ...Components> inline std::tuple<entityx::ComponentHandle<Components>...> components()

template<typename ...Components> inline std::tuple<entityx::ComponentHandle<const Components, const entityx::EntityManager>...> components() const

template<typename C> inline bool hasComponent() const

template<typename A, typename ...Args> inline void unpack(entityx::ComponentHandle<A> &a, entityx::ComponentHandle<Args>&... args)

inline void destroy()

template<> entityx::ComponentHandle<ChildrenComponent> assign()

template<> entityx::ComponentHandle<ParentComponent> assign(Entity &&entity)

template<> entityx::ComponentHandle<ParentComponent> assign(Entity &&entity)

template<> entityx::ComponentHandle<ParentComponent> assign(Entity &entity)

template<> entityx::ComponentHandle<ParentComponent> assign(const Entity &entity)

template<> entityx::ComponentHandle<ParentComponent> assign(ParentComponent &&parentComponent)

template<> entityx::ComponentHandle<ParentComponent> assign(ParentComponent &&parentComponent)

template<> entityx::ComponentHandle<ParentComponent> assign(ParentComponent &parentComponent)

template<> entityx::ComponentHandle<ParentComponent> assign(const ParentComponent &parentComponent)

template<> entityx::ComponentHandle<ParentComponent> assign()

template<> entityx::ComponentHandle<ChildrenComponent> assign(ChildrenComponent &&childrenComponent)

template<> entityx::ComponentHandle<ChildrenComponent> assign(ChildrenComponent &&childrenComponent)

template<> entityx::ComponentHandle<ChildrenComponent> assign(ChildrenComponent &childrenComponent)

template<> entityx::ComponentHandle<ChildrenComponent> assign(const ChildrenComponent &childrenComponent)

template<> entityx::ComponentHandle<ChildrenComponent> assign()

template<> entityx::ComponentHandle<ParentBoneAttachmentComponent> assign(ParentBoneAttachmentComponent &&parentBoneAttachmentComponent)

template<> entityx::ComponentHandle<ParentBoneAttachmentComponent> assign(ParentBoneAttachmentComponent &&parentBoneAttachmentComponent)

template<> entityx::ComponentHandle<ParentBoneAttachmentComponent> assign(const ParentBoneAttachmentComponent &parentBoneAttachmentComponent)

template<> entityx::ComponentHandle<ParentBoneAttachmentComponent> assign()

Friends

inline friend friend std::ostream & operator<< (std::ostream &os, const Entity &other)

class EntityComponentSystem

#include <EntityComponentSystem.hpp>

Public Functions

inline explicit EntityComponentSystem(Scene *scene)

inline EcsView<true> entities()

inline const EcsView<true> entities() const

~EntityComponentSystem() = default

template<class T, typename Receiver> inline void subscribe(Receiver &receiver)

inline Entity create()

inline void destroy(Entity entity)

inline bool valid(entityx::Entity::Id id) const

inline entityx::Entity::Id createId(uint32 index) const

inline Entity get(entityx::Entity::Id id)

template<typename C, typename = typename std::enable_if<!std::is_const<C>::value>::type> inline entityx::ComponentHandle<C> component(entityx::Entity::Id id)

template<typename C, typename = typename std::enable_if<std::is_const<C>::value>::type> inline const entityx::ComponentHandle<C, const entityx::EntityManager> component(entityx::Entity::Id id) const

template<typename C> inline bool hasComponent(entityx::Entity::Id id) const

template<typename C, typename ...Args> inline entityx::ComponentHandle<C> assign(entityx::Entity::Id id, Args&&... args)

template<typename ...C> inline EcsView<false> entitiesWithComponents()

template<typename ...C> inline const EcsView<false> entitiesWithComponents() const

template<typename C> inline void remove(entityx::Entity::Id id)

inline size_t numEntities() const

Friends

friend class boost::serialization::access

struct GhostObjectComponent

#include <GhostObjectComponent.hpp>

Public Functions

GhostObjectComponent() = default

inline GhostObjectComponent(physics::CollisionShapeHandle collisionShapeHandle)

inline GhostObjectComponent(physics::CollisionShapeHandle collisionShapeHandle, physics::GhostObjectHandle ghostObjectHandle)

Public Members

physics::CollisionShapeHandle collisionShapeHandle

physics::GhostObjectHandle ghostObjectHandle

Public Static Functions

static inline uint8 id()

struct GraphicsComponent

#include <GraphicsComponent.hpp>

Public Functions

GraphicsComponent() = default

inline GraphicsComponent(graphics::MeshHandle meshHandle)

inline GraphicsComponent(graphics::MeshHandle meshHandle, graphics::TextureHandle textureHandle)

inline GraphicsComponent(graphics::MeshHandle meshHandle, graphics::TextureHandle textureHandle, glm::vec3 scale)

inline GraphicsComponent(graphics::MeshHandle meshHandle, graphics::TextureHandle textureHandle, glm::vec3 scale, graphics::RenderableHandle renderableHandle)

Public Members

graphics::MeshHandle meshHandle

graphics::TextureHandle textureHandle

glm::vec3 scale = glm::vec3(1.0f, 1.0f, 1.0f)

graphics::RenderableHandle renderableHandle

Public Static Functions

static inline uint8 id()

struct GraphicsSkyboxComponent

#include <GraphicsSkyboxComponent.hpp>

Public Functions

GraphicsSkyboxComponent() = default

inline GraphicsSkyboxComponent(graphics::SkyboxHandle skyboxHandle)

inline GraphicsSkyboxComponent(graphics::SkyboxHandle skyboxHandle, graphics::SkyboxRenderableHandle skyboxRenderableHandle)

Public Members

graphics::SkyboxHandle skyboxHandle

graphics::SkyboxRenderableHandle skyboxRenderableHandle

Public Static Functions

static inline uint8 id()

struct GraphicsTerrainComponent

#include <GraphicsTerrainComponent.hpp>

Public Functions

GraphicsTerrainComponent() = default

inline GraphicsTerrainComponent(graphics::TerrainHandle terrainHandle)

inline GraphicsTerrainComponent(graphics::TerrainHandle terrainHandle, graphics::TerrainRenderableHandle terrainRenderableHandle)

Public Members

graphics::TerrainHandle terrainHandle

graphics::TerrainRenderableHandle terrainRenderableHandle

Public Static Functions

static inline uint8 id()

struct OrientationComponent

#include <OrientationComponent.hpp>

Public Functions

OrientationComponent() = default

inline OrientationComponent(glm::quat orientation)

Public Members

glm::quat orientation = glm::quat(1.0f, 0.0f, 0.0f, 0.0f)

Public Static Functions

static inline uint8 id()

struct ParentBoneAttachmentComponent

#include <ParentBoneAttachmentComponent.hpp>

Public Functions

ParentBoneAttachmentComponent() = default

inline ParentBoneAttachmentComponent(std::string boneName)

inline ParentBoneAttachmentComponent(std::string boneName, glm::ivec4 boneIds, glm::vec4 boneWeights)

Public Members

std::string boneName

glm::ivec4 boneIds

glm::vec4 boneWeights

Public Static Functions

static inline uint8 id()

struct ParentComponent

#include <ParentComponent.hpp>

Public Functions

ParentComponent() = default

inline ParentComponent(Entity entity)

Public Members

Entity entity

Public Static Functions

static inline uint8 id()

struct PathfindingAgentComponent

#include <PathfindingAgentComponent.hpp>

Public Functions

PathfindingAgentComponent() = default

inline PathfindingAgentComponent(pathfinding::CrowdHandle crowdHandle, pathfinding::AgentHandle agentHandle, pathfinding::AgentParams agentParams = pathfinding::AgentParams(), glm::vec3 target = glm::vec3())

inline PathfindingAgentComponent(pathfinding::CrowdHandle crowdHandle, pathfinding::AgentParams agentParams, glm::vec3 target)

Public Members

pathfinding::CrowdHandle crowdHandle

pathfinding::AgentHandle agentHandle

pathfinding::AgentParams agentParams

pathfinding::AgentState agentState = pathfinding::AgentState::INVALID

pathfinding::MovementRequestState movementRequestState = pathfinding::MovementRequestState::NONE

glm::vec3 target

Public Static Functions

static inline uint8 id()

struct PathfindingCrowdComponent

#include <PathfindingCrowdComponent.hpp>

Public Functions

PathfindingCrowdComponent() = default

inline PathfindingCrowdComponent(pathfinding::NavigationMeshHandle navigationMeshHandle, pathfinding::CrowdConfig crowdConfig = pathfinding::CrowdConfig(), pathfinding::CrowdHandle crowdHandle = pathfinding::CrowdHandle())

Public Members

pathfinding::NavigationMeshHandle navigationMeshHandle

pathfinding::CrowdConfig crowdConfig

pathfinding::CrowdHandle crowdHandle

Public Static Functions

static inline uint8 id()

struct PathfindingObstacleComponent

#include <PathfindingObstacleComponent.hpp>

Public Functions

PathfindingObstacleComponent() = default

inline PathfindingObstacleComponent(pathfinding::PolygonMeshHandle polygonMeshHandle, float32 radius = 0.0f, float32 height = 0.0f, pathfinding::ObstacleHandle obstacleHandle = pathfinding::ObstacleHandle())

Public Members

pathfinding::PolygonMeshHandle polygonMeshHandle

float32 radius = 0.0f

float32 height = 0.0f

pathfinding::ObstacleHandle obstacleHandle

Public Static Functions

static inline uint8 id()

struct PersistableComponent

#include <PersistableComponent.hpp>

Public Functions

PersistableComponent() = default

struct PointLightComponent

#include <PointLightComponent.hpp>

Public Functions

PointLightComponent() = default

inline PointLightComponent(graphics::PointLightHandle pointLightHandle)

Public Members

graphics::PointLightHandle pointLightHandle

Public Static Functions

static inline uint8 id()

struct PositionComponent

#include <PositionComponent.hpp>

Public Functions

PositionComponent() = default

inline PositionComponent(glm::vec3 position)

Public Members

glm::vec3 position

Public Static Functions

static inline uint8 id()

struct PositionOrientationComponent

#include <PositionOrientationComponent.hpp>

Public Functions

PositionOrientationComponent() = default

inline PositionOrientationComponent(glm::vec3 position, glm::quat orientation)

inline PositionOrientationComponent(glm::vec3 position, glm::vec3 lookAt)

Public Members

glm::vec3 position

glm::quat orientation = glm::quat(1.0f, 0.0f, 0.0f, 0.0f)

struct PropertiesComponent

#include <PropertiesComponent.hpp>

Public Functions

PropertiesComponent() = default

inline PropertiesComponent(std::unordered_map<std::string, std::string> properties)

Public Members

std::unordered_map<std::string, std::string> properties

Public Static Functions

static inline uint8 id()

struct RigidBodyObjectComponent

#include <RigidBodyObjectComponent.hpp>

Public Functions

RigidBodyObjectComponent() = default

inline RigidBodyObjectComponent(physics::CollisionShapeHandle collisionShapeHandle)

inline RigidBodyObjectComponent(physics::CollisionShapeHandle collisionShapeHandle, float32 mass, float32 friction, float32 restitution)

inline RigidBodyObjectComponent(physics::CollisionShapeHandle collisionShapeHandle, float32 mass, float32 friction, float32 restitution, physics::RigidBodyObjectHandle rigidBodyObjectHandle)

Public Members

physics::CollisionShapeHandle collisionShapeHandle

float32 mass = 1.0f

float32 friction = 1.0f

float32 restitution = 1.0f

physics::RigidBodyObjectHandle rigidBodyObjectHandle

Public Static Functions

static inline uint8 id()

class SceneDelegate

#include <Entity.hpp>

Public Functions

inline SceneDelegate(Scene *scene = nullptr)

const std::string &name() const

pathfinding::CrowdHandle createCrowd(const pathfinding::NavigationMeshHandle &navigationMeshHandle, const pathfinding::CrowdConfig &crowdConfig)

void destroy(const pathfinding::CrowdHandle &crowdHandle)

pathfinding::AgentHandle createAgent(const pathfinding::CrowdHandle &crowdHandle, const glm::vec3 &position, const pathfinding::AgentParams &agentParams = pathfinding::AgentParams())

void destroy(const pathfinding::CrowdHandle &crowdHandle, const pathfinding::AgentHandle &agentHandle)

physics::RigidBodyObjectHandle createRigidBodyObject(const physics::CollisionShapeHandle &collisionShapeHandle)

physics::RigidBodyObjectHandle createRigidBodyObject(const physics::CollisionShapeHandle &collisionShapeHandle, const float32 mass, const float32 friction, const float32 restitution)

physics::RigidBodyObjectHandle createRigidBodyObject(const physics::CollisionShapeHandle &collisionShapeHandle, const glm::vec3 &position, const glm::quat &orientation, const float32 mass = 1.0f, const float32 friction = 1.0f, const float32 restitution = 1.0f)

void destroy(const physics::RigidBodyObjectHandle &rigidBodyObjectHandle)

physics::GhostObjectHandle createGhostObject(const physics::CollisionShapeHandle &collisionShapeHandle)

physics::GhostObjectHandle createGhostObject(const physics::CollisionShapeHandle &collisionShapeHandle, const glm::vec3 &position, const glm::quat &orientation)

void destroy(const physics::GhostObjectHandle &ghostObjectHandle)

graphics::RenderableHandle createRenderable(const ModelHandle &modelHandle, const glm::vec3 &position, const glm::quat &orientation, const glm::vec3 &scale = glm::vec3(1.0f))

graphics::RenderableHandle createRenderable(const graphics::MeshHandle &meshHandle, const graphics::TextureHandle &textureHandle, const glm::vec3 &position, const glm::quat &orientation, const glm::vec3 &scale = glm::vec3(1.0f))

void destroy(const graphics::RenderableHandle &renderableHandle)

graphics::PointLightHandle createPointLight(const glm::vec3 &position)

void destroy(const graphics::PointLightHandle &pointLightHandle)

graphics::BonesHandle createBones(const uint32 maxNumberOfBones)

void destroy(const graphics::BonesHandle &bonesHandle)

void attach(const graphics::RenderableHandle &renderableHandle, const graphics::BonesHandle &bonesHandle)

void detach(const graphics::RenderableHandle &renderableHandle, const graphics::BonesHandle &bonesHandle)

void attachBoneAttachment(const graphics::RenderableHandle &renderableHandle, const graphics::BonesHandle &bonesHandle, const glm::ivec4 &boneIds, const glm::vec4 &boneWeights)

void attachBoneAttachment(const graphics::RenderableHandle &renderableHandle, const graphics::BonesHandle &bonesHandle, const graphics::MeshHandle meshHandle, const std::string &boneName, const glm::ivec4 &boneIds, const glm::vec4 &boneWeights)

void detachBoneAttachment(const graphics::RenderableHandle &renderableHandle)

graphics::TerrainRenderableHandle createTerrainRenderable(const graphics::TerrainHandle terrainHandle)

void destroy(const graphics::TerrainRenderableHandle &terrainRenderableHandle)

graphics::SkyboxRenderableHandle createSkyboxRenderable(const graphics::SkyboxHandle skyboxHandle)

void destroy(const graphics::SkyboxRenderableHandle &skyboxRenderableHandle)

pathfinding::IPathfindingEngine &pathfindingEngine() const

struct ScriptObjectComponent

#include <ScriptObjectComponent.hpp>

Public Functions

ScriptObjectComponent() = default

inline ScriptObjectComponent(void *object)

inline ScriptObjectComponent(scripting::ScriptObjectHandle scriptObjectHandle1)

Public Members

scripting::ScriptObjectHandle scriptObjectHandle

Public Static Functions

static inline uint8 id()

struct SkeletonComponent

#include <SkeletonComponent.hpp>

Public Functions

SkeletonComponent() = default

inline SkeletonComponent(SkeletonHandle skeletonHandle)

Public Members

SkeletonHandle skeletonHandle

Public Static Functions

static inline uint8 id()

template<bool All = false> class ViewIterator

#include <EntityComponentSystem.hpp>

Subclassed by ice_engine::ecs::EcsView< All >::Iterator

Public Functions

inline ViewIterator(Scene *scene, entityx::EntityManager::ViewIterator<typename entityx::EntityManager::BaseView<All>::Iterator, All> viewIterator)

inline ViewIterator &operator++()

inline bool operator==(const ViewIterator &rhs) const

inline bool operator!=(const ViewIterator &rhs) const

inline Entity operator*()

inline const Entity operator*() const

namespace extras

class FpsCamera

#include <FpsCamera.hpp>

Public Functions

FpsCamera()

virtual ~FpsCamera()

bool isActive()

void moveForward()

void moveBack()

void moveLeft()

void moveRight()

void rotate(const float32 &degrees, const glm::vec3 &axis)

void tick(float32 time)

namespace fs

Enums

enum FileFlags

Values:

enumerator READ

enumerator WRITE

enumerator APPEND

enumerator BINARY

class File : public ice_engine::fs::IFile

#include <File.hpp>

Public Functions

File(const std::string &file, int32 flags)

~File() override

virtual bool isOpen() const override

virtual uint64 size() const override

virtual bool eof() const override

virtual std::string path() const override

virtual void close() override

virtual void write(const char *data) override

virtual void write(const std::string &data) override

virtual std::string read(const uint32 length = 256) override

virtual std::string readAll() override

virtual std::istream &getInputStream() override

virtual std::ostream &getOutputStream() override

class FileSystem : public ice_engine::fs::IFileSystem

#include <FileSystem.hpp>

Public Functions

FileSystem(const std::vector<std::string> &baseDirectories = std::vector<std::string>())

void mountBaseDirectory(const std::string &baseDir)

Mounts a base directory that will be used when looking for files.

You may call this method multiple times to mount several base directories.

Note that once you mount a directory, any file that is looked for that does not have its base path within a mounted directory will fail to find the file.

Parameters: baseDir –

void unmountBaseDirectory(const std::string &baseDir)

void mountFile(const std::string &path, const std::string &mountPoint)

Mounts a file that can be accessed by it’s mount point.

You may call this method multiple times to mount several files.

Parameters: baseDir –

void unmountFile(const std::string &mountPoint)

virtual bool exists(const std::string &file) const override

virtual bool isDirectory(const std::string &file) const override

virtual std::vector<std::string> list(const std::string &directoryName) const override

virtual void deleteFile(const std::string &file) const override

virtual void makeDirectory(const std::string &directoryName) const override

virtual std::string getBasePath(const std::string &filename) const override

virtual std::string getDirectorySeperator() const override

virtual std::string getTempDirectory() const override

virtual std::string getFilename(const std::string &filename) const override

virtual std::string getFilenameWithoutExtension(const std::string &filename) const override

virtual std::string getCanonicalPath(const std::string &filename) const override

virtual std::string readAll(const std::string &file, const bool isBinary = false) const override

virtual std::unique_ptr<IFile> open(const std::string &file, int32 flags) const override

virtual std::string generateTempFilename() const override

class IFile

#include <IFile.hpp>

Subclassed by ice_engine::fs::File

Public Functions

virtual ~IFile() = default

virtual bool isOpen() const = 0

virtual uint64 size() const = 0

virtual bool eof() const = 0

virtual std::string path() const = 0

virtual void close() = 0

virtual void write(const char *data) = 0

virtual void write(const std::string &data) = 0

virtual std::string read(const uint32 length = 256) = 0

virtual std::string readAll() = 0

virtual std::istream &getInputStream() = 0

virtual std::ostream &getOutputStream() = 0

class IFileSystem

#include <IFileSystem.hpp>

Subclassed by ice_engine::fs::FileSystem

Public Functions

virtual ~IFileSystem() = default

virtual bool exists(const std::string &file) const = 0

virtual bool isDirectory(const std::string &file) const = 0

virtual std::vector<std::string> list(const std::string &directoryName) const = 0

virtual void deleteFile(const std::string &file) const = 0

virtual void makeDirectory(const std::string &directoryName) const = 0

virtual std::string getBasePath(const std::string &filename) const = 0

virtual std::string getDirectorySeperator() const = 0

virtual std::string getTempDirectory() const = 0

virtual std::string getFilename(const std::string &filename) const = 0

virtual std::string getFilenameWithoutExtension(const std::string &filename) const = 0

virtual std::string getCanonicalPath(const std::string &filename) const = 0

virtual std::string readAll(const std::string &file, const bool isBinary = false) const = 0

virtual std::unique_ptr<IFile> open(const std::string &file, int32 flags) const = 0

virtual std::string generateTempFilename() const = 0

namespace graphics

Typedefs

typedef int32 KeyCode

Enums

enum State

Values:

enumerator RELEASED

enumerator PRESSED

enum EventType

Values:

enumerator UNKNOWN

enumerator QUIT

enumerator WINDOWEVENT

enumerator TEXTINPUT

enumerator KEYDOWN

enumerator KEYUP

enumerator MOUSEMOTION

enumerator MOUSEBUTTONDOWN

enumerator MOUSEBUTTONUP

enumerator MOUSEWHEEL

enum ScanCode

Values:

enumerator SCANCODE_UNKNOWN

enumerator SCANCODE_A

enumerator SCANCODE_B

enumerator SCANCODE_C

enumerator SCANCODE_D

enumerator SCANCODE_E

enumerator SCANCODE_F

enumerator SCANCODE_G

enumerator SCANCODE_H

enumerator SCANCODE_I

enumerator SCANCODE_J

enumerator SCANCODE_K

enumerator SCANCODE_L

enumerator SCANCODE_M

enumerator SCANCODE_N

enumerator SCANCODE_O

enumerator SCANCODE_P

enumerator SCANCODE_Q

enumerator SCANCODE_R

enumerator SCANCODE_S

enumerator SCANCODE_T

enumerator SCANCODE_U

enumerator SCANCODE_V

enumerator SCANCODE_W

enumerator SCANCODE_X

enumerator SCANCODE_Y

enumerator SCANCODE_Z

enumerator SCANCODE_1

enumerator SCANCODE_2

enumerator SCANCODE_3

enumerator SCANCODE_4

enumerator SCANCODE_5

enumerator SCANCODE_6

enumerator SCANCODE_7

enumerator SCANCODE_8

enumerator SCANCODE_9

enumerator SCANCODE_0

enumerator SCANCODE_RETURN

enumerator SCANCODE_ESCAPE

enumerator SCANCODE_BACKSPACE

enumerator SCANCODE_TAB

enumerator SCANCODE_SPACE

enumerator SCANCODE_MINUS

enumerator SCANCODE_EQUALS

enumerator SCANCODE_LEFTBRACKET

enumerator SCANCODE_RIGHTBRACKET

enumerator SCANCODE_BACKSLASH

enumerator SCANCODE_NONUSHASH

enumerator SCANCODE_SEMICOLON

enumerator SCANCODE_APOSTROPHE

enumerator SCANCODE_GRAVE

enumerator SCANCODE_COMMA

enumerator SCANCODE_PERIOD

enumerator SCANCODE_SLASH

enumerator SCANCODE_CAPSLOCK

enumerator SCANCODE_F1

enumerator SCANCODE_F2

enumerator SCANCODE_F3

enumerator SCANCODE_F4

enumerator SCANCODE_F5

enumerator SCANCODE_F6

enumerator SCANCODE_F7

enumerator SCANCODE_F8

enumerator SCANCODE_F9

enumerator SCANCODE_F10

enumerator SCANCODE_F11

enumerator SCANCODE_F12

enumerator SCANCODE_PRINTSCREEN

enumerator SCANCODE_SCROLLLOCK

enumerator SCANCODE_PAUSE

enumerator SCANCODE_INSERT

enumerator SCANCODE_HOME

enumerator SCANCODE_PAGEUP

enumerator SCANCODE_DELETE

enumerator SCANCODE_END

enumerator SCANCODE_PAGEDOWN

enumerator SCANCODE_RIGHT

enumerator SCANCODE_LEFT

enumerator SCANCODE_DOWN

enumerator SCANCODE_UP

enumerator SCANCODE_NUMLOCKCLEAR

enumerator SCANCODE_KP_DIVIDE

enumerator SCANCODE_KP_MULTIPLY

enumerator SCANCODE_KP_MINUS

enumerator SCANCODE_KP_PLUS

enumerator SCANCODE_KP_ENTER

enumerator SCANCODE_KP_1

enumerator SCANCODE_KP_2

enumerator SCANCODE_KP_3

enumerator SCANCODE_KP_4

enumerator SCANCODE_KP_5

enumerator SCANCODE_KP_6

enumerator SCANCODE_KP_7

enumerator SCANCODE_KP_8

enumerator SCANCODE_KP_9

enumerator SCANCODE_KP_0

enumerator SCANCODE_KP_PERIOD

enumerator SCANCODE_NONUSBACKSLASH

enumerator SCANCODE_APPLICATION

enumerator SCANCODE_POWER

enumerator SCANCODE_KP_EQUALS

enumerator SCANCODE_F13

enumerator SCANCODE_F14

enumerator SCANCODE_F15

enumerator SCANCODE_F16

enumerator SCANCODE_F17

enumerator SCANCODE_F18

enumerator SCANCODE_F19

enumerator SCANCODE_F20

enumerator SCANCODE_F21

enumerator SCANCODE_F22

enumerator SCANCODE_F23

enumerator SCANCODE_F24

enumerator SCANCODE_EXECUTE

enumerator SCANCODE_HELP

enumerator SCANCODE_MENU

enumerator SCANCODE_SELECT

enumerator SCANCODE_STOP

enumerator SCANCODE_AGAIN

enumerator SCANCODE_UNDO

enumerator SCANCODE_CUT

enumerator SCANCODE_COPY

enumerator SCANCODE_PASTE

enumerator SCANCODE_FIND

enumerator SCANCODE_MUTE

enumerator SCANCODE_VOLUMEUP

enumerator SCANCODE_VOLUMEDOWN

enumerator SCANCODE_KP_COMMA

enumerator SCANCODE_KP_EQUALSAS400

enumerator SCANCODE_INTERNATIONAL1

enumerator SCANCODE_INTERNATIONAL2

enumerator SCANCODE_INTERNATIONAL3

enumerator SCANCODE_INTERNATIONAL4

enumerator SCANCODE_INTERNATIONAL5

enumerator SCANCODE_INTERNATIONAL6

enumerator SCANCODE_INTERNATIONAL7

enumerator SCANCODE_INTERNATIONAL8

enumerator SCANCODE_INTERNATIONAL9

enumerator SCANCODE_LANG1

enumerator SCANCODE_LANG2

enumerator SCANCODE_LANG3

enumerator SCANCODE_LANG4

enumerator SCANCODE_LANG5

enumerator SCANCODE_LANG6

enumerator SCANCODE_LANG7

enumerator SCANCODE_LANG8

enumerator SCANCODE_LANG9

enumerator SCANCODE_ALTERASE

enumerator SCANCODE_SYSREQ

enumerator SCANCODE_CANCEL

enumerator SCANCODE_CLEAR

enumerator SCANCODE_PRIOR

enumerator SCANCODE_RETURN2

enumerator SCANCODE_SEPARATOR

enumerator SCANCODE_OUT

enumerator SCANCODE_OPER

enumerator SCANCODE_CLEARAGAIN

enumerator SCANCODE_CRSEL

enumerator SCANCODE_EXSEL

enumerator SCANCODE_KP_00

enumerator SCANCODE_KP_000

enumerator SCANCODE_THOUSANDSSEPARATOR

enumerator SCANCODE_DECIMALSEPARATOR

enumerator SCANCODE_CURRENCYUNIT

enumerator SCANCODE_CURRENCYSUBUNIT

enumerator SCANCODE_KP_LEFTPAREN

enumerator SCANCODE_KP_RIGHTPAREN

enumerator SCANCODE_KP_LEFTBRACE

enumerator SCANCODE_KP_RIGHTBRACE

enumerator SCANCODE_KP_TAB

enumerator SCANCODE_KP_BACKSPACE

enumerator SCANCODE_KP_A

enumerator SCANCODE_KP_B

enumerator SCANCODE_KP_C

enumerator SCANCODE_KP_D

enumerator SCANCODE_KP_E

enumerator SCANCODE_KP_F

enumerator SCANCODE_KP_XOR

enumerator SCANCODE_KP_POWER

enumerator SCANCODE_KP_PERCENT

enumerator SCANCODE_KP_LESS

enumerator SCANCODE_KP_GREATER

enumerator SCANCODE_KP_AMPERSAND

enumerator SCANCODE_KP_DBLAMPERSAND

enumerator SCANCODE_KP_VERTICALBAR

enumerator SCANCODE_KP_DBLVERTICALBAR

enumerator SCANCODE_KP_COLON

enumerator SCANCODE_KP_HASH

enumerator SCANCODE_KP_SPACE

enumerator SCANCODE_KP_AT

enumerator SCANCODE_KP_EXCLAM

enumerator SCANCODE_KP_MEMSTORE

enumerator SCANCODE_KP_MEMRECALL

enumerator SCANCODE_KP_MEMCLEAR

enumerator SCANCODE_KP_MEMADD

enumerator SCANCODE_KP_MEMSUBTRACT

enumerator SCANCODE_KP_MEMMULTIPLY

enumerator SCANCODE_KP_MEMDIVIDE

enumerator SCANCODE_KP_PLUSMINUS

enumerator SCANCODE_KP_CLEAR

enumerator SCANCODE_KP_CLEARENTRY

enumerator SCANCODE_KP_BINARY

enumerator SCANCODE_KP_OCTAL

enumerator SCANCODE_KP_DECIMAL

enumerator SCANCODE_KP_HEXADECIMAL

enumerator SCANCODE_LCTRL

enumerator SCANCODE_LSHIFT

enumerator SCANCODE_LALT

enumerator SCANCODE_LGUI

enumerator SCANCODE_RCTRL

enumerator SCANCODE_RSHIFT

enumerator SCANCODE_RALT

enumerator SCANCODE_RGUI

enumerator SCANCODE_MODE

enumerator SCANCODE_AUDIONEXT

enumerator SCANCODE_AUDIOPREV

enumerator SCANCODE_AUDIOSTOP

enumerator SCANCODE_AUDIOPLAY

enumerator SCANCODE_AUDIOMUTE

enumerator SCANCODE_MEDIASELECT

enumerator SCANCODE_WWW

enumerator SCANCODE_MAIL

enumerator SCANCODE_CALCULATOR

enumerator SCANCODE_COMPUTER

enumerator SCANCODE_AC_SEARCH

enumerator SCANCODE_AC_HOME

enumerator SCANCODE_AC_BACK

enumerator SCANCODE_AC_FORWARD

enumerator SCANCODE_AC_STOP

enumerator SCANCODE_AC_REFRESH

enumerator SCANCODE_AC_BOOKMARKS

enumerator SCANCODE_BRIGHTNESSDOWN

enumerator SCANCODE_BRIGHTNESSUP

enumerator SCANCODE_DISPLAYSWITCH

enumerator SCANCODE_KBDILLUMTOGGLE

enumerator SCANCODE_KBDILLUMDOWN

enumerator SCANCODE_KBDILLUMUP

enumerator SCANCODE_EJECT

enumerator SCANCODE_SLEEP

enumerator SCANCODE_APP1

enumerator SCANCODE_APP2

enum [anonymous]

Values:

enumerator KEY_UNKNOWN

enumerator KEY_RETURN

enumerator KEY_ESCAPE

enumerator KEY_BACKSPACE

enumerator KEY_TAB

enumerator KEY_SPACE

enumerator KEY_EXCLAIM

enumerator KEY_QUOTEDBL

enumerator KEY_HASH

enumerator KEY_PERCENT

enumerator KEY_DOLLAR

enumerator KEY_AMPERSAND

enumerator KEY_QUOTE

enumerator KEY_LEFTPAREN

enumerator KEY_RIGHTPAREN

enumerator KEY_ASTERISK

enumerator KEY_PLUS

enumerator KEY_COMMA

enumerator KEY_MINUS

enumerator KEY_PERIOD

enumerator KEY_SLASH

enumerator KEY_0

enumerator KEY_1

enumerator KEY_2

enumerator KEY_3

enumerator KEY_4

enumerator KEY_5

enumerator KEY_6

enumerator KEY_7

enumerator KEY_8

enumerator KEY_9

enumerator KEY_COLON

enumerator KEY_SEMICOLON

enumerator KEY_LESS

enumerator KEY_EQUALS

enumerator KEY_GREATER

enumerator KEY_QUESTION

enumerator KEY_AT

enumerator KEY_LEFTBRACKET

enumerator KEY_BACKSLASH

enumerator KEY_RIGHTBRACKET

enumerator KEY_CARET

enumerator KEY_UNDERSCORE

enumerator KEY_BACKQUOTE

enumerator KEY_a

enumerator KEY_b

enumerator KEY_c

enumerator KEY_d

enumerator KEY_e

enumerator KEY_f

enumerator KEY_g

enumerator KEY_h

enumerator KEY_i

enumerator KEY_j

enumerator KEY_k

enumerator KEY_l

enumerator KEY_m

enumerator KEY_n

enumerator KEY_o

enumerator KEY_p

enumerator KEY_q

enumerator KEY_r

enumerator KEY_s

enumerator KEY_t

enumerator KEY_u

enumerator KEY_v

enumerator KEY_w

enumerator KEY_x

enumerator KEY_y

enumerator KEY_z

enumerator KEY_CAPSLOCK

enumerator KEY_F1

enumerator KEY_F2

enumerator KEY_F3

enumerator KEY_F4

enumerator KEY_F5

enumerator KEY_F6

enumerator KEY_F7

enumerator KEY_F8

enumerator KEY_F9

enumerator KEY_F10

enumerator KEY_F11

enumerator KEY_F12

enumerator KEY_PRINTSCREEN

enumerator KEY_SCROLLLOCK

enumerator KEY_PAUSE

enumerator KEY_INSERT

enumerator KEY_HOME

enumerator KEY_PAGEUP

enumerator KEY_DELETE

enumerator KEY_END

enumerator KEY_PAGEDOWN

enumerator KEY_RIGHT

enumerator KEY_LEFT

enumerator KEY_DOWN

enumerator KEY_UP

enumerator KEY_NUMLOCKCLEAR

enumerator KEY_KP_DIVIDE

enumerator KEY_KP_MULTIPLY

enumerator KEY_KP_MINUS

enumerator KEY_KP_PLUS

enumerator KEY_KP_ENTER

enumerator KEY_KP_1

enumerator KEY_KP_2

enumerator KEY_KP_3

enumerator KEY_KP_4

enumerator KEY_KP_5

enumerator KEY_KP_6

enumerator KEY_KP_7

enumerator KEY_KP_8

enumerator KEY_KP_9

enumerator KEY_KP_0

enumerator KEY_KP_PERIOD

enumerator KEY_APPLICATION

enumerator KEY_POWER

enumerator KEY_KP_EQUALS

enumerator KEY_F13

enumerator KEY_F14

enumerator KEY_F15

enumerator KEY_F16

enumerator KEY_F17

enumerator KEY_F18

enumerator KEY_F19

enumerator KEY_F20

enumerator KEY_F21

enumerator KEY_F22

enumerator KEY_F23

enumerator KEY_F24

enumerator KEY_EXECUTE

enumerator KEY_HELP

enumerator KEY_MENU

enumerator KEY_SELECT

enumerator KEY_STOP

enumerator KEY_AGAIN

enumerator KEY_UNDO

enumerator KEY_CUT

enumerator KEY_COPY

enumerator KEY_PASTE

enumerator KEY_FIND

enumerator KEY_MUTE

enumerator KEY_VOLUMEUP

enumerator KEY_VOLUMEDOWN

enumerator KEY_KP_COMMA

enumerator KEY_KP_EQUALSAS400

enumerator KEY_ALTERASE

enumerator KEY_SYSREQ

enumerator KEY_CANCEL

enumerator KEY_CLEAR

enumerator KEY_PRIOR

enumerator KEY_RETURN2

enumerator KEY_SEPARATOR

enumerator KEY_OUT

enumerator KEY_OPER

enumerator KEY_CLEARAGAIN

enumerator KEY_CRSEL

enumerator KEY_EXSEL

enumerator KEY_KP_00

enumerator KEY_KP_000

enumerator KEY_THOUSANDSSEPARATOR

enumerator KEY_DECIMALSEPARATOR

enumerator KEY_CURRENCYUNIT

enumerator KEY_CURRENCYSUBUNIT

enumerator KEY_KP_LEFTPAREN

enumerator KEY_KP_RIGHTPAREN

enumerator KEY_KP_LEFTBRACE

enumerator KEY_KP_RIGHTBRACE

enumerator KEY_KP_TAB

enumerator KEY_KP_BACKSPACE

enumerator KEY_KP_A

enumerator KEY_KP_B

enumerator KEY_KP_C

enumerator KEY_KP_D

enumerator KEY_KP_E

enumerator KEY_KP_F

enumerator KEY_KP_XOR

enumerator KEY_KP_POWER

enumerator KEY_KP_PERCENT

enumerator KEY_KP_LESS

enumerator KEY_KP_GREATER

enumerator KEY_KP_AMPERSAND

enumerator KEY_KP_DBLAMPERSAND

enumerator KEY_KP_VERTICALBAR

enumerator KEY_KP_DBLVERTICALBAR

enumerator KEY_KP_COLON

enumerator KEY_KP_HASH

enumerator KEY_KP_SPACE

enumerator KEY_KP_AT

enumerator KEY_KP_EXCLAM

enumerator KEY_KP_MEMSTORE

enumerator KEY_KP_MEMRECALL

enumerator KEY_KP_MEMCLEAR

enumerator KEY_KP_MEMADD

enumerator KEY_KP_MEMSUBTRACT

enumerator KEY_KP_MEMMULTIPLY

enumerator KEY_KP_MEMDIVIDE

enumerator KEY_KP_PLUSMINUS

enumerator KEY_KP_CLEAR

enumerator KEY_KP_CLEARENTRY

enumerator KEY_KP_BINARY

enumerator KEY_KP_OCTAL

enumerator KEY_KP_DECIMAL

enumerator KEY_KP_HEXADECIMAL

enumerator KEY_LCTRL

enumerator KEY_LSHIFT

enumerator KEY_LALT

enumerator KEY_LGUI

enumerator KEY_RCTRL

enumerator KEY_RSHIFT

enumerator KEY_RALT

enumerator KEY_RGUI

enumerator KEY_MODE

enumerator KEY_AUDIONEXT

enumerator KEY_AUDIOPREV

enumerator KEY_AUDIOSTOP

enumerator KEY_AUDIOPLAY

enumerator KEY_AUDIOMUTE

enumerator KEY_MEDIASELECT

enumerator KEY_WWW

enumerator KEY_MAIL

enumerator KEY_CALCULATOR

enumerator KEY_COMPUTER

enumerator KEY_AC_SEARCH

enumerator KEY_AC_HOME

enumerator KEY_AC_BACK

enumerator KEY_AC_FORWARD

enumerator KEY_AC_STOP

enumerator KEY_AC_REFRESH

enumerator KEY_AC_BOOKMARKS

enumerator KEY_BRIGHTNESSDOWN

enumerator KEY_BRIGHTNESSUP

enumerator KEY_DISPLAYSWITCH

enumerator KEY_KBDILLUMTOGGLE

enumerator KEY_KBDILLUMDOWN

enumerator KEY_KBDILLUMUP

enumerator KEY_EJECT

enumerator KEY_SLEEP

enum KeyState

Values:

enumerator KEY_PRESSED

enumerator KEY_RELEASED

enum KeyMod

Values:

enumerator KEYMOD_NONE

enumerator KEYMOD_LSHIFT

enumerator KEYMOD_RSHIFT

enumerator KEYMOD_LCTRL

enumerator KEYMOD_RCTRL

enumerator KEYMOD_LALT

enumerator KEYMOD_RALT

enumerator KEYMOD_LGUI

enumerator KEYMOD_RGUI

enumerator KEYMOD_NUM

enumerator KEYMOD_CAPS

enumerator KEYMOD_MODE

enumerator KEYMOD_RESERVED

enumerator KEYMOD_CTRL

enumerator KEYMOD_SHIFT

enumerator KEYMOD_ALT

enumerator KEYMOD_GUI

enum MouseButtonCode

Values:

enumerator BUTTON_LEFT

enumerator BUTTON_MIDDLE

enumerator BUTTON_RIGHT

enumerator BUTTON_X1

enumerator BUTTON_X2

enum ShaderType

Values:

enumerator UNKNOWN

enumerator VERTEX

enumerator TESSELLATION_CONTROL

enumerator TESSELLATION_EVALUATION

enumerator GEOMETRY

enumerator FRAGMENT

enumerator COMPUTE

enum TransformSpace

Values:

enumerator TS_LOCAL

enumerator TS_WORLD

enum WindowEventType

Values:

enumerator WINDOWEVENT_UNKNOWN

enumerator WINDOWEVENT_NONE

enumerator WINDOWEVENT_SHOWN

enumerator WINDOWEVENT_HIDDEN

enumerator WINDOWEVENT_EXPOSED

enumerator WINDOWEVENT_MOVED

enumerator WINDOWEVENT_RESIZED

enumerator WINDOWEVENT_SIZE_CHANGED

enumerator WINDOWEVENT_MINIMIZED

enumerator WINDOWEVENT_MAXIMIZED

enumerator WINDOWEVENT_RESTORED

enumerator WINDOWEVENT_ENTER

enumerator WINDOWEVENT_LEAVE

enumerator WINDOWEVENT_FOCUS_GAINED

enumerator WINDOWEVENT_FOCUS_LOST

enumerator WINDOWEVENT_CLOSE

enumerator WINDOWEVENT_TAKE_FOCUS

enumerator WINDOWEVENT_HIT_TEST

enumerator WINDOWEVENT_UNKNOWN

enumerator WINDOWEVENT_NONE

enumerator WINDOWEVENT_SHOWN

enumerator WINDOWEVENT_HIDDEN

enumerator WINDOWEVENT_EXPOSED

enumerator WINDOWEVENT_MOVED

enumerator WINDOWEVENT_RESIZED

enumerator WINDOWEVENT_SIZE_CHANGED

enumerator WINDOWEVENT_MINIMIZED

enumerator WINDOWEVENT_MAXIMIZED

enumerator WINDOWEVENT_RESTORED

enumerator WINDOWEVENT_ENTER

enumerator WINDOWEVENT_LEAVE

enumerator WINDOWEVENT_FOCUS_GAINED

enumerator WINDOWEVENT_FOCUS_LOST

enumerator WINDOWEVENT_CLOSE

enumerator WINDOWEVENT_TAKE_FOCUS

enumerator WINDOWEVENT_HIT_TEST

enum WindowEventType

Values:

enumerator WINDOWEVENT_UNKNOWN

enumerator WINDOWEVENT_NONE

enumerator WINDOWEVENT_SHOWN

enumerator WINDOWEVENT_HIDDEN

enumerator WINDOWEVENT_EXPOSED

enumerator WINDOWEVENT_MOVED

enumerator WINDOWEVENT_RESIZED

enumerator WINDOWEVENT_SIZE_CHANGED

enumerator WINDOWEVENT_MINIMIZED

enumerator WINDOWEVENT_MAXIMIZED

enumerator WINDOWEVENT_RESTORED

enumerator WINDOWEVENT_ENTER

enumerator WINDOWEVENT_LEAVE

enumerator WINDOWEVENT_FOCUS_GAINED

enumerator WINDOWEVENT_FOCUS_LOST

enumerator WINDOWEVENT_CLOSE

enumerator WINDOWEVENT_TAKE_FOCUS

enumerator WINDOWEVENT_HIT_TEST

enumerator WINDOWEVENT_UNKNOWN

enumerator WINDOWEVENT_NONE

enumerator WINDOWEVENT_SHOWN

enumerator WINDOWEVENT_HIDDEN

enumerator WINDOWEVENT_EXPOSED

enumerator WINDOWEVENT_MOVED

enumerator WINDOWEVENT_RESIZED

enumerator WINDOWEVENT_SIZE_CHANGED

enumerator WINDOWEVENT_MINIMIZED

enumerator WINDOWEVENT_MAXIMIZED

enumerator WINDOWEVENT_RESTORED

enumerator WINDOWEVENT_ENTER

enumerator WINDOWEVENT_LEAVE

enumerator WINDOWEVENT_FOCUS_GAINED

enumerator WINDOWEVENT_FOCUS_LOST

enumerator WINDOWEVENT_CLOSE

enumerator WINDOWEVENT_TAKE_FOCUS

enumerator WINDOWEVENT_HIT_TEST

Variables

constexpr uint8 TEXTINPUTEVENT_TEXT_SIZE = 32

class BonesHandle : public ice_engine::handles::Handle<BonesHandle>: #include <BonesHandle.hpp>

class CameraHandle : public ice_engine::handles::Handle<CameraHandle>: #include <CameraHandle.hpp>

class Color

#include <Color.hpp>

Public Functions

Color() = default

inline Color(const uint32 color)

inline Color(const uint8 r, const uint8 g, const uint8 b, const uint8 a)

inline void setColor(const uint32 color)

inline void setColor(const uint8 r, const uint8 g, const uint8 b, const uint8 a)

inline uint32 color() const

struct DisplacementMap

#include <IGraphicsEngine.hpp>

Public Functions

DisplacementMap() = default

inline DisplacementMap(IImage *displacementMap)

Public Members

IImage *displacementMap = nullptr

union Event

#include <Event.hpp>

Public Members

uint32 type

GenericEvent generic

WindowEvent window

KeyboardEvent key

TextInputEvent text

MouseMotionEvent motion

MouseButtonEvent button

MouseWheelEvent wheel

class FragmentShaderHandle : public ice_engine::handles::Handle<FragmentShaderHandle>: #include <FragmentShaderHandle.hpp>

struct GenericEvent

#include <Event.hpp>

Public Members

uint32 type

struct GraphicsException : public virtual ice_engine::Exception: #include <GraphicsException.hpp>

class GraphicsFactory

#include <GraphicsFactory.hpp>

Public Static Functions

static std::unique_ptr<IGraphicsEngine> createGraphicsEngine(utilities::Properties *properties, fs::IFileSystem *fileSystem, logger::ILogger *logger)

class IDisplacementMap

#include <IDisplacementMap.hpp>

Subclassed by ice_engine::DisplacementMap

Public Functions

inline virtual ~IDisplacementMap()

class IEventListener

#include <IEventListener.hpp>

Subclassed by ice_engine::GameEngine

Public Functions

inline virtual ~IEventListener()

virtual bool processEvent(const Event &event) = 0

class IGraphicsEngine

#include <IGraphicsEngine.hpp>

Public Functions

virtual ~IGraphicsEngine() = default

virtual void setViewport(const uint32 width, const uint32 height) = 0

virtual glm::uvec2 getViewport() const = 0

virtual glm::mat4 getModelMatrix() const = 0

virtual glm::mat4 getViewMatrix() const = 0

virtual glm::mat4 getProjectionMatrix() const = 0

virtual void beginRender() = 0

virtual void render(const RenderSceneHandle &renderSceneHandle) = 0

virtual void renderLine(const glm::vec3 &from, const glm::vec3 &to, const glm::vec3 &color) = 0

virtual void renderLines(const std::vector<std::tuple<glm::vec3, glm::vec3, glm::vec3>> &lineData) = 0

virtual void endRender() = 0

virtual RenderSceneHandle createRenderScene() = 0

virtual bool valid(const RenderSceneHandle &renderSceneHandle) const = 0

virtual void destroy(const RenderSceneHandle &renderSceneHandle) = 0

virtual CameraHandle createCamera(const glm::vec3 &position, const glm::vec3 &lookAt = glm::vec3(0.0f, 0.0f, 0.0f)) = 0

virtual bool valid(const CameraHandle &cameraHandle) const = 0

virtual void destroy(const CameraHandle &cameraHandle) = 0

virtual PointLightHandle createPointLight(const RenderSceneHandle &renderSceneHandle, const glm::vec3 &position) = 0

virtual bool valid(const RenderSceneHandle &renderSceneHandle, const PointLightHandle &pointLightHandle) const = 0

virtual void destroy(const RenderSceneHandle &renderSceneHandle, const PointLightHandle &pointLightHandle) = 0

virtual MeshHandle createStaticMesh(const IMesh &mesh) = 0

virtual MeshHandle createDynamicMesh(const IMesh &mesh) = 0

virtual bool valid(const MeshHandle &meshHandle) const = 0

virtual void destroy(const MeshHandle &meshHandle) = 0

virtual SkeletonHandle createSkeleton(const MeshHandle &meshHandle, const ISkeleton &skeleton) = 0

virtual bool valid(const SkeletonHandle &skeletonHandle) const = 0

virtual void destroy(const SkeletonHandle &skeletonHandle) = 0

virtual BonesHandle createBones(const uint32 maxNumberOfBones) = 0

virtual bool valid(const BonesHandle &bonesHandle) const = 0

virtual void destroy(const BonesHandle &bonesHandle) = 0

virtual void attach(const RenderSceneHandle &renderSceneHandle, const RenderableHandle &renderableHandle, const BonesHandle &bonesHandle) = 0

virtual void detach(const RenderSceneHandle &renderSceneHandle, const RenderableHandle &renderableHandle, const BonesHandle &bonesHandle) = 0

virtual void attachBoneAttachment(const RenderSceneHandle &renderSceneHandle, const RenderableHandle &renderableHandle, const BonesHandle &bonesHandle, const glm::ivec4 &boneIds, const glm::vec4 &boneWeights) = 0

virtual void detachBoneAttachment(const RenderSceneHandle &renderSceneHandle, const RenderableHandle &renderableHandle) = 0

virtual TextureHandle createTexture2d(const ITexture &texture) = 0

virtual bool valid(const TextureHandle &textureHandle) const = 0

virtual void destroy(const TextureHandle &textureHandle) = 0

virtual MaterialHandle createMaterial(const IPbrMaterial &pbrMaterial) = 0

virtual bool valid(const MaterialHandle &materialHandle) const = 0

virtual void destroy(const MaterialHandle &materialHandle) = 0

virtual TerrainHandle createStaticTerrain(const IHeightMap &heightMap, const ISplatMap &splatMap, const IDisplacementMap &displacementMap) = 0

virtual bool valid(const TerrainHandle &terrainHandle) const = 0

virtual void destroy(const TerrainHandle &terrainHandle) = 0

virtual SkyboxHandle createStaticSkybox(const IImage &back, const IImage &down, const IImage &front, const IImage &left, const IImage &right, const IImage &up) = 0

virtual bool valid(const SkyboxHandle &skyboxHandle) const = 0

virtual void destroy(const SkyboxHandle &skyboxHandle) = 0

virtual VertexShaderHandle createVertexShader(const std::string &data) = 0

virtual FragmentShaderHandle createFragmentShader(const std::string &data) = 0

virtual TessellationControlShaderHandle createTessellationControlShader(const std::string &data) = 0

virtual TessellationEvaluationShaderHandle createTessellationEvaluationShader(const std::string &data) = 0

virtual bool valid(const VertexShaderHandle &shaderHandle) const = 0

virtual bool valid(const FragmentShaderHandle &shaderHandle) const = 0

virtual bool valid(const TessellationControlShaderHandle &shaderHandle) const = 0

virtual bool valid(const TessellationEvaluationShaderHandle &shaderHandle) const = 0

virtual void destroy(const VertexShaderHandle &shaderHandle) = 0

virtual void destroy(const FragmentShaderHandle &shaderHandle) = 0

virtual void destroy(const TessellationControlShaderHandle &shaderHandle) = 0

virtual void destroy(const TessellationEvaluationShaderHandle &shaderHandle) = 0

virtual ShaderProgramHandle createShaderProgram(const VertexShaderHandle &vertexShaderHandle, const FragmentShaderHandle &fragmentShaderHandle) = 0

virtual ShaderProgramHandle createShaderProgram(const VertexShaderHandle &vertexShaderHandle, const TessellationControlShaderHandle &tessellationControlShaderHandle, const TessellationEvaluationShaderHandle &tessellationEvaluationShaderHandle, const FragmentShaderHandle &fragmentShaderHandle) = 0

virtual bool valid(const ShaderProgramHandle &shaderProgramHandle) const = 0

virtual void destroy(const ShaderProgramHandle &shaderProgramHandle) = 0

virtual RenderableHandle createRenderable(const RenderSceneHandle &renderSceneHandle, const MeshHandle &meshHandle, const TextureHandle &textureHandle, const glm::vec3 &position, const glm::quat &orientation, const glm::vec3 &scale = glm::vec3(1.0f), const ShaderProgramHandle &shaderProgramHandle = ShaderProgramHandle()) = 0

virtual RenderableHandle createRenderable(const RenderSceneHandle &renderSceneHandle, const MeshHandle &meshHandle, const MaterialHandle &materialHandle, const glm::vec3 &position, const glm::quat &orientation, const glm::vec3 &scale = glm::vec3(1.0f)) = 0

virtual bool valid(const RenderSceneHandle &renderSceneHandle, const RenderableHandle &renderableHandle) const = 0

virtual void destroy(const RenderSceneHandle &renderSceneHandle, const RenderableHandle &renderableHandle) = 0

virtual TerrainRenderableHandle createTerrainRenderable(const RenderSceneHandle &renderSceneHandle, const TerrainHandle &terrainHandle) = 0

virtual bool valid(const RenderSceneHandle &renderSceneHandle, const TerrainRenderableHandle &terrainRenderableHandle) const = 0

virtual void destroy(const RenderSceneHandle &renderSceneHandle, const TerrainRenderableHandle &terrainRenderableHandle) = 0

virtual SkyboxRenderableHandle createSkyboxRenderable(const RenderSceneHandle &renderSceneHandle, const SkyboxHandle &skyboxHandle) = 0

virtual bool valid(const RenderSceneHandle &renderSceneHandle, const SkyboxRenderableHandle &skyboxRenderableHandle) const = 0

virtual void destroy(const RenderSceneHandle &renderSceneHandle, const SkyboxRenderableHandle &skyboxRenderableHandle) = 0

virtual void rotate(const RenderSceneHandle &renderSceneHandle, const RenderableHandle &renderableHandle, const glm::quat &quaternion, const TransformSpace &relativeTo = TransformSpace::TS_LOCAL) = 0

virtual void rotate(const RenderSceneHandle &renderSceneHandle, const RenderableHandle &renderableHandle, const float32 degrees, const glm::vec3 &axis, const TransformSpace &relativeTo = TransformSpace::TS_LOCAL) = 0

virtual void rotate(const CameraHandle &cameraHandle, const glm::quat &quaternion, const TransformSpace &relativeTo = TransformSpace::TS_LOCAL) = 0

virtual void rotate(const CameraHandle &cameraHandle, const float32 degrees, const glm::vec3 &axis, const TransformSpace &relativeTo = TransformSpace::TS_LOCAL) = 0

virtual void rotation(const RenderSceneHandle &renderSceneHandle, const RenderableHandle &renderableHandle, const glm::quat &quaternion) = 0

virtual void rotation(const RenderSceneHandle &renderSceneHandle, const RenderableHandle &renderableHandle, const float32 degrees, const glm::vec3 &axis) = 0

virtual glm::quat rotation(const RenderSceneHandle &renderSceneHandle, const RenderableHandle &renderableHandle) const = 0

virtual void rotation(const CameraHandle &cameraHandle, const glm::quat &quaternion) = 0

virtual void rotation(const CameraHandle &cameraHandle, const float32 degrees, const glm::vec3 &axis) = 0

virtual glm::quat rotation(const CameraHandle &cameraHandle) const = 0

virtual void translate(const RenderSceneHandle &renderSceneHandle, const RenderableHandle &renderableHandle, const float32 x, const float32 y, const float32 z) = 0

virtual void translate(const RenderSceneHandle &renderSceneHandle, const RenderableHandle &renderableHandle, const glm::vec3 &trans) = 0

virtual void translate(const RenderSceneHandle &renderSceneHandle, const PointLightHandle &pointLightHandle, const float32 x, const float32 y, const float32 z) = 0

virtual void translate(const RenderSceneHandle &renderSceneHandle, const PointLightHandle &pointLightHandle, const glm::vec3 &trans) = 0

virtual void translate(const CameraHandle &cameraHandle, const float32 x, const float32 y, const float32 z) = 0

virtual void translate(const CameraHandle &cameraHandle, const glm::vec3 &trans) = 0

virtual void scale(const RenderSceneHandle &renderSceneHandle, const RenderableHandle &renderableHandle, const float32 x, const float32 y, const float32 z) = 0

virtual void scale(const RenderSceneHandle &renderSceneHandle, const RenderableHandle &renderableHandle, const glm::vec3 &scale) = 0

virtual void scale(const RenderSceneHandle &renderSceneHandle, const RenderableHandle &renderableHandle, const float32 scale) = 0

virtual glm::vec3 scale(const RenderSceneHandle &renderSceneHandle, const RenderableHandle &renderableHandle) const = 0

virtual void position(const RenderSceneHandle &renderSceneHandle, const RenderableHandle &renderableHandle, const float32 x, const float32 y, const float32 z) = 0

virtual void position(const RenderSceneHandle &renderSceneHandle, const RenderableHandle &renderableHandle, const glm::vec3 &position) = 0

virtual glm::vec3 position(const RenderSceneHandle &renderSceneHandle, const RenderableHandle &renderableHandle) const = 0

virtual void position(const RenderSceneHandle &renderSceneHandle, const PointLightHandle &pointLightHandle, const float32 x, const float32 y, const float32 z) = 0

virtual void position(const RenderSceneHandle &renderSceneHandle, const PointLightHandle &pointLightHandle, const glm::vec3 &position) = 0

virtual glm::vec3 position(const RenderSceneHandle &renderSceneHandle, const PointLightHandle &pointLightHandle) const = 0

virtual void position(const CameraHandle &cameraHandle, const float32 x, const float32 y, const float32 z) = 0

virtual void position(const CameraHandle &cameraHandle, const glm::vec3 &position) = 0

virtual glm::vec3 position(const CameraHandle &cameraHandle) const = 0

virtual void lookAt(const RenderSceneHandle &renderSceneHandle, const RenderableHandle &renderableHandle, const glm::vec3 &lookAt) = 0

virtual void lookAt(const CameraHandle &cameraHandle, const glm::vec3 &lookAt) = 0

virtual void assign(const RenderSceneHandle &renderSceneHandle, const RenderableHandle &renderableHandle, const SkeletonHandle &skeletonHandle) = 0

virtual void update(const RenderSceneHandle &renderSceneHandle, const RenderableHandle &renderableHandle, const BonesHandle &bonesHandle, const std::vector<glm::mat4> &transformations) = 0

virtual void setMouseRelativeMode(const bool enabled) = 0

virtual void setWindowGrab(const bool enabled) = 0

virtual bool cursorVisible() const = 0

virtual void setCursorVisible(const bool visible) = 0

virtual void processEvents() = 0

virtual void addEventListener(IEventListener *eventListener) = 0

virtual void removeEventListener(IEventListener *eventListener) = 0

class IGraphicsEngineFactory

#include <IGraphicsEngineFactory.hpp>

Public Functions

virtual ~IGraphicsEngineFactory() = default

virtual std::unique_ptr<IGraphicsEngine> create(utilities::Properties *properties, fs::IFileSystem *fileSystem, logger::ILogger *logger) = 0

class IHeightMap

#include <IHeightMap.hpp>

Subclassed by ice_engine::HeightMap

Public Functions

virtual ~IHeightMap() = default

virtual const IImage *image() const = 0

class IImage

#include <IImage.hpp>

Subclassed by ice_engine::IImage

Public Types

enum Format

Values:

enumerator FORMAT_UNKNOWN

enumerator FORMAT_RGB

enumerator FORMAT_RGBA

Public Functions

virtual ~IImage() = default

virtual const std::vector<byte> &data() const = 0

virtual uint32 width() const = 0

virtual uint32 height() const = 0

virtual int32 format() const = 0

class IMesh

#include <IMesh.hpp>

Subclassed by ice_engine::Mesh

Public Functions

virtual ~IMesh() = default

virtual const std::string &name() const = 0

virtual const std::vector<glm::vec3> &vertices() const = 0

virtual const std::vector<uint32> &indices() const = 0

virtual const std::vector<glm::vec4> &colors() const = 0

virtual const std::vector<glm::vec3> &normals() const = 0

virtual const std::vector<glm::vec2> &textureCoordinates() const = 0

class IPbrMaterial

#include <IPbrMaterial.hpp>

Subclassed by ice_engine::PbrMaterial

Public Functions

inline virtual ~IPbrMaterial()

virtual const IImage *albedo() const = 0

virtual const IImage *normal() const = 0

virtual const IImage *metalness() const = 0

virtual const IImage *roughness() const = 0

virtual const IImage *ambientOcclusion() const = 0

class ISkeleton

#include <ISkeleton.hpp>

Subclassed by ice_engine::VertexBoneData

Public Functions

virtual ~ISkeleton() = default

virtual const std::string &name() const = 0

virtual const std::vector<glm::ivec4> &boneIds() const = 0

virtual const std::vector<glm::vec4> &boneWeights() const = 0

class ISplatMap

#include <ISplatMap.hpp>

Subclassed by ice_engine::SplatMap

Public Functions

inline virtual ~ISplatMap()

virtual const std::vector<IPbrMaterial*> &materialMap() const = 0

virtual const IImage *terrainMap() const = 0

class ITexture

#include <ITexture.hpp>

Subclassed by ice_engine::Texture

Public Functions

virtual ~ITexture() = default

virtual const std::string &name() const = 0

virtual const IImage *image() const = 0

struct KeyboardEvent

#include <Event.hpp>

Public Members

uint32 type

uint8 state

uint8 repeat

uint8 padding2

uint8 padding3

KeySym keySym

struct KeySym

#include <Keyboard.hpp>

Public Members

ScanCode scancode

KeyCode sym

uint16 mod

class MaterialHandle : public ice_engine::handles::Handle<MaterialHandle>: #include <MaterialHandle.hpp>

class MeshHandle : public ice_engine::handles::Handle<T>, public ice_engine::handles::Handle<MeshHandle>

#include <MeshHandle.hpp>

Public Static Attributes

static const MeshHandle INVALID

class ModelHandle : public ice_engine::handles::Handle<ModelHandle>: #include <ModelHandle.hpp>

class ModelInstanceHandle : public ResourceHandle

#include <ModelInstanceHandle.hpp>

Public Static Attributes

static const ModelInstanceHandle INVALID

struct MouseButtonEvent

#include <Event.hpp>

Public Members

uint32 type

uint8 button

uint8 state

uint8 clicks

uint8 padding3

int32 x

int32 y

struct MouseMotionEvent

#include <Event.hpp>

Public Members

uint32 type

uint32 state

uint8 padding1

uint8 padding2

uint8 padding3

int32 x

int32 y

int32 xrel

int32 yrel

struct MouseWheelEvent

#include <Event.hpp>

Public Members

uint32 type

int32 x

int32 y

uint32 direction

class PointLightHandle : public ice_engine::handles::Handle<PointLightHandle>: #include <PointLightHandle.hpp>

class RenderableHandle : public ice_engine::handles::Handle<RenderableHandle>: #include <RenderableHandle.hpp>

class RenderSceneHandle : public ice_engine::handles::Handle<RenderSceneHandle>: #include <RenderSceneHandle.hpp>

class ShaderHandle : public ice_engine::handles::Handle<ShaderHandle>: #include <ShaderHandle.hpp>

class ShaderProgramHandle : public ice_engine::handles::Handle<ShaderProgramHandle>: #include <ShaderProgramHandle.hpp>

class SkeletonHandle : public ice_engine::handles::Handle<SkeletonHandle>: #include <SkeletonHandle.hpp>

class SkyboxHandle : public ice_engine::handles::Handle<SkyboxHandle>: #include <SkyboxHandle.hpp>

class SkyboxRenderableHandle : public ice_engine::handles::Handle<SkyboxRenderableHandle>: #include <SkyboxRenderableHandle.hpp>

class TerrainHandle : public ice_engine::handles::Handle<TerrainHandle>: #include <TerrainHandle.hpp>

class TerrainRenderableHandle : public ice_engine::handles::Handle<TerrainRenderableHandle>: #include <TerrainRenderableHandle.hpp>

class TessellationControlShaderHandle : public ice_engine::handles::Handle<TessellationControlShaderHandle>: #include <TessellationControlShaderHandle.hpp>

class TessellationEvaluationShaderHandle : public ice_engine::handles::Handle<TessellationEvaluationShaderHandle>: #include <TessellationEvaluationShaderHandle.hpp>

struct TextInputEvent

#include <Event.hpp>

Public Members

uint32 type

uint32 timestamp

char text[TEXTINPUTEVENT_TEXT_SIZE]

class TextureHandle : public ice_engine::handles::Handle<TextureHandle>: #include <TextureHandle.hpp>

class VertexShaderHandle : public ice_engine::handles::Handle<VertexShaderHandle>: #include <VertexShaderHandle.hpp>

struct WindowEvent

#include <Event.hpp>

Public Members

uint32 type

uint32 timestamp

uint32 windowId

WindowEventType eventType

uint8 padding1

uint8 padding2

uint8 padding3

sint32 data1

sint32 data2

namespace gui

Enums

enum WindowFlags

Values:

enumerator ICEENGINE_TITLE_BAR

enumerator ICEENGINE_MOVABLE

enumerator ICEENGINE_NO_SCROLLBAR

enumerator ICEENGINE_CLOSABLE

enumerator ICEENGINE_MINIMIZABLE

enumerator ICEENGINE_RESIZABLE

enumerator ICEENGINE_MENUBAR

enumerator ICEENGINE_NO_INPUT

class IButton : public virtual ice_engine::graphics::gui::IComponent

#include <IButton.hpp>

Public Functions

virtual ~IButton() = default

virtual void setLabel(const std::string &label) = 0

virtual const std::string &label() const = 0

virtual void setCallback(std::function<void()> &callback) = 0

class IComboBox : public virtual ice_engine::graphics::gui::IComponent

#include <IComboBox.hpp>

Public Functions

virtual ~IComboBox() = default

virtual IComboBoxItem *createItem(const std::string &label) = 0

virtual IComboBoxItem *getItem(const std::string &label) const = 0

virtual void destroy(const IComboBoxItem *comboBoxItem) = 0

virtual void select(IComboBoxItem *comboBoxItem) = 0

virtual void unselect(const IComboBoxItem *comboBoxItem) = 0

virtual bool selected(const IComboBoxItem *comboBoxItem) const = 0

virtual void setCallback(std::function<void(IComboBoxItem*)> &callback) = 0

class IComboBoxItem

#include <IComboBoxItem.hpp>

Public Functions

virtual ~IComboBoxItem() = default

virtual void setLabel(const std::string &label) = 0

virtual const std::string &label() const = 0

class IComponent

#include <IComponent.hpp>

Public Functions

virtual ~IComponent() = default

virtual void render() = 0

virtual void tick(const float32 delta) = 0

virtual bool visible() const = 0

virtual void setVisible(const bool visible) = 0

virtual bool disabled() const = 0

virtual void setDisabled(const bool disabled) = 0

virtual void setStyle(const Style &style) = 0

virtual const Style &style() const = 0

virtual void setPosition(const uint32 x, const uint32 y) = 0

virtual glm::ivec2 position() const = 0

virtual void setDimensions(const uint32 with, const uint32 height) = 0

virtual glm::ivec2 dimensions() const = 0

virtual void addComponent(IComponent *component) = 0

virtual void removeComponent(IComponent *component) = 0

virtual void removeAllComponents() = 0

class IGenericComponentContainer

#include <IGenericComponentContainer.hpp>

Subclassed by ice_engine::graphics::gui::IPopupModal, ice_engine::graphics::gui::IWindow

Public Functions

virtual ~IGenericComponentContainer() = default

virtual ILabel *createLabel(const std::string label = std::string()) = 0

virtual ILabel *createLabel(const uint32 x, const uint32 y, const uint32 width, const uint32 height, const std::string label = std::string()) = 0

virtual IButton *createButton(const std::string label = std::string()) = 0

virtual IButton *createButton(const uint32 x, const uint32 y, const uint32 width, const uint32 height, const std::string label = std::string()) = 0

virtual ITextField *createTextField(const std::string text = std::string()) = 0

virtual ITextField *createTextField(const uint32 x, const uint32 y, const uint32 width, const uint32 height, const std::string text = std::string()) = 0

virtual ITextArea *createTextArea(const std::string text = std::string()) = 0

virtual ITextArea *createTextArea(const uint32 x, const uint32 y, const uint32 width, const uint32 height, const std::string text = std::string()) = 0

virtual ITreeView *createTreeView() = 0

virtual IComboBox *createComboBox() = 0

virtual void add(std::unique_ptr<IComponent> component) = 0

virtual void destroy(const ILabel *label) = 0

virtual void destroy(const IButton *button) = 0

virtual void destroy(const ITextField *textField) = 0

virtual void destroy(const ITextArea *textArea) = 0

virtual void destroy(const ITreeView *treeView) = 0

virtual void destroy(const IComboBox *comboBox) = 0

virtual std::unique_ptr<IComponent> remove(const IComponent *component) = 0

class IGui

#include <IGui.hpp>

Public Functions

virtual ~IGui() = default

virtual void setViewport(const uint32 width, const uint32 height) = 0

virtual void render() = 0

virtual void tick(const float32 delta) = 0

virtual bool visible() const = 0

virtual void setVisible(const bool visible) = 0

virtual void setStyle(const Style &style) = 0

virtual const Style &style() const = 0

virtual IWindow *createWindow(const uint32 x, const uint32 y, const uint32 width, const uint32 height, const std::string title = std::string()) = 0

virtual IWindow *createWindow(const uint32 x, const uint32 y, const uint32 width, const uint32 height, const uint32 flags, const std::string title = std::string()) = 0

virtual IMainMenuBar *createMainMenuBar() = 0

virtual void destroyMainMenuBar() = 0

virtual IPopupModal *createPopupModal(const std::string &title) = 0

virtual void destroy(const IWindow *window) = 0

virtual void destroy(const IPopupModal *popupModal) = 0

virtual bool processEvent(const graphics::WindowEvent &event) = 0

virtual bool processEvent(const graphics::KeyboardEvent &event) = 0

virtual bool processEvent(const graphics::TextInputEvent &event) = 0

virtual bool processEvent(const graphics::MouseButtonEvent &event) = 0

virtual bool processEvent(const graphics::MouseMotionEvent &event) = 0

virtual bool processEvent(const graphics::MouseWheelEvent &event) = 0

class IGuiFactory

#include <IGuiFactory.hpp>

Public Functions

virtual ~IGuiFactory() = default

virtual std::unique_ptr<IGui> create(utilities::Properties *properties, fs::IFileSystem *fileSystem, logger::ILogger *logger, IGraphicsEngine *graphicsEngine) = 0

class ILabel : public virtual ice_engine::graphics::gui::IComponent

#include <ILabel.hpp>

Public Functions

virtual ~ILabel() = default

virtual void setLabel(const std::string &label) = 0

virtual const std::string &label() const = 0

class IMainMenuBar : public virtual ice_engine::graphics::gui::IComponent

#include <IMainMenuBar.hpp>

Public Functions

virtual ~IMainMenuBar() = default

virtual IMenu *createMenu(const std::string &label) = 0

virtual IMenu *getMenu(const std::string &label) const = 0

class IMenu : public virtual ice_engine::graphics::gui::IComponent

#include <IMenu.hpp>

Public Functions

virtual ~IMenu() = default

virtual void setLabel(const std::string &label) = 0

virtual const std::string &label() const = 0

virtual IMenu *createMenu(const std::string &label) = 0

virtual IMenu *getMenu(const std::string &label) const = 0

virtual void createSeparator() = 0

virtual IMenuItem *createMenuItem(const std::string &label) = 0

class IMenuBar : public virtual ice_engine::graphics::gui::IComponent

#include <IMenuBar.hpp>

Public Functions

virtual ~IMenuBar() = default

virtual IMenu *createMenu(const std::string &label) = 0

virtual IMenu *getMenu(const std::string &label) const = 0

class IMenuItem : public virtual ice_engine::graphics::gui::IComponent

#include <IMenuItem.hpp>

Public Functions

virtual ~IMenuItem() = default

virtual void setLabel(const std::string &label) = 0

virtual const std::string &label() const = 0

virtual void setCallback(std::function<void()> &callback) = 0

virtual IMenuItem *createMenuItem(const std::string &label) = 0

class IPopupModal : public virtual ice_engine::graphics::gui::IGenericComponentContainer, public virtual ice_engine::graphics::gui::IComponent

#include <IPopupModal.hpp>

Public Functions

virtual ~IPopupModal() = default

virtual void close() = 0

class IRectangle : public virtual ice_engine::graphics::gui::IComponent

#include <IRectangle.hpp>

Public Functions

virtual ~IRectangle() = default

virtual void setPoints(const glm::vec2 &start, const glm::vec2 &end) = 0

virtual const glm::vec2 &startPoint() const = 0

virtual const glm::vec2 &endPoint() const = 0

virtual void setColor(const Color &color) = 0

virtual const Color &color() const = 0

class ITextArea : public virtual ice_engine::graphics::gui::IComponent

#include <ITextArea.hpp>

Public Functions

virtual ~ITextArea() = default

virtual const std::string &text() const = 0

virtual void setText(const std::string &text) = 0

virtual void setOnChangeCallback(std::function<void()> &onChangeCallback) = 0

class ITextField : public virtual ice_engine::graphics::gui::IComponent

#include <ITextField.hpp>

Public Functions

virtual ~ITextField() = default

virtual void setText(const std::string &text) = 0

virtual const std::string &text() const = 0

virtual void setOnChangeCallback(std::function<void()> &onChangeCallback) = 0

class ITreeNode : public virtual ice_engine::graphics::gui::IComponent

#include <ITreeNode.hpp>

Public Functions

virtual ~ITreeNode() = default

virtual ITreeNode *createNode(const std::string &label) = 0

virtual ITreeNode *getNode(const std::string &label) = 0

virtual void destroy(const ITreeNode *treeNode) = 0

virtual void setLabel(const std::string &label) = 0

virtual const std::string &label() const = 0

class ITreeView : public virtual ice_engine::graphics::gui::IComponent

#include <ITreeView.hpp>

Public Functions

virtual ~ITreeView() = default

virtual ITreeNode *createNode(const std::string &label) = 0

virtual ITreeNode *getNode(const std::string &label) = 0

virtual void destroy(const ITreeNode *treeNode) = 0

virtual void select(ITreeNode *treeNode) = 0

virtual void unselect(const ITreeNode *treeNode) = 0

virtual bool selected(const ITreeNode *treeNode) const = 0

virtual void setCallback(std::function<void(ITreeNode*)> &callback) = 0

class IWindow : public virtual ice_engine::graphics::gui::IComponent, public virtual ice_engine::graphics::gui::IGenericComponentContainer

#include <IWindow.hpp>

Public Functions

virtual ~IWindow() = default

virtual IMenuBar *createMenuBar() = 0

virtual IRectangle *createRectangle(const glm::vec2 &start, const glm::vec2 &end, const Color &color) = 0

virtual void destroy(const IRectangle *rectangle) = 0

virtual void setTitle(const std::string &title) = 0

virtual const std::string &title() const = 0

virtual void setBackgroundAlpha(const float32 alpha) = 0

struct Style

#include <Style.hpp>

Public Members

float32 alpha = 1.0f

namespace model

Functions

void animateSkeleton(std::vector<glm::mat4> &transformations, const glm::mat4 &globalInverseTransformation, const std::unordered_map<std::string, AnimatedBoneNode> &animatedBoneNodes, const BoneNode &rootBoneNode, const BoneData &boneData, const float64 duration, const float64 ticksPerSecond, const float32 runningTime, const uint32 startFrame = 0, const uint32 endFrame = 0)

void animateSkeleton(std::vector<glm::mat4> &transformations, const glm::mat4 &globalInverseTransformation, const std::unordered_map<std::string, AnimatedBoneNode> &animatedBoneNodes, const BoneNode &rootBoneNode, const BoneData &boneData, const float64 duration, const float64 ticksPerSecond, const float32 runningTime, std::vector<uint32> &indexCache, const uint32 startFrame = 0, const uint32 endFrame = 0)

struct AnimatedBoneNode

#include <AnimatedBoneNode.hpp>

Public Functions

inline AnimatedBoneNode()

inline AnimatedBoneNode(std::string name, std::vector<float64> positionTimes, std::vector<float64> rotationTimes, std::vector<float64> scalingTimes, std::vector<glm::vec3> positions, std::vector<glm::quat> rotations, std::vector<glm::vec3> scalings)

Public Members

std::string name

std::vector<float64> positionTimes

std::vector<float64> rotationTimes

std::vector<float64> scalingTimes

std::vector<glm::vec3> positions

std::vector<glm::quat> rotations

std::vector<glm::vec3> scalings

struct Animation

#include <Animation.hpp>

Public Functions

Animation() = default

inline Animation(std::string name, float64 duration, float64 ticksPerSecond, std::unordered_map<std::string, AnimatedBoneNode> animatedBoneNodes)

Public Members

std::string name

float64 duration

float64 ticksPerSecond

std::unordered_map<std::string, AnimatedBoneNode> animatedBoneNodes

struct AnimationSet

#include <AnimationSet.hpp>

Public Members

std::string name

BoneNode rootBoneNode

std::unordered_map<std::string, Animation> animations

glm::mat4 globalInverseTransformation = glm::mat4(1.0f)

struct Bone

#include <Bone.hpp>

Public Members

std::string name

glm::mat4 boneOffset = glm::mat4(1.0f)

struct BoneData

#include <BoneData.hpp>

Public Members

std::string name

std::unordered_map<std::string, uint32> boneIndexMap

std::vector<Bone> boneTransform

struct BoneNode

#include <BoneNode.hpp>

Public Members

std::string name

glm::mat4 transformation = glm::mat4(1.0f)

std::vector<BoneNode> children

struct Material

#include <Material.hpp>

Public Members

std::string name

glm::vec4 ambient

glm::vec4 diffuse

glm::vec4 specular

glm::vec4 emission

float32 shininess

float32 strength

struct Mesh

#include <Mesh.hpp>

Public Members

std::string name

std::vector<glm::vec3> vertices

std::vector<uint32> indices

std::vector<glm::vec4> colors

std::vector<glm::vec3> normals

std::vector<glm::vec2> textureCoordinates

std::vector<VertexBoneData> bones

struct Model

#include <Model.hpp>

Public Members

std::vector<Mesh> meshes

std::vector<Material> materials

std::vector<Texture> textures

std::vector<BoneData> boneData

std::vector<Animation> animations

BoneNode rootBoneNode

glm::mat4 globalInverseTransformation = glm::mat4(1.0f)

struct Texture

#include <Texture.hpp>

Public Functions

Texture() = default

inline Texture(const Texture &other)

Public Members

std::string filename

Image image

struct VertexBoneData

#include <VertexBoneData.hpp>

Public Functions

inline VertexBoneData()

inline void addBoneWeight(uint32 id, float32 weight)

Public Members

glm::ivec4 boneIds

glm::vec4 weights

namespace handles

Functions

template<typename H, typename = typename std::enable_if<std::is_base_of<BaseHandle, H>::value, H>::type> inline std::ostream &operator<<(std::ostream &os, const H &handle)

template<typename H, bool unused = false, typename = typename std::enable_if<std::is_base_of<BasePointerHandle, H>::value, H>::type> inline std::ostream &operator<<(std::ostream &os, const H &handle)

class BaseHandle: #include <Handle.hpp>
Subclassed by ice_engine::handles::Handle< AgentHandle >, ice_engine::handles::Handle< AnimationHandle >, ice_engine::handles::Handle< AudioSceneHandle >, ice_engine::handles::Handle< BonesHandle >, ice_engine::handles::Handle< CameraHandle >, ice_engine::handles::Handle< ClientHandle >, ice_engine::handles::Handle< CollisionShapeHandle >, ice_engine::handles::Handle< CrowdHandle >, ice_engine::handles::Handle< ExecutionContextHandle >, ice_engine::handles::Handle< FragmentShaderHandle >, ice_engine::handles::Handle< ListenerHandle >, ice_engine::handles::Handle< MaterialHandle >, ice_engine::handles::Handle< MeshHandle >, ice_engine::handles::Handle< ModelHandle >, ice_engine::handles::Handle< ModuleHandle >, ice_engine::handles::Handle< NavigationMeshHandle >, ice_engine::handles::Handle< ObstacleHandle >, ice_engine::handles::Handle< PathfindingSceneHandle >, ice_engine::handles::Handle< PhysicsSceneHandle >, ice_engine::handles::Handle< PointLightHandle >, ice_engine::handles::Handle< PolygonMeshHandle >, ice_engine::handles::Handle< RemoteConnectionHandle >, ice_engine::handles::Handle< RenderableHandle >, ice_engine::handles::Handle< RenderSceneHandle >, ice_engine::handles::Handle< ScriptHandle >, ice_engine::handles::Handle< ServerHandle >, ice_engine::handles::Handle< ShaderHandle >, ice_engine::handles::Handle< ShaderProgramHandle >, ice_engine::handles::Handle< SkeletonHandle >, ice_engine::handles::Handle< SkyboxHandle >, ice_engine::handles::Handle< SkyboxRenderableHandle >, ice_engine::handles::Handle< SoundHandle >, ice_engine::handles::Handle< SoundSourceHandle >, ice_engine::handles::Handle< TerrainHandle >, ice_engine::handles::Handle< TerrainRenderableHandle >, ice_engine::handles::Handle< TessellationControlShaderHandle >, ice_engine::handles::Handle< TessellationEvaluationShaderHandle >, ice_engine::handles::Handle< TextureHandle >, ice_engine::handles::Handle< VertexShaderHandle >, ice_engine::handles::Handle< T >

class BasePointerHandle: #include <PointerHandle.hpp>
Subclassed by ice_engine::handles::PointerHandle< T >, ice_engine::handles::PointerHandle< GhostObjectHandle >, ice_engine::handles::PointerHandle< RigidBodyObjectHandle >, ice_engine::handles::PointerHandle< ScriptFunctionHandle >, ice_engine::handles::PointerHandle< ScriptObjectFunctionHandle >, ice_engine::handles::PointerHandle< ScriptObjectHandle >

template<typename T> class Handle : private ice_engine::handles::BaseHandle

#include <Handle.hpp>

Subclassed by ice_engine::graphics::MeshHandle

Public Functions

Handle() = default

inline Handle(const Handle &other)

inline Handle(Handle &&other) noexcept

inline explicit Handle(uint64 id)

inline Handle(uint32 index, uint32 version)

inline uint64 id() const

inline uint32 index() const

inline uint32 version() const

inline void invalidate()

inline bool valid() const

inline explicit operator bool() const

Handle &operator=(const Handle &other) = default

Handle &operator=(Handle &&other) noexcept = default

inline bool operator==(const T &other) const

inline bool operator!=(const T &other) const

inline bool operator<(const T &other) const

inline bool operator>(const T &other) const

inline bool operator<=(const T &other) const

inline bool operator>=(const T &other) const

Public Static Attributes

static constexpr uint64 INVALID = 0

Friends

inline friend friend std::ostream & operator<< (std::ostream &os, const T &other)

template<typename T, typename HandleType> struct HandleData

#include <HandleVector.hpp>

Public Members

HandleType handle

T *pointer

template<typename T, typename HandleType> class HandleVector

#include <HandleVector.hpp>

Public Types

typedef HandleVectorIterator<T, HandleType> iterator

typedef HandleVectorConstIterator<T, HandleType> const_iterator

typedef ptrdiff_t difference_type

typedef size_t size_type

typedef T value_type

typedef T *pointer

typedef T &reference

Public Functions

HandleVector() = default

template<typename ...Args> inline HandleType create(Args&&... args)

inline void destroy(const HandleType &handle)

inline bool valid(const HandleType &handle) const

inline HandleType handle(const uint64 id) const

inline HandleType handle(const uint32 index) const

inline size_t size() const

inline void clear()

inline T *get(const HandleType &handle) const

inline T &operator[](const HandleType &handle) const

inline T &operator[](const uint32 index) const

inline iterator begin()

inline iterator end()

inline const_iterator begin() const

inline const_iterator end() const

inline const_iterator cbegin() const

inline const_iterator cend() const

Friends

friend class HandleVectorIterator< T, HandleType >

friend class HandleVectorConstIterator< T, HandleType >

template<typename T, typename HandleType> class HandleVectorConstIterator

#include <HandleVector.hpp>

Public Functions

inline HandleVectorConstIterator(const HandleVector<T, HandleType> &handleManager, size_t index)

inline bool operator==(HandleVectorConstIterator other) const

inline bool operator!=(HandleVectorConstIterator other) const

inline const T &operator*() const

inline const T *operator->() const

inline HandleVectorConstIterator<T, HandleType> &operator++()

inline HandleVectorConstIterator<T, HandleType> operator++(int)

inline HandleType handle() const

template<typename T, typename HandleType> class HandleVectorIterator

#include <HandleVector.hpp>

Public Functions

inline HandleVectorIterator(HandleVector<T, HandleType> &handleManager, size_t index)

inline HandleVectorIterator(const HandleVectorIterator &other)

inline HandleVectorIterator(HandleVectorIterator &&other)

inline bool operator==(HandleVectorIterator other) const

inline bool operator!=(HandleVectorIterator other) const

inline T &operator*() const

inline T *operator->() const

inline HandleVectorIterator<T, HandleType> &operator++()

inline HandleVectorIterator<T, HandleType> operator++(int)

inline HandleType handle() const

template<typename T> class PointerHandle : private ice_engine::handles::BasePointerHandle

#include <PointerHandle.hpp>

Public Functions

PointerHandle() = default

inline explicit PointerHandle(void *object)

inline PointerHandle(const PointerHandle &other)

inline PointerHandle(PointerHandle &&other) noexcept

inline void *get()

inline void *get() const

inline void invalidate()

inline bool valid() const

inline explicit operator bool() const

PointerHandle &operator=(const PointerHandle &other) = default

PointerHandle &operator=(PointerHandle &&other) noexcept = default

inline bool operator==(const T &other) const

inline bool operator!=(const T &other) const

template<typename T, typename HandleType> struct PointerHandleData

#include <PointerHandleVector.hpp>

Public Members

HandleType handle

T *pointer

template<typename T, typename HandleType> class PointerHandleVector

#include <PointerHandleVector.hpp>

Public Types

typedef PointerHandleVectorIterator<T, HandleType> iterator

typedef PointerHandleVectorConstIterator<T, HandleType> const_iterator

typedef ptrdiff_t difference_type

typedef size_t size_type

typedef T value_type

typedef T *pointer

typedef T &reference

Public Functions

PointerHandleVector() = default

template<typename ...Args> inline HandleType create(Args&&... args)

inline void destroy(const HandleType &handle)

inline bool valid(const HandleType &handle) const

inline HandleType handle(const uint32 index) const

inline size_t size() const

inline void clear()

inline T *get(const HandleType &handle) const

inline T &operator[](const HandleType &handle) const

inline T &operator[](const uint32 index) const

inline iterator begin()

inline iterator end()

inline const_iterator begin() const

inline const_iterator end() const

inline const_iterator cbegin() const

inline const_iterator cend() const

Friends

friend class PointerHandleVectorIterator< T, HandleType >

friend class PointerHandleVectorConstIterator< T, HandleType >

template<typename T, typename HandleType> class PointerHandleVectorConstIterator

#include <PointerHandleVector.hpp>

Public Functions

inline PointerHandleVectorConstIterator(const PointerHandleVector<T, HandleType> &handleManager, uint32 index)

inline bool operator==(PointerHandleVectorConstIterator other) const

inline bool operator!=(PointerHandleVectorConstIterator other) const

inline const T &operator*() const

inline const T *operator->() const

inline PointerHandleVectorConstIterator<T, HandleType> &operator++()

inline PointerHandleVectorConstIterator<T, HandleType> operator++(int)

inline HandleType handle() const

template<typename T, typename HandleType> class PointerHandleVectorIterator

#include <PointerHandleVector.hpp>

Public Functions

inline PointerHandleVectorIterator(PointerHandleVector<T, HandleType> &handleManager, uint32 index)

inline PointerHandleVectorIterator(const PointerHandleVectorIterator &other)

inline PointerHandleVectorIterator(PointerHandleVectorIterator &&other)

inline bool operator==(PointerHandleVectorIterator other) const

inline bool operator!=(PointerHandleVectorIterator other) const

inline T &operator*() const

inline T *operator->() const

inline PointerHandleVectorIterator<T, HandleType> &operator++()

inline PointerHandleVectorIterator<T, HandleType> operator++(int)

inline HandleType handle() const

namespace idebugrenderer

Functions

void pushLine(const glm::vec3 &from, const glm::vec3 &to, const glm::vec3 &color, IDebugRenderer *debugRenderer)

namespace logger

Functions

inline ILogger *globalLogger()

inline void setGlobalLogger(ILogger *globalLogger)

Variables

static ILogger *gLogger = nullptr

class ILogger

#include <ILogger.hpp>

Subclassed by ice_engine::logger::Logger

Public Functions

virtual ~ILogger() = default

virtual void info(const std::string &message) = 0

virtual void debug(const std::string &message) = 0

virtual void trace(const std::string &message) = 0

virtual void warn(const std::string &message) = 0

virtual void error(const std::string &message) = 0

virtual void fatal(const std::string &message) = 0

virtual void info(const std::wstring &message) = 0

virtual void debug(const std::wstring &message) = 0

virtual void trace(const std::wstring &message) = 0

virtual void warn(const std::wstring &message) = 0

virtual void error(const std::wstring &message) = 0

virtual void fatal(const std::wstring &message) = 0

class Logger : public ice_engine::logger::ILogger

#include <Logger.hpp>

Public Functions

Logger(const std::string &fileName = std::string(~~"ice_engine.log"~~))

Logger(const Logger &other)

Logger &operator=(const Logger &other)

virtual ~Logger()

virtual void info(const std::string &message) override

virtual void debug(const std::string &message) override

virtual void trace(const std::string &message) override

virtual void warn(const std::string &message) override

virtual void error(const std::string &message) override

virtual void fatal(const std::string &message) override

virtual void info(const std::wstring &message) override

virtual void debug(const std::wstring &message) override

virtual void trace(const std::wstring &message) override

virtual void warn(const std::wstring &message) override

virtual void error(const std::wstring &message) override

virtual void fatal(const std::wstring &message) override

namespace memory

template<typename T> class MemoryPool

#include <MemoryPool.hpp>

Public Functions

inline MemoryPool()

inline T *malloc()

inline void free(T *chunk)

inline bool isFrom(T *chunk) const

inline bool releaseMemory()

inline bool purgeMemory()

namespace model

Functions

std::unique_ptr<graphics::model::Model> load(const std::string &filename, logger::ILogger *logger, fs::IFileSystem *fileSystem)

std::unique_ptr<graphics::model::Model> import(const std::string &filename, logger::ILogger *logger, fs::IFileSystem *fileSystem)

void save(const std::string &filename, const graphics::model::Model &model, logger::ILogger *logger, fs::IFileSystem *fileSystem)

namespace networking

Enums

enum EventType

Values:

enumerator UNKNOWN

enumerator SERVERDISCONNECT

enumerator CLIENTDISCONNECT

enumerator SERVERCONNECT

enumerator SERVERCONNECTFAILED

enumerator CLIENTCONNECT

enumerator SERVERMESSAGE

enumerator CLIENTMESSAGE

class ClientHandle : public ice_engine::handles::Handle<ClientHandle>: #include <ClientHandle.hpp>

struct ConnectEvent : public ice_engine::networking::GenericEvent: #include <Event.hpp>

struct DisconnectEvent : public ice_engine::networking::GenericEvent: #include <Event.hpp>

struct GenericEvent

#include <Event.hpp>

Subclassed by ice_engine::networking::ConnectEvent, ice_engine::networking::DisconnectEvent, ice_engine::networking::MessageEvent

Public Members

uint32 type

uint32 timestamp

ServerHandle serverHandle

ClientHandle clientHandle

RemoteConnectionHandle remoteConnectionHandle

class IEventListener

#include <IEventListener.hpp>

Subclassed by ice_engine::GameEngine

Public Functions

inline virtual ~IEventListener()

virtual bool processEvent(const ConnectEvent &event) = 0

virtual bool processEvent(const DisconnectEvent &event) = 0

virtual bool processEvent(const MessageEvent &event) = 0

class INetworkingEngine

#include <INetworkingEngine.hpp>

Public Functions

inline virtual ~INetworkingEngine()

virtual ServerHandle createServer() = 0

virtual ClientHandle createClient() = 0

virtual void destroyServer(const ServerHandle &serverHandle) = 0

virtual void destroyClient(const ClientHandle &clientHandle) = 0

virtual void tick(const float32 delta) = 0

virtual void send(const ServerHandle &serverHandle, const std::vector<uint8> &data) = 0

virtual void send(const ServerHandle &serverHandle, const RemoteConnectionHandle &remoteConnectionHandle, const std::vector<uint8> &data) = 0

virtual void send(const ClientHandle &clientHandle, const std::vector<uint8> &data) = 0

virtual void processEvents() = 0

virtual void addEventListener(IEventListener *eventListener) = 0

virtual void removeEventListener(IEventListener *eventListener) = 0

class INetworkingEngineFactory

#include <INetworkingEngineFactory.hpp>

Public Functions

inline virtual ~INetworkingEngineFactory()

virtual std::unique_ptr<INetworkingEngine> create(utilities::Properties *properties, fs::IFileSystem *fileSystem, logger::ILogger *logger) = 0

struct MessageEvent : public ice_engine::networking::GenericEvent

#include <Event.hpp>

Public Members

std::vector<uint8> message

class RemoteConnectionHandle : public ice_engine::handles::Handle<RemoteConnectionHandle>: #include <RemoteConnectionHandle.hpp>

class ServerHandle : public ice_engine::handles::Handle<ServerHandle>: #include <ServerHandle.hpp>

namespace noise

class Noise

#include <Noise.hpp>

Public Functions

Noise() = default

inline Noise(const uint32 seed)

inline void setSeed(const uint32 seed)

inline uint32 getSeed() const

inline float32 getValue(const float32 x, const float32 y) const

namespace pathfinding

Enums

enum AgentState

Values:

enumerator INVALID

enumerator WALKING

enumerator OFFMESH

enum MovementRequestState

Values:

enumerator NONE

enumerator FAILED

enumerator VALID

enumerator REQUESTING

enumerator WAITING_FOR_QUEUE

enumerator WAITING_FOR_PATH

enumerator VELOCITY

enum UserDataType

Values:

enumerator TYPE_UNKNOWN

enumerator TYPE_BOOL

enumerator TYPE_INT8

enumerator TYPE_UINT8

enumerator TYPE_INT16

enumerator TYPE_UINT16

enumerator TYPE_INT32

enumerator TYPE_UINT32

enumerator TYPE_INT64

enumerator TYPE_UINT64

enumerator TYPE_FLOAT32

enumerator TYPE_FLOAT64

enumerator TYPE_OBJECT_REF

enumerator TYPE_OBJECT_VAL

Functions

inline std::ostream &operator<<(std::ostream &os, const AgentParams &data)

inline std::ostream &operator<<(std::ostream &os, const CrowdConfig &data)

inline std::ostream &operator<<(std::ostream &os, const NavigationMeshConfig &data)

inline std::ostream &operator<<(std::ostream &os, const PolygonMeshConfig &data)

class AgentHandle : public ice_engine::handles::Handle<AgentHandle>: #include <AgentHandle.hpp>

struct AgentParams

#include <AgentParams.hpp>

Public Members

float radius = 0.0f

float height = 0.1f: Agent height. [Limit: > 0].

float maxAcceleration = 0.0f

float maxSpeed = 0.0f

float collisionQueryRange = 0.1f: Defines how close a collision element must be before it is considered for steering behaviors. [Limits: > 0].

float pathOptimizationRange = 0.1f: The path visibility optimization range. [Limit: > 0].

float separationWeight = 0.0f

struct CrowdConfig

#include <CrowdConfig.hpp>

Public Members

int maxAgents = 1000

float maxAgentRadius = 0.6f

class CrowdHandle : public ice_engine::handles::Handle<CrowdHandle>: #include <CrowdHandle.hpp>

class IAgentMotionChangeListener

#include <IAgentMotionChangeListener.hpp>

Subclassed by ice_engine::IceEnginePathfindingAgentMotionChangeListener

Public Functions

inline virtual ~IAgentMotionChangeListener()

virtual void update(const glm::vec3 &position) = 0

class IAgentStateChangeListener

#include <IAgentStateChangeListener.hpp>

Subclassed by ice_engine::IceEnginePathfindingAgentStateChangeListener

Public Functions

inline virtual ~IAgentStateChangeListener()

virtual void update(const AgentState &agentState) = 0

class IImage

#include <IImage.hpp>

Public Types

enum Format

Values:

enumerator FORMAT_UNKNOWN

enumerator FORMAT_RGB

enumerator FORMAT_RGBA

Public Functions

inline virtual ~IImage()

virtual const std::vector<byte> &data() const = 0

virtual uint32 width() const = 0

virtual uint32 height() const = 0

virtual Format format() const = 0

class IMovementRequestStateChangeListener

#include <IMovementRequestStateChangeListener.hpp>

Subclassed by ice_engine::IceEnginePathfindingMovementRequestStateChangeListener

Public Functions

inline virtual ~IMovementRequestStateChangeListener()

virtual void update(const MovementRequestState &movementRequestState) = 0

class IPathfindingDebugRenderer

#include <IPathfindingDebugRenderer.hpp>

Subclassed by ice_engine::IDebugRenderer

Public Functions

virtual ~IPathfindingDebugRenderer() = default

virtual void pushLine(const glm::vec3 &from, const glm::vec3 &to, const glm::vec3 &color) = 0

virtual void pushLines(const std::vector<std::tuple<glm::vec3, glm::vec3, glm::vec3>> &lineData) = 0

class IPathfindingEngine

#include <IPathfindingEngine.hpp>

Public Functions

virtual ~IPathfindingEngine() = default

virtual void tick(const PathfindingSceneHandle &pathfindingSceneHandle, const float32 delta) = 0

virtual void renderDebug(const PathfindingSceneHandle &pathfindingSceneHandle) = 0

virtual PathfindingSceneHandle createPathfindingScene() = 0

virtual void destroyPathfindingScene(const PathfindingSceneHandle &pathfindingSceneHandle) = 0

virtual void setPathfindingDebugRenderer(IPathfindingDebugRenderer *pathfindingDebugRenderer) = 0

virtual void setDebugRendering(const PathfindingSceneHandle &pathfindingSceneHandle, const bool enabled) = 0

virtual PolygonMeshHandle createPolygonMesh(const ITerrain *terrain, const PolygonMeshConfig &polygonMeshConfig = PolygonMeshConfig()) = 0

virtual void destroy(const PolygonMeshHandle &polygonMeshHandle) = 0

virtual ObstacleHandle createObstacle(const PolygonMeshHandle &polygonMeshHandle, const glm::vec3 &position, const float32 radius, const float32 height) = 0

virtual void destroy(const PolygonMeshHandle &polygonMeshHandle, const ObstacleHandle &obstacleHandle) = 0

virtual NavigationMeshHandle createNavigationMesh(const PolygonMeshHandle &polygonMeshHandle, const NavigationMeshConfig &navigationMeshConfig = NavigationMeshConfig()) = 0

virtual void destroy(const NavigationMeshHandle &navigationMeshHandle) = 0

virtual CrowdHandle createCrowd(const PathfindingSceneHandle &pathfindingSceneHandle, const NavigationMeshHandle &navigationMeshHandle, const CrowdConfig &crowdConfig) = 0

virtual void destroy(const PathfindingSceneHandle &pathfindingSceneHandle, const CrowdHandle &crowdHandle) = 0

virtual AgentHandle createAgent(const PathfindingSceneHandle &pathfindingSceneHandle, const CrowdHandle &crowdHandle, const glm::vec3 &position, const AgentParams &agentParams = AgentParams(), std::unique_ptr<IAgentMotionChangeListener> agentMotionChangeListener = nullptr, std::unique_ptr<IAgentStateChangeListener> agentStateChangeListener = nullptr, std::unique_ptr<IMovementRequestStateChangeListener> movementRequestStateChangeListener = nullptr, const boost::any &userData = UserData()) = 0

virtual void destroy(const PathfindingSceneHandle &pathfindingSceneHandle, const CrowdHandle &crowdHandle, const AgentHandle &agentHandle) = 0

virtual void requestMoveTarget(const PathfindingSceneHandle &pathfindingSceneHandle, const CrowdHandle &crowdHandle, const AgentHandle &agentHandle, const glm::vec3 &position) = 0

virtual void resetMoveTarget(const PathfindingSceneHandle &pathfindingSceneHandle, const CrowdHandle &crowdHandle, const AgentHandle &agentHandle) = 0

virtual void requestMoveVelocity(const PathfindingSceneHandle &pathfindingSceneHandle, const CrowdHandle &crowdHandle, const AgentHandle &agentHandle, const glm::vec3 &velocity) = 0

virtual void setMotionChangeListener(const PathfindingSceneHandle &pathfindingSceneHandle, const CrowdHandle &crowdHandle, const AgentHandle &agentHandle, std::unique_ptr<IAgentMotionChangeListener> agentMotionChangeListener) = 0

virtual void setStateChangeListener(const PathfindingSceneHandle &pathfindingSceneHandle, const CrowdHandle &crowdHandle, const AgentHandle &agentHandle, std::unique_ptr<IAgentStateChangeListener> agentStateChangeListener) = 0

virtual void setMovementRequestChangeListener(const PathfindingSceneHandle &pathfindingSceneHandle, const CrowdHandle &crowdHandle, const AgentHandle &agentHandle, std::unique_ptr<IMovementRequestStateChangeListener> movementRequestStateChangeListener) = 0

virtual void setUserData(const PathfindingSceneHandle &pathfindingSceneHandle, const CrowdHandle &crowdHandle, const AgentHandle &agentHandle, const boost::any &userData) = 0

virtual boost::any &getUserData(const PathfindingSceneHandle &pathfindingSceneHandle, const CrowdHandle &crowdHandle, const AgentHandle &agentHandle) const = 0

class IPathfindingEngineFactory

#include <IPathfindingEngineFactory.hpp>

Public Functions

inline virtual ~IPathfindingEngineFactory()

virtual std::unique_ptr<IPathfindingEngine> create(utilities::Properties *properties, fs::IFileSystem *fileSystem, logger::ILogger *logger) = 0

class ITerrain

#include <ITerrain.hpp>

Subclassed by ice_engine::PathfindingTerrain

Public Functions

virtual ~ITerrain() = default

virtual const std::vector<glm::vec3> &vertices() const = 0

virtual const std::vector<uint32> &indices() const = 0

struct NavigationMeshConfig

#include <NavigationMeshConfig.hpp>

Public Members

float walkableHeight = 0.0f

float walkableRadius = 0.0f

float walkableClimb = 0.0f

class NavigationMeshHandle : public ice_engine::handles::Handle<NavigationMeshHandle>: #include <NavigationMeshHandle.hpp>

class ObstacleHandle : public ice_engine::handles::Handle<ObstacleHandle>: #include <ObstacleHandle.hpp>

class PathfindingSceneHandle : public ice_engine::handles::Handle<PathfindingSceneHandle>: #include <PathfindingSceneHandle.hpp>

struct PolygonMeshConfig

#include <PolygonMeshConfig.hpp>

Public Members

int width = 0

int height = 0

int tileSize = 48

int borderSize = 0

float cellSize = 1.0f

float cellHeight = 1.0f

float walkableSlopeAngle = 0.0f

int walkableHeight = 0

int walkableClimb = 0

int walkableRadius = 0

int maxEdgeLength = 0

float maxSimplificationError = 0.0f

int minRegionArea = 0

int mergeRegionArea = 0

int maxVertsPerPoly = 3

float detailSampleDist = 0.0f

float detailSampleMaxError = 0.0f

int maxObstacles = 128

class PolygonMeshHandle : public ice_engine::handles::Handle<PolygonMeshHandle>: #include <PolygonMeshHandle.hpp>

class UserData

#include <UserData.hpp>

TODO: Make sure we destroy any copied objects if we set a new value for this parameter.

Public Functions

inline UserData()

inline UserData(const UserData &other)

copy this parameter.

Note that if the other UserData has an object copied by value, the copy constructor will make another copy of that object by allocating new memory and copying the contents of that object.

When this newly created parameter is destroyed, it will call the destructor on that copied object.

inline virtual ~UserData(): If the parameter holds a copy of an object, the destructor for that object will be called.

template<typename T> inline void valueRef(T &value): Set the parameter by reference.

template<typename T> inline void value(T value)

Set the parameter by value. This will make a copy of the passed in value using that values copy constructor.

Note that when the parameter object is destroyed, it will call the destructor on the copied object.

It is highly recommended that you use relatively simple values.

template<typename T> inline T &valueRef()

template<typename T> inline T value()

inline void *pointer() const

inline UserDataType type() const

template<> inline void valueRef(bool &value)

template<> inline void value(bool value)

template<> inline void valueRef(uint8 &value)

template<> inline void value(uint8 value)

template<> inline void valueRef(int8 &value)

template<> inline void value(int8 value)

template<> inline void valueRef(uint16 &value)

template<> inline void value(uint16 value)

template<> inline void valueRef(int16 &value)

template<> inline void value(int16 value)

template<> inline void valueRef(uint32 &value)

template<> inline void value(uint32 value)

template<> inline void valueRef(int32 &value)

template<> inline void value(int32 value)

template<> inline void valueRef(uint64 &value)

template<> inline void value(uint64 value)

template<> inline void valueRef(int64 &value)

template<> inline void value(int64 value)

template<> inline void value(float32 value)

template<> inline void valueRef(float32 &value)

template<> inline void value(float64 value)

template<> inline void valueRef(float64 &value)

template<> inline bool value()

template<> inline bool &valueRef()

template<> inline uint8 value()

template<> inline uint8 &valueRef()

template<> inline int8 value()

template<> inline int8 &valueRef()

template<> inline uint16 value()

template<> inline uint16 &valueRef()

template<> inline int16 value()

template<> inline uint32 value()

template<> inline uint32 &valueRef()

template<> inline int32 value()

template<> inline int32 &valueRef()

template<> inline uint64 value()

template<> inline int64 &valueRef()

template<> inline int64 value()

template<> inline float32 value()

template<> inline float32 &valueRef()

template<> inline float64 value()

template<> inline float64 &valueRef()

union Value

#include <UserData.hpp>

Public Members

bool valueBoolean

uint8 valueUint8

int8 valueInt8

uint16 valueUint16

int16 valueInt16

uint32 valueUint32

int32 valueInt32

uint64 valueUint64

int64 valueInt64

float32 valueFloat32

float64 valueFloat64

void *valuePointer

namespace physics

Enums

enum UserDataType

Values:

enumerator TYPE_UNKNOWN

enumerator TYPE_BOOL

enumerator TYPE_INT8

enumerator TYPE_UINT8

enumerator TYPE_INT16

enumerator TYPE_UINT16

enumerator TYPE_INT32

enumerator TYPE_UINT32

enumerator TYPE_INT64

enumerator TYPE_UINT64

enumerator TYPE_FLOAT32

enumerator TYPE_FLOAT64

enumerator TYPE_OBJECT_REF

enumerator TYPE_OBJECT_VAL

class CollisionShapeHandle : public ice_engine::handles::Handle<CollisionShapeHandle>: #include <CollisionShapeHandle.hpp>

class GhostObjectHandle : public ice_engine::handles::PointerHandle<GhostObjectHandle>

#include <GhostObjectHandle.hpp>

Public Static Attributes

static const GhostObjectHandle INVALID

class IHeightfield

#include <IHeightfield.hpp>

Subclassed by ice_engine::Heightfield

Public Functions

virtual ~IHeightfield() = default

virtual const std::vector<byte> &data() const = 0

virtual uint32 width() const = 0

virtual uint32 length() const = 0

virtual uint32 height() const = 0

class IImage

#include <IImage.hpp>

Subclassed by ice_engine::IImage

Public Types

enum Format

Values:

enumerator FORMAT_UNKNOWN

enumerator FORMAT_RGB

enumerator FORMAT_RGBA

Public Functions

inline virtual ~IImage()

virtual const std::vector<byte> &data() const = 0

virtual uint32 width() const = 0

virtual uint32 height() const = 0

virtual int32 format() const = 0

class IMotionChangeListener

#include <IMotionChangeListener.hpp>

Subclassed by ice_engine::IceEngineMotionChangeListener

Public Functions

inline virtual ~IMotionChangeListener()

virtual void update(const glm::vec3 &position, const glm::quat &orientation) = 0

class IPhysicsDebugRenderer

#include <IPhysicsDebugRenderer.hpp>

Subclassed by ice_engine::IDebugRenderer

Public Functions

virtual ~IPhysicsDebugRenderer() = default

virtual void pushLine(const glm::vec3 &from, const glm::vec3 &to, const glm::vec3 &color) = 0

virtual void pushLines(const std::vector<std::tuple<glm::vec3, glm::vec3, glm::vec3>> &lineData) = 0

class IPhysicsEngine

#include <IPhysicsEngine.hpp>

Public Functions

virtual ~IPhysicsEngine() = default

virtual void tick(const PhysicsSceneHandle &physicsSceneHandle, const float32 delta) = 0

virtual void renderDebug(const PhysicsSceneHandle &physicsSceneHandle) = 0

virtual PhysicsSceneHandle createPhysicsScene() = 0

virtual void destroy(const PhysicsSceneHandle &physicsSceneHandle) = 0

virtual void setGravity(const PhysicsSceneHandle &physicsSceneHandle, const glm::vec3 &gravity) = 0

virtual void setPhysicsDebugRenderer(IPhysicsDebugRenderer *physicsDebugRenderer) = 0

virtual void setDebugRendering(const PhysicsSceneHandle &physicsSceneHandle, const bool enabled) = 0

virtual CollisionShapeHandle createStaticPlaneShape(const glm::vec3 &planeNormal, const float32 planeConstant) = 0

virtual CollisionShapeHandle createStaticBoxShape(const glm::vec3 &dimensions) = 0

virtual CollisionShapeHandle createStaticSphereShape(const float32 radius) = 0

virtual CollisionShapeHandle createStaticTerrainShape(const IHeightfield &heightfield) = 0

virtual void destroy(const CollisionShapeHandle &collisionShapeHandle) = 0

virtual void destroyAllStaticShapes() = 0

virtual RigidBodyObjectHandle createRigidBodyObject(const PhysicsSceneHandle &physicsSceneHandle, const CollisionShapeHandle &collisionShapeHandle, std::unique_ptr<IMotionChangeListener> motionStateListener = nullptr, const boost::any &userData = boost::any()) = 0

virtual RigidBodyObjectHandle createRigidBodyObject(const PhysicsSceneHandle &physicsSceneHandle, const CollisionShapeHandle &collisionShapeHandle, const float32 mass, const float32 friction, const float32 restitution, std::unique_ptr<IMotionChangeListener> motionStateListener = nullptr, const boost::any &userData = boost::any()) = 0

virtual RigidBodyObjectHandle createRigidBodyObject(const PhysicsSceneHandle &physicsSceneHandle, const CollisionShapeHandle &collisionShapeHandle, const glm::vec3 &position, const glm::quat &orientation, const float32 mass = 1.0f, const float32 friction = 1.0f, const float32 restitution = 1.0f, std::unique_ptr<IMotionChangeListener> motionStateListener = nullptr, const boost::any &userData = boost::any()) = 0

virtual GhostObjectHandle createGhostObject(const PhysicsSceneHandle &physicsSceneHandle, const CollisionShapeHandle &collisionShapeHandle, const boost::any &userData = boost::any()) = 0

virtual GhostObjectHandle createGhostObject(const PhysicsSceneHandle &physicsSceneHandle, const CollisionShapeHandle &collisionShapeHandle, const glm::vec3 &position, const glm::quat &orientation, const boost::any &userData = boost::any()) = 0

virtual void destroy(const PhysicsSceneHandle &physicsSceneHandle, const RigidBodyObjectHandle &rigidBodyObjectHandle) = 0

virtual void destroy(const PhysicsSceneHandle &physicsSceneHandle, const GhostObjectHandle &ghostObjectHandle) = 0

virtual void destroyAllRigidBodies() = 0

virtual void setUserData(const PhysicsSceneHandle &physicsSceneHandle, const RigidBodyObjectHandle &rigidBodyObjectHandle, const boost::any &userData) = 0

virtual void setUserData(const PhysicsSceneHandle &physicsSceneHandle, const GhostObjectHandle &ghostObjectHandle, const boost::any &userData) = 0

virtual boost::any &getUserData(const PhysicsSceneHandle &physicsSceneHandle, const RigidBodyObjectHandle &rigidBodyObjectHandle) const = 0

virtual boost::any &getUserData(const PhysicsSceneHandle &physicsSceneHandle, const GhostObjectHandle &ghostObjectHandle) const = 0

virtual Raycast raycast(const PhysicsSceneHandle &physicsSceneHandle, const ray::Ray &ray) = 0

virtual std::vector<boost::variant<RigidBodyObjectHandle, GhostObjectHandle>> query(const PhysicsSceneHandle &physicsSceneHandle, const glm::vec3 &origin, const std::vector<glm::vec3> &points) = 0

virtual std::vector<boost::variant<RigidBodyObjectHandle, GhostObjectHandle>> query(const PhysicsSceneHandle &physicsSceneHandle, const glm::vec3 &origin, const float32 radius) = 0

virtual void setMotionChangeListener(const PhysicsSceneHandle &physicsSceneHandle, const RigidBodyObjectHandle &rigidBodyObjectHandle, std::unique_ptr<IMotionChangeListener> motionStateListener) = 0

virtual void rotation(const PhysicsSceneHandle &physicsSceneHandle, const RigidBodyObjectHandle &rigidBodyObjectHandle, const glm::quat &orientation) = 0

virtual glm::quat rotation(const PhysicsSceneHandle &physicsSceneHandle, const RigidBodyObjectHandle &rigidBodyObjectHandle) const = 0

virtual void rotation(const PhysicsSceneHandle &physicsSceneHandle, const GhostObjectHandle &ghostObjectHandle, const glm::quat &orientation) = 0

virtual glm::quat rotation(const PhysicsSceneHandle &physicsSceneHandle, const GhostObjectHandle &ghostObjectHandle) const = 0

virtual void position(const PhysicsSceneHandle &physicsSceneHandle, const RigidBodyObjectHandle &rigidBodyObjectHandle, const float32 x, const float32 y, const float32 z) = 0

virtual void position(const PhysicsSceneHandle &physicsSceneHandle, const RigidBodyObjectHandle &rigidBodyObjectHandle, const glm::vec3 &position) = 0

virtual glm::vec3 position(const PhysicsSceneHandle &physicsSceneHandle, const RigidBodyObjectHandle &rigidBodyObjectHandle) const = 0

virtual void position(const PhysicsSceneHandle &physicsSceneHandle, const GhostObjectHandle &ghostObjectHandle, const float32 x, const float32 y, const float32 z) = 0

virtual void position(const PhysicsSceneHandle &physicsSceneHandle, const GhostObjectHandle &ghostObjectHandle, const glm::vec3 &position) = 0

virtual glm::vec3 position(const PhysicsSceneHandle &physicsSceneHandle, const GhostObjectHandle &ghostObjectHandle) const = 0

virtual void mass(const PhysicsSceneHandle &physicsSceneHandle, const RigidBodyObjectHandle &rigidBodyObjectHandle, const float32 mass) = 0

virtual float32 mass(const PhysicsSceneHandle &physicsSceneHandle, const RigidBodyObjectHandle &rigidBodyObjectHandle) const = 0: Note: This value must be calculated, so it may not be exactly what you set originally.

virtual void friction(const PhysicsSceneHandle &physicsSceneHandle, const RigidBodyObjectHandle &rigidBodyObjectHandle, const float32 friction) = 0

virtual float32 friction(const PhysicsSceneHandle &physicsSceneHandle, const RigidBodyObjectHandle &rigidBodyObjectHandle) const = 0

virtual void restitution(const PhysicsSceneHandle &physicsSceneHandle, const RigidBodyObjectHandle &rigidBodyObjectHandle, const float32 restitution) = 0

virtual float32 restitution(const PhysicsSceneHandle &physicsSceneHandle, const RigidBodyObjectHandle &rigidBodyObjectHandle) const = 0

class IPhysicsEngineFactory

#include <IPhysicsEngineFactory.hpp>

Public Functions

inline virtual ~IPhysicsEngineFactory()

virtual std::unique_ptr<IPhysicsEngine> create(utilities::Properties *properties, fs::IFileSystem *fileSystem, logger::ILogger *logger) = 0

class PhysicsSceneHandle : public ice_engine::handles::Handle<PhysicsSceneHandle>: #include <PhysicsSceneHandle.hpp>

class Raycast

#include <Raycast.hpp>

Public Functions

Raycast() = default

inline Raycast(const ray::Ray &ray)

inline const ray::Ray &ray() const

inline void setRay(const ray::Ray &ray)

inline const glm::vec3 &hitPointWorld() const

inline void setHitPointWorld(const glm::vec3 &hitPointWorld)

inline const glm::vec3 &hitNormalWorld() const

inline void setHitNormalWorld(const glm::vec3 &hitNormalWorld)

inline const RigidBodyObjectHandle &rigidBodyObjectHandle() const

inline void setRigidBodyObjectHandle(const RigidBodyObjectHandle &rigidBodyObjectHandle)

inline const GhostObjectHandle &ghostObjectHandle() const

inline void setGhostObjectHandle(const GhostObjectHandle &ghostObjectHandle)

class RigidBodyObjectHandle : public ice_engine::handles::PointerHandle<RigidBodyObjectHandle>

#include <RigidBodyObjectHandle.hpp>

Public Static Attributes

static const RigidBodyObjectHandle INVALID

class UserData

#include <UserData.hpp>

TODO: Make sure we destroy any copied objects if we set a new value for this parameter.

Public Functions

inline UserData()

inline UserData(const UserData &other)

copy this parameter.

Note that if the other UserData has an object copied by value, the copy constructor will make another copy of that object by allocating new memory and copying the contents of that object.

When this newly created parameter is destroyed, it will call the destructor on that copied object.

inline UserData(UserData &&other)

inline ~UserData(): If the parameter holds a copy of an object, the destructor for that object will be called.

inline UserData &operator=(const UserData &other)

template<typename T> inline void valueRef(T &value): Set the parameter by reference.

template<typename T> inline void value(T value)

Set the parameter by value. This will make a copy of the passed in value using that values copy constructor.

Note that when the parameter object is destroyed, it will call the destructor on the copied object.

It is highly recommended that you use relatively simple values.

template<typename T> inline T &valueRef()

template<typename T> inline T value()

inline void *pointer() const

inline UserDataType type() const

template<> inline void valueRef(bool &value)

template<> inline void value(bool value)

template<> inline void valueRef(uint8 &value)

template<> inline void value(uint8 value)

template<> inline void valueRef(int8 &value)

template<> inline void value(int8 value)

template<> inline void valueRef(uint16 &value)

template<> inline void value(uint16 value)

template<> inline void valueRef(int16 &value)

template<> inline void value(int16 value)

template<> inline void valueRef(uint32 &value)

template<> inline void value(uint32 value)

template<> inline void valueRef(int32 &value)

template<> inline void value(int32 value)

template<> inline void valueRef(uint64 &value)

template<> inline void value(uint64 value)

template<> inline void valueRef(int64 &value)

template<> inline void value(int64 value)

template<> inline void value(float32 value)

template<> inline void valueRef(float32 &value)

template<> inline void value(float64 value)

template<> inline void valueRef(float64 &value)

template<> inline bool value()

template<> inline bool &valueRef()

template<> inline uint8 value()

template<> inline uint8 &valueRef()

template<> inline int8 value()

template<> inline int8 &valueRef()

template<> inline uint16 value()

template<> inline uint16 &valueRef()

template<> inline int16 value()

template<> inline uint32 value()

template<> inline uint32 &valueRef()

template<> inline int32 value()

template<> inline int32 &valueRef()

template<> inline uint64 value()

template<> inline int64 &valueRef()

template<> inline int64 value()

template<> inline float32 value()

template<> inline float32 &valueRef()

template<> inline float64 value()

template<> inline float64 &valueRef()

union Value

#include <UserData.hpp>

Public Members

bool valueBoolean

uint8 valueUint8

int8 valueInt8

uint16 valueUint16

int16 valueInt16

uint32 valueUint32

int32 valueInt32

uint64 valueUint64

int64 valueInt64

float32 valueFloat32

float64 valueFloat64

void *valuePointer

namespace ray

struct Ray

#include <Ray.hpp>

Public Functions

Ray() = default

inline Ray(const glm::vec3 &from, const glm::vec3 &to)

Public Members

glm::vec3 from

glm::vec3 to

namespace raybinding

Functions

void InitConstructor(const glm::vec3 &from, const glm::vec3 &to, void *memory)

namespace scripting

Enums

enum DebugAction

Values:

enumerator CONTINUE

enumerator STEP_INTO

enumerator STEP_OVER

enumerator STEP_OUT

enum EventType

Values:

enumerator UNKNOWN

enumerator HIT_BREAKPOINT

enumerator DONE

enum ParameterType

Values:

enumerator TYPE_UNKNOWN

enumerator TYPE_BOOL

enumerator TYPE_INT8

enumerator TYPE_UINT8

enumerator TYPE_INT16

enumerator TYPE_UINT16

enumerator TYPE_INT32

enumerator TYPE_UINT32

enumerator TYPE_INT64

enumerator TYPE_UINT64

enumerator TYPE_FLOAT32

enumerator TYPE_FLOAT64

enumerator TYPE_OBJECT_REF

enumerator TYPE_OBJECT_VAL

struct DebugEvent

#include <IScriptingEngineDebugger.hpp>

Public Members

uint32 type

class ExecutionContextHandle : public ice_engine::handles::Handle<ExecutionContextHandle>: #include <ExecutionContextHandle.hpp>

class IDebugEventListener

#include <IScriptingEngineDebugger.hpp>

Subclassed by ice_engine::GameEngine

Public Functions

virtual ~IDebugEventListener() = default

virtual void processEvent(const DebugEvent &event) = 0

class IScriptingEngine

#include <IScriptingEngine.hpp>

Subclassed by ice_engine::scripting::angel_script::ScriptingEngine

Public Functions

virtual ~IScriptingEngine() = default

virtual void run(const std::string &filename, const std::string &function, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void run(const std::string &filename, const std::string &function, ParameterList &arguments, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void run(const std::string &filename, const std::string &function, ParameterList &arguments, std::function<void(void*)> returnObjectParser, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void run(const std::string &filename, const std::string &function, ParameterList &arguments, float32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void run(const std::string &filename, const std::string &function, ParameterList &arguments, float64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void run(const std::string &filename, const std::string &function, ParameterList &arguments, int8 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void run(const std::string &filename, const std::string &function, ParameterList &arguments, uint8 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void run(const std::string &filename, const std::string &function, ParameterList &arguments, int16 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void run(const std::string &filename, const std::string &function, ParameterList &arguments, uint16 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void run(const std::string &filename, const std::string &function, ParameterList &arguments, int32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void run(const std::string &filename, const std::string &function, ParameterList &arguments, uint32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void run(const std::string &filename, const std::string &function, ParameterList &arguments, int64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void run(const std::string &filename, const std::string &function, ParameterList &arguments, uint64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const std::string &scriptData, const std::string &function, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const std::string &scriptData, const std::string &function, std::function<void(void*)> returnObjectParser, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const std::string &scriptData, const std::string &function, float32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const std::string &scriptData, const std::string &function, float64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const std::string &scriptData, const std::string &function, int8 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const std::string &scriptData, const std::string &function, uint8 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const std::string &scriptData, const std::string &function, int16 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const std::string &scriptData, const std::string &function, uint16 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const std::string &scriptData, const std::string &function, int32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const std::string &scriptData, const std::string &function, uint32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const std::string &scriptData, const std::string &function, int64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const std::string &scriptData, const std::string &function, uint64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const std::string &scriptData, const std::string &function, ParameterList &arguments, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const std::string &scriptData, const std::string &function, ParameterList &arguments, std::function<void(void*)> returnObjectParser, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const std::string &scriptData, const std::string &function, ParameterList &arguments, float32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const std::string &scriptData, const std::string &function, ParameterList &arguments, float64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const std::string &scriptData, const std::string &function, ParameterList &arguments, int8 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const std::string &scriptData, const std::string &function, ParameterList &arguments, uint8 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const std::string &scriptData, const std::string &function, ParameterList &arguments, int16 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const std::string &scriptData, const std::string &function, ParameterList &arguments, uint16 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const std::string &scriptData, const std::string &function, ParameterList &arguments, int32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const std::string &scriptData, const std::string &function, ParameterList &arguments, uint32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const std::string &scriptData, const std::string &function, ParameterList &arguments, int64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const std::string &scriptData, const std::string &function, ParameterList &arguments, uint64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptFunctionHandle &scriptFunctionHandle, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptFunctionHandle &scriptFunctionHandle, std::function<void(void*)> returnObjectParser, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptFunctionHandle &scriptFunctionHandle, float32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptFunctionHandle &scriptFunctionHandle, float64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptFunctionHandle &scriptFunctionHandle, int8 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptFunctionHandle &scriptFunctionHandle, uint8 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptFunctionHandle &scriptFunctionHandle, int16 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptFunctionHandle &scriptFunctionHandle, uint16 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptFunctionHandle &scriptFunctionHandle, int32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptFunctionHandle &scriptFunctionHandle, uint32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptFunctionHandle &scriptFunctionHandle, int64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptFunctionHandle &scriptFunctionHandle, uint64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptFunctionHandle &scriptFunctionHandle, ParameterList &arguments, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptFunctionHandle &scriptFunctionHandle, ParameterList &arguments, std::function<void(void*)> returnObjectParser, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptFunctionHandle &scriptFunctionHandle, ParameterList &arguments, float32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptFunctionHandle &scriptFunctionHandle, ParameterList &arguments, float64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptFunctionHandle &scriptFunctionHandle, ParameterList &arguments, int8 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptFunctionHandle &scriptFunctionHandle, ParameterList &arguments, uint8 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptFunctionHandle &scriptFunctionHandle, ParameterList &arguments, int16 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptFunctionHandle &scriptFunctionHandle, ParameterList &arguments, uint16 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptFunctionHandle &scriptFunctionHandle, ParameterList &arguments, int32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptFunctionHandle &scriptFunctionHandle, ParameterList &arguments, uint32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptFunctionHandle &scriptFunctionHandle, ParameterList &arguments, int64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptFunctionHandle &scriptFunctionHandle, ParameterList &arguments, uint64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ModuleHandle &moduleHandle, const std::string &function, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ModuleHandle &moduleHandle, const std::string &function, std::function<void(void*)> returnObjectParser, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ModuleHandle &moduleHandle, const std::string &function, float32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ModuleHandle &moduleHandle, const std::string &function, float64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ModuleHandle &moduleHandle, const std::string &function, int8 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ModuleHandle &moduleHandle, const std::string &function, uint8 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ModuleHandle &moduleHandle, const std::string &function, int16 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ModuleHandle &moduleHandle, const std::string &function, uint16 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ModuleHandle &moduleHandle, const std::string &function, int32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ModuleHandle &moduleHandle, const std::string &function, uint32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ModuleHandle &moduleHandle, const std::string &function, int64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ModuleHandle &moduleHandle, const std::string &function, uint64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ModuleHandle &moduleHandle, const std::string &function, ParameterList &arguments, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ModuleHandle &moduleHandle, const std::string &function, ParameterList &arguments, std::function<void(void*)> returnObjectParser, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ModuleHandle &moduleHandle, const std::string &function, ParameterList &arguments, float32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ModuleHandle &moduleHandle, const std::string &function, ParameterList &arguments, float64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ModuleHandle &moduleHandle, const std::string &function, ParameterList &arguments, int8 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ModuleHandle &moduleHandle, const std::string &function, ParameterList &arguments, uint8 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ModuleHandle &moduleHandle, const std::string &function, ParameterList &arguments, int16 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ModuleHandle &moduleHandle, const std::string &function, ParameterList &arguments, uint16 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ModuleHandle &moduleHandle, const std::string &function, ParameterList &arguments, int32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ModuleHandle &moduleHandle, const std::string &function, ParameterList &arguments, uint32 &returnaszValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ModuleHandle &moduleHandle, const std::string &function, ParameterList &arguments, int64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ModuleHandle &moduleHandle, const std::string &function, ParameterList &arguments, uint64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const std::string &function, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const std::string &function, std::function<void(void*)> returnObjectParser, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const std::string &function, float32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const std::string &function, float64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const std::string &function, int8 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const std::string &function, uint8 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const std::string &function, int16 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const std::string &function, uint16 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const std::string &function, int32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const std::string &function, uint32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const std::string &function, int64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const std::string &function, uint64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const std::string &function, ParameterList &arguments, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const std::string &function, ParameterList &arguments, std::function<void(void*)> returnObjectParser, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const std::string &function, ParameterList &arguments, float32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const std::string &function, ParameterList &arguments, float64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const std::string &function, ParameterList &arguments, int8 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const std::string &function, ParameterList &arguments, uint8 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const std::string &function, ParameterList &arguments, int16 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const std::string &function, ParameterList &arguments, uint16 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const std::string &function, ParameterList &arguments, int32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const std::string &function, ParameterList &arguments, uint32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const std::string &function, ParameterList &arguments, int64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const std::string &function, ParameterList &arguments, uint64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const ScriptObjectFunctionHandle &scriptObjectFunctionHandle, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const ScriptObjectFunctionHandle &scriptObjectFunctionHandle, std::function<void(void*)> returnObjectParser, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const ScriptObjectFunctionHandle &scriptObjectFunctionHandle, float32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const ScriptObjectFunctionHandle &scriptObjectFunctionHandle, float64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const ScriptObjectFunctionHandle &scriptObjectFunctionHandle, int8 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const ScriptObjectFunctionHandle &scriptObjectFunctionHandle, uint8 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const ScriptObjectFunctionHandle &scriptObjectFunctionHandle, int16 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const ScriptObjectFunctionHandle &scriptObjectFunctionHandle, uint16 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const ScriptObjectFunctionHandle &scriptObjectFunctionHandle, int32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const ScriptObjectFunctionHandle &scriptObjectFunctionHandle, uint32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const ScriptObjectFunctionHandle &scriptObjectFunctionHandle, int64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const ScriptObjectFunctionHandle &scriptObjectFunctionHandle, uint64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const ScriptObjectFunctionHandle &scriptObjectFunctionHandle, ParameterList &arguments, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const ScriptObjectFunctionHandle &scriptObjectFunctionHandle, ParameterList &arguments, std::function<void(void*)> returnObjectParser, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const ScriptObjectFunctionHandle &scriptObjectFunctionHandle, ParameterList &arguments, float32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const ScriptObjectFunctionHandle &scriptObjectFunctionHandle, ParameterList &arguments, float64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const ScriptObjectFunctionHandle &scriptObjectFunctionHandle, ParameterList &arguments, int8 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const ScriptObjectFunctionHandle &scriptObjectFunctionHandle, ParameterList &arguments, uint8 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const ScriptObjectFunctionHandle &scriptObjectFunctionHandle, ParameterList &arguments, int16 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const ScriptObjectFunctionHandle &scriptObjectFunctionHandle, ParameterList &arguments, uint16 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const ScriptObjectFunctionHandle &scriptObjectFunctionHandle, ParameterList &arguments, int32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const ScriptObjectFunctionHandle &scriptObjectFunctionHandle, ParameterList &arguments, uint32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const ScriptObjectFunctionHandle &scriptObjectFunctionHandle, ParameterList &arguments, int64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const ScriptObjectFunctionHandle &scriptObjectFunctionHandle, ParameterList &arguments, uint64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) = 0

virtual ExecutionContextHandle createExecutionContext() = 0

virtual void destroyExecutionContext(const ExecutionContextHandle &executionContextHandle) = 0

virtual std::string getScriptObjectName(const ScriptObjectHandle &scriptObjectHandle) const = 0

virtual ScriptObjectHandle createUninitializedScriptObject(const ModuleHandle &moduleHandle, const std::string &name) = 0

virtual ModuleHandle createModule(const std::string &name, const std::vector<std::string> &scriptData, const std::unordered_map<std::string, std::string> &includeOverrides = {}) = 0

virtual ModuleHandle getModule(const std::string &name) const = 0

virtual void destroyModule(const ModuleHandle &moduleHandle) = 0

virtual void destroyAllModules() = 0

virtual void releaseScriptObject(const ScriptObjectHandle &scriptObjectHandle) = 0

virtual void releaseAllScriptObjects() = 0

virtual void releaseScriptObjectFunction(const ScriptObjectFunctionHandle &scriptObjectFunctionHandle) = 0

virtual void releaseAllScriptObjectFunctions() = 0

virtual void releaseScriptFunction(const ScriptFunctionHandle &scriptFunctionHandle) = 0

virtual void releaseAllScriptFunctions() = 0

virtual void tick(const float32 delta) = 0

virtual void registerGlobalFunction(const std::string &name, const asSFuncPtr &funcPointer, asDWORD callConv, void *objForThiscall = nullptr) = 0

virtual void registerGlobalProperty(const std::string &declaration, void *pointer) = 0

virtual void registerClass(const std::string &name) = 0

virtual void registerClass(const std::string &name, const std::string &classFactorySignature, const std::string &addRefSignature, const std::string &releaseRefSignature, const asSFuncPtr &classFactoryFuncPointer, const asSFuncPtr &addRefFuncPointer, const asSFuncPtr &releaseRefFuncPointer) = 0

virtual void registerClassFactory(const std::string &name, const std::string &classFactorySignature, const asSFuncPtr &classFactoryFuncPointer) = 0

virtual void registerClassAddRef(const std::string &name, const std::string &addRefSignature, const asSFuncPtr &addRefFuncPointer) = 0

virtual void registerClassReleaseRef(const std::string &name, const std::string &releaseRefSignature, const asSFuncPtr &releaseRefFuncPointer) = 0

virtual void registerClassMethod(const std::string &className, const std::string &methodSignature, const asSFuncPtr &funcPointer) = 0

virtual void registerFunctionDefinition(const std::string &name) = 0

virtual void registerInterface(const std::string &name) = 0

virtual void registerInterfaceMethod(const std::string &name, const std::string &declaration) = 0

virtual void registerEnum(const std::string &type) = 0

virtual void registerEnumValue(const std::string &type, const std::string &name, const int64 value) = 0

virtual ScriptFunctionHandle getScriptFunction(const ModuleHandle &moduleHandle, const std::string &function) = 0

virtual ScriptObjectFunctionHandle getScriptObjectFunction(const ScriptObjectHandle &scriptObjectHandle, const std::string &function) = 0

virtual void registerObjectType(const std::string &obj, const int32 byteSize, asDWORD flags) = 0

virtual void registerObjectMethod(const std::string &obj, const std::string &declaration, const asSFuncPtr &funcPointer, asDWORD callConv, void *auxiliary = nullptr) = 0

virtual void registerObjectProperty(const std::string &obj, const std::string &declaration, int32 byteOffset) = 0

virtual void registerObjectBehaviour(const std::string &obj, asEBehaviours behaviour, const std::string &declaration, const asSFuncPtr &funcPointer, asDWORD callConv) = 0

virtual IScriptingEngineDebugger *debugger() = 0

virtual void MessageCallback(const asSMessageInfo *msg, void *param) = 0

virtual void testPrintCallstack() = 0

class IScriptingEngineDebugger

#include <IScriptingEngineDebugger.hpp>

Subclassed by ice_engine::scripting::angel_script::AngelscriptDebugger

Public Functions

virtual ~IScriptingEngineDebugger() = default

virtual void addBreakPoint(const std::string &file, const uint32 line) = 0

virtual void performAction(const DebugAction action) = 0

virtual std::string filename() const = 0

Returns the name of the file that the debugger is currently in.

If we aren’t currently debugging anything, returns an empty string.

Returns

virtual std::string functionName() const = 0

Returns the name of the function that the debugger is currently in.

If we aren’t currently debugging anything, returns an empty string.

Returns

virtual int32 line() const = 0

Returns the line in the file that the debugger is currently on.

If we aren’t currently debugging anything, returns -1.

Returns

virtual std::string stacktrace() = 0

virtual std::string variables() = 0

virtual void registerToStringCallback(const std::string &obj, const std::function<std::string(void*)> &function) = 0

virtual void addDebugEventListener(IDebugEventListener *listener) = 0

virtual void removeDebugEventListener(const IDebugEventListener *listener) = 0

virtual bool enabled() const = 0

virtual void setEnabled(const bool enabled) = 0

virtual bool running() const = 0

virtual void setRunning(const bool running) = 0

class ModuleHandle : public ice_engine::handles::Handle<ModuleHandle>: #include <ModuleHandle.hpp>

class Parameter

#include <Parameter.hpp>

TODO: Make sure we destroy any copied objects if we set a new value for this parameter.

Public Functions

inline Parameter()

inline Parameter(const Parameter &other)

copy this parameter.

Note that if the other Parameter has an object copied by value, the copy constructor will make another copy of that object by allocating new memory and copying the contents of that object.

When this newly created parameter is destroyed, it will call the destructor on that copied object.

inline virtual ~Parameter(): If the parameter holds a copy of an object, the destructor for that object will be called.

template<typename T> inline void valueRef(T &value): Set the parameter by reference.

template<typename T> inline void value(T value)

Set the parameter by value. This will make a copy of the passed in value using that values copy constructor.

Note that when the parameter object is destroyed, it will call the destructor on the copied object.

It is highly recommended that you use relatively simple values.

template<typename T> inline T &valueRef()

template<typename T> inline T value()

inline void *pointer() const

inline ParameterType type() const

template<> inline void valueRef(bool &value)

template<> inline void value(bool value)

template<> inline void valueRef(uint8 &value)

template<> inline void value(uint8 value)

template<> inline void valueRef(int8 &value)

template<> inline void value(int8 value)

template<> inline void valueRef(uint16 &value)

template<> inline void value(uint16 value)

template<> inline void valueRef(int16 &value)

template<> inline void value(int16 value)

template<> inline void valueRef(uint32 &value)

template<> inline void value(uint32 value)

template<> inline void valueRef(int32 &value)

template<> inline void value(int32 value)

template<> inline void valueRef(uint64 &value)

template<> inline void value(uint64 value)

template<> inline void valueRef(int64 &value)

template<> inline void value(int64 value)

template<> inline void value(float32 value)

template<> inline void valueRef(float32 &value)

template<> inline void value(float64 value)

template<> inline void valueRef(float64 &value)

template<> inline bool value()

template<> inline bool &valueRef()

template<> inline uint8 value()

template<> inline uint8 &valueRef()

template<> inline int8 value()

template<> inline int8 &valueRef()

template<> inline uint16 value()

template<> inline uint16 &valueRef()

template<> inline int16 value()

template<> inline uint32 value()

template<> inline uint32 &valueRef()

template<> inline int32 value()

template<> inline int32 &valueRef()

template<> inline uint64 value()

template<> inline int64 &valueRef()

template<> inline int64 value()

template<> inline float32 value()

template<> inline float32 &valueRef()

template<> inline float64 value()

template<> inline float64 &valueRef()

class ParameterList

#include <ParameterList.hpp>

Public Functions

inline ParameterList()

inline virtual ~ParameterList()

inline Parameter &operator[](size_t index)

inline const Parameter &operator[](size_t index) const

inline size_t size() const

inline std::vector<Parameter>::iterator begin()

inline std::vector<Parameter>::const_iterator begin() const

inline std::vector<Parameter>::const_iterator cbegin() const

inline std::vector<Parameter>::iterator end()

inline std::vector<Parameter>::const_iterator end() const

inline std::vector<Parameter>::const_iterator cend() const

template<typename T> inline void addRef(T &value)

template<typename T> inline void add(T value)

inline void add(Parameter p)

inline std::vector<Parameter> &list()

template<typename T> class ReturnObject

#include <ReturnObject.hpp>

Public Functions

inline ReturnObject()

inline virtual ~ReturnObject()

inline std::function<void(void*)> parser()

Public Members

T value

class ScriptFunctionHandle : public ice_engine::handles::PointerHandle<ScriptFunctionHandle>

#include <ScriptFunctionHandle.hpp>

Public Static Attributes

static const ScriptFunctionHandle INVALID

class ScriptHandle : public ice_engine::handles::Handle<ScriptHandle>: #include <ScriptHandle.hpp>

class ScriptingFactory

#include <ScriptingFactory.hpp>

Public Static Functions

static std::unique_ptr<IScriptingEngine> createScriptingEngine(utilities::Properties *properties, fs::IFileSystem *fileSystem, logger::ILogger *logger)

class ScriptObjectFunctionHandle : public ice_engine::handles::PointerHandle<ScriptObjectFunctionHandle>

#include <ScriptObjectFunctionHandle.hpp>

Public Static Attributes

static const ScriptObjectFunctionHandle INVALID

class ScriptObjectHandle : public ice_engine::handles::PointerHandle<ScriptObjectHandle>

#include <ScriptObjectHandle.hpp>

Public Static Attributes

static const ScriptObjectHandle INVALID

union Value

#include <Parameter.hpp>

Public Members

bool valueBoolean

uint8 valueUint8

int8 valueInt8

uint16 valueUint16

int16 valueInt16

uint32 valueUint32

int32 valueInt32

uint64 valueUint64

int64 valueInt64

float32 valueFloat32

float64 valueFloat64

void *valuePointer

namespace angel_script

Functions

inline void assertNoAngelscriptError(const int32 returnCode)

class AngelscriptCPreProcessor : public ice_engine::CPreProcessor

#include <AngelscriptCPreProcessor.hpp>

Public Functions

AngelscriptCPreProcessor(fs::IFileSystem *fileSystem, logger::ILogger *logger, const std::unordered_map<std::string, std::string> &includeOverrides = {})

std::string process(std::string source, const std::unordered_map<std::string, std::string> &defineMap = {}, const bool autoIncludeGuard = false, const bool preserveLineNumbers = false)

std::vector<std::pair<std::string, std::string>> getProcessedFileSources() const

template<typename ContextT> inline void opened_include_file(ContextT const &ctx, std::string const &relname, std::string const &filename, bool is_system_include)

template<typename ContextT> inline void returning_from_include_file(ContextT const &ctx)

template<typename ContextT> inline bool found_include_directive(ContextT const &ctx, std::string const &filename, bool include_next)

template<typename ContextT, typename TokenT> inline void skipped_token(ContextT const &ctx, TokenT const &token)

class AngelscriptDebugger : public CDebugger, public ice_engine::scripting::IScriptingEngineDebugger

#include <AngelscriptDebugger.hpp>

Public Functions

inline AngelscriptDebugger(logger::ILogger *logger)

inline void prepare(asIScriptContext *context)

inline virtual void addBreakPoint(const std::string &file, const uint32 line) override

inline virtual void performAction(const scripting::DebugAction action) override

inline virtual std::string filename() const override

Returns the name of the file that the debugger is currently in.

If we aren’t currently debugging anything, returns an empty string.

Returns

inline virtual std::string functionName() const override

Returns the name of the function that the debugger is currently in.

If we aren’t currently debugging anything, returns an empty string.

Returns

inline virtual int32 line() const override

Returns the line in the file that the debugger is currently on.

If we aren’t currently debugging anything, returns -1.

Returns

inline virtual std::string stacktrace() override

inline virtual std::string variables() override

inline virtual void Output(const std::string &str) override

inline virtual std::string ToString(void *value, asUINT typeId, int expandMembers, asIScriptEngine *engine) override

inline virtual void registerToStringCallback(const std::string &obj, const std::function<std::string(void*)> &function) override

inline virtual void addDebugEventListener(IDebugEventListener *listener) override

inline virtual void removeDebugEventListener(const IDebugEventListener *listener) override

inline virtual bool enabled() const override

inline virtual void setEnabled(const bool enabled) override

inline virtual bool running() const override

inline virtual void setRunning(const bool running) override

inline virtual void TakeCommands(asIScriptContext *ctx) override

class ScriptingEngine : public ice_engine::scripting::IScriptingEngine

#include <ScriptingEngine.hpp>

Public Functions

ScriptingEngine(utilities::Properties *properties, fs::IFileSystem *fileSystem, logger::ILogger *logger)

ScriptingEngine(const ScriptingEngine &other) = delete

~ScriptingEngine() override

virtual void run(const std::string &filename, const std::string &function, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void run(const std::string &filename, const std::string &function, ParameterList &arguments, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void run(const std::string &filename, const std::string &function, ParameterList &arguments, std::function<void(void*)> returnObjectParser, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void run(const std::string &filename, const std::string &function, ParameterList &arguments, float32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void run(const std::string &filename, const std::string &function, ParameterList &arguments, float64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void run(const std::string &filename, const std::string &function, ParameterList &arguments, int8 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void run(const std::string &filename, const std::string &function, ParameterList &arguments, uint8 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void run(const std::string &filename, const std::string &function, ParameterList &arguments, int16 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void run(const std::string &filename, const std::string &function, ParameterList &arguments, uint16 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void run(const std::string &filename, const std::string &function, ParameterList &arguments, int32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void run(const std::string &filename, const std::string &function, ParameterList &arguments, uint32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void run(const std::string &filename, const std::string &function, ParameterList &arguments, int64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void run(const std::string &filename, const std::string &function, ParameterList &arguments, uint64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const std::string &scriptData, const std::string &function, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const std::string &scriptData, const std::string &function, std::function<void(void*)> returnObjectParser, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const std::string &scriptData, const std::string &function, float32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const std::string &scriptData, const std::string &function, float64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const std::string &scriptData, const std::string &function, int8 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const std::string &scriptData, const std::string &function, uint8 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const std::string &scriptData, const std::string &function, int16 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const std::string &scriptData, const std::string &function, uint16 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const std::string &scriptData, const std::string &function, int32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const std::string &scriptData, const std::string &function, uint32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const std::string &scriptData, const std::string &function, int64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const std::string &scriptData, const std::string &function, uint64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const std::string &scriptData, const std::string &function, ParameterList &arguments, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const std::string &scriptData, const std::string &function, ParameterList &arguments, std::function<void(void*)> returnObjectParser, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const std::string &scriptData, const std::string &function, ParameterList &arguments, float32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const std::string &scriptData, const std::string &function, ParameterList &arguments, float64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const std::string &scriptData, const std::string &function, ParameterList &arguments, int8 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const std::string &scriptData, const std::string &function, ParameterList &arguments, uint8 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const std::string &scriptData, const std::string &function, ParameterList &arguments, int16 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const std::string &scriptData, const std::string &function, ParameterList &arguments, uint16 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const std::string &scriptData, const std::string &function, ParameterList &arguments, int32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const std::string &scriptData, const std::string &function, ParameterList &arguments, uint32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const std::string &scriptData, const std::string &function, ParameterList &arguments, int64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const std::string &scriptData, const std::string &function, ParameterList &arguments, uint64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptFunctionHandle &scriptFunctionHandle, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptFunctionHandle &scriptFunctionHandle, std::function<void(void*)> returnObjectParser, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptFunctionHandle &scriptFunctionHandle, float32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptFunctionHandle &scriptFunctionHandle, float64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptFunctionHandle &scriptFunctionHandle, int8 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptFunctionHandle &scriptFunctionHandle, uint8 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptFunctionHandle &scriptFunctionHandle, int16 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptFunctionHandle &scriptFunctionHandle, uint16 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptFunctionHandle &scriptFunctionHandle, int32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptFunctionHandle &scriptFunctionHandle, uint32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptFunctionHandle &scriptFunctionHandle, int64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptFunctionHandle &scriptFunctionHandle, uint64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptFunctionHandle &scriptFunctionHandle, ParameterList &arguments, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptFunctionHandle &scriptFunctionHandle, ParameterList &arguments, std::function<void(void*)> returnObjectParser, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptFunctionHandle &scriptFunctionHandle, ParameterList &arguments, float32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptFunctionHandle &scriptFunctionHandle, ParameterList &arguments, float64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptFunctionHandle &scriptFunctionHandle, ParameterList &arguments, int8 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptFunctionHandle &scriptFunctionHandle, ParameterList &arguments, uint8 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptFunctionHandle &scriptFunctionHandle, ParameterList &arguments, int16 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptFunctionHandle &scriptFunctionHandle, ParameterList &arguments, uint16 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptFunctionHandle &scriptFunctionHandle, ParameterList &arguments, int32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptFunctionHandle &scriptFunctionHandle, ParameterList &arguments, uint32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptFunctionHandle &scriptFunctionHandle, ParameterList &arguments, int64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptFunctionHandle &scriptFunctionHandle, ParameterList &arguments, uint64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ModuleHandle &moduleHandle, const std::string &function, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ModuleHandle &moduleHandle, const std::string &function, std::function<void(void*)> returnObjectParser, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ModuleHandle &moduleHandle, const std::string &function, float32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ModuleHandle &moduleHandle, const std::string &function, float64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ModuleHandle &moduleHandle, const std::string &function, int8 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ModuleHandle &moduleHandle, const std::string &function, uint8 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ModuleHandle &moduleHandle, const std::string &function, int16 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ModuleHandle &moduleHandle, const std::string &function, uint16 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ModuleHandle &moduleHandle, const std::string &function, int32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ModuleHandle &moduleHandle, const std::string &function, uint32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ModuleHandle &moduleHandle, const std::string &function, int64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ModuleHandle &moduleHandle, const std::string &function, uint64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ModuleHandle &moduleHandle, const std::string &function, ParameterList &arguments, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ModuleHandle &moduleHandle, const std::string &function, ParameterList &arguments, std::function<void(void*)> returnObjectParser, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ModuleHandle &moduleHandle, const std::string &function, ParameterList &arguments, float32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ModuleHandle &moduleHandle, const std::string &function, ParameterList &arguments, float64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ModuleHandle &moduleHandle, const std::string &function, ParameterList &arguments, int8 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ModuleHandle &moduleHandle, const std::string &function, ParameterList &arguments, uint8 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ModuleHandle &moduleHandle, const std::string &function, ParameterList &arguments, int16 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ModuleHandle &moduleHandle, const std::string &function, ParameterList &arguments, uint16 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ModuleHandle &moduleHandle, const std::string &function, ParameterList &arguments, int32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ModuleHandle &moduleHandle, const std::string &function, ParameterList &arguments, uint32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ModuleHandle &moduleHandle, const std::string &function, ParameterList &arguments, int64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ModuleHandle &moduleHandle, const std::string &function, ParameterList &arguments, uint64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const std::string &function, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const std::string &function, std::function<void(void*)> returnObjectParser, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const std::string &function, float32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const std::string &function, float64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const std::string &function, int8 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const std::string &function, uint8 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const std::string &function, int16 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const std::string &function, uint16 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const std::string &function, int32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const std::string &function, uint32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const std::string &function, int64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const std::string &function, uint64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const std::string &function, ParameterList &arguments, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const std::string &function, ParameterList &arguments, std::function<void(void*)> returnObjectParser, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const std::string &function, ParameterList &arguments, float32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const std::string &function, ParameterList &arguments, float64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const std::string &function, ParameterList &arguments, int8 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const std::string &function, ParameterList &arguments, uint8 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const std::string &function, ParameterList &arguments, int16 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const std::string &function, ParameterList &arguments, uint16 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const std::string &function, ParameterList &arguments, int32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const std::string &function, ParameterList &arguments, uint32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const std::string &function, ParameterList &arguments, int64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const std::string &function, ParameterList &arguments, uint64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const ScriptObjectFunctionHandle &scriptObjectFunctionHandle, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const ScriptObjectFunctionHandle &scriptObjectFunctionHandle, std::function<void(void*)> returnObjectParser, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const ScriptObjectFunctionHandle &scriptObjectFunctionHandle, float32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const ScriptObjectFunctionHandle &scriptObjectFunctionHandle, float64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const ScriptObjectFunctionHandle &scriptObjectFunctionHandle, int8 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const ScriptObjectFunctionHandle &scriptObjectFunctionHandle, uint8 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const ScriptObjectFunctionHandle &scriptObjectFunctionHandle, int16 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const ScriptObjectFunctionHandle &scriptObjectFunctionHandle, uint16 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const ScriptObjectFunctionHandle &scriptObjectFunctionHandle, int32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const ScriptObjectFunctionHandle &scriptObjectFunctionHandle, uint32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const ScriptObjectFunctionHandle &scriptObjectFunctionHandle, int64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const ScriptObjectFunctionHandle &scriptObjectFunctionHandle, uint64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const ScriptObjectFunctionHandle &scriptObjectFunctionHandle, ParameterList &arguments, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const ScriptObjectFunctionHandle &scriptObjectFunctionHandle, ParameterList &arguments, std::function<void(void*)> returnObjectParser, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const ScriptObjectFunctionHandle &scriptObjectFunctionHandle, ParameterList &arguments, float32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const ScriptObjectFunctionHandle &scriptObjectFunctionHandle, ParameterList &arguments, float64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const ScriptObjectFunctionHandle &scriptObjectFunctionHandle, ParameterList &arguments, int8 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const ScriptObjectFunctionHandle &scriptObjectFunctionHandle, ParameterList &arguments, uint8 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const ScriptObjectFunctionHandle &scriptObjectFunctionHandle, ParameterList &arguments, int16 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const ScriptObjectFunctionHandle &scriptObjectFunctionHandle, ParameterList &arguments, uint16 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const ScriptObjectFunctionHandle &scriptObjectFunctionHandle, ParameterList &arguments, int32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const ScriptObjectFunctionHandle &scriptObjectFunctionHandle, ParameterList &arguments, uint32 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const ScriptObjectFunctionHandle &scriptObjectFunctionHandle, ParameterList &arguments, int64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual void execute(const ScriptObjectHandle &scriptObjectHandle, const ScriptObjectFunctionHandle &scriptObjectFunctionHandle, ParameterList &arguments, uint64 &returnValue, const ExecutionContextHandle &executionContextHandle = ExecutionContextHandle(0)) override

virtual ExecutionContextHandle createExecutionContext() override

virtual void destroyExecutionContext(const ExecutionContextHandle &executionContextHandle) override

virtual std::string getScriptObjectName(const ScriptObjectHandle &scriptObjectHandle) const override

virtual ScriptObjectHandle createUninitializedScriptObject(const ModuleHandle &moduleHandle, const std::string &name) override

virtual ModuleHandle createModule(const std::string &name, const std::vector<std::string> &scriptData, const std::unordered_map<std::string, std::string> &includeOverrides = {}) override

virtual ModuleHandle getModule(const std::string &name) const override

virtual void destroyModule(const ModuleHandle &moduleHandle) override

virtual void destroyAllModules() override

virtual void releaseScriptObject(const ScriptObjectHandle &scriptObjectHandle) override

virtual void releaseAllScriptObjects() override

virtual void releaseScriptObjectFunction(const ScriptObjectFunctionHandle &scriptObjectFunctionHandle) override

virtual void releaseAllScriptObjectFunctions() override

virtual void releaseScriptFunction(const ScriptFunctionHandle &scriptFunctionHandle) override

virtual void releaseAllScriptFunctions() override

virtual void tick(const float32 delta) override

virtual void registerGlobalFunction(const std::string &name, const asSFuncPtr &funcPointer, asDWORD callConv, void *objForThiscall = nullptr) override

virtual void registerGlobalProperty(const std::string &declaration, void *pointer) override

virtual void registerClass(const std::string &name) override

virtual void registerClass(const std::string &name, const std::string &classFactorySignature, const std::string &addRefSignature, const std::string &releaseRefSignature, const asSFuncPtr &classFactoryFuncPointer, const asSFuncPtr &addRefFuncPointer, const asSFuncPtr &releaseRefFuncPointer) override

virtual void registerClassFactory(const std::string &name, const std::string &classFactorySignature, const asSFuncPtr &classFactoryFuncPointer) override

virtual void registerClassAddRef(const std::string &name, const std::string &addRefSignature, const asSFuncPtr &addRefFuncPointer) override

virtual void registerClassReleaseRef(const std::string &name, const std::string &releaseRefSignature, const asSFuncPtr &releaseRefFuncPointer) override

virtual void registerClassMethod(const std::string &className, const std::string &methodSignature, const asSFuncPtr &funcPointer) override

virtual void registerFunctionDefinition(const std::string &name) override

virtual void registerInterface(const std::string &name) override

virtual void registerInterfaceMethod(const std::string &name, const std::string &declaration) override

virtual void registerEnum(const std::string &type) override

virtual void registerEnumValue(const std::string &type, const std::string &name, const int64 value) override

virtual ScriptFunctionHandle getScriptFunction(const ModuleHandle &moduleHandle, const std::string &function) override

virtual ScriptObjectFunctionHandle getScriptObjectFunction(const ScriptObjectHandle &scriptObjectHandle, const std::string &function) override

virtual void registerObjectType(const std::string &obj, const int32 byteSize, asDWORD flags) override

virtual void registerObjectMethod(const std::string &obj, const std::string &declaration, const asSFuncPtr &funcPointer, asDWORD callConv, void *auxiliary = nullptr) override

virtual void registerObjectProperty(const std::string &obj, const std::string &declaration, int32 byteOffset) override

virtual void registerObjectBehaviour(const std::string &obj, asEBehaviours behaviour, const std::string &declaration, const asSFuncPtr &funcPointer, asDWORD callConv) override

virtual IScriptingEngineDebugger *debugger() override

virtual void MessageCallback(const asSMessageInfo *msg, void *param) override

virtual void testPrintCallstack() override

Public Static Functions

static void print(const std::string &msg)

static void println(const std::string &msg)

namespace serialization

class ISerializable

#include <ISerializable.hpp>

Subclassed by ice_engine::Scene

Public Functions

inline virtual ~ISerializable()

virtual void serialize(const std::string &filename) = 0

Serialize the object to the provided filename.

Not Thread Safe: This method is not safe to call in a multi-threaded environment. When you are calling this method, no other threads should be accessing this object.

virtual void deserialize(const std::string &filename) = 0

Deserializes the object from the provided filename.

Not Thread Safe: This method is not safe to call in a multi-threaded environment. When you are calling this method, no other threads should be accessing this object.

class ITextSerializable

#include <ITextSerializable.hpp>

Public Functions

inline virtual ~ITextSerializable()

virtual void serialize(const std::string &filename) = 0

Serialize the object to the provided filename.

Not Thread Safe: This method is not safe to call in a multi-threaded environment. When you are calling this method, no other threads should be accessing this object.

virtual void serialize(TextOutArchive &outArchive) = 0

Serialize the object to the provided archive.

Not Thread Safe: This method is not safe to call in a multi-threaded environment. When you are calling this method, no other threads should be accessing this object.

virtual void deserialize(const std::string &filename) = 0

Deserializes the object from the provided filename.

Not Thread Safe: This method is not safe to call in a multi-threaded environment. When you are calling this method, no other threads should be accessing this object.

virtual void deserialize(TextInArchive &inArchive) = 0

Deserializes the object from the provided archive.

Not Thread Safe: This method is not safe to call in a multi-threaded environment. When you are calling this method, no other threads should be accessing this object.

class TextInArchive : public text_iarchive

#include <TextInArchive.hpp>

Public Functions

inline TextInArchive(std::istream &istream)

virtual ~TextInArchive() = default

class TextOutArchive : public text_oarchive

#include <TextOutArchive.hpp>

Public Functions

inline TextOutArchive(std::ostream &ostream)

virtual ~TextOutArchive() = default

namespace utilities

Functions

bool isEmpty(const boost::any &operand)

bool isInt(const boost::any &operand)

bool isUint(const boost::any &operand)

bool isFloat(const boost::any &operand)

bool isDouble(const boost::any &operand)

bool isBool(const boost::any &operand)

bool isString(const boost::any &operand)

bool isWstring(const boost::any &operand)

bool isVec3InSphere(const glm::vec3 &point, const glm::vec3 &sphereCenter, float32 radius)

inline void saveImageToFile(fs::IFile &file, const Image &image)

inline std::vector<char> readAllBytes(std::istream &inputStream)

inline std::string toString(const std::wstring &ws)

inline std::wstring toWstring(const std::string &s)

template<class OutIt> inline void explode(const std::string &input, const char sep, OutIt output)

Variables

const glm::vec3 GLM_UNIT_VECTOR_X = glm::vec3(1.0f, 0.0f, 0.0f)

const glm::vec3 GLM_UNIT_VECTOR_Y = glm::vec3(0.0f, 1.0f, 0.0f)

const glm::vec3 GLM_UNIT_VECTOR_Z = glm::vec3(0.0f, 0.0f, 1.0f)

class Properties

#include <Properties.hpp>

Public Functions

Properties() = default

Properties(fs::IFile *file)

Properties(const std::string &properties)

~Properties() = default

inline std::string getStringValue(const std::string &name, std::string defaultValue = std::string()) const

inline int32 getIntValue(const std::string &name, const int32 defaultValue = 0) const

inline int64 getLongValue(const std::string &name, const int64 defaultValue = 0L) const

inline float32 getFloatValue(const std::string &name, const float32 defaultValue = 0.0f) const

inline float64 getDoubleValue(const std::string &name, const float64 defaultValue = 0.0) const

inline bool getBoolValue(const std::string &name, const bool defaultValue = false) const

ice_engine¶

`ice_engine`¶