Physics stuff

HydraEngine/includes/Hydra.h

@@ -12,6 +12,7 @@
 #include "../source/actor/HydraSpotLightActor.h"
 #include "../source/actor/HydraTestCubeActor.h"
 #include "../source/actor/PlanetActor/HydraPlanetActor.h"
+#include "../source/actor/LightSpawner/HydraLightSpawnerActor.h"
 #include "../source/camera/HydraCamera.h"
 
 #include <GLMIncludes.h>

HydraEngine/source/HydraDefines.h

@@ -47,7 +47,7 @@ const uint32_t MAX_POINT_SHADOWS = 10;
 //const uint32_t SHADOW_MAP_SIZE = 1024;
 const uint32_t DIRECTIONAL_SHADOW_MAP_SIZE = 4096;
 const uint32_t SPOT_SHADOW_MAP_SIZE = 1024;
-const uint32_t POINT_SHADOW_MAP_SIZE = 1024;
+const uint32_t POINT_SHADOW_MAP_SIZE = 2048;
 
 enum class HYDRA_PHYSICS_TYPE
 {

HydraEngine/source/actor/HydraActor.h

@@ -25,11 +25,10 @@ class CLASS_DEFINE HydraActor : public HydraObject
         std::string Name;
         virtual ~HydraActor(){};
         virtual void InitialiseComponents() = 0;
-        virtual void DeferredInitialiseComponents() {};
-        HydraID GetID() {return m_id;}
-        virtual void FixedTick(float delta_t) {};
-        
+        virtual void DeferredInitialiseComponents() {};        
+        virtual void FixedTick(float delta_t) {};        
         virtual void _Cleanup(){};
+        HydraID GetID() {return m_id;}
 
 };
 

HydraEngine/source/actor/HydraActorManager.cpp

@@ -95,22 +95,15 @@ void HydraActorManager::Initialise(size_t max_actors)
 }
 
 
-void HydraActorManager::TickActors(float delta_t)
+
+void HydraActorManager::FixedTickActor(float actor_id, float delta_t)
 {
-    // std::lock_guard<std::mutex> lock(m_mutex);
+    HydraActor *actor = GetActor(actor_id);
+    if (actor != nullptr)
+    {
+        actor->FixedTick(delta_t);
+    }
 
-    // //   HydraID barrierID = GetEngine()->TaskScheduler()->CreateBarrier();
-    // for (int i = 0; i < m_actors_to_tick_fixed.size(); i++)
-    // {
-    //     HydraID tick_actors_task_id = GetEngine()->TaskScheduler()->CreateTask<HydraFixedTickActorTask>(HydraThreadAffinity::General);
-    //     if (tick_actors_task_id != INVALID_HYDRA_ID)
-    //     {
-    //         ((HydraFixedTickActorTask *)(GetEngine()->TaskScheduler()->GetTask(tick_actors_task_id)))->Initialise(m_actors_to_tick_fixed[i], delta_t);
-
-    //         GetEngine()->TaskScheduler()->StartTask(tick_actors_task_id);
-    //     }
-    // }
-    // GetEngine()->TaskScheduler()->WaitForBarrier(barrierID);
 }
 void HydraActorManager::InitialiseActor(HydraID actorID)
 {
@@ -188,6 +181,16 @@ void HydraActorManager::SetOrientation(HydraID actorID, float x, float y, float
     }
 }
 
+void HydraActorManager::SetLinearVelocity(HydraID actor_id, glm::vec3 velocity)
+{
+    HydraECS* ecs = GetEngine()->ECS();
+    if (ecs->HasComponent<HydraPhysicsComponent>(actor_id))
+    {
+        std::shared_ptr<HydraPhysicsSystem> phys_sys = ecs->GetSystem<HydraPhysicsSystem>();
+        phys_sys->SetLinearVelocity(actor_id, velocity);
+    }
+}
+
 void HydraActorManager::SetPositionAndOrientation(HydraID actorID, glm::dvec3 position, glm::vec3 euler_angles, bool ignore_physics)
 {
     HydraECS *ecs = GetEngine()->ECS();

HydraEngine/source/actor/HydraActorManager.h

@@ -33,13 +33,15 @@ class CLASS_DEFINE HydraActorManager : public HydraObject
         void Initialise(size_t max_actors);
         template<class T> HydraID CreateActor();
 		
-		HydraID LoadActor(std::string filename);				
+		HydraID LoadActor(std::string filename);		
+				
 		
 		void DeleteActor(HydraID actorID);		
 		HydraActor* const GetActor(HydraID actorID);		
 		std::vector<HydraID>& GetChildren(HydraID actor_id);
         
-		void TickActors(float delta_t);
+		
+		void FixedTickActor(float actor_id, float delta_t);
 		void InitialiseActor(HydraID actorID);
 
 		void Shutdown();
@@ -48,15 +50,14 @@ class CLASS_DEFINE HydraActorManager : public HydraObject
 		
 		void SetPosition(HydraID actorID, glm::dvec3 position);
 		void SetOrientation(HydraID actorID, float x, float y, float z);
+		void SetLinearVelocity(HydraID actor_id, glm::vec3 velocity);
 		void SetPositionAndOrientation(HydraID actorID, glm::dvec3 position, glm::vec3 euler_angles, bool ignore_physics = false);
 		void SetScale(HydraID actor_id, glm::dvec3 scaling);
 
 		void TranslateActor(HydraID actorID, glm::dvec3 translation);
 		
 		void SetRelationship(HydraID parent_id, HydraID child_id);
-	//	void AddComponentType(HydraID actorID, uint32_t component_type);
-	//	bool HasComponentType(HydraID actorID, uint32_t component_type);
-	//	void RemoveComponentType(HydraID actorID, uint32_t component_type);
+
 		
 		HydraID GetParent(HydraID actor_id);
 		HydraID GetRoot(HydraID actor_id);

HydraEngine/source/actor/HydraPlaneActor.cpp

@@ -19,12 +19,12 @@ void HydraPlaneActor::InitialiseComponents()
 	// HydraECS* ecs = GetEngine()->ECS();
 	// HydraID entity_id = ecs->CreateEntity();
 	_CreatePosition();
-	// _CreatePhysics();
+	_CreatePhysics();
 
 	_CreateMaterial();
 	_CreateMesh();
 	_CreateRenderableComponent();
-	_CreatePhysics();
+	
 }
 
 void HydraPlaneActor::DeferredInitialiseComponents()

HydraEngine/source/actor/LightSpawner/HydraLightSpawnerActor.cpp

@@ -0,0 +1,79 @@
+#include "HydraLightSpawnerActor.h"
+#include "../../ecs/components/HydraPositionComponent.h"
+#include "../../ecs/components/HydraTickComponent.h"
+#include "../../ecs/HydraECS.h"
+#include "../../engine/HydraEngine.h"
+#include "../../actor/HydraActorManager.h"
+#include "HydraSpawnedLightActor.h"
+
+
+void HydraLightSpawnerActor::FixedTick(float delta_t)
+{
+    if(m_enabled)
+    {
+        std::chrono::time_point<std::chrono::steady_clock> current_tick = std::chrono::steady_clock::now();        
+        auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(current_tick - m_last_tick);
+        long elapsed_milli_seconds = elapsed.count();
+        if(elapsed_milli_seconds >= (m_interval * 1000.0f))
+        {
+            HydraEngine* engine = GetEngine();
+            
+            HydraPositionComponent pos_comp =engine->ECS()->GetComponent<HydraPositionComponent>(GetID());
+            HydraActorManager* actor_manager = engine->ActorManager();
+            HydraID actor_id = actor_manager->CreateActor<HydraSpawnedLightActor>();            
+            actor_manager->InitialiseActor(actor_id);            
+            actor_manager->SetPosition(actor_id, pos_comp.position);            
+            actor_manager->SetLinearVelocity(actor_id, m_spawn_direction * m_spawn_velocity);    
+            m_last_tick = current_tick;
+            
+        }
+        
+    }
+}
+
+void HydraLightSpawnerActor::_CreatePosition()
+{
+    HydraECS *ecs = GetEngine()->ECS();
+	HydraPositionComponent position_component;
+	ecs->AddComponent<HydraPositionComponent>(GetID(), position_component);
+}
+
+void HydraLightSpawnerActor::_CreateTick()
+{
+    HydraECS *ecs = GetEngine()->ECS();
+	HydraTickComponent tick_component;
+    tick_component.entity_id = GetID();
+    tick_component.fixed = true;
+	ecs->AddComponent<HydraTickComponent>(GetID(), tick_component);
+}
+void HydraLightSpawnerActor::InitialiseComponents()
+{
+    _CreatePosition();
+    _CreateTick();
+}
+
+void HydraLightSpawnerActor::SetEnabled(bool enabled)
+{
+    m_enabled = enabled;
+    if(enabled == true)
+    { 
+        m_last_tick = std::chrono::steady_clock::now();
+        
+    }
+}
+
+void HydraLightSpawnerActor::SpawnSettings(float spawns_per_second, 
+                            glm::vec3 spawn_direction, 
+                            glm::vec3 dir_variation, 
+                            float spawn_velocity, 
+                            float velocity_variation,
+                            float spawn_duration)
+{
+    m_spawns_per_second = spawns_per_second;
+    m_spawn_direction = spawn_direction;
+    m_dir_variation = dir_variation;    
+    m_spawn_velocity = spawn_velocity;
+    m_velocity_variation = velocity_variation;
+    m_spawn_duration = spawn_duration;
+    m_interval = 1.0f / spawns_per_second;
+}

HydraEngine/source/actor/LightSpawner/HydraLightSpawnerActor.h

@@ -0,0 +1,37 @@
+#ifndef HYDRALIGHTSPAWNERACTOR
+#define HYDRALIGHTSPAWNERACTOR
+
+#include "../HydraActor.h"
+#include <chrono>
+#include <queue>
+#include <GLMIncludes.h>
+class CLASS_DEFINE HydraLightSpawnerActor : public HydraActor
+{
+    public:
+        void InitialiseComponents() override;
+        void SetEnabled(bool enabled);
+        void FixedTick(float delta_t);
+        void SpawnSettings(float spawns_per_second, 
+                            glm::vec3 spawn_direction, 
+                            glm::vec3 dir_variation, 
+                            float spawn_velocity, 
+                            float velocity_variation,
+                            float spawn_duration);
+                            
+    private:
+        void _CreatePosition();
+        void _CreateTick();    
+        float m_spawns_per_second =0;
+        glm::vec3 m_spawn_direction = {0.0f, 1.0f, 0.0f};
+        glm::vec3 m_dir_variation = {0.0f, 0.0f, 0.0f};
+        float m_spawn_velocity = 0.0f;
+        float m_velocity_variation = 0.0f;
+        float m_spawn_duration;
+        float m_interval = 0.0f;
+        bool m_enabled = false;
+        std::chrono::time_point<std::chrono::steady_clock> m_last_tick;
+        std::queue<HydraID> m_spawned_actors;
+};
+
+
+#endif /* HYDRALIGHTSPAWNERACTOR */

HydraEngine/source/actor/LightSpawner/HydraSpawnedLightActor.cpp

@@ -0,0 +1,203 @@
+#include "HydraSpawnedLightActor.h"
+#include "../../engine/HydraEngine.h"
+#include "../../actor/HydraActorManager.h"
+#include "../../task/HydraTask.h"
+#include "../../ecs/HydraECS.h"
+#include "../../ecs/components/HydraPositionComponent.h"
+#include "../../ecs/components/HydraMeshComponent.h"
+#include "../../ecs/components/HydraRenderableComponent.h"
+#include "../../ecs/components/HydraMaterialComponent.h"
+#include "../../ecs/components/HydraPhysicsComponent.h"
+#include "../../buffer/HydraMaterialBufferManager.h"
+#include "../../buffer/HydraTextureBufferManager.h"
+#include "../../buffer/HydraMaterialBuffer.h"
+#include "../../mesh/HydraMeshManager.h"
+#include "../../mesh/HydraMesh.h"
+
+void HydraSpawnedLightActor::InitialiseComponents()
+{
+	
+	_CreatePosition();
+	_CreatePhysics();
+	_CreateMaterial();
+	_CreateMesh();
+	_CreateRenderableComponent();
+}
+
+void HydraSpawnedLightActor::DeferredInitialiseComponents()
+{
+}
+
+void HydraSpawnedLightActor::_CreatePosition()
+{
+	HydraECS *ecs = GetEngine()->ECS();
+	HydraPositionComponent position_component;
+	ecs->AddComponent<HydraPositionComponent>(GetID(), position_component);
+}
+
+void HydraSpawnedLightActor::_CreateMesh()
+{
+	HydraMeshManager *mesh_manager = GetEngine()->MeshManager();
+	HydraID mesh_id = mesh_manager->CreateMesh();
+	HydraMesh *mesh = mesh_manager->GetMesh(mesh_id);
+
+	HydraMaterialComponent mat_comp = GetEngine()->ECS()->GetComponent<HydraMaterialComponent>(GetID());
+
+	mesh->vertexes.resize(24);
+	mesh->indexes.resize(36);
+
+	float scale_x = 0.3f;
+	float scale_y = 0.3f;
+	float scale_z = 0.3f;
+
+	float min_x = -0.5f * scale_x;
+	float min_y = -0.5f * scale_y;
+	float min_z = -0.5f * scale_z;
+
+	float max_x = 0.5f * scale_x;
+	float max_y = 0.5f * scale_y;
+	float max_z = 0.5f * scale_z;
+
+	float min_u = 1;
+	float min_v = 1;
+
+	float max_u = 0;
+	float max_v = 0;
+
+	// 1---2		5---6
+	//|	/ |		| / |
+	// 0---3		4---7
+
+	HydraID actor_id = GetID();
+	mesh->vertexes[0] = {min_x, min_y, min_z, min_u, min_v, actor_id, mat_comp.material_id, 0};
+	mesh->vertexes[1] = {min_x, max_y, min_z, min_u, max_v, actor_id, mat_comp.material_id, 0};
+	mesh->vertexes[2] = {max_x, max_y, min_z, max_u, max_v, actor_id, mat_comp.material_id, 0};
+	mesh->vertexes[3] = {max_x, min_y, min_z, max_u, min_v, actor_id, mat_comp.material_id, 0};
+
+	// Face 0
+	mesh->indexes[0] = 0;
+	mesh->indexes[1] = 1;
+	mesh->indexes[2] = 2;
+
+	mesh->indexes[3] = 0;
+	mesh->indexes[4] = 2;
+	mesh->indexes[5] = 3;
+
+	mesh->vertexes[4] = {max_x, min_y, min_z, min_u, min_v, actor_id, mat_comp.material_id, 0};
+	mesh->vertexes[5] = {max_x, max_y, min_z, min_u, max_v, actor_id, mat_comp.material_id, 0};
+	mesh->vertexes[6] = {max_x, max_y, max_z, max_u, max_v, actor_id, mat_comp.material_id, 0};
+	mesh->vertexes[7] = {max_x, min_y, max_z, max_u, min_v, actor_id, mat_comp.material_id, 0};
+
+	mesh->indexes[6] = 4;
+	mesh->indexes[7] = 5;
+	mesh->indexes[8] = 6;
+
+	mesh->indexes[9] = 4;
+	mesh->indexes[10] = 6;
+	mesh->indexes[11] = 7;
+
+	// Back Face
+	mesh->vertexes[8] = {max_x, min_y, max_z, min_u, min_v, actor_id, mat_comp.material_id, 0};
+	mesh->vertexes[9] = {max_x, max_y, max_z, min_u, max_v, actor_id, mat_comp.material_id, 0};
+	mesh->vertexes[10] = {min_x, max_y, max_z, max_u, max_v, actor_id, mat_comp.material_id, 0};
+	mesh->vertexes[11] = {min_x, min_y, max_z, max_u, min_v, actor_id, mat_comp.material_id, 0};
+
+	mesh->indexes[12] = 8;
+	mesh->indexes[13] = 9;
+	mesh->indexes[14] = 10;
+
+	mesh->indexes[15] = 8;
+	mesh->indexes[16] = 10;
+	mesh->indexes[17] = 11;
+
+	mesh->vertexes[12] = {min_x, min_y, max_z, min_u, min_v, actor_id, mat_comp.material_id, 0};
+	mesh->vertexes[13] = {min_x, max_y, max_z, min_u, max_v, actor_id, mat_comp.material_id, 0};
+	mesh->vertexes[14] = {min_x, max_y, min_z, max_u, max_v, actor_id, mat_comp.material_id, 0};
+	mesh->vertexes[15] = {min_x, min_y, min_z, max_u, min_v, actor_id, mat_comp.material_id, 0};
+
+	mesh->indexes[18] = 12;
+	mesh->indexes[19] = 13;
+	mesh->indexes[20] = 14;
+
+	mesh->indexes[21] = 12;
+	mesh->indexes[22] = 14;
+	mesh->indexes[23] = 15;
+
+	mesh->vertexes[16] = {min_x, max_y, min_z, min_u, min_v, actor_id, mat_comp.material_id, 0};
+	mesh->vertexes[17] = {min_x, max_y, max_z, min_u, max_v, actor_id, mat_comp.material_id, 0};
+	mesh->vertexes[18] = {max_x, max_y, max_z, max_u, max_v, actor_id, mat_comp.material_id, 0};
+	mesh->vertexes[19] = {max_x, max_y, min_z, max_u, min_v, actor_id, mat_comp.material_id, 0};
+
+	mesh->indexes[24] = 16;
+	mesh->indexes[25] = 17;
+	mesh->indexes[26] = 18;
+
+	mesh->indexes[27] = 16;
+	mesh->indexes[28] = 18;
+	mesh->indexes[29] = 19;
+
+	mesh->vertexes[20] = {min_x, min_y, min_z, min_u, min_v, actor_id, mat_comp.material_id, 0};
+	mesh->vertexes[21] = {max_x, min_y, min_z, min_u, max_v, actor_id, mat_comp.material_id, 0};
+	mesh->vertexes[22] = {max_x, min_y, max_z, max_u, max_v, actor_id, mat_comp.material_id, 0};
+	mesh->vertexes[23] = {min_x, min_y, max_z, max_u, min_v, actor_id, mat_comp.material_id, 0};
+
+	mesh->indexes[30] = 20;
+	mesh->indexes[31] = 21;
+	mesh->indexes[32] = 22;
+
+	mesh->indexes[33] = 20;
+	mesh->indexes[34] = 22;
+	mesh->indexes[35] = 23;
+
+	mesh_manager->CalculateNormals(mesh->mesh_id);
+
+	HydraECS *ecs = GetEngine()->ECS();
+	HydraMeshComponent mesh_comp;
+
+	mesh_comp.mesh_id = mesh_id;
+	mesh_comp.mesh_state = HYDRA_STATE::Waiting;
+
+	ecs->AddComponent<HydraMeshComponent>(GetID(), mesh_comp);
+}
+
+void HydraSpawnedLightActor::_CreateMaterial()
+{
+
+	HydraEngine *engine = GetEngine();
+	std::string filename = std::string(texture_base) + std::string("/DesignArea/DesignArea_Albedo.png");
+
+	HydraID tex_id = engine->TextureBufferManager()->LoadTexture(filename);
+
+	HydraMaterialBuffer material = {};
+
+	material.diffuse_texture_id = tex_id;
+	material.diffuse_colour = glm::vec4(1, 1, 1, 1);
+	material.metalic_rough = glm::vec4(0, 0.5, 0.3, 1);
+	HydraID mat_id = engine->MaterialBufferManager()->CreateMaterial(material);
+
+	HydraMaterialComponent mat_comp = {};
+	mat_comp.material_id = mat_id;
+	engine->ECS()->AddComponent<HydraMaterialComponent>(GetID(), mat_comp);
+}
+
+void HydraSpawnedLightActor::_CreatePhysics()
+{
+	HydraEngine *engine = GetEngine();
+	HydraPhysicsComponent phys_comp = {};
+	phys_comp.mass = 0;
+	phys_comp.phyics_type = HYDRA_PHYSICS_TYPE::HYDRA_RIGID_BODY;
+	phys_comp.physics_shape = HYDRA_PHYSICS_SHAPE::HYDRA_PHYSICS_BOX;
+
+	phys_comp.depth = 0.3f;
+	phys_comp.height = 0.3f;
+	phys_comp.width = 0.3f;
+
+	engine->ECS()->AddComponent<HydraPhysicsComponent>(GetID(), phys_comp);
+}
+void HydraSpawnedLightActor::_CreateRenderableComponent()
+{
+	HydraRenderableComponent render_comp;
+	HydraECS *ecs = GetEngine()->ECS();
+	render_comp.renderable_types.set((uint32_t)HYDRA_RENDERABLE_TYPE::HYDRA_COLOUR, true);
+	ecs->AddComponent<HydraRenderableComponent>(GetID(), render_comp);
+}

HydraEngine/source/actor/LightSpawner/HydraSpawnedLightActor.h

@@ -0,0 +1,26 @@
+#ifndef HYDRASPAWNEDLIGHTACTOR
+#define HYDRASPAWNEDLIGHTACTOR
+#include "../HydraActor.h"
+
+class CLASS_DEFINE HydraSpawnedLightActor : public HydraActor
+{
+    private:
+        double m_scale = 1.0;
+        double m_widthscale = 1.0f;
+        HydraID m_material_component = INVALID_HYDRA_ID;
+        HydraID m_position_component = INVALID_HYDRA_ID;
+        HydraID m_mesh_component = INVALID_HYDRA_ID;
+    protected:
+        void _CreatePosition();
+        void _CreateMesh();
+        void _CreateMaterial();
+        void _CreatePhysics();
+        void _CreateRenderableComponent();
+    public:
+        void InitialiseComponents() override;
+        void DeferredInitialiseComponents() override;
+        
+        
+};
+
+#endif /* HYDRASPAWNEDLIGHTACTOR */

HydraEngine/source/ecs/HydraSystem.h

@@ -13,13 +13,14 @@ class HydraSystem : public HydraObject
 
         void Update(float delta_t_seconds);
         void InitialiseComponents();
+        virtual void InitialiseComponent(HydraID actor_id) {};
         void DestroyComponents(HydraID actor_id);
         virtual void Shutdown();
         virtual void Initialise(){};
     protected:
         
         virtual void UpdateSystem(float delta_t_seconds) = 0;
-        virtual void InitialiseComponent(HydraID actor_id) {};
+        
         virtual void DestroyComponent(HydraID actor_id) {};
         virtual void FreeSystemResources(){};
 };

HydraEngine/source/ecs/HydraSystemManager.h

@@ -54,6 +54,7 @@ public:
     }
     void EntitySignatureChanged(HydraID entity_id, HydraSignature signature)
 	{
+		
 		// Notify each system that an entity's signature changed
 		for (auto const& pair : m_systems)
 		{
@@ -68,6 +69,8 @@ public:
 			{
 				system->EntitiesToCreate.insert(entity_id);
 				system->Entities.insert(entity_id);
+				//system->InitialiseComponent(entity_id);
+				
 			}
 			// Entity signature does not match system signature - erase from set
 			else
@@ -77,6 +80,7 @@ public:
 				system->EntitiesToCreate.erase(entity_id);
 			}
 		}
+
 	}
     void EntityDeleted(HydraID entity_id)
     {

HydraEngine/source/ecs/components/HydraPositionComponent.h

@@ -2,6 +2,7 @@
 #define HYDRAECSPOSITIONCOMPONENT
 
 
+#include "../../engine/HydraEngine.h"
 struct HydraPositionComponent
 {
     glm::dvec3 position = {};

HydraEngine/source/ecs/components/HydraTickComponent.h

@@ -0,0 +1,12 @@
+#ifndef HYDRAFIXEDTICKCOMPONENT
+#define HYDRAFIXEDTICKCOMPONENT
+
+#include "../../engine/HydraEngine.h"
+
+struct HydraTickComponent
+{        
+	HydraID entity_id;
+	bool fixed = false;
+	bool every_frame = false;
+};
+#endif /* HYDRAFIXEDTICKCOMPONENT */

HydraEngine/source/ecs/systems/HydraDirectionalShadowSourceSystem.h

@@ -12,8 +12,9 @@ class HydraDirectionalShadowSourceSystem : public HydraSystem
 {
     public:        
         virtual void Initialise() override;
-    protected: 
         void InitialiseComponent(HydraID entity_id) override;
+    protected: 
+        
         void DestroyComponent(HydraID entity_id) override;
         void UpdateSystem(float delta_t_seconds) override;
     private:

HydraEngine/source/ecs/systems/HydraLightSystem.h

@@ -14,9 +14,9 @@ class HydraLightSystem : public HydraSystem
 {
     public:        
         void Initialise() override;
-        //uint32_t GetLightCount();
-    protected: 
         void InitialiseComponent(HydraID entity_id) override;
+    protected: 
+        
         void DestroyComponent(HydraID actor_id) override;
         virtual void UpdateSystem(float delta_t_seconds);
     private:

HydraEngine/source/ecs/systems/HydraMaterialSystem.h

@@ -13,12 +13,10 @@ class HydraMaterialSystem : public HydraSystem
 {
     public:        
         void Initialise() override;
-    protected: 
         void InitialiseComponent(HydraID entity_id) override;
+    protected: 
         void FreeSystemResources() override;
         virtual void UpdateSystem(float delta_t_seconds);
-
-
     private:
         void _WriteToGPU();
         HydraID m_material_buffer_id = INVALID_HYDRA_ID;

HydraEngine/source/ecs/systems/HydraMeshSystem.h

@@ -9,13 +9,10 @@
 class HydraMeshSystem : public HydraSystem
 {
     public:
-        
         void Initialise() override;
-        
-    protected: 
         void InitialiseComponent(HydraID entity_id) override;
+    protected: 
         void DestroyComponent(HydraID entity_id) override;
-        
         virtual void UpdateSystem(float delta_t_seconds){}
 };
 

HydraEngine/source/ecs/systems/HydraPhysicsSystem.cpp

@@ -7,6 +7,7 @@
 #include "../../task/physics/HydraSetPhysicsTransform.hpp"
 #include "../../task/physics/HydraGetPhysicsUpdatesTask.hpp"
 #include "../../task/physics/HydraStepPhysicsTask.h"
+#include "../../task/physics/HydraSetPhysicsLinearVelocity.hpp"
 #include "../../ecs/HydraECS.h"
 #include "../../ecs/components/HydraPhysicsComponent.h"
 #include "../../ecs/components/HydraPositionComponent.h"
@@ -40,14 +41,35 @@ void HydraPhysicsSystem::SetTransform(HydraID entity_id)
     HydraPhysicsComponent &phys_comp = GetEngine()->ECS()->GetComponent<HydraPhysicsComponent>(entity_id);
     if(!phys_comp.needs_update)
     {
-        m_bodies_to_set.push(entity_id);
+        m_bodies_to_set_transform.push(entity_id);
         phys_comp.needs_update = true;
     }
+    // HydraTaskScheduler *task_scheduler = GetEngine()->TaskScheduler();
+    // HydraPhysicsComponent& phys_comp = GetEngine()->ECS()->GetComponent<HydraPhysicsComponent>(entity_id);
+    // HydraPositionComponent& pos_comp = GetEngine()->ECS()->GetComponent<HydraPositionComponent>(entity_id);
+
+    // HydraID task_id = task_scheduler->CreateTask<HydraSetPhysicsTransform>(HydraThreadAffinity::Physics);
+    // HydraSetPhysicsTransform *set_task = static_cast<HydraSetPhysicsTransform *>(task_scheduler->GetTask(task_id));
+    // set_task->Initialise(phys_comp.body_id, pos_comp.position, glm::quat(pos_comp.orientation));
+    // task_scheduler->WaitForTask(task_id);       
+}
+
+void HydraPhysicsSystem::SetLinearVelocity(HydraID entity_id, glm::vec3 velocity)
+{
+    PhysicsVelocity vel = {entity_id, velocity};
+    m_bodies_to_set_velocity.push(vel);
+    // HydraPhysicsComponent& phys_comp = GetEngine()->ECS()->GetComponent<HydraPhysicsComponent>(entity_id);
+    // HydraTaskScheduler *task_scheduler = GetEngine()->TaskScheduler();
+    // HydraID task_id = task_scheduler->CreateTask<HydraSetPhysicsLinearVelocity>(HydraThreadAffinity::Physics);
+    // HydraSetPhysicsLinearVelocity *set_task = static_cast<HydraSetPhysicsLinearVelocity *>(task_scheduler->GetTask(task_id));
+    // set_task->Initialise(phys_comp.body_id, velocity);
+    // task_scheduler->WaitForTask(task_id); 
 }
 
 void HydraPhysicsSystem::InitialiseComponent(HydraID entity_id)
 {
     b3BodyId body_id = {};
+
     HydraPhysicsComponent& phys_comp = GetEngine()->ECS()->GetComponent<HydraPhysicsComponent>(entity_id);
     HydraPositionComponent& pos_comp = GetEngine()->ECS()->GetComponent<HydraPositionComponent>(entity_id);
 
@@ -69,15 +91,16 @@ void HydraPhysicsSystem::InitialiseComponent(HydraID entity_id)
 
 void HydraPhysicsSystem::DestroyComponent(HydraID entity_id)
 {
+ 
 }
 
 void HydraPhysicsSystem::UpdateSystem(float delta_t_seconds)
 {
     HydraTaskScheduler *task_scheduler = GetEngine()->TaskScheduler();
-    while(m_bodies_to_set.size() >0)
+    while(m_bodies_to_set_transform.size() >0)
     {
-        HydraID entity_id = m_bodies_to_set.front();
-        m_bodies_to_set.pop();
+        HydraID entity_id = m_bodies_to_set_transform.front();
+        m_bodies_to_set_transform.pop();
         HydraPhysicsComponent& phys_comp = GetEngine()->ECS()->GetComponent<HydraPhysicsComponent>(entity_id);
         HydraPositionComponent& pos_comp = GetEngine()->ECS()->GetComponent<HydraPositionComponent>(entity_id);
 
@@ -86,7 +109,17 @@ void HydraPhysicsSystem::UpdateSystem(float delta_t_seconds)
         set_task->Initialise(phys_comp.body_id, pos_comp.position, glm::quat(pos_comp.orientation));
         task_scheduler->WaitForTask(task_id);          
     }
-       
+    while(m_bodies_to_set_velocity.size() >0)
+    {
+        PhysicsVelocity vel = m_bodies_to_set_velocity.front();
+        m_bodies_to_set_velocity.pop();
+        HydraPhysicsComponent& phys_comp = GetEngine()->ECS()->GetComponent<HydraPhysicsComponent>(vel.entity_id);
+
+        HydraID task_id = task_scheduler->CreateTask<HydraSetPhysicsLinearVelocity>(HydraThreadAffinity::Physics);
+        HydraSetPhysicsLinearVelocity *set_task = static_cast<HydraSetPhysicsLinearVelocity *>(task_scheduler->GetTask(task_id));
+        set_task->Initialise(phys_comp.body_id, vel.velocity);
+        task_scheduler->WaitForTask(task_id);          
+    }
 }
 
 void HydraPhysicsSystem::StepPhysics(float delta_t)

HydraEngine/source/ecs/systems/HydraPhysicsSystem.h

@@ -8,6 +8,12 @@
 
 #include <box3d/box3d.h>
 
+struct PhysicsVelocity
+{
+    HydraID entity_id;
+    glm::vec3 velocity;
+};
+
 class HydraPhysicsSystem : public HydraSystem
 {
     public:
@@ -15,15 +21,17 @@ class HydraPhysicsSystem : public HydraSystem
         void Initialise() override;
         void Shutdown() override;
         void SetTransform(HydraID entity_id);
+        void SetLinearVelocity(HydraID entity_id, glm::vec3 velocity);
         void StepPhysics(float delta_t);
-    protected: 
         void InitialiseComponent(HydraID entity_id) override;
+    protected: 
         void DestroyComponent(HydraID entity_id) override;
-        
         virtual void UpdateSystem(float delta_t_seconds);
     private: 
         b3WorldId m_world_id;
-        std::queue<HydraID> m_bodies_to_set;
+        std::queue<HydraID> m_bodies_to_set_transform;
+        std::queue<PhysicsVelocity> m_bodies_to_set_velocity;
+        
 };
 
 #endif /* HYDRAPHYSICSSYSTEM */

HydraEngine/source/ecs/systems/HydraPointShadowSourceSystem.h

@@ -13,8 +13,8 @@ class HydraPointShadowSourceSystem : public HydraSystem
 {
     public:        
         virtual void Initialise() override;
-    protected: 
         void InitialiseComponent(HydraID entity_id) override;
+    protected: 
         void UpdateSystem(float delta_t_seconds) override;
         void DestroyComponent(HydraID entity_id) override;
     private:

HydraEngine/source/ecs/systems/HydraSpotShadowSourceSystem.h

@@ -14,8 +14,9 @@ class HydraSpotShadowSourceSystem : public HydraSystem
 {
     public:        
         virtual void Initialise() override;
-    protected: 
         void InitialiseComponent(HydraID entity_id) override;
+    protected: 
+        
         void UpdateSystem(float delta_t_seconds) override;
         void DestroyComponent(HydraID entity_id) override;
     private:

HydraEngine/source/ecs/systems/HydraTickActorsSystem.cpp

@@ -0,0 +1,25 @@
+#include "HydraTickActorsSystem.h"
+#include "../../actor/HydraActorManager.h"
+#include "../components/HydraTickComponent.h"
+#include "../HydraECS.h"
+
+void HydraTickActorsSystem::FixedUpdate(float delta_t_seconds)
+{
+    HydraActorManager* actor_manager = GetEngine()->ActorManager();
+    HydraECS* ecs = GetEngine()->ECS();
+    
+
+    for(HydraID entity_id:Entities)
+    {
+        HydraTickComponent tick_comp = ecs->GetComponent<HydraTickComponent>(entity_id);
+        if(tick_comp.fixed)
+        {
+            actor_manager->FixedTickActor(entity_id, delta_t_seconds);
+        }
+    }
+}
+
+void HydraTickActorsSystem::UpdateSystem(float delta_t_seconds)
+{
+    
+}

HydraEngine/source/ecs/systems/HydraTickActorsSystem.h

@@ -0,0 +1,23 @@
+#ifndef HYDRATICKACTORSSYSTEM
+#define HYDRATICKACTORSSYSTEM
+
+#include "../../engine/HydraObject.h"
+#include "../HydraSystem.h"
+#include "../components/HydraLightComponent.h"
+#include <GLMIncludes.h>
+#include <queue>
+#include <vector>
+
+
+
+class HydraTickActorsSystem : public HydraSystem
+{
+    public:        
+       void FixedUpdate(float delta_t_seconds);
+    protected: 
+       void UpdateSystem(float delta_t_seconds) override;
+    private:            
+        
+  
+};
+#endif /* HYDRAFIXEDTICKACTORSSYSTEM */

HydraEngine/source/ecs/systems/HydraTransformSystem.cpp

@@ -13,7 +13,6 @@
 
 void HydraTransformSystem::UpdateTransform(HydraID actor_id, bool ignore_physics)
 {
-
     HydraECS *ecs = GetEngine()->ECS();
     HydraPositionComponent &pos_comp = ecs->GetComponent<HydraPositionComponent>(actor_id);
     pos_comp.needs_update = true;

HydraEngine/source/ecs/systems/HydraTransformSystem.h

@@ -10,11 +10,9 @@ class HydraTransformSystem : public HydraSystem
         
         void UpdateTransform(HydraID actor_id, bool ignore_physics = false);
         void Initialise() override;
-        
-    protected: 
-
-        virtual void UpdateSystem(float delta_t_seconds) override;
         void InitialiseComponent(HydraID actor_id) override;
+    protected: 
+        virtual void UpdateSystem(float delta_t_seconds) override;
         void FreeSystemResources() override;
     private:
         void _UpdateChild(HydraID parent_id, HydraID actor_id, glm::mat4 parent_transform);

HydraEngine/source/engine/HydraEngine.cpp

@@ -25,6 +25,7 @@
 #include "../ecs/systems/HydraSpotShadowSourceSystem.h"
 #include "../ecs/systems/HydraPointShadowSourceSystem.h"
 #include "../ecs/systems/HydraPhysicsSystem.h"
+#include "../ecs/systems/HydraTickActorsSystem.h"
 
 #include "../ecs/components/HydraPositionComponent.h"
 #include "../ecs/components/HydraMeshComponent.h"
@@ -36,7 +37,7 @@
 #include "../ecs/components/HydraSpotShadowSourceComponent.h"
 #include "../ecs/components/HydraPointShadowSourceComponent.h"
 #include "../ecs/components/HydraPhysicsComponent.h"
-
+#include "../ecs/components/HydraTickComponent.h"
 
 #include "../camera/HydraCamera.h"
 #include "../actor/HydraActorManager.h"
@@ -175,6 +176,11 @@ float HydraEngine::GetDeltaT()
     return m_delta_t;
 }
 
+float HydraEngine::GetFixedDeltaT()
+{
+    return m_fixed_delta_t;
+}
+
 uint32_t HydraEngine::GetLightCount()
 {
     return m_light_buffer_manager->GetLightCount();
@@ -238,6 +244,7 @@ void HydraEngine::_InitialiseSystems()
     m_ecs->RegisterComponentType<HydraSpotShadowSourceComponent>();
     m_ecs->RegisterComponentType<HydraPointShadowSourceComponent>();
     m_ecs->RegisterComponentType<HydraPhysicsComponent>();
+    m_ecs->RegisterComponentType<HydraTickComponent>();
 
     m_mesh_system = m_ecs->RegisterSystem<HydraMeshSystem>();
     m_transform_system = m_ecs->RegisterSystem<HydraTransformSystem>();
@@ -248,6 +255,7 @@ void HydraEngine::_InitialiseSystems()
     m_spot_shadow_system = m_ecs->RegisterSystem<HydraSpotShadowSourceSystem>();
     m_point_shadow_system = m_ecs->RegisterSystem<HydraPointShadowSourceSystem>();
     m_physics_system = m_ecs->RegisterSystem<HydraPhysicsSystem>();
+    m_tick_system = m_ecs->RegisterSystem<HydraTickActorsSystem>();
 
     HydraSignature mesh_sig;
     HydraSignature trans_sig;
@@ -258,6 +266,7 @@ void HydraEngine::_InitialiseSystems()
     HydraSignature spot_shadow_sig;
     HydraSignature point_shadow_sig;
     HydraSignature physics_sig;
+    HydraSignature tick_sig;
 
     mesh_sig.set(m_ecs->GetComponentType<HydraMeshComponent>(),true);
     trans_sig.set(m_ecs->GetComponentType<HydraPositionComponent>(),true);
@@ -282,6 +291,8 @@ void HydraEngine::_InitialiseSystems()
     physics_sig.set(m_ecs->GetComponentType<HydraPhysicsComponent>(), true);
     physics_sig.set(m_ecs->GetComponentType<HydraPositionComponent>(), true);
 
+    tick_sig.set(m_ecs->GetComponentType<HydraTickComponent>(), true);
+    
     m_ecs->SetSystemSignature<HydraMeshSystem>(mesh_sig);
     m_ecs->SetSystemSignature<HydraTransformSystem>(trans_sig);
     m_ecs->SetSystemSignature<HydraRenderSystem>(render_sig);
@@ -291,7 +302,7 @@ void HydraEngine::_InitialiseSystems()
     m_ecs->SetSystemSignature<HydraSpotShadowSourceSystem>(spot_shadow_sig);
     m_ecs->SetSystemSignature<HydraPointShadowSourceSystem>(point_shadow_sig);
     m_ecs->SetSystemSignature<HydraPhysicsSystem>(physics_sig);
-
+    m_ecs->SetSystemSignature<HydraTickActorsSystem>(tick_sig);
 }
 
  void HydraEngine::_UpdateSystems()
@@ -299,7 +310,7 @@ void HydraEngine::_InitialiseSystems()
 
     //Update physics system with any changes from the transform system
     m_physics_system->Update(m_delta_t);
-
+    
     HydraID posUpdateBarrierID = m_task_scheduler->CreateBarrier();
 
     HydraID update_trans_id = m_task_scheduler->CreateTask<HydraUpdateSystemTask>(HydraThreadAffinity::General, posUpdateBarrierID);
@@ -340,6 +351,7 @@ void HydraEngine::_InitialiseSystems()
     m_task_scheduler->StartTask(update_point_shadow_id);
     m_task_scheduler->WaitForBarrier(shadow_barrier);
 
+    m_tick_system->FixedUpdate(m_fixed_delta_t);
     m_shadow_buffer_manager->UpdateShadowBuffer();
 }
 

HydraEngine/source/engine/HydraEngine.h

@@ -30,6 +30,7 @@ class HydraSpotShadowSourceSystem;
 class HydraShadowBufferManager;
 class HydraPointShadowSourceSystem;
 class HydraPhysicsSystem;
+class HydraTickActorsSystem;
 
 class CLASS_DEFINE HydraEngine : public HydraObject
 {
@@ -67,6 +68,7 @@ public:
     void PossessPlayer(HydraID actor_id);
     HydraID GetPossessedPlayer();
     float GetDeltaT();
+    float GetFixedDeltaT();
     uint32_t GetLightCount();
 private: 
     void _CreateManagers();
@@ -105,7 +107,7 @@ private:
     std::shared_ptr<HydraSpotShadowSourceSystem> m_spot_shadow_system;
     std::shared_ptr<HydraPointShadowSourceSystem> m_point_shadow_system;
     std::shared_ptr<HydraPhysicsSystem> m_physics_system;
-
+    std::shared_ptr<HydraTickActorsSystem> m_tick_system;
     bool m_running = true;
     float m_delta_t = 0.0f;
     float m_fixed_delta_t = 0.0f;

HydraEngine/source/task/physics/HydraSetPhysicsLinearVelocity.hpp

@@ -0,0 +1,31 @@
+#ifndef HYDRASETPHYSICSLINEARVELOCITY
+#define HYDRASETPHYSICSLINEARVELOCITY
+
+
+#include "../HydraTask.h"
+#include "../../engine/HydraEngine.h"
+#include "../../renderer/HydraRenderer.h"
+#include <GLMIncludes.h>
+#include "../../GlewIncludes.h"
+#include "../../buffer/HydraTextureBufferManager.h"
+#include <box3d/box3d.h>
+
+class HydraSetPhysicsLinearVelocity : public HydraTask
+{
+private:
+    b3BodyId m_body_id = {};
+    glm::vec3 m_velocity = {};
+protected:
+public:
+    void Process() override
+    {
+        b3Vec3 velocity = {m_velocity.x, m_velocity.y, m_velocity.z};
+        b3Body_SetLinearVelocity(m_body_id, velocity);
+    }
+    void Initialise(b3BodyId body_id, glm::vec3 velocity)
+    {
+        m_body_id = body_id;
+        m_velocity = velocity;
+    }
+};
+#endif /* HYDRASETPHYSICSLINEARVELOCITY */

HydraEngine/source/task/physics/HydraSetPhysicsTransform.hpp

@@ -25,7 +25,7 @@ public:
         b3Quat rotation = {m_rotation.x, m_rotation.y, m_rotation.z, m_rotation.w};
 
         b3Body_SetTransform(m_body_id, position, rotation);
-            
+        
     }
     void Initialise(b3BodyId body_id, glm::vec3 position, glm::quat rotation)
     {

HydraEngine/source/task/physics/HydraStepPhysicsTask.h

@@ -22,6 +22,7 @@ public:
        b3World_Step(m_world_id, m_delta_t_seconds, 1);
     
         b3BodyEvents events = b3World_GetBodyEvents(m_world_id);
+        
         HydraTaskScheduler* task_scheduler = GetEngine()->TaskScheduler();
         HydraID barrier_id = task_scheduler->CreateBarrier();