BTH/axyz
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge branch 'master' into Respawning

Browse Source 
# Conflicts:
#	src/Game/Game.cpp
#	src/Game/Systems/PlayerSpawnSystem.cpp
#	src/Game/Systems/SoundSystem.cpp
This commit is contained in:
William Moberg
2016-02-11 16:15:47 +01:00
parent 8eea0c8395 38a3e88999
commit 97b915f130
126 changed files with 2545 additions and 1062 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/Engine/Collision/CollisionSystem.h
+2 -2
View File
@@ -13,8 +13,8 @@
class CollisionSystem : public PureSystem
{
public:
CollisionSystem(World* world, EventBroker* eventBroker, Octree<EntityAABB>* octree)
: System(world, eventBroker)
CollisionSystem(SystemParams params, Octree<EntityAABB>* octree)
: System(params)
, PureSystem("Collidable")
, m_Octree(octree)
{ }
include/Engine/Collision/FillFrustumOctreeSystem.h
+2 -2
View File
@@ -9,8 +9,8 @@
class FillFrustumOctreeSystem : public ImpureSystem, public PureSystem
{
public:
FillFrustumOctreeSystem(World* world, EventBroker* eventBroker, Octree<EntityAABB>* octree)
: System(world, eventBroker)
FillFrustumOctreeSystem(SystemParams params, Octree<EntityAABB>* octree)
: System(params)
, PureSystem("Model")
, m_Octree(octree)
{ }
include/Engine/Collision/FillOctreeSystem.h
+2 -2
View File
@@ -9,8 +9,8 @@
class FillOctreeSystem : public ImpureSystem, public PureSystem
{
public:
FillOctreeSystem(World* world, EventBroker* eventBroker, Octree<EntityAABB>* octree, const std::string& fillComponentType)
: System(world, eventBroker)
FillOctreeSystem(SystemParams params, Octree<EntityAABB>* octree, const std::string& fillComponentType)
: System(params)
, PureSystem(fillComponentType)
, m_Octree(octree)
{ }
include/Engine/Collision/TriggerSystem.h
+2 -2
View File
@@ -15,8 +15,8 @@ class AABB;
class TriggerSystem : public PureSystem
{
public:
TriggerSystem(World* world, EventBroker* eventBroker, Octree<EntityAABB>* octree)
: System(world, eventBroker)
TriggerSystem(SystemParams params, Octree<EntityAABB>* octree)
: System(params)
, PureSystem("Trigger")
, m_Octree(octree)
{
include/Engine/Core/ComponentInfo.h
+1
View File
@@ -13,6 +13,7 @@ struct ComponentInfo
unsigned int Allocation = 0;
std::map<std::string, std::string> FieldAnnotations;
std::map<std::string, std::map<std::string, EnumType>> FieldEnumDefinitions;
bool NetworkReplicated = true;
};
struct Field_t
include/Engine/Core/ComponentWrapper.h
+13
View File
@@ -1,6 +1,7 @@
#ifndef ComponentWrapper_h__
#define ComponentWrapper_h__
#include <boost/shared_array.hpp>
#include "../Common.h"
#include "Entity.h"
#include "ComponentInfo.h"
@@ -81,6 +82,18 @@ struct ComponentWrapper
SubscriptProxy operator[](std::string propertyName) { return SubscriptProxy(this, propertyName); }
};
// A component wrapper that "owns" its data through a shared pointer
struct SharedComponentWrapper : ComponentWrapper
{
SharedComponentWrapper(const ComponentInfo& componentInfo, boost::shared_array<char> data)
: ComponentWrapper(componentInfo, data.get())
, m_DataReference(data)
{ }
private:
boost::shared_array<char> m_DataReference;
};
// TODO: Move this to Tests once entity importing is finished
class ComponentWrapperFactory
{
include/Engine/Core/EntityFilePreprocessor.h
+2
View File
@@ -3,6 +3,8 @@
#include <xercesc/framework/psvi/XSElementDeclaration.hpp>
#include <xercesc/framework/psvi/XSComplexTypeDefinition.hpp>
#include <xercesc/framework/psvi/XSAttributeUse.hpp>
#include <xercesc/framework/psvi/XSAttributeDeclaration.hpp>
#include <xercesc/framework/psvi/XSParticle.hpp>
#include <xercesc/framework/psvi/XSModelGroup.hpp>
#include <xercesc/framework/psvi/XSModelGroupDefinition.hpp>
include/Engine/Core/EntityWrapper.h
+1 -1
View File
@@ -30,7 +30,7 @@ struct EntityWrapper
EntityWrapper FirstChildByName(const std::string& name);
EntityWrapper FirstParentWithComponent(const std::string& componentType);
bool IsChildOf(EntityWrapper potentialParent);
bool Valid();
bool Valid() const;
ComponentWrapper operator[](const char* componentName);
bool operator==(const EntityWrapper& e) const;
include/Engine/Core/EventBroker.h
+2 -1
View File
@@ -5,6 +5,7 @@
#include <functional>
#include <list>
#include <tuple>
#include <set>
#include "../Common.h"
#include "Event.h"
@@ -107,7 +108,7 @@ private:
typedef std::unordered_map<ContextTypeName_t, EventRelays_t> ContextRelays_t;
ContextRelays_t m_ContextRelays;
std::vector<BaseEventRelay*> m_RelaysToSubscribe;
std::vector<std::tuple<EventID, ContextTypeName_t, EventTypeName_t>> m_RelaysToUnsubscribe;
std::unordered_map<BaseEventRelay*, std::tuple<EventID, ContextTypeName_t, EventTypeName_t>> m_RelaysToUnsubscribe;
typedef std::list<std::pair<EventTypeName_t, std::shared_ptr<Event>>> EventQueue_t;
std::shared_ptr<EventQueue_t> m_EventQueueRead;
include/Engine/Core/Octree.h
+1 -3
View File
@@ -6,9 +6,7 @@
#include "../Common.h"
#include "AABB.h"
#include "Frustum.h"
//Fwd declarations.
class Ray;
#include "Ray.h"
namespace OctSpace
{
include/Engine/Core/System.h
+40 -6
View File
@@ -5,21 +5,55 @@
#include "World.h"
#include "EntityWrapper.h"
#include "ComponentWrapper.h"
#include "EPlayerSpawned.h"
struct SystemParams
{
SystemParams(::World* World, ::EventBroker* EventBroker, bool IsClient, bool IsServer)
: World(World)
, EventBroker(EventBroker)
, IsClient(IsClient)
, IsServer(IsServer)
{ }
::World* World;
::EventBroker* EventBroker;
bool IsClient = false;
bool IsServer = false;
};
class System
{
friend class SystemPipeline;
protected:
System(World* world, EventBroker) { }
System(World* world, EventBroker* eventBroker)
: m_World(world)
, m_EventBroker(eventBroker)
{ }
System(SystemParams params)
: m_World(params.World)
, m_EventBroker(params.EventBroker)
, IsClient(params.IsClient)
, IsServer(params.IsServer)
{
if (IsClient) {
EVENT_SUBSCRIBE_MEMBER(m_EPlayerSpawned, &System::setLocalPlayer);
}
}
virtual ~System() = default;
World* m_World;
EventBroker* m_EventBroker;
bool IsClient = false;
bool IsServer = false;
EntityWrapper LocalPlayer = EntityWrapper::Invalid;
private:
EventRelay<System, Events::PlayerSpawned> m_EPlayerSpawned;
virtual bool setLocalPlayer(Events::PlayerSpawned& e)
{
if (e.PlayerID == -1) {
LocalPlayer = e.Player;
}
return true;
}
};
class PureSystem : public virtual System
@@ -34,7 +68,7 @@ protected:
const std::string m_ComponentType;
virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& cComponent, double dt) = 0;
virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& cPlayer, double dt) = 0;
};
class ImpureSystem : public virtual System
include/Engine/Core/SystemPipeline.h
+9 -2
View File
@@ -10,9 +10,11 @@
class SystemPipeline
{
public:
SystemPipeline(World* world, EventBroker* eventBroker)
SystemPipeline(World* world, EventBroker* eventBroker, bool isClient, bool isServer)
: m_World(world)
, m_EventBroker(eventBroker)
, m_IsClient(isClient)
, m_IsServer(isServer)
{
EVENT_SUBSCRIBE_MEMBER(m_EPause, &SystemPipeline::OnPause);
EVENT_SUBSCRIBE_MEMBER(m_EResume, &SystemPipeline::OnResume);
@@ -35,7 +37,7 @@ public:
m_OrderedSystemGroups.resize(updateOrderLevel + 1);
}
UnorderedSystems& group = m_OrderedSystemGroups[updateOrderLevel];
System* system = new T(m_World, m_EventBroker, args...);
System* system = new T(SystemParams(m_World, m_EventBroker, m_IsClient, m_IsServer), args...);
group.Systems[typeid(T).name()] = system;
PureSystem* pureSystem = dynamic_cast<PureSystem*>(system);
@@ -59,6 +61,9 @@ public:
dt = 0.0;
}
// Process utility events for the System base class
m_EventBroker->Process<System>();
for (UnorderedSystems& group : m_OrderedSystemGroups) {
// Process events
for (auto& pair : group.Systems) {
@@ -88,6 +93,8 @@ public:
private:
World* m_World;
EventBroker* m_EventBroker;
bool m_IsClient = false;
bool m_IsServer = false;
bool m_Paused = false;
struct UnorderedSystems
include/Engine/Core/UniformScaleSystem.h
+1 -1
View File
@@ -8,7 +8,7 @@
class UniformScaleSystem : public PureSystem
{
public:
UniformScaleSystem(World* world, EventBroker* eventBroker);
UniformScaleSystem(SystemParams params);
virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& cUniformScale, double dt) override;
include/Engine/Editor/EditorRenderSystem.h
+1 -1
View File
@@ -10,7 +10,7 @@
class EditorRenderSystem : public ImpureSystem
{
public:
EditorRenderSystem(World* world, EventBroker* eventBroker, IRenderer* renderer, RenderFrame* renderFrame);
EditorRenderSystem(SystemParams params, IRenderer* renderer, RenderFrame* renderFrame);
virtual void Update(double dt) override;
include/Engine/Editor/EditorSystem.h
+1 -1
View File
@@ -17,7 +17,7 @@
class EditorSystem : public ImpureSystem
{
public:
EditorSystem(World* world, EventBroker* eventBroker, IRenderer* renderer, RenderFrame* renderFrame);
EditorSystem(SystemParams params, IRenderer* renderer, RenderFrame* renderFrame);
~EditorSystem();
void Update(double dt);
include/Engine/Editor/EditorWidgetSystem.h
+1 -1
View File
@@ -25,7 +25,7 @@ struct WidgetDelta : Event
class EditorWidgetSystem : public ImpureSystem, PureSystem
{
public:
EditorWidgetSystem(World* world, EventBroker* eventBroker, IRenderer* renderer);
EditorWidgetSystem(SystemParams params, IRenderer* renderer);
virtual void Update(double dt) override;
virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& cEditorWidget, double dt) override;
include/Engine/GUI/TextureFrame.h
+3 -2
View File
@@ -3,6 +3,7 @@
#include "Frame.h"
#include "../Rendering/Texture.h"
#include "../Rendering/Util/CommonFunctions.h"
namespace GUI
{
@@ -55,10 +56,10 @@ public:
return;
}
m_Texture = ResourceManager::Load<Texture>(resourceName);
m_Texture = CommonFunctions::LoadTexture(resourceName, false);
m_TextureName = resourceName;
if (m_Texture == nullptr) {
m_Texture = ResourceManager::Load<Texture>("Textures/Core/ErrorTexture.png");
m_Texture = CommonFunctions::LoadTexture("Textures/Core/ErrorTexture.png", false);
}
SizeToTexture();
include/Engine/Input/FirstPersonInputController.h
+15 -10
View File
@@ -55,6 +55,7 @@ protected:
//specialabilitys
bool m_MovementKeyDown = false;
bool m_SpecialAbilityKeyDown = false;
int m_NumberOfMovementKeysDown = 0;
EventRelay<EventContext, Events::LockMouse> m_ELockMouse;
bool OnLockMouse(const Events::LockMouse& e);
@@ -132,6 +133,7 @@ bool FirstPersonInputController<EventContext>::OnCommand(const Events::InputComm
}
//if value = 0 then you have just released this key
if (e.Value != 0) {
m_NumberOfMovementKeysDown++;
m_MovementKeyDown = true;
//if you pressed the same key within m_AssaultDashDoubleTapSensitivityTimer then you have doubletapped it
if (m_AssaultDashDoubleTapDeltaTime < m_AssaultDashDoubleTapSensitivityTimer && m_AssaultDashTapDirection == m_CurrentDirectionVector) {
@@ -139,10 +141,14 @@ bool FirstPersonInputController<EventContext>::OnCommand(const Events::InputComm
}
} else {
//== 0
m_MovementKeyDown = false;
//you have just released the key, store what key it was and reset the doubletap-sensitivity-timer
m_AssaultDashTapDirection = m_CurrentDirectionVector;
m_AssaultDashDoubleTapDeltaTime = 0.f;
m_NumberOfMovementKeysDown--;
if (m_NumberOfMovementKeysDown == 0) {
m_MovementKeyDown = false;
}
//you have just released the key, store what key it was and reset the doubletap-sensitivity-timer
m_AssaultDashTapDirection = m_CurrentDirectionVector;
m_AssaultDashDoubleTapDeltaTime = 0.f;
}
}
@@ -202,12 +208,6 @@ void FirstPersonInputController<EventContext>::AssaultDashCheck(double dt, bool
m_AssaultDashCoolDownTimer = assaultDashCoolDownMaxTimer;
m_AssaultDashDoubleTapped = true;
m_AssaultDashDoubleTapDeltaTime = 0.f;
//moving to the side has priority
return;
}
//dashing with doubletap - check if doubletap to dash enabled
if (ResourceManager::Load<ConfigFile>("Input.ini")->Get<bool>("Keyboard.DoubleTapToDash", false)) {
return;
}
@@ -216,6 +216,11 @@ void FirstPersonInputController<EventContext>::AssaultDashCheck(double dt, bool
m_AssaultDashDoubleTapped = false;
}
//dashing with doubletap - check if doubletap to dash enabled
if (!ResourceManager::Load<ConfigFile>("Input.ini")->Get<bool>("Keyboard.DoubleTapToDash", false)) {
return;
}
//check if we have received a valid doubletap
if (!m_ValidDoubleTap) {
return;
include/Engine/Network/Client.h
+11 -6
View File
@@ -20,16 +20,22 @@
#include "Input/EInputCommand.h"
#include "Core/EPlayerDamage.h"
#include "Network/EInterpolate.h"
#include "Network/SnapshotFilter.h"
#include "Core/EPlayerSpawned.h"
class Client : public Network
{
public:
Client(ConfigFile* config);
Client(World* world, EventBroker* eventBroker);
Client(World* world, EventBroker* eventBroker, std::unique_ptr<SnapshotFilter> snapshotFilter);
~Client();
void Start(World* world, EventBroker* eventBroker) override;
void Connect(std::string address, int port);
void Update() override;
private:
std::unique_ptr<SnapshotFilter> m_SnapshotFilter = nullptr;
// Assio UDP logic
boost::asio::ip::udp::endpoint m_ReceiverEndpoint;
boost::asio::io_service m_IOService;
@@ -45,10 +51,8 @@ private:
PacketID m_SendPacketID = 0;
// Game logic
World* m_World;
std::string m_PlayerName;
PlayerID m_PlayerID = -1;
EntityID m_ServerEntityID = std::numeric_limits<EntityID>::max();
bool m_IsConnected = false;
EntityWrapper m_LocalPlayer = EntityWrapper::Invalid;
// Server Client Lookup map
@@ -74,7 +78,9 @@ private:
void connect();
void disconnect();
void parseMessageType(Packet& packet);
void updateFields(Packet& packet, const ComponentInfo& componentInfo, const EntityID& entityID, const std::string& componentType);
void updateFields(Packet& packet, const ComponentInfo& componentInfo, const EntityID& entityID);
SharedComponentWrapper createSharedComponent(Packet& packet, EntityID entityID, const ComponentInfo& componentInfo);
void ignoreFields(Packet& packet, const ComponentInfo& componentInfo);
void parseConnect(Packet& packet);
void parsePlayerConnected(Packet& packet);
void parsePing();
@@ -99,7 +105,6 @@ private:
void deleteFromServerClientMaps(EntityID serverEntityID, EntityID clientEntityID);
// Events
EventBroker* m_EventBroker;
EventRelay<Client, Events::InputCommand> m_EInputCommand;
bool OnInputCommand(const Events::InputCommand& e);
EventRelay<Client, Events::PlayerDamage> m_EPlayerDamage;
include/Engine/Network/EInterpolate.h
+7 -2
View File
@@ -11,8 +11,13 @@ namespace Events
struct Interpolate : Event
{
EntityID Entity;
boost::shared_array<char> DataArray;
Interpolate(EntityWrapper Entity, SharedComponentWrapper Component)
: Entity(Entity)
, Component(Component)
{ }
EntityWrapper Entity;
SharedComponentWrapper Component;
};
}
include/Engine/Network/Network.h
+6 -2
View File
@@ -19,10 +19,15 @@ typedef unsigned int PacketID;
class Network
{
public:
Network(World* world, EventBroker* eventBroker);
virtual ~Network() { };
virtual void Start(World* m_world, EventBroker *eventBroker) = 0;
virtual void Update() = 0;
protected:
World* m_World;
EventBroker* m_EventBroker;
// For Debug
bool isReadingData = false;
NetworkData m_NetworkData;
@@ -32,7 +37,6 @@ protected:
double m_TimeoutMs;
void saveToFile();
void updateNetworkData();
void initialize();
};
#endif
include/Engine/Network/Server.h
+7 -7
View File
@@ -22,15 +22,17 @@
class Server : public Network
{
public:
Server();
Server(World* world, EventBroker* eventBroker, int port);
~Server();
void Start(World* m_world, EventBroker *eventBroker) override;
void Update() override;
private:
int m_Port = 27666;
// UDP logic
boost::asio::ip::udp::endpoint m_ReceiverEndpoint;
boost::asio::io_service m_IOService;
boost::asio::ip::udp::socket m_Socket;
std::unique_ptr<boost::asio::ip::udp::socket> m_Socket;
// Sending messages to client logic
std::map<PlayerID, PlayerDefinition> m_ConnectedPlayers;
@@ -46,13 +48,10 @@ private:
float snapshotInterval;
int checkTimeOutInterval = 100;
int m_NextPlayerID = 0;
std::vector<Events::InputCommand> m_InputCommandsToBroadcast;
//Timers
std::clock_t m_StartPingTime;
// Game logic
World* m_World;
EventBroker* m_EventBroker;
// Packet loss logic
PacketID m_PacketID = 0;
@@ -66,6 +65,7 @@ private:
void broadcast(Packet& packet);
void sendSnapshot();
void addChildrenToPacket(Packet& packet, EntityID entityID);
void addInputCommandsToPacket(Packet& packet);
void sendPing();
void checkForTimeOuts();
void disconnect(PlayerID playerID);
include/Engine/Network/SnapshotFilter.h
+19
View File
@@ -0,0 +1,19 @@
#ifndef SnapshotFilter_h__
#define SnapshotFilter_h__
#include "../Core/EntityWrapper.h"
#include "../Core/ComponentWrapper.h"
class SnapshotFilter
{
public:
// Filters an incoming snapshot.
// Modify the component and return true if the component snapshot should be applied.
// Otherwise return false and it will be ignored.
virtual bool FilterComponent(EntityWrapper entity, SharedComponentWrapper& component)
{
return true;
}
};
#endif
include/Engine/Rendering/AnimationSystem.h
+3 -5
View File
@@ -14,8 +14,8 @@
class AnimationSystem : public PureSystem
{
public:
AnimationSystem(World* world, EventBroker* eventBroker)
: System(world, eventBroker)
AnimationSystem(SystemParams params)
: System(params)
, PureSystem("Animation")
{
@@ -23,9 +23,7 @@ public:
~AnimationSystem() { }
virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& animationComponent, double dt) override;
private:
float angle = 0.f;
bool b_forward = false;
char bone[100];
};
#endif
include/Engine/Rendering/BoneAttachmentSystem.h
+2 -2
View File
@@ -13,8 +13,8 @@
class BoneAttachmentSystem : public PureSystem
{
public:
BoneAttachmentSystem(World* world, EventBroker* eventBroker)
: System(world, eventBroker)
BoneAttachmentSystem(SystemParams params)
: System(params)
, PureSystem("BoneAttachment")
{
include/Engine/Rendering/Camera.h
+2
View File
@@ -33,6 +33,8 @@ public:
glm::mat4 ViewMatrix() const { return m_ViewMatrix; }
void SetViewMatrix(glm::mat4 val);
glm::mat4 BillboardMatrix();
float AspectRatio() const { return m_AspectRatio; }
void SetAspectRatio(float val);
include/Engine/Rendering/DrawFinalPass.h
+4
View File
@@ -7,6 +7,7 @@
#include "FrameBuffer.h"
#include "ShaderProgram.h"
#include "Util/UnorderedMapVec2.h"
#include "Util/CommonFunctions.h"
#include "Texture.h"
class DrawFinalPass
@@ -35,6 +36,7 @@ private:
void GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type) const;
void GenerateMipMapTexture(GLuint* texture, GLenum wrapping, glm::vec2 dimensions, GLint format, GLenum type, GLint numMipMaps) const;
void DrawSprites(std::list<std::shared_ptr<RenderJob>>&jobs, RenderScene& scene);
void DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene);
void DrawShieldToStencilBuffer(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene);
void DrawShieldedModelRenderQueue(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene);
@@ -50,6 +52,7 @@ private:
Texture* m_BlackTexture;
Texture* m_NeutralNormalTexture;
Texture* m_GreyTexture;
Texture* m_ErrorTexture;
FrameBuffer m_FinalPassFrameBuffer;
FrameBuffer m_FinalPassFrameBufferLowRes;
@@ -69,6 +72,7 @@ private:
ShaderProgram* m_ForwardPlusProgram;
ShaderProgram* m_ExplosionEffectProgram;
ShaderProgram* m_ExplosionEffectSplatMapProgram;
ShaderProgram* m_SpriteProgram;
ShaderProgram* m_ForwardPlusSplatMapProgram;
ShaderProgram* m_ShieldToStencilProgram;
ShaderProgram* m_FillDepthBufferProgram;
include/Engine/Rendering/IRenderer.h
+3
View File
@@ -32,6 +32,8 @@ public:
virtual void SetFullscreen(bool fullscreen) { m_Fullscreen = fullscreen; }
bool VSYNC() const { return m_VSYNC; }
virtual void SetVSYNC(bool vsync) { m_VSYNC = vsync; }
std::string WindowTitle() const { return m_WindowTitle; }
virtual void SetWindowTitle(const std::string& title) { glfwSetWindowTitle(m_Window, title.c_str()); m_WindowTitle = title; }
//Returns screen size excluding window border and header
Rectangle GetViewportSize() const { return m_ViewportSize; }
virtual void Initialize() = 0;
@@ -47,6 +49,7 @@ protected:
int m_GLVersion[2];
std::string m_GLVendor;
GLFWwindow* m_Window = nullptr;
std::string m_WindowTitle;
};
#endif // Renderer_h__
include/Engine/Rendering/Model.h
+1
View File
@@ -2,6 +2,7 @@
#define Model_h__
#include "Rendering/RawModelCustom.h"
#include "Util/CommonFunctions.h"
//#include "Rendering/RawModelAssimp.h"
#include "../OpenGL.h"
#include "Core/AABB.h"
include/Engine/Rendering/ModelJob.h
+4 -28
View File
@@ -117,33 +117,11 @@ struct ModelJob : RenderJob
FillColor = fillColor;
FillPercentage = fillPercentage;
Skeleton = Model->m_RawModel->m_Skeleton;
if (Skeleton != nullptr) {
if (world->HasComponent(Entity, "Animation")) {
auto animationComponent = world->GetComponent(Entity, "Animation");
for (int i = 1; i <= 3; i++) {
::Skeleton::AnimationData animationData;
animationData.animation = model->m_RawModel->m_Skeleton->GetAnimation(animationComponent["AnimationName" + std::to_string(i)]);
if (animationData.animation == nullptr) {
continue;
}
animationData.time = (double)animationComponent["Time" + std::to_string(i)];
animationData.weight = (double)animationComponent["Weight" + std::to_string(i)];
Animations.push_back(animationData);
}
}
if (world->HasComponent(Entity, "AnimationOffset")) {
auto animationOffsetComponent = world->GetComponent(Entity, "AnimationOffset");
AnimationOffset.animation = model->m_RawModel->m_Skeleton->GetAnimation(animationOffsetComponent["AnimationName"]);
AnimationOffset.time = (double)animationOffsetComponent["Time"];
} else {
AnimationOffset.animation = nullptr;
}
if (model->IsSkinned()) {
Skeleton = Model->m_RawModel->m_Skeleton;
}
};
unsigned int TextureID;
@@ -164,10 +142,8 @@ struct ModelJob : RenderJob
::Skeleton* Skeleton = nullptr;
// const ::Skeleton::Animation* Animation = nullptr;
std::vector<::Skeleton::AnimationData> Animations;
::Skeleton::AnimationOffset AnimationOffset;
float AnimationTime = 0.f;
glm::vec4 DiffuseColor;
glm::vec4 SpecularColor;
include/Engine/Rendering/PNG.h
+2 -1
View File
@@ -6,9 +6,10 @@
#include <png.h>
#include "../Common.h"
#include "../Core/ResourceManager.h"
#include "Image.h"
class PNG : public Image
class PNG : public Image, public Resource
{
public:
PNG(std::string path);
include/Engine/Rendering/RawModelCustom.h
+1 -1
View File
@@ -50,7 +50,7 @@ public:
struct TextureProperties {
std::string TexturePath;
glm::vec2 UVRepeat;
std::shared_ptr<::Texture> Texture;
Texture* Texture;
};
struct MaterialBasic
include/Engine/Rendering/RenderQueue.h
+3 -1
View File
@@ -15,6 +15,7 @@
#include "PointLightJob.h"
#include "DirectionalLightJob.h"
#include "ExplosionEffectJob.h"
#include "SpriteJob.h"
struct RenderScene
{
@@ -25,6 +26,7 @@ struct RenderScene
std::list<std::shared_ptr<RenderJob>> OpaqueShieldedObjects;
std::list<std::shared_ptr<RenderJob>> TransparentShieldedObjects;
std::list<std::shared_ptr<RenderJob>> ShieldObjects;
std::list<std::shared_ptr<RenderJob>> SpriteJob;
std::list<std::shared_ptr<RenderJob>> PointLight;
std::list<std::shared_ptr<RenderJob>> Text;
std::list<std::shared_ptr<RenderJob>> DirectionalLight;
@@ -41,7 +43,7 @@ struct RenderScene
Jobs.OpaqueShieldedObjects.clear();
Jobs.TransparentShieldedObjects.clear();
Jobs.ShieldObjects.clear();
Jobs.Text.clear();
Jobs.SpriteJob.clear();
Jobs.DirectionalLight.clear();
}
};
include/Engine/Rendering/RenderSystem.h
+2 -2
View File
@@ -22,7 +22,7 @@
class RenderSystem : public ImpureSystem
{
public:
RenderSystem(World* world, EventBroker* eventBrokerer, const IRenderer* renderer, RenderFrame* renderFrame, Octree<EntityAABB>* frustumCullOctree);
RenderSystem(SystemParams params, const IRenderer* renderer, RenderFrame* renderFrame, Octree<EntityAABB>* frustumCullOctree);
~RenderSystem();
virtual void Update(double dt) override;
@@ -31,7 +31,6 @@ private:
const IRenderer* m_Renderer;
RenderFrame* m_RenderFrame;
Camera* m_Camera;
World* m_World;
EntityWrapper m_CurrentCamera = EntityWrapper::Invalid;
EntityWrapper m_LocalPlayer = EntityWrapper::Invalid;
Octree<EntityAABB>* m_Octree;
@@ -48,6 +47,7 @@ private:
void fillPointLights(std::list<std::shared_ptr<RenderJob>>& jobs, World* world);
void fillDirectionalLights(std::list<std::shared_ptr<RenderJob>>& jobs, World* world);
void fillLight(std::list<std::shared_ptr<RenderJob>>& jobs);
void fillSprites(std::list<std::shared_ptr<RenderJob>>& jobs, World* world);
bool isChildOfACamera(EntityWrapper entity);
bool isChildOfCurrentCamera(EntityWrapper entity);
};
include/Engine/Rendering/Renderer.h
+1
View File
@@ -22,6 +22,7 @@
#include "../Core/Transform.h"
#include "imgui/imgui.h"
#include "TextPass.h"
#include "Util/CommonFunctions.h"
class Renderer : public IRenderer
{
include/Engine/Rendering/Skeleton.h
+29 -6
View File
@@ -100,13 +100,13 @@ public:
int GetBoneID(std::string name);
const Animation* GetAnimation(std::string name);
std::vector<glm::mat4> GetFrameBones(std::vector<AnimationData> animations, bool noRootMotion = false);
std::vector<glm::mat4> GetFrameBones(std::vector<AnimationData> animations, AnimationOffset animationOffset, bool noRootMotion = false);
void CalculateFrameBones(std::vector<AnimationData> animations, AnimationOffset animationOffset, bool noRootMotion = false);
void CalculateFrameBones(std::vector<AnimationData> animations, bool noRootMotion = false);
//void AccumulateBoneTransforms(bool noRootMotion, const Animation* animation, float time, std::map<int, glm::mat4>& boneMatrices, const Bone* bone, glm::mat4 parentMatrix);
void AccumulateBoneTransforms(bool noRootMotion, std::vector<AnimationData> animations, std::map<int, glm::mat4>& boneMatrices, const Bone* bone, glm::mat4 parentMatrix);
void AccumulateBoneTransforms(bool noRootMotion, std::vector<AnimationData> animations, AnimationOffset animationOffset, std::map<int, glm::mat4>& boneMatrices, const Bone* bone, glm::mat4 parentMatrix);
const Animation* GetAnimation(std::string name);
void AccumulateBoneTransforms(bool noRootMotion, std::vector<AnimationData> animations, const Bone* bone, glm::mat4 parentMatrix);
void AccumulateBoneTransforms(bool noRootMotion, std::vector<AnimationData> animations, AnimationOffset animationOffset, const Bone* bone, glm::mat4 parentMatrix);
void PrintSkeleton();
void PrintSkeleton(const Bone* parent, int depthCount);
@@ -115,12 +115,35 @@ public:
glm::mat4 GetBoneTransform(const Bone* bone, const Animation* animation, float time, glm::mat4 childMatrix);
int GetKeyframe(const Animation& animation, double time);
std::vector<glm::mat4> GetBones()
{
std::vector<glm::mat4> finalMatrices;
for (auto &kv : m_BoneLocalTransforms) {
finalMatrices.push_back(kv.second);
}
return finalMatrices;;
}
glm::mat4 GetBoneTransformSuper(int boneID)
{
if(m_BoneTransforms.find(boneID) != m_BoneTransforms.end()) {
return m_BoneTransforms.at(boneID);
} else {
return glm::mat4(1);
}
}
private:
glm::mat4 GetOffsetTransform(const Bone* bone, AnimationOffset animationOffset);
std::map<std::string, Bone*> m_BonesByName;
float aim = 0.f;
std::map<int, glm::mat4> m_BoneLocalTransforms;
std::map<int, glm::mat4> m_BoneTransforms;
};
#endif
include/Engine/Rendering/SpriteJob.h
+73
View File
@@ -0,0 +1,73 @@
#ifndef SpriteJob_h__
#define SpriteJob_h__
#include <cstdint>
#include "../Common.h"
#include "../GLM.h"
#include "../Core/ComponentWrapper.h"
#include "Texture.h"
#include "Model.h"
#include "RenderJob.h"
#include "../Core/ResourceManager.h"
#include "Camera.h"
#include "../Core/World.h"
#include "../Core/Transform.h"
#include "Skeleton.h"
struct SpriteJob : RenderJob
{
SpriteJob(ComponentWrapper cSprite, Camera* camera, glm::mat4 matrix, World* world, glm::vec4 fillColor, float fillPercentage, bool depthSorted)
: RenderJob()
{
Model = ResourceManager::Load<::Model>("Models/Core/UnitQuad.mesh");
::RawModel::MaterialProperties matProp = Model->MaterialGroups().front();
TextureID = 0;
DiffuseTexture = CommonFunctions::LoadTexture(cSprite["DiffuseTexture"], true);
IncandescenceTexture = CommonFunctions::LoadTexture(cSprite["GlowMap"], true);
StartIndex = matProp.material->StartIndex;
EndIndex = matProp.material->EndIndex;
Matrix = matrix;
Color = cSprite["Color"];
Entity = cSprite.EntityID;
Position = Transform::AbsolutePosition(world, cSprite.EntityID);
Depth = 0;
if (depthSorted) {
glm::vec3 viewpos = glm::vec3(camera->ViewMatrix() * glm::vec4(Position, 1));
Depth = viewpos.z;
}
World = world;
FillColor = fillColor;
FillPercentage = fillPercentage;
};
unsigned int TextureID;
EntityID Entity;
glm::mat4 Matrix;
const Texture* DiffuseTexture;
const Texture* NormalTexture;
const Texture* SpecularTexture;
const Texture* IncandescenceTexture;
float Shininess = 0.f;
glm::vec4 Color;
glm::vec3 Position;
const ::Model* Model = nullptr;
unsigned int StartIndex = 0;
unsigned int EndIndex = 0;
World* World;
glm::vec4 FillColor = glm::vec4(0);
float FillPercentage = 0.0;
void CalculateHash() override
{
Hash = TextureID;
}
};
#endif
include/Engine/Rendering/Util/CommonFunctions.h
+4 -7
View File
@@ -4,14 +4,11 @@
#include "../../Common.h"
#include "../../OpenGL.h"
#include "../../GLM.h"
#include "../Texture.h"
class CommonFuntions
{
public:
CommonFuntions() = delete;
private:
namespace CommonFunctions
{
Texture* LoadTexture(std::string path, bool threaded);
};
#endif
include/Game/ExplosionEffectSystem.h
-24
View File
@@ -1,24 +0,0 @@
#include "Common.h"
#include "Core/System.h"
class ExplosionEffectSystem : public PureSystem
{
public:
ExplosionEffectSystem(World* world, EventBroker* eventBroker)
: System(world, eventBroker)
, PureSystem("ExplosionEffect")
{ }
virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt) override
{
if ((double)component["TimeSinceDeath"] > (double)component["ExplosionDuration"]) {
(double)component["TimeSinceDeath"] = 0.f;
}
(double&)component["TimeSinceDeath"] += dt;
//if ((bool)Component["Gravity"] == true) {
// (bool)Component["ExponentialAccelaration"] = false;
//}
}
};
include/Game/Game.h
+12 -17
View File
@@ -1,6 +1,8 @@
#ifndef Game_h__
#define Game_h__
#include <boost/program_options.hpp>
#include "Core/ResourceManager.h"
#include "Core/ConfigFile.h"
#include "Core/EventBroker.h"
@@ -14,7 +16,7 @@
#include "Core/EKeyDown.h"
#include "Core/EntityFilePreprocessor.h"
#include "Core/SystemPipeline.h"
#include "ExplosionEffectSystem.h"
#include "Systems/ExplosionEffectSystem.h"
#include "Editor/EditorSystem.h"
#include "Core/EntityFile.h"
#include "Rendering/RenderSystem.h"
@@ -43,7 +45,9 @@ public:
void Tick();
private:
double m_LastTime;
std::string m_NetworkAddress;
int m_NetworkPort = 0;
ConfigFile* m_Config = nullptr;
EventBroker* m_EventBroker;
IRenderer* m_Renderer;
@@ -56,24 +60,15 @@ private:
Octree<EntityAABB>* m_OctreeFrustrumCulling;
SystemPipeline* m_SystemPipeline;
RenderFrame* m_RenderFrame;
// Network variables
boost::thread m_NetworkThread;
// Network methods
void networkFunction();
Network* m_ClientOrServer;
bool m_IsClientOrServer = false;
// Sound
Client* m_NetworkClient = nullptr;
Server* m_NetworkServer = nullptr;
SoundManager* m_SoundManager;
double m_LastTime;
//EventRelay<Game, Events::InputCommand> m_EInputCommand;
//bool debugOnInputCommand(const Events::InputCommand& e);
void debugInitialize();
void debugTick(double dt);
EventRelay<Client, Events::KeyDown> m_EKeyDown;
bool m_IsClient = false;
bool m_IsServer = false;
int parseArgs(int argc, char* argv[]);
};
#endif
include/Game/Network/MultiplayerSnapshotFilter.h
+25
View File
@@ -0,0 +1,25 @@
#ifndef MultiplayerSnapshotFilter_h__
#define MultiplayerSnapshotFilter_h__
#include "Core/EventBroker.h"
#include "Core/EPlayerSpawned.h"
#include "Network/SnapshotFilter.h"
#include "Network/EInterpolate.h"
class MultiplayerSnapshotFilter : public SnapshotFilter
{
public:
MultiplayerSnapshotFilter(EventBroker* eventBroker);
virtual bool FilterComponent(EntityWrapper entity, SharedComponentWrapper& component) override;
private:
EventBroker* m_EventBroker;
EntityWrapper m_LocalPlayer = EntityWrapper::Invalid;
EventRelay<MultiplayerSnapshotFilter, Events::PlayerSpawned> m_EPlayerSpawned;
bool OnPlayerSpawned(Events::PlayerSpawned ePlayerSpawned);
};
#endif
include/Game/Systems/CapturePointHUDSystem.h
+22
View File
@@ -0,0 +1,22 @@
#ifndef CapturePointHUDSystem_h__
#define CapturePointHUDSystem_h__
#include <GLFW/glfw3.h>
#include <glm/common.hpp>
#include <glm/gtc/quaternion.hpp>
#include "Common.h"
#include "Core/System.h"
#include "Engine/Collision/ETrigger.h"
class CapturePointHUDSystem : public ImpureSystem
{
public:
CapturePointHUDSystem(SystemParams params);
virtual void Update(double dt) override;
private:
};
#endif
include/Game/Systems/CapturePointSystem.h
+1 -1
View File
@@ -17,7 +17,7 @@ class CapturePointSystem : public PureSystem
{
public:
//WARNING: on new map, destroy all info in the vectors, as well as reset all variables (just make new?)
CapturePointSystem(World* world, EventBroker* eventBroker);
CapturePointSystem(SystemParams params);
//updatecomponent
virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& capturePoint, double dt) override;
include/Game/Systems/ExplosionEffectSystem.h
+18
View File
@@ -0,0 +1,18 @@
#ifndef ExplosionEffectSystem_h__
#define ExplosionEffectSystem_h__
#include "Common.h"
#include "Core/System.h"
class ExplosionEffectSystem : public PureSystem
{
public:
ExplosionEffectSystem(SystemParams params)
: System(params)
, PureSystem("ExplosionEffect")
{ }
virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt) override;
};
#endif
include/Game/Systems/HealthSystem.h
+1 -1
View File
@@ -17,7 +17,7 @@
class HealthSystem : public PureSystem
{
public:
HealthSystem(World* world, EventBroker* eventBroker);
HealthSystem(SystemParams params);
//updatecomponent
virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt) override;
include/Game/Systems/InterpolationSystem.h
+31 -22
View File
@@ -16,38 +16,47 @@
#include "Network/EInterpolate.h"
class InterpolationSystem : public PureSystem
class InterpolationSystem : public ImpureSystem
{
struct Transform
{
glm::vec3 Position;
glm::vec3 Scale;
glm::quat Orientation;
float interpolationTime;
};
public:
InterpolationSystem(World* world, EventBroker* eventBroker);
InterpolationSystem(SystemParams params);
~InterpolationSystem() { }
virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& transform, double dt) override;
private:
std::unordered_map<EntityID, Transform> m_NextTransform;
std::unordered_map<EntityID, Transform> m_LastReceivedTransform;
EntityWrapper m_LocalPlayer = EntityWrapper::Invalid;
//glm::vec3 vectorInterpolation(glm::vec3 prev, glm::vec3 next, double currentTime);
virtual void Update(double dt) override;
private:
template <typename T>
struct Interpolation
{
Interpolation(const ComponentWrapper& Component, const std::string& Field, const T& Start, const T& Goal)
: Component(Component)
, Field(Field)
, Start(Start)
, Goal(Goal)
{ }
ComponentWrapper Component;
std::string Field;
T Start;
T Goal;
double Alpha = 0.0;
};
float m_SnapshotInterval;
std::unordered_map<EntityWrapper, Interpolation<glm::vec3>> m_InterpolatePosition;
std::unordered_map<EntityWrapper, Interpolation<glm::quat>> m_InterpolateOrientation;
std::unordered_map<EntityWrapper, Interpolation<glm::vec3>> m_InterpolateVelocity;
EventRelay<InterpolationSystem, Events::Interpolate> m_EInterpolate;
bool InterpolationSystem::OnInterpolate(Events::Interpolate& e);
template <typename T>
T vectorInterpolation(T prev, T next, double currentTime)
{
T difference = next - prev;
T vector = (difference / m_SnapshotInterval) * static_cast<float>(currentTime);
T vector = difference * (static_cast<float>(currentTime) / m_SnapshotInterval);
return vector;
}
float m_SnapshotInterval;
EventRelay<InterpolationSystem, Events::Interpolate> m_EInterpolate;
bool InterpolationSystem::OnInterpolate(const Events::Interpolate& e);
EventRelay<InterpolationSystem, Events::PlayerSpawned> m_EPlayerSpawned;
bool OnPlayerSpawned(Events::PlayerSpawned& e);
};
#endif
include/Game/Systems/LifetimeSystem.h
+2 -2
View File
@@ -6,8 +6,8 @@
class LifetimeSystem : public ImpureSystem, PureSystem
{
public:
LifetimeSystem(World* world, EventBroker* eventBroker)
: System(world, eventBroker)
LifetimeSystem(SystemParams params)
: System(params)
, PureSystem("Lifetime")
{
LOG_INFO("ASDASDASSA");
include/Game/Systems/PickupSpawnSystem.h
+1 -1
View File
@@ -14,7 +14,7 @@
class PickupSpawnSystem : public ImpureSystem
{
public:
PickupSpawnSystem(World* world, EventBroker* eventBroker);
PickupSpawnSystem(SystemParams params);
virtual void Update(double dt) override;
include/Game/Systems/PlayerDeathSystem.h
+1 -1
View File
@@ -15,7 +15,7 @@
class PlayerDeathSystem : public ImpureSystem
{
public:
PlayerDeathSystem(World* world, EventBroker* eventBroker);
PlayerDeathSystem(SystemParams params);
virtual void Update(double dt) override;
include/Game/Systems/PlayerHUD.h → include/Game/Systems/PlayerHUDSystem.h
+4 -8
View File
@@ -6,18 +6,14 @@
#include "../../Engine/Rendering/ESetCamera.h"
#include <imgui/imgui.h>
class PlayerHUD : public ImpureSystem
class PlayerHUDSystem : public ImpureSystem
{
public:
PlayerHUD(World* world, EventBroker* eventBrokerer);
~PlayerHUD();
PlayerHUDSystem(SystemParams params)
: System(params)
{ }
virtual void Update(double dt) override;
private:
World* m_World;
EventBroker* m_EventBroker;
};
#endif
include/Game/Systems/PlayerMovementSystem.h
+7 -3
View File
@@ -7,14 +7,16 @@
#include "Events/EDoubleJump.h"
#include "../Engine/Sound/EPlaySoundOnEntity.h"
class PlayerMovementSystem : public ImpureSystem, PureSystem
#include "Core/EntityFile.h"
#include "Core/EntityFileParser.h"
class PlayerMovementSystem : public ImpureSystem
{
public:
PlayerMovementSystem(World* world, EventBroker* eventBroker);
PlayerMovementSystem(SystemParams params);
~PlayerMovementSystem();
virtual void Update(double dt) override;
virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt);
private:
// State
@@ -36,4 +38,6 @@ private:
EventRelay<PlayerMovementSystem, Events::PlayerSpawned> m_EPlayerSpawned;
bool OnPlayerSpawned(Events::PlayerSpawned& e);
void updateMovementControllers(double dt);
void updateVelocity(double dt);
};
include/Game/Systems/PlayerSpawnSystem.h
+1 -1
View File
@@ -10,7 +10,7 @@
class PlayerSpawnSystem : public ImpureSystem
{
public:
PlayerSpawnSystem(World* world, EventBroker* eventBroker);
PlayerSpawnSystem(SystemParams params);
virtual void Update(double dt) override;
include/Game/Systems/RaptorCopterSystem.h
+2 -2
View File
@@ -4,8 +4,8 @@
class RaptorCopterSystem : public PureSystem
{
public:
RaptorCopterSystem(World* world, EventBroker* eventBroker)
: System(world, eventBroker)
RaptorCopterSystem(SystemParams params)
: System(params)
, PureSystem("RaptorCopter")
{ }
include/Game/Systems/SoundSystem.h
+1 -7
View File
@@ -27,14 +27,10 @@
class SoundSystem : public PureSystem, ImpureSystem
{
public:
SoundSystem(World* world, EventBroker* eventbroker);
SoundSystem(SystemParams params);
virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& cComponent, double dt) override;
virtual void Update(double dt) override;
private:
EntityWrapper m_LocalPlayer = EntityWrapper();
World* m_World = nullptr;
EventBroker* m_EventBroker = nullptr;
std::string m_Announcer = "";
// Logic for playing a sound when a player jumps
void playerJumps();
@@ -56,8 +52,6 @@ private:
bool OnDashAbility(const Events::DashAbility &e);
EventRelay<SoundSystem, Events::TriggerTouch> m_ETriggerTouch;
bool OnTriggerTouch(const Events::TriggerTouch &e);
EventRelay<SoundSystem, Events::Shoot> m_EShoot;
bool OnShoot(const Events::Shoot &e);
EventRelay<SoundSystem, Events::Captured> m_ECaptured;
bool OnCaptured(const Events::Captured &e);
EventRelay<SoundSystem, Events::PlayerDamage> m_EPlayerDamage;
include/Game/Systems/SpawnerSystem.h
+1 -1
View File
@@ -13,7 +13,7 @@
class SpawnerSystem : public System
{
public:
SpawnerSystem(World* world, EventBroker* eventBroker);
SpawnerSystem(SystemParams params);
static EntityWrapper Spawn(EntityWrapper spawner, EntityWrapper parent = EntityWrapper::Invalid);
include/Game/Systems/WeaponSystem.h
+159 -10
View File
@@ -13,31 +13,180 @@
#include "Input/EInputCommand.h"
#include "Core/EntityFile.h"
#include "Core/EntityFileParser.h"
#include "Core/Octree.h"
#include "Collision/EntityAABB.h"
#include "Systems/SpawnerSystem.h"
#include "Sound/EPlaySoundOnEntity.h"
#include <tuple>
#include <vector>
class WeaponBehaviour;
class WeaponSystem : public ImpureSystem
class WeaponSystem : public PureSystem, ImpureSystem
{
public:
WeaponSystem(World* world, EventBroker* eventBroker, IRenderer* renderer);
WeaponSystem(SystemParams params, IRenderer* renderer, Octree<EntityAABB>* collisionOctree);
virtual void Update(double dt) override;
virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& cPlayer, double dt) override;
private:
SystemParams m_SystemParams;
IRenderer* m_Renderer;
Octree<EntityAABB>* m_CollisionOctree;
// State
EntityWrapper m_LocalPlayer = EntityWrapper::Invalid;
std::unordered_map<EntityWrapper, std::shared_ptr<WeaponBehaviour>> m_ActiveWeapons;
// Events
EventRelay<WeaponSystem, Events::PlayerSpawned> m_EPlayerSpawned;
bool WeaponSystem::OnPlayerSpawned(const Events::PlayerSpawned& e);
bool OnPlayerSpawned(Events::PlayerSpawned& e);
EventRelay<WeaponSystem, Events::Shoot> m_EShoot;
bool WeaponSystem::OnShoot(Events::Shoot& e);
bool OnShoot(Events::Shoot& e);
EventRelay<WeaponSystem, Events::InputCommand> m_EInputCommand;
bool WeaponSystem::OnInputCommand(const Events::InputCommand& e);
bool OnInputCommand(Events::InputCommand& e);
void selectWeapon(EntityWrapper player, ComponentInfo::EnumType slot);
};
class WeaponBehaviour : public System
{
public:
WeaponBehaviour(SystemParams systemParams, Octree<EntityAABB>* collisionOctree, EntityWrapper weaponEntity)
: System(systemParams)
, m_CollisionOctree(collisionOctree)
, m_Entity(weaponEntity)
{ }
virtual ~WeaponBehaviour() = default;
WeaponBehaviour(const WeaponBehaviour&) = delete;
WeaponBehaviour& operator=(const WeaponBehaviour &) = delete;
virtual void Fire() = 0;
virtual void CeaseFire() { }
virtual void Reload() { }
virtual void Update(double dt) { }
protected:
Octree<EntityAABB>* m_CollisionOctree;
EntityWrapper m_Entity;
};
class AssaultWeaponBehaviour : public WeaponBehaviour
{
public:
AssaultWeaponBehaviour(SystemParams systemParams, Octree<EntityAABB>* collisionOctree, EntityWrapper weaponEntity)
: WeaponBehaviour(systemParams, collisionOctree, weaponEntity)
{ }
virtual void Fire() override
{
m_TimeSinceLastFire = 0.0;
m_Firing = true;
fireRound();
}
virtual void CeaseFire() override
{
m_Firing = false;
}
virtual void Reload() override
{
ComponentWrapper& cAssaultWeapon = m_Entity["AssaultWeapon"];
int& magAmmo = cAssaultWeapon["MagazineAmmo"];
int magSize = cAssaultWeapon["MagazineSize"];
int& ammo = cAssaultWeapon["Ammo"];
// Don't reload if we're already fully loaded
if (magAmmo == magSize) {
return;
}
// Throw away rounds in magazine to incentivise ammo sharing
int toLoad = glm::min(magSize, ammo);
magAmmo = toLoad;
ammo -= toLoad;
}
virtual void Update(double dt) override
{
if (!m_Firing) {
return;
}
m_TimeSinceLastFire += dt;
ComponentWrapper& cAssaultWeapon = m_Entity["AssaultWeapon"];
if (m_TimeSinceLastFire >= 1.0 / ((double)cAssaultWeapon["RPM"] / 60.0)) {
fireRound();
}
}
private:
bool m_Firing = false;
double m_TimeSinceLastFire = 0.0;
EntityFile* m_RayRed = nullptr;
EntityFile* m_RayBlue = nullptr;
void fireRound()
{
ComponentWrapper& cAssaultWeapon = m_Entity["AssaultWeapon"];
int& magAmmo = cAssaultWeapon["MagazineAmmo"];
int ammo = cAssaultWeapon["Ammo"];
// Reload if our magazine is empty
if (magAmmo <= 0) {
Reload();
return;
}
// Fire
magAmmo -= 1;
spawnTracer();
playSound();
m_TimeSinceLastFire = 0.0;
}
void spawnTracer()
{
if (!IsClient) {
return;
}
EntityWrapper spawner;
if (m_Entity == LocalPlayer) {
spawner = m_Entity.FirstChildByName("WeaponMuzzle");
} else {
spawner = m_Entity.FirstChildByName("ThirdPersonWeaponMuzzle");
}
if (!spawner.Valid()) {
return;
}
Events::SpawnerSpawn e;
e.Spawner = spawner;
m_EventBroker->Publish(e);
}
float traceRayDistance(glm::vec3 origin, glm::vec3 direction)
{
// TODO: Cast a ray and size tracer appropriately
return 100.f;
}
void playSound()
{
if (!IsClient) {
return;
}
Events::PlaySoundOnEntity e;
e.EmitterID = m_Entity.ID;
e.FilePath = "Audio/laser/laser1.wav";
m_EventBroker->Publish(e);
}
};
#endif