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

Merge remote-tracking branch 'origin/master' into Animations

Browse Source
This commit is contained in:
viktorljung
2016-02-11 23:48:30 +01:00
parent bd385a0d59 e473194671
commit 648d864d6e
88 changed files with 7946 additions and 736 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/Engine/Collision/Collision.h
+18 -5
View File
@@ -20,6 +20,9 @@
class World;
struct ComponentWrapper;
template<typename T>
class Octree;
namespace Collision
{
//Return true if the ray hits the box.
@@ -44,21 +47,24 @@ bool RayVsTriangle(const Ray& ray,
float& outVCoord,
bool trueOnNegativeDistance = false);
//Return true if the ray hits any of the triangles in the model. Stops checking when a hit is detected.
bool RayVsModel(const Ray& ray,
const std::vector<RawModel::Vertex>& modelVertices,
const std::vector<unsigned int>& modelIndices);
bool RayVsModel(const Ray& ray,
const RawModel::Vertex* modelVertices,
const std::vector<unsigned int>& modelIndices,
const glm::mat4& modelMatrix);
//Return true if the ray hits any of the triangles in the model.
//Also returns the position of the intersection point. Will loop through all the whole model indices.
bool RayVsModel(const Ray& ray,
const std::vector<RawModel::Vertex>& modelVertices,
const RawModel::Vertex* modelVertices,
const std::vector<unsigned int>& modelIndices,
const glm::mat4& modelMatrix,
glm::vec3& outHitPosition);
//Return true if the ray hits any of the triangles in the model.
//Also returns the distance from the ray origin to the closest
//intersection point, and the barycentric u,v-coordinates. Will loop through all the whole model indices.
bool RayVsModel(const Ray& ray,
const std::vector<RawModel::Vertex>& modelVertices,
const RawModel::Vertex* modelVertices,
const std::vector<unsigned int>& modelIndices,
const glm::mat4& modelMatrix,
float& outDistance,
float& outUCoord,
float& outVCoord);
@@ -81,6 +87,13 @@ bool AABBVsAABB(const AABB& a, const AABB& b, glm::vec3& minimumTranslation);
// Calculates an absolute AABB from an entity AABB component
boost::optional<EntityAABB> EntityAbsoluteAABB(EntityWrapper& entity, bool takeModelBox = false);
boost::optional<EntityAABB> AbsoluteAABBExplosionEffect(EntityWrapper& entity);
//Returns the first entity hit by the input ray. entitiesPotentiallyHitSorted needs to be sorted
//by their distance to the ray, e.g. result from Octree<EntityAABB>::ObjectsPossiblyHitByRay.
//Returns boost::none if none was hit. outDistance will be the distance to the intersection point if the ray intersects.
boost::optional<EntityAABB> EntityFirstHitByRay(const Ray& ray, std::vector<EntityAABB> entitiesPotentiallyHitSorted, float& outDistance, glm::vec3& outIntersectPos);
//Returns the first entity hit by the input ray that exists in the octree.
//outDistance will be the distance to the intersection point if the ray intersects.
boost::optional<EntityAABB> EntityFirstHitByRay(const Ray& ray, Octree<EntityAABB>* octree, float& outDistance, glm::vec3& outIntersectPos);
}
include/Engine/Core/EPlayerDamage.h
+2 -2
View File
@@ -9,8 +9,8 @@ namespace Events
struct PlayerDamage : Event
{
//NOTE: this struct is missing information on what the damageSource is
EntityWrapper Player;
EntityWrapper Inflictor;
EntityWrapper Victim;
double Damage;
};
include/Engine/Core/EShoot.h
+2 -1
View File
@@ -9,7 +9,8 @@ namespace Events
struct Shoot : Event
{
EntityWrapper Player;
EntityWrapper Inflictor;
double Damage;
};
}
include/Engine/Core/Octree.h
+75
View File
@@ -41,6 +41,8 @@ public:
void ObjectsInSameRegion(const Box& box, std::vector<T>& outObjects);
//Get the objects that are inside the frustum, the objects are put in outObjects.
void ObjectsInFrustum(const Frustum& frustum, std::vector<T>& outObjects);
//Get objects, which AABB the input ray intersects, the objects are put in outObjects.
void ObjectsPossiblyHitByRay(const Ray& ray, std::vector<T>& outObjects);
//Empty the tree of all objects, static and dynamic.
void ClearObjects();
//Empty the tree of all dynamic objects. Static objects remain in the tree.
@@ -100,6 +102,8 @@ struct Child
void ObjectsInSameRegion(const Box& box, std::vector<T>& outObjects) const;
template<typename T>
void ObjectsInFrustum(const Frustum& frustum, std::vector<T>& outObjects, bool takeAllDontTest) const;
template<typename T>
void ObjectsPossiblyHitByRay(const Ray& ray, std::vector<T>& outObjects) const;
void ClearObjects();
void ClearDynamicObjects();
bool RayCollides(const Ray& ray, Output& data) const;
@@ -119,6 +123,15 @@ struct Child
std::vector<int> childIndicesContainingBox(const AABB& box) const;
};
//To be able to sort child nodes and contained objects based on distance to ray origin.
struct RaySorterInfo
{
int Index;
float Distance;
};
bool isFirstLower(const RaySorterInfo& first, const RaySorterInfo& second);
}
template<typename T>
@@ -164,6 +177,13 @@ void Octree<T>::ObjectsInFrustum(const Frustum& frustum, std::vector<T>& outObje
m_Root->ObjectsInFrustum(frustum, outObjects, false);
}
template<typename T>
void Octree<T>::ObjectsPossiblyHitByRay(const Ray& ray, std::vector<T>& outObjects)
{
falsifyObjectChecks();
m_Root->ObjectsPossiblyHitByRay(ray, outObjects);
}
template<typename T>
void Octree<T>::ClearObjects()
{
@@ -282,4 +302,59 @@ void OctSpace::Child::ObjectsInFrustum(const Frustum& frustum, std::vector<T>& o
}
}
template<typename T>
void OctSpace::Child::ObjectsPossiblyHitByRay(const Ray& ray, std::vector<T>& outObjects) const
{
//If the node AABB is missed, everything it contains is missed.
if (Collision::RayAABBIntr(ray, m_Box)) {
//If the ray shoots the tree, and it is a parent.
if (hasChildren()) {
//Sort children according to their distance from the ray origin.
std::vector<RaySorterInfo> childInfos;
childInfos.resize(8);
for (int i = 0; i < 8; ++i) {
childInfos[i] = { i, glm::distance(ray.Origin(), m_Children[i]->m_Box.Origin()) };
}
std::sort(childInfos.begin(), childInfos.end(), isFirstLower);
//Loop through the children, starting with the one closest to the ray origin. I.e the first to be hit.
for (const RaySorterInfo& info : childInfos) {
m_Children[info.Index]->ObjectsPossiblyHitByRay(ray, outObjects);
}
} else {
//Check against boxes in the node.
bool intersected = false;
float dist;
//Sort all contained objects according to the distance from the ray origin to
//the intersection, if they are intersecting.
std::vector<RaySorterInfo> objectHitInfos;
objectHitInfos.reserve(m_StaticObjIndices.size() + m_DynamicObjIndices.size());
for (int i : m_StaticObjIndices) {
//If we haven't tested against this object before, and the ray hits.
if (!m_StaticObjectsRef[i].Checked &&
Collision::RayVsAABB(ray, *m_StaticObjectsRef[i].Box, dist)) {
objectHitInfos.push_back({ i, dist });
}
m_StaticObjectsRef[i].Checked = true;
}
for (int i : m_DynamicObjIndices) {
//If we haven't tested against this object before, and the ray hits.
if (!m_DynamicObjectsRef[i].Checked &&
Collision::RayVsAABB(ray, *m_DynamicObjectsRef[i].Box, dist)) {
objectHitInfos.push_back({ i + (int)m_StaticObjIndices.size(), dist });
}
m_DynamicObjectsRef[i].Checked = true;
}
std::sort(objectHitInfos.begin(), objectHitInfos.end(), isFirstLower);
int startSize = (int)outObjects.size();
outObjects.resize(startSize + objectHitInfos.size());
for (int i = 0; i < objectHitInfos.size(); ++i) {
outObjects[startSize + i] = (objectHitInfos[i].Index < m_StaticObjIndices.size()) ?
*static_cast<T*>(m_StaticObjectsRef[objectHitInfos[i].Index].Box.get()) :
*static_cast<T*>(m_DynamicObjectsRef[objectHitInfos[i].Index - m_StaticObjIndices.size()].Box.get());
}
}
}
}
#endif
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/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/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/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
+5
View File
@@ -18,6 +18,7 @@
#include "../Core/EPlayerSpawned.h"
#include "../Core/Octree.h"
#include "../Collision/EntityAABB.h"
#include "../Core/ConfigFile.h"
class RenderSystem : public ImpureSystem
{
@@ -47,6 +48,10 @@ 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 isEntityVisible(EntityWrapper& entity);
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/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/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
View File
@@ -44,7 +44,6 @@ private:
//std::vector<ComponentWrapper>
const double m_CaptureTimeToTakeOver = 15.0;
bool m_ResetTimers = false;
//vectors which will keep track of enter/leave changes
include/Game/Systems/DamageIndicatorSystem.h
+33
View File
@@ -0,0 +1,33 @@
#ifndef DamageIndicatorSystem_h__
#define DamageIndicatorSystem_h__
#include "Core/System.h"
#include "Core/Transform.h"
#include "Core/ResourceManager.h"
#include "Core/EntityFileParser.h"
#include "Core/EPlayerDamage.h"
#include "Common.h"
#include <tuple>
#include "Rendering/ESetCamera.h"
#include <glm/gtc/quaternion.hpp>
#include <glm/gtx/vector_angle.hpp>
#include "Rendering/Util/CommonFunctions.h"
class DamageIndicatorSystem : public System
{
public:
DamageIndicatorSystem(SystemParams params);
private:
EventRelay<DamageIndicatorSystem, Events::PlayerDamage> m_EPlayerDamage;
bool OnPlayerDamage(Events::PlayerDamage& e);
EventRelay<DamageIndicatorSystem, Events::SetCamera> m_ESetCamera;
bool OnSetCamera(const Events::SetCamera& e);
EntityID m_CurrentCamera = -1;
};
#endif
include/Game/Systems/PlayerMovementSystem.h
+3
View File
@@ -7,6 +7,9 @@
#include "Events/EDoubleJump.h"
#include "../Engine/Sound/EPlaySoundOnEntity.h"
#include "Core/EntityFile.h"
#include "Core/EntityFileParser.h"
class PlayerMovementSystem : public ImpureSystem
{
public:
include/Game/Systems/Weapon/AssaultWeaponBehaviour.h
+44
View File
@@ -0,0 +1,44 @@
#include "Sound/EPlaySoundOnEntity.h"
#include "Collision/Collision.h"
#include "Rendering/AnimationSystem.h"
#include "WeaponBehaviour.h"
#include "../SpawnerSystem.h"
#include "Core/EPlayerDamage.h"
#include "Core/EShoot.h"
class AssaultWeaponBehaviour : public WeaponBehaviour
{
public:
AssaultWeaponBehaviour(SystemParams systemParams, IRenderer* renderer, Octree<EntityAABB>* collisionOctree, EntityWrapper weaponEntity);
virtual void Fire() override;
virtual void CeaseFire() override;
virtual void Reload() override;
virtual void Update(double dt) override;
private:
EntityWrapper m_FirstPersonModel;
// State
bool m_Firing = false;
bool m_Reloading = false;
double m_ReloadTimer = 0.0;
EntityWrapper m_ReloadImpersonator;
double m_TimeSinceLastFire = 0.0;
EventRelay<WeaponBehaviour, Events::AnimationComplete> m_EAnimationComplete;
bool OnAnimationComplete(Events::AnimationComplete& e);
bool hasAmmo();
void fireRound();
void spawnTracer();
float traceRayDistance(glm::vec3 origin, glm::vec3 direction);
void playSound();
void viewPunch();
void finishReload();
void playShootAnimation();
void playIdleAnimation();
void playReloadAnimation();
bool shoot(double damage);
void showHitMarker();
};
include/Game/Systems/Weapon/WeaponBehaviour.h
+34
View File
@@ -0,0 +1,34 @@
#ifndef WeaponBehaviour_h__
#define WeaponBehaviour_h__
#include "Core/System.h"
#include "Rendering/IRenderer.h"
#include "Core/Octree.h"
#include "Collision/EntityAABB.h"
class WeaponBehaviour : public System
{
public:
WeaponBehaviour(SystemParams systemParams, IRenderer* renderer, Octree<EntityAABB>* collisionOctree, EntityWrapper player)
: System(systemParams)
, m_Renderer(renderer)
, m_CollisionOctree(collisionOctree)
, m_Player(player)
{ }
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:
IRenderer* m_Renderer;
Octree<EntityAABB>* m_CollisionOctree;
EntityWrapper m_Player;
};
#endif
include/Game/Systems/Weapon/WeaponSystem.h
+44
View File
@@ -0,0 +1,44 @@
#ifndef WeaponSystem_h__
#define WeaponSystem_h__
#include "Rendering/IRenderer.h"
#include "Common.h"
#include "Core/System.h"
#include "Core/EPlayerDamage.h"
#include "Core/EShoot.h"
#include "Core/EPlayerSpawned.h"
#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 "AssaultWeaponBehaviour.h"
class WeaponSystem : public PureSystem, ImpureSystem
{
public:
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;
std::unordered_map<EntityWrapper, std::shared_ptr<WeaponBehaviour>> m_ActiveWeapons;
// Events
EventRelay<WeaponSystem, Events::PlayerSpawned> m_EPlayerSpawned;
bool OnPlayerSpawned(Events::PlayerSpawned& e);
EventRelay<WeaponSystem, Events::InputCommand> m_EInputCommand;
bool OnInputCommand(Events::InputCommand& e);
void selectWeapon(EntityWrapper player, ComponentInfo::EnumType slot);
};
#endif
include/Game/Systems/WeaponSystem.h
-192
View File
@@ -1,192 +0,0 @@
#ifndef WeaponSystem_h__
#define WeaponSystem_h__
//#include <GLFW/glfw3.h>
//#include <glm/common.hpp>
#include "Rendering/IRenderer.h"
#include "Common.h"
#include "Core/System.h"
#include "Core/EPlayerDamage.h"
#include "Core/EShoot.h"
#include "Core/EPlayerSpawned.h"
#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"
class WeaponBehaviour;
class WeaponSystem : public PureSystem, ImpureSystem
{
public:
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;
std::unordered_map<EntityWrapper, std::shared_ptr<WeaponBehaviour>> m_ActiveWeapons;
// Events
EventRelay<WeaponSystem, Events::PlayerSpawned> m_EPlayerSpawned;
bool OnPlayerSpawned(Events::PlayerSpawned& e);
EventRelay<WeaponSystem, Events::Shoot> m_EShoot;
bool OnShoot(Events::Shoot& e);
EventRelay<WeaponSystem, Events::InputCommand> m_EInputCommand;
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