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

Merge branch 'master' into UnpickableComponent

Browse Source 
# Conflicts:
#	resources/Schema/Components.xsd
#	resources/Schema/Types/Entity.xsd
This commit is contained in:
sippeangelo
2016-03-13 22:00:10 +01:00
parent b3ea26779a d9b47ddb62
commit 53dd96d44d
186 changed files with 28974 additions and 20087 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/Engine/Collision/Collision.h
+13 -1
View File
@@ -12,7 +12,7 @@
#include "../Core/AABB.h"
#include "Rendering/RawModelCustom.h"
//#include "Rendering/RawModelAssimp.h"
#include "../Core/Transform.h"
#include "../Core/TransformSystem.h"
#include "../Core/Entity.h"
#include "../Core/EntityWrapper.h"
#include "EntityAABB.h"
@@ -84,6 +84,18 @@ bool AABBvsTriangles(const AABB& box,
const std::vector<unsigned int>& modelIndices,
const glm::mat4& modelMatrix);
enum Output
{
OutContained,
OutSeparated,
OutIntersecting
};
//Detects intersection and containment.
Output AABBvsTrianglesWContainment(const AABB& box,
const RawModel::Vertex* modelVertices,
const std::vector<unsigned int>& modelIndices,
const glm::mat4& modelMatrix);
//Return true if the boxes are intersecting.
bool AABBVsAABB(const AABB& a, const AABB& b);
//Return true if the boxes are intersecting.
include/Engine/Core/ComponentInfo.h
+12
View File
@@ -2,6 +2,7 @@
#define ComponentInfo_h__
#include "../Common.h"
#include "Entity.h"
#include <boost/shared_array.hpp>
struct ComponentInfo
@@ -21,6 +22,7 @@ struct ComponentInfo
{
std::string Name;
std::string Type;
unsigned char Index;
unsigned int Offset;
unsigned int Stride;
};
@@ -32,6 +34,16 @@ struct ComponentInfo
unsigned int Stride = 0;
boost::shared_array<char> Defaults = nullptr;
std::shared_ptr<Meta_t> Meta = nullptr;
std::size_t GetHeaderSize() const
{
std::size_t size = 0;
// A component block starts with an entity ID
size += sizeof(EntityID);
return size;
}
};
template<>
include/Engine/Core/ComponentPool.h
+13 -9
View File
@@ -5,16 +5,15 @@
#include "MemoryPool.h"
#include "ComponentInfo.h"
#include "ComponentWrapper.h"
#include "DirtySet.h"
class ComponentPool;
class ComponentPoolForwardIterator
: public std::iterator<std::forward_iterator_tag, ComponentWrapper>
{
public:
ComponentPoolForwardIterator(const ComponentInfo& componentInfo, const MemoryPool<char>::iterator begin, const MemoryPool<char>::iterator end)
: m_ComponentInfo(componentInfo)
, m_MemoryPoolIterator(begin)
, m_MemoryPoolEnd(end)
{ }
ComponentPoolForwardIterator(ComponentPool* pool, const MemoryPool<char>::iterator begin, const MemoryPool<char>::iterator end);
ComponentPoolForwardIterator(const ComponentPoolForwardIterator& other) = default;
ComponentPoolForwardIterator(ComponentPoolForwardIterator&& other) = default;
@@ -27,6 +26,7 @@ public:
ComponentWrapper operator*() const;
private:
ComponentPool* m_ComponentPool;
const ComponentInfo& m_ComponentInfo;
MemoryPool<char>::iterator m_MemoryPoolIterator;
const MemoryPool<char>::iterator m_MemoryPoolEnd;
@@ -34,6 +34,7 @@ private:
class ComponentPool
{
friend class ComponentPoolForwardIterator;
public:
typedef ComponentPoolForwardIterator iterator;
typedef ptrdiff_t difference_type;
@@ -42,9 +43,10 @@ public:
typedef ComponentWrapper* pointer;
typedef ComponentWrapper& reference;
ComponentPool(const ::ComponentInfo& ci)
ComponentPool(const ::ComponentInfo& ci, World* world)
: m_ComponentInfo(ci)
, m_Pool(ci.Meta->Allocation, sizeof(EntityID) + ci.Stride)
, m_Pool(ci.Meta->Allocation, ci.GetHeaderSize() + ci.Stride)
, m_World(world)
{ }
~ComponentPool();
ComponentPool(const ComponentPool& other);
@@ -61,8 +63,8 @@ public:
// Delete a component and free its memory
void Delete(ComponentWrapper& wrapper);
iterator begin() const;
iterator end() const;
iterator begin();
iterator end();
size_t size() const;
//Dumps information about what the pool memory looks like right now
@@ -80,6 +82,8 @@ private:
::ComponentInfo m_ComponentInfo;
MemoryPool<char> m_Pool;
std::unordered_map<EntityID, char*> m_EntityToComponent;
DirtySet m_DirtySet;
World* m_World;
};
#endif
include/Engine/Core/ComponentWrapper.h
+155 -44
View File
@@ -4,46 +4,32 @@
#include <boost/shared_array.hpp>
#include <boost/any.hpp>
#include "../Common.h"
#include "../GLM.h"
#include "Entity.h"
#include "ComponentInfo.h"
#include "DirtySet.h"
#include "Util/Any.h"
template <typename T, typename Enable = void>
struct ComponentField { };
template <typename T>
struct ComponentField<T, typename std::enable_if<std::is_trivially_copyable<T>::value>::type>
{
static T& Get(const ComponentInfo::Field_t& info, char* data) { return *reinterpret_cast<T*>(data); }
static void Set(const ComponentInfo::Field_t& info, char* data, const T& value) { Get(data) = value; }
};
template <>
struct ComponentField<std::string, void>
{
static std::string& Get(const ComponentInfo::Field_t& info, char* data) { return **reinterpret_cast<std::string**>(data); }
static void Set(const ComponentInfo::Field_t& info, char* data, const std::string& value) { Get(info, data) = value; }
};
class World;
struct ComponentWrapper
{
ComponentWrapper(const ComponentInfo& componentInfo, char* data)
: Info(componentInfo)
, EntityID(*reinterpret_cast<::EntityID*>(data))
, Data(data + sizeof(::EntityID))
{ }
ComponentWrapper(const ComponentInfo& componentInfo, char* data, ::DirtyBitField* dirtyBitField, World* world);
World* m_World;
const ComponentInfo& Info;
const ::EntityID EntityID;
char* Data;
::DirtyBitField* DirtyBitField = nullptr;
ComponentInfo::EnumType Enum(const char* fieldName, const char* enumKey)
{
return Info.Meta->FieldEnumDefinitions.at(fieldName).at(enumKey);
}
ComponentInfo::EnumType Enum(const char* fieldName, const char* enumKey);
bool Dirty(DirtySetType type, const std::string& fieldName);
void SetDirty(DirtySetType type, const std::string& fieldName, bool dirty = true);
void SetAllDirty(const std::string& fieldName, bool dirty = true);
template <typename T>
T& Field(std::string name)
T& Field(const std::string& name)
{
const ComponentInfo::Field_t& field = Info.Fields.at(name);
if (sizeof(T) > field.Stride) {
@@ -55,13 +41,15 @@ struct ComponentWrapper
}
template <typename T>
void SetField(std::string name, const T value) { Field<T>(name) = value; }
//template <typename T>
//void SetField(std::string name, T& value) { Field<T>(name) = value; }
void SetField(const std::string& name, const T& value)
{
Field<T>(name) = value;
SetAllDirty(name);
}
// Specialization for string literals
template <std::size_t N>
void SetField(std::string name, const char(&value)[N]) { Field<std::string>(name) = std::string(value); }
void SetField(const std::string& name, const char(&value)[N]) { SetField(name, std::string(value)); }
void Copy(ComponentWrapper& destination)
{
@@ -95,40 +83,163 @@ struct ComponentWrapper
struct SubscriptProxy
{
friend struct ComponentWrapper;
private:
SubscriptProxy(ComponentWrapper* component, std::string propertyName)
public:
SubscriptProxy(ComponentWrapper* component, std::string fieldName)
: m_Component(component)
, m_PropertyName(propertyName)
, m_FieldName(fieldName)
{ }
ComponentWrapper* m_Component;
std::string m_PropertyName;
std::string m_FieldName;
public:
// Return the integer value of an enum type key for this field
ComponentInfo::EnumType Enum(const char* enumKey) { return m_Component->Enum(m_PropertyName.c_str(), enumKey); }
ComponentInfo::EnumType Enum(const char* enumKey) { return m_Component->Enum(m_FieldName.c_str(), enumKey); }
bool Dirty(DirtySetType type) { return m_Component->Dirty(type, m_FieldName); }
void SetDirty(DirtySetType type, bool dirty = true) { m_Component->SetDirty(type, m_FieldName, dirty); }
void SetAllDirty(bool dirty = true) { m_Component->SetAllDirty(m_FieldName, dirty); }
template <typename T>
operator T&() { return m_Component->Field<T>(m_PropertyName); }
operator const double&() { return m_Component->Field<double>(m_FieldName); }
operator const float&() { return m_Component->Field<float>(m_FieldName); }
operator const int&() { return m_Component->Field<int>(m_FieldName); }
operator const glm::vec3&() { return m_Component->Field<glm::vec3>(m_FieldName); }
operator const glm::vec4&() { return m_Component->Field<glm::vec4>(m_FieldName); }
operator const glm::quat&() { return m_Component->Field<glm::quat>(m_FieldName); }
operator const bool&() { return m_Component->Field<bool>(m_FieldName); }
operator const std::string&() { return m_Component->Field<std::string>(m_FieldName); }
// Don't allow non-const references
// If this wasn't deleted, the above overloads would still get called for some reason...
template <
typename T,
typename = typename std::enable_if<!std::is_base_of<::FIELDLOL, T>::value>::type
>
//operator T&() = delete;
operator T&() { static_assert(constexpr(false), "https://github.com/teamfisk/TacticalZ/pull/212"); }
// Value assignment
template <typename T>
void operator=(const T val) { m_Component->SetField<T>(m_PropertyName, val); }
// TODO: Pass by reference and rvalue (universal reference?)
//template <typename T>
//void operator=(T& val) { m_Component->SetField<T>(m_PropertyName, val); }
void operator=(const T& val) { m_Component->SetField<T>(m_FieldName, val); }
// Specialization for string literals
template <std::size_t N>
void operator=(const char(&val)[N]) { m_Component->SetField<N>(m_PropertyName, val); }
void operator=(const char(&val)[N]) { m_Component->SetField<N>(m_FieldName, val); }
};
SubscriptProxy operator[](std::string propertyName) { return SubscriptProxy(this, propertyName); }
SubscriptProxy operator[](const std::string& propertyName) { return SubscriptProxy(this, propertyName); }
};
struct FIELDLOL { }; // lol
template <typename T>
struct FieldBase : FIELDLOL
{
FieldBase(ComponentWrapper::SubscriptProxy& Proxy)
: Proxy(Proxy)
, Data(Proxy.m_Component->Field<T>(Proxy.m_FieldName))
{ }
void SetAllDirty() { Proxy.SetAllDirty(); }
FieldBase& operator=(const FieldBase& rhs) { Data = rhs.Data; SetAllDirty(); return *this; }
FieldBase& operator=(const T& rhs) { Data = rhs; SetAllDirty(); return *this; }
template <typename T2> FieldBase& operator+=(const T2& rhs) { Data += rhs; SetAllDirty(); return *this; }
template <typename T2> FieldBase& operator-=(const T2& rhs) { Data -= rhs; SetAllDirty(); return *this; }
template <typename T2> FieldBase& operator*=(const T2& rhs) { Data *= rhs; SetAllDirty(); return *this; }
template <typename T2> FieldBase& operator/=(const T2& rhs) { Data /= rhs; SetAllDirty(); return *this; }
template <typename T2> FieldBase& operator%=(const T2& rhs) { Data %= rhs; SetAllDirty(); return *this; }
template <typename T2> FieldBase& operator&=(const T2& rhs) { Data &= rhs; SetAllDirty(); return *this; }
template <typename T2> FieldBase& operator|=(const T2& rhs) { Data |= rhs; SetAllDirty(); return *this; }
template <typename T2> FieldBase& operator^=(const T2& rhs) { Data ^= rhs; SetAllDirty(); return *this; }
template <typename T2> FieldBase& operator<<=(const T2& rhs) { Data <<= rhs; SetAllDirty(); return *this; }
template <typename T2> FieldBase& operator>>=(const T2& rhs) { Data >>= rhs; SetAllDirty(); return *this; }
T operator+() const { return +Data; }
T operator-() const { return -Data; }
T operator~() const { return ~Data; }
FieldBase& operator++() { Data++; SetAllDirty(); return *this; }
T operator++(int) { T tmp = Data; operator++(); return tmp; }
FieldBase& operator--() { Data--; SetAllDirty(); return *this; }
T operator--(int) { T tmp = Data; operator--(); return tmp; }
operator const T&() const { return Data; }
const T& operator*() const { return operator const T&(); }
protected:
ComponentWrapper::SubscriptProxy Proxy;
T& Data;
};
template <typename T>
struct Field : FieldBase<T>
{
using FieldBase<T>::FieldBase;
using FieldBase<T>::operator=;
};
template <>
struct Field<glm::vec3> : FieldBase<glm::vec3>
{
using FieldBase<glm::vec3>::FieldBase;
using FieldBase<glm::vec3>::operator=;
glm::vec3::value_type x() const { return Data.x; }
void x(glm::vec3::value_type val) { Data.x = val; SetAllDirty(); }
glm::vec3::value_type y() const { return Data.y; }
void y(glm::vec3::value_type val) { Data.y = val; SetAllDirty(); }
glm::vec3::value_type z() const { return Data.z; }
void z(glm::vec3::value_type val) { Data.z = val; SetAllDirty(); }
template <typename T> friend glm::vec3 operator+(const Field<glm::vec3>& lhs, const T& rhs) { return static_cast<glm::vec3>(lhs) + glm::vec3(rhs); }
template <typename T> friend glm::vec3 operator-(const Field<glm::vec3>& lhs, const T& rhs) { return static_cast<glm::vec3>(lhs) - glm::vec3(rhs); }
template <typename T> friend glm::vec3 operator*(const Field<glm::vec3>& lhs, const T& rhs) { return static_cast<glm::vec3>(lhs) * glm::vec3(rhs); }
template <typename T> friend glm::vec3 operator/(const Field<glm::vec3>& lhs, const T& rhs) { return static_cast<glm::vec3>(lhs) / glm::vec3(rhs); }
template <typename T> friend glm::vec3 operator+(const T& lhs, const Field<glm::vec3>& rhs) { return glm::vec3(lhs) + static_cast<glm::vec3>(rhs); }
template <typename T> friend glm::vec3 operator-(const T& lhs, const Field<glm::vec3>& rhs) { return glm::vec3(lhs) - static_cast<glm::vec3>(rhs); }
template <typename T> friend glm::vec3 operator*(const T& lhs, const Field<glm::vec3>& rhs) { return glm::vec3(lhs) * static_cast<glm::vec3>(rhs); }
template <typename T> friend glm::vec3 operator/(const T& lhs, const Field<glm::vec3>& rhs) { return glm::vec3(lhs) / static_cast<glm::vec3>(rhs); }
friend glm::vec3& operator+=(glm::vec3& lhs, const Field<glm::vec3>& rhs) { lhs += *rhs; return lhs; }
};
template <>
struct Field<glm::vec4> : FieldBase<glm::vec4>
{
//Field(glm::vec4& Data)
// : FieldBase(Data)
//{ }
using FieldBase<glm::vec4>::FieldBase;
using FieldBase<glm::vec4>::operator=;
glm::vec4::value_type x() const { return Data.x; }
void x(glm::vec4::value_type val) { Data.x = val; SetAllDirty(); }
glm::vec4::value_type y() const { return Data.y; }
void y(glm::vec4::value_type val) { Data.y = val; SetAllDirty(); }
glm::vec4::value_type z() const { return Data.z; }
void z(glm::vec4::value_type val) { Data.z = val; SetAllDirty(); }
glm::vec4::value_type w() const { return Data.w; }
void w(glm::vec4::value_type val) { Data.w = val; SetAllDirty(); }
template <typename T> friend glm::vec4 operator+(const Field<glm::vec4>& lhs, const T& rhs) { return static_cast<glm::vec4>(lhs) + glm::vec4(rhs); }
template <typename T> friend glm::vec4 operator-(const Field<glm::vec4>& lhs, const T& rhs) { return static_cast<glm::vec4>(lhs) - glm::vec4(rhs); }
template <typename T> friend glm::vec4 operator*(const Field<glm::vec4>& lhs, const T& rhs) { return static_cast<glm::vec4>(lhs) * glm::vec4(rhs); }
template <typename T> friend glm::vec4 operator/(const Field<glm::vec4>& lhs, const T& rhs) { return static_cast<glm::vec4>(lhs) / glm::vec4(rhs); }
template <typename T> friend glm::vec4 operator+(const T& lhs, const Field<glm::vec4>& rhs) { return glm::vec4(lhs) + static_cast<glm::vec4>(rhs); }
template <typename T> friend glm::vec4 operator-(const T& lhs, const Field<glm::vec4>& rhs) { return glm::vec4(lhs) - static_cast<glm::vec4>(rhs); }
template <typename T> friend glm::vec4 operator*(const T& lhs, const Field<glm::vec4>& rhs) { return glm::vec4(lhs) * static_cast<glm::vec4>(rhs); }
template <typename T> friend glm::vec4 operator/(const T& lhs, const Field<glm::vec4>& rhs) { return glm::vec4(lhs) / static_cast<glm::vec4>(rhs); }
friend glm::vec4& operator+=(glm::vec4& lhs, const Field<glm::vec4>& rhs) { lhs += *rhs; return lhs; }
};
// 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())
: ComponentWrapper(componentInfo, data.get(), nullptr, nullptr)
, m_DataReference(data)
{ }
include/Engine/Core/DirtySet.h
+16
View File
@@ -0,0 +1,16 @@
#ifndef DirtySet_h__
#define DirtySet_h__
#include <set>
#include "ComponentInfo.h"
enum class DirtySetType
{
Transform,
Network
};
typedef std::unordered_map<DirtySetType, std::set<decltype(ComponentInfo::Field_t::Index)>> DirtyBitField;
typedef std::unordered_map<EntityID, DirtyBitField> DirtySet;
#endif
include/Engine/Core/ECaptured.h
+2 -2
View File
@@ -1,5 +1,5 @@
#ifndef ECaptured_h__
#define ECaptured_h__
#ifndef Events_Captured_h__
#define Events_Captured_h__
#include "EventBroker.h"
#include "../Core/Entity.h"
include/Engine/Core/EEntityDeleted.h
+2 -2
View File
@@ -2,14 +2,14 @@
#define EEntityDeleted_h__
#include "Event.h"
#include "Entity.h"
#include "EntityWrapper.h"
namespace Events
{
struct EntityDeleted : Event
{
EntityID DeletedEntity;
EntityWrapper DeletedEntity;
// True if the entity deletion was triggered because the entity's parent was deleted before it
bool Cascaded;
};
include/Engine/Core/EntityWrapper.h
+2 -1
View File
@@ -45,8 +45,9 @@ struct EntityWrapper
private:
EntityWrapper firstChildByNameRecursive(const std::string& name, EntityID parent);
EntityWrapper cloneRecursive(EntityWrapper entity, EntityWrapper parent);
void childrenWithComponentRecursive(const std::string& componentType, EntityWrapper& entity, std::vector<EntityWrapper>& childrenWithComponent);
static void fillRelationships(std::unordered_multimap<EntityWrapper, EntityWrapper>& relationMap, EntityWrapper entity);
static void recreateRelationships(const std::unordered_multimap<EntityWrapper, EntityWrapper>& relationMap, EntityWrapper templateEntity, EntityWrapper parent = EntityWrapper::Invalid);
};
namespace std
include/Engine/Core/PerformanceTimer.h
+5
View File
@@ -2,8 +2,11 @@
#define PerformanceTimer_h__
#include "../Common.h"
#ifdef DEBUG
#include <boost/timer/timer.hpp>
using boost::timer::cpu_timer;
#endif //DEBUG
class PerformanceTimer
{
@@ -17,9 +20,11 @@ public:
static void CreateExcelData();
private:
#ifdef DEBUG
static std::map<std::string, cpu_timer> timers;
static cpu_timer m_Timer;
static std::string currentTimerRunning;
#endif //DEBUG
};
#endif
include/Engine/Core/ResourceManager.h
+1
View File
@@ -19,6 +19,7 @@ class Resource
protected:
Resource() { }
virtual ~Resource() = default;
public:
//Should be thrown in a Resource's constructor if it cannot complete because another resource is still loading.
include/Engine/Core/SystemPipeline.h
+1 -1
View File
@@ -81,7 +81,7 @@ public:
for (auto& pair : group.PureSystems) {
const std::string& componentName = pair.first;
auto& systems = pair.second;
const ComponentPool* pool = m_World->GetComponents(componentName);
ComponentPool* pool = m_World->GetComponents(componentName);
if (pool == nullptr) {
continue;
}
include/Engine/Core/Transform.h
-25
View File
@@ -1,25 +0,0 @@
#ifndef Transform_h__
#define Transform_h__
#include "../GLM.h"
#include "World.h"
#include "EntityWrapper.h"
namespace Transform
{
glm::mat4 AbsoluteTransformation(EntityWrapper entity);
glm::vec3 AbsolutePosition(EntityWrapper entity);
glm::vec3 AbsolutePosition(World* world, EntityID entity);
glm::vec3 AbsoluteOrientationEuler(EntityWrapper entity);
glm::quat AbsoluteOrientation(EntityWrapper entity);
glm::quat AbsoluteOrientation(World* world, EntityID entity);
glm::vec3 AbsoluteScale(EntityWrapper entity);
glm::vec3 AbsoluteScale(World* world, EntityID entity);
glm::mat4 ModelMatrix(EntityWrapper entity);
glm::mat4 ModelMatrix(EntityID entity, World* world);
glm::vec3 TransformPoint(const glm::vec3& point, const glm::mat4& matrix);
}
#endif
include/Engine/Core/TransformSystem.h
+39
View File
@@ -0,0 +1,39 @@
#ifndef Transform_h__
#define Transform_h__
#include "../GLM.h"
#include "System.h"
#include "EEntityDeleted.h"
class TransformSystem : public System
{
public:
TransformSystem(SystemParams params);
//glm::mat4 AbsoluteTransformation(EntityWrapper entity);
static glm::vec3 AbsolutePosition(EntityWrapper entity);
static glm::vec3 AbsolutePosition(World* world, EntityID entity);
static glm::vec3 AbsoluteOrientationEuler(EntityWrapper entity);
static glm::quat AbsoluteOrientation(EntityWrapper entity);
static glm::quat AbsoluteOrientation(World* world, EntityID entity);
static glm::vec3 AbsoluteScale(EntityWrapper entity);
static glm::vec3 AbsoluteScale(World* world, EntityID entity);
static glm::mat4 ModelMatrix(EntityWrapper entity);
static glm::mat4 ModelMatrix(EntityID entity, World* world);
static glm::vec3 TransformPoint(const glm::vec3& point, const glm::mat4& matrix);
static int RecalculatedPositions;
static int RecalculatedOrientations;
static int RecalculatedScales;
private:
static std::unordered_map<EntityWrapper, glm::vec3> PositionCache;
static std::unordered_map<EntityWrapper, glm::quat> OrientationCache;
static std::unordered_map<EntityWrapper, glm::vec3> ScaleCache;
static std::unordered_map<EntityWrapper, glm::mat4> MatrixCache;
EventRelay<TransformSystem, Events::EntityDeleted> m_EEntityDeleted;
bool OnEntityDeleted(const Events::EntityDeleted& e);
};
#endif
include/Engine/Core/World.h
+1 -1
View File
@@ -35,7 +35,7 @@ public:
// Delete a component off an entity
void DeleteComponent(EntityID entity, const std::string& componentType);
// Get all components of the specified type
const ComponentPool* GetComponents(const std::string& componentType);
ComponentPool* GetComponents(const std::string& componentType);
// Get entity parent
EntityID GetParent(EntityID entity);
// Change the parent of an entity
include/Engine/Editor/EditorSystem.h
+1
View File
@@ -47,6 +47,7 @@ private:
// Utility functions
EntityWrapper importEntity(EntityWrapper parent, boost::filesystem::path filePath);
void setWidgetMode(EditorGUI::WidgetMode mode);
bool isAnyParentMissingTransform(EntityID entityID);
// GUI callbacks
void OnEntitySelected(EntityWrapper entity);
include/Engine/Input/FirstPersonInputController.h
+5 -2
View File
@@ -19,6 +19,7 @@ public:
virtual const glm::vec3 Rotation() const { return m_Rotation; }
virtual bool Jumping() const { return m_Jumping; }
virtual bool Crouching() const { return m_Crouching; }
virtual bool CrouchingLastFrame() const { return m_CrouchingLastFrame; }
virtual bool DoubleJumping() const { return m_DoubleJumping; }
virtual void SetDoubleJumping(bool isDoubleJumping) {
m_DoubleJumping = isDoubleJumping;
@@ -29,7 +30,7 @@ public:
virtual bool OnCommand(const Events::InputCommand& e) override;
virtual void Reset();
void AssaultDashCheck(double dt, bool isJumping, double assaultDashCoolDownMaxTimer, double& assaultDashCoolDownTimer, EntityID playerID);
void AssaultDashCheck(double dt, bool isJumping, double assaultDashCoolDownMaxTimer, Field<double> assaultDashCoolDownTimer, EntityID playerID);
virtual bool AssaultDashDoubleTapped() const { return m_AssaultDashDoubleTapped; }
virtual bool PlayerIsDashing() const { return m_PlayerIsDashing; }
bool SpecialAbilityKeyDown() const { return m_SpecialAbilityKeyDown; }
@@ -44,6 +45,7 @@ protected:
bool m_Jumping = false;
bool m_DoubleJumping = false;
bool m_Crouching = false;
bool m_CrouchingLastFrame = false;
//assault dash membervariables - needed to calculate the doubletap- and dashlogic
double m_AssaultDashDoubleTapDeltaTime = 0.0;
//i will let m_AssaultDashDoubleTapSensitivityTimer stay hardcoded, its not really a gamevariable (more an inputvariable),
@@ -82,6 +84,7 @@ void FirstPersonInputController<EventContext>::Reset()
{
m_Rotation = glm::vec3(0.f, 0.f, 0.f);
m_Jumping = false;
m_CrouchingLastFrame = m_Crouching;
}
template <typename EventContext>
@@ -355,7 +358,7 @@ bool FirstPersonInputController<EventContext>::OnLockMouse(const Events::LockMou
}
template <typename EventContext>
void FirstPersonInputController<EventContext>::AssaultDashCheck(double dt, bool isJumping, double assaultDashCoolDownMaxTimer, double& assaultDashCoolDownTimer, EntityID playerID) {
void FirstPersonInputController<EventContext>::AssaultDashCheck(double dt, bool isJumping, double assaultDashCoolDownMaxTimer, Field<double> assaultDashCoolDownTimer, EntityID playerID) {
m_AssaultDashDoubleTapDeltaTime += dt;
assaultDashCoolDownTimer -= dt;
//cooldown = assaultDashCoolDownMaxTimer sec, pretend the dash lasts 0.25 sec (for friction to do its work)
include/Engine/Network/Client.h
+28 -24
View File
@@ -10,28 +10,32 @@
#include <boost/asio.hpp>
#include <boost/shared_array.hpp>
#include "Core/World.h"
#include "Core/EntityFile.h"
#include "Core/EventBroker.h"
#include "Core/ConfigFile.h"
#include "Core/EPlayerDeath.h"
#include "Core/EPlayerDamage.h"
#include "Core/EPlayerSpawned.h"
#include "Core/EAmmoPickup.h"
#include "Game/Events/EDoubleJump.h"
#include "Game/Events/EDashAbility.h"
#include "Game/Events/EReset.h"
#include "Input/EInputCommand.h"
#include "imgui/imgui.h"
#include "Network/Network.h"
#include "Network/MessageType.h"
#include "Network/PlayerDefinition.h"
#include "Network/UDPClient.h"
#include "Network/TCPClient.h"
#include "Network/SnapshotDefinitions.h"
#include "Core/World.h"
#include "Core/EntityFile.h"
#include "Core/EventBroker.h"
#include "Core/ConfigFile.h"
#include "Core/EPlayerDeath.h"
#include "Input/EInputCommand.h"
#include "Core/EPlayerDamage.h"
#include "../Game/Events/EDoubleJump.h"
#include "Network/EInterpolate.h"
#include "Network/SnapshotFilter.h"
#include "Core/EPlayerSpawned.h"
#include "Core/EAmmoPickup.h"
#include "Network/ESearchForServers.h"
#include "../Game/Events/EDashAbility.h"
#include "Network/EDisplayServerlist.h"
#include "Network/EConnectRequest.h"
#include "Network/EPlayerDisconnected.h"
#include "Network/ESearchForServers.h"
#include "Network/EInterpolate.h"
#include "Network/SnapshotFilter.h"
class Client : public Network
{
public:
@@ -40,9 +44,9 @@ public:
~Client();
void Connect(std::string address, int port);
void Update() override;
void Update(double dt) override;
private:
//UDPClient m_Unreliable;
UDPClient m_Unreliable;
TCPClient m_Reliable;
std::vector<Events::PlayerSpawned> m_PlayerSpawnEvents;
void parseSpawnEvents();
@@ -74,14 +78,14 @@ private:
// Network logic
PlayerDefinition m_PlayerDefinitions[8];
SnapshotDefinitions m_NextSnapshot;
double m_DurationOfPingTime;
std::clock_t m_StartPingTime;
std::clock_t m_TimeSinceSentInputs;
unsigned int m_SendInputIntervalMs;
double m_DurationOfPingTime = 0;
double m_StartPingTime = 0;
double m_TimeSinceSentInputs = 0;
double m_SendInputInterval = 0.033;
std::vector<Events::InputCommand> m_InputCommandBuffer;
// Private member functions
size_t receive(char* data);
size_t receive(char* data);
void disconnect();
void parseMessageType(Packet& packet);
void updateFields(Packet& packet, const ComponentInfo& componentInfo, const EntityID& entityID);
@@ -100,6 +104,7 @@ private:
void parseDoubleJump(Packet& packet);
void parseDashEffect(Packet& packet);
void parseAmmoPickup(Packet& packet);
void parseRemoveWorld(Packet& packet);
void InterpolateFields(Packet& packet, const ComponentInfo & componentInfo, const EntityID & entityID, const std::string & componentType);
void parseSnapshot(Packet& packet);
void identifyPacketLoss();
@@ -109,7 +114,6 @@ private:
void sendLocalPlayerTransform();
void becomePlayer();
void displayServerlist();
void removeWorld();
void createMainMenu();
// Mapping Logic
// Returns if local EntityID exist in map
@@ -138,8 +142,8 @@ private:
UDPClient m_ServerlistRequest;
std::vector<ServerInfo> m_Serverlist;
bool m_SearchingForServers = false;
std::clock_t m_StartSearchTime;
double m_SearchingTime = 2000; // Config I guess
double m_TimeSearched = 0;
double m_SearchingTime = 0.2; // Config I guess
};
#endif
include/Engine/Network/MessageType.h
+1
View File
@@ -23,6 +23,7 @@ enum class MessageType
OnDashEffect,
ServerlistRequest,
AmmoPickup,
RemoveWorld,
Invalid
};
include/Engine/Network/Network.h
+3 -1
View File
@@ -22,7 +22,7 @@ public:
Network(World* world, EventBroker* eventBroker);
virtual ~Network() { };
virtual void Update() = 0;
virtual void Update(double dt) = 0;
protected:
World* m_World;
@@ -39,6 +39,8 @@ protected:
void logReceivedData(int bytesReceived);
void saveToFile();
void updateNetworkData();
void popNetworkSegmentOfHeader(Packet& packet);
void removeWorld();
};
#endif
include/Engine/Network/Packet.h
+19 -3
View File
@@ -16,7 +16,9 @@ public:
Packet(char* data, const size_t sizeOfPacket);
Packet(MessageType type);
~Packet();
void Init(MessageType type, unsigned int& packetID);
void Init(MessageType type, unsigned int& packetID,
int groupIndex, int groupSize,
int packetGroup);
// Add primitive types like int, float, char...
template<typename T>
@@ -25,7 +27,8 @@ public:
// Check if we are trying to add more than the package can fit.
if (m_MaxPacketSize < m_Offset + sizeof(T)) {
if (m_MaxPacketSize >= 32000) {
LOG_WARNING("Package::WritePrimitive(): New size is huge %i bytes\n", m_MaxPacketSize*2);
// This will spam couse 8 players are over 100 000 bytes
//LOG_WARNING("Package::WritePrimitive(): New size is huge %i bytes\n", m_MaxPacketSize*2);
}
resizeData();
}
@@ -57,13 +60,19 @@ public:
void UpdateSize();
char* ReadData(int SizeOfData);
void ChangePacketID(unsigned int& packetID);
void ChangeGroupIndex(int groupIndex);
void ChangeGroupSize(int groupSize);
void ChangeGroup(int group);
size_t Size() { return m_Offset; };
char* Data() { return m_Data; };
MessageType GetMessageType();
size_t Group();
size_t DataReadSize() { return m_ReturnDataOffset; }
size_t MaxSize() { return m_MaxPacketSize; }
size_t HeaderSize() { return m_HeaderSize; }
size_t GroupIndex();
size_t GroupSize();
size_t PacketID();
private:
char* m_Data;
size_t m_ReturnDataOffset = 0;
@@ -72,6 +81,13 @@ private:
size_t m_HeaderSize = 0;
void resizeData();
void resizeData(int size);
size_t packetSizeOffset = 0;
size_t groupOffset = 0;
size_t groupIndexOffset = 0;
size_t groupSizeOffset = 0;
size_t messageTypeOffset = 0;
size_t packetIDOffset = 0;
};
#endif
include/Engine/Network/PlayerDefinition.h
+1
View File
@@ -14,6 +14,7 @@ struct PlayerDefinition {
unsigned short TCPPort;
// use for tcp connections
boost::shared_ptr<boost::asio::ip::tcp::socket> TCPSocket;
int PacketGroup = 1;
};
#endif
include/Engine/Network/Server.h
+17 -9
View File
@@ -11,6 +11,7 @@
#include "Network/MessageType.h"
#include "Network/PlayerDefinition.h"
#include "Core/World.h"
#include "Core/EntityFile.h"
#include "Core/EventBroker.h"
#include "../Network/Network.h"
#include "Input/EInputCommand.h"
@@ -24,6 +25,8 @@
#include "Core/EPlayerDeath.h"
#include "Network/EPlayerConnected.h"
#include "Network/EKillDeath.h"
#include "Core/EWin.h"
#include "Game/Events/EReset.h"
class Server : public Network
{
@@ -31,16 +34,17 @@ public:
Server(World* world, EventBroker* eventBroker, int port);
~Server();
void Update() override;
void Update(double dt) override;
private:
// Network channels
TCPServer m_Reliable;
//UDPServer m_Unreliable;
UDPServer m_Unreliable;
UDPServer m_ServerlistRequest;
// dont forget to set these in the childrens receive logic
boost::asio::ip::address m_Address;
int m_Port = 27666;
bool m_GameIsOver = false;
// Sending messages to client logic
std::map<PlayerID, PlayerDefinition> m_ConnectedPlayers;
std::vector<PlayerID> m_PlayersToDisconnect;
@@ -48,14 +52,14 @@ private:
char readBuffer[BUFFERSIZE] = { 0 };
size_t bytesRead = 0;
// time for previouse message
std::clock_t previousePingMessage = std::clock();
std::clock_t previousSnapshotMessage = std::clock();
std::clock_t timOutTimer = std::clock();
double previousPingMessage = 0;
double previousSnapshotMessage = 0;
double timeOutTimer = 0;
// How often we send messages (milliseconds)
float pingIntervalMs;
float snapshotInterval;
int checkTimeOutInterval = 100;
// How often we send messages (seconds)
double pingInterval = 1;
double snapshotInterval = 0.05;
double checkTimeOutInterval = 0.1;
int m_NextPlayerID = 0;
std::vector<Events::InputCommand> m_InputCommandsToBroadcast;
//Timers
@@ -71,6 +75,7 @@ private:
void reliableBroadcast(Packet& packet);
void unreliableBroadcast(Packet& packet);
void sendSnapshot();
void createWorldSnapshot(Packet& packet);
void addPlayersToPacket(Packet& packet, EntityID entityID);
void addChildrenToPacket(Packet& packet, EntityID entityID);
void addInputCommandsToPacket(Packet& packet);
@@ -83,6 +88,7 @@ private:
void kick(PlayerID player);
PlayerID getPlayerIDFromEndpoint();
PlayerID getPlayerIDFromEntityID(EntityID entityID);
void resetMap();
void parsePlayerTransform(Packet& packet);
void parseOnInputCommand(Packet& packet);
void parseClientPing();
@@ -110,6 +116,8 @@ private:
bool OnAmmoPickup(const Events::AmmoPickup& e);
EventRelay<Server, Events::PlayerDeath> m_EPlayerDeath;
bool OnPlayerDeath(const Events::PlayerDeath& e);
EventRelay<Server, Events::Win> m_EWin;
bool OnWin(const Events::Win& e);
};
#endif
include/Engine/Network/UDPClient.h
+14 -1
View File
@@ -1,5 +1,7 @@
#ifndef UDPClient_h__
#define UDPClient_h__
#include <map>
#include <algorithm>
#include <boost/asio.hpp>
#include "Network/NetworkClient.h"
@@ -13,16 +15,27 @@ public:
bool Connect(std::string playerName, std::string address, int port);
void Disconnect();
void Receive(Packet& packet);
void Send(Packet & packet);
void ReceivePackets();
void Send(Packet& packet);
void Broadcast(Packet& packet, int port);
bool IsSocketAvailable();
// Returns false if no packets are available
bool GetNextPacket(Packet& packet);
private:
typedef std::map<unsigned int, std::vector<std::pair<int, boost::shared_ptr<char>>>> PacketMap;
// Assio UDP logic
boost::asio::io_service m_IOService;
boost::asio::ip::udp::endpoint m_ReceiverEndpoint;
boost::shared_ptr<boost::asio::ip::udp::socket> m_Socket;
int m_LastReceivedSnapshotGroup = 0;
int readBuffer();
void readPartOfPacket();
PacketID m_SendPacketID = 0;
//map:(packetGroup, vector:(pair:(groupIndex, packetData)))
PacketMap m_PacketSegmentMap;
bool hasReceivedPacket(int packetGroup, int groupIndex);
// 2^19
const int m_SizeOfSocketBuffer = 524288;
};
#endif
include/Engine/Network/UDPServer.h
+2
View File
@@ -3,6 +3,7 @@
#include "NetworkServer.h"
#include <boost/asio/ip/udp.hpp>
#define MAXPACKETSIZE 64000
class UDPServer : public NetworkServer
{
@@ -13,6 +14,7 @@ public:
void AcceptNewConnections(int& nextPlayerID, std::map<PlayerID, PlayerDefinition>& connectedPlayers);
void Receive(Packet & packet, PlayerDefinition & playerDefinition);
void Send(Packet & packet, PlayerDefinition & playerDefinition);
void SendToConnectedPlayers(Packet & packet, std::map<PlayerID, PlayerDefinition>& playersTosendTo);
void Send(Packet & packet);
void Send(Packet & packet, boost::asio::ip::udp::endpoint endpoint);
void Broadcast(Packet & packet, int port);
include/Engine/Rendering/CubeMapPass.h
+2 -1
View File
@@ -3,6 +3,7 @@
#include "IRenderer.h"
#include "ShaderProgram.h"
#include "PNG.h"
class CubeMapPass
{
@@ -21,7 +22,7 @@ private:
IRenderer* m_Renderer;
std::string m_PreviusCubeMapTexture;
std::vector<Texture*> m_CubeMapTextures;
std::vector<std::string> m_CubeMapTextures;
};
#endif
include/Engine/Rendering/DirectionalLightJob.h
+2 -2
View File
@@ -7,7 +7,7 @@
#include "../GLM.h"
#include "../Core/ComponentWrapper.h"
#include "RenderJob.h"
#include "../Core/Transform.h"
#include "../Core/TransformSystem.h"
#include "../Core/World.h"
struct DirectionalLightJob : RenderJob
@@ -16,7 +16,7 @@ struct DirectionalLightJob : RenderJob
: RenderJob()
{
Direction = glm::vec4(0,0,-1,0) * glm::inverse(Transform::AbsoluteOrientation(m_World, transformComponent.EntityID));
Direction = glm::vec4(0,0,-1,0) * glm::inverse(TransformSystem::AbsoluteOrientation(m_World, transformComponent.EntityID));
//Direction = glm::vec4((glm::vec3)directionalLightComponent["Direction"], 0.f);
Color = (glm::vec4)directionalLightComponent["Color"];
Intensity = (double)directionalLightComponent["Intensity"];
include/Engine/Rendering/DrawFinalPass.h
+73 -10
View File
@@ -17,7 +17,7 @@
class DrawFinalPass
{
public:
DrawFinalPass(IRenderer* renderer, LightCullingPass* lightCullingPass, CubeMapPass* cubeMapPass, SSAOPass* ssaoPass, ShadowPass* shadowPass);
DrawFinalPass(IRenderer* renderer, LightCullingPass* lightCullingPass, CubeMapPass* cubeMapPass, SSAOPass* ssaoPass, ShadowPass* shadowPass, ConfigFile* config);
~DrawFinalPass();
void InitializeTextures();
void InitializeFrameBuffers();
@@ -25,17 +25,77 @@ public:
void Draw(RenderScene& scene, BlurHUD* blurHUDPass);
void ClearBuffer();
void OnWindowResize();
void setMSAA(unsigned int numberOfSamples);
//Return the texture that is used in later stages to apply the bloom effect
GLuint BloomTexture() const { return m_BloomTexture; }
GLuint BloomTexture() {
if (m_MSAA){
m_AntiAliasedFrameBuffer->Bind();
glClearColor(0.f, 0.f, 0.f, 0.f);
glClear(GL_COLOR_BUFFER_BIT);
m_AntiAliasedFrameBuffer->Unbind();
m_FinalPassFrameBuffer->Read();
glReadBuffer(GL_COLOR_ATTACHMENT1);
m_AntiAliasedFrameBuffer->Draw();
glBlitFramebuffer(
0, 0, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height,
0, 0, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height,
GL_COLOR_BUFFER_BIT, GL_NEAREST);
return m_AntiAliasedTexture;
}
return m_BloomTexture; }
//Return the texture with diffuse and lighting of the scene.
GLuint SceneTexture() const { return m_SceneTexture; }
GLuint DrawFinalPass::SceneTexture() {
if (m_MSAA) {
m_AntiAliasedFrameBuffer->Bind();
glClearColor(0.f, 0.f, 0.f, 0.f);
glClear(GL_COLOR_BUFFER_BIT);
m_AntiAliasedFrameBuffer->Unbind();
m_FinalPassFrameBuffer->Read();
glReadBuffer(GL_COLOR_ATTACHMENT0);
m_AntiAliasedFrameBuffer->Draw();
glBlitFramebuffer(
0, 0, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height,
0, 0, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height,
GL_COLOR_BUFFER_BIT, GL_NEAREST);
return m_AntiAliasedTexture;
}
return m_SceneTexture;
}
//Return the SceneTexture with the blurred HUD bits.
GLuint CombinedSceneTexture() const { return m_CombinedTexture; }
GLuint CombinedSceneTexture() {
if (m_MSAA) {
m_AntiAliasedFrameBuffer->Bind();
glClearColor(0.f, 0.f, 0.f, 0.f);
glClear(GL_COLOR_BUFFER_BIT);
m_AntiAliasedFrameBuffer->Unbind();
m_FinalPassFrameBuffer->Read();
m_AntiAliasedFrameBuffer->Draw();
glBlitFramebuffer(
0, 0, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height,
0, 0, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height,
GL_COLOR_BUFFER_BIT, GL_NEAREST);
return m_AntiAliasedTexture;
}
return m_CombinedTexture; }
//Return the blurred scene texture.
GLuint FullBlurredTexture() const { return m_FullBlurredTexture; }
GLuint FullBlurredTexture() {
if (m_MSAA) {
m_AntiAliasedFrameBuffer->Bind();
glClearColor(0.f, 0.f, 0.f, 0.f);
glClear(GL_COLOR_BUFFER_BIT);
m_AntiAliasedFrameBuffer->Unbind();
m_FinalPassFrameBuffer->Read();
m_AntiAliasedFrameBuffer->Draw();
glBlitFramebuffer(
0, 0, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height,
0, 0, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height,
GL_COLOR_BUFFER_BIT, GL_NEAREST);
return m_AntiAliasedTexture;
}
return m_FullBlurredTexture; }
//Return the framebuffer used in the scene rendering stage.
FrameBuffer* FinalPassFrameBuffer() { return &m_FinalPassFrameBuffer; }
FrameBuffer* FinalPassFrameBuffer() { return m_FinalPassFrameBuffer; }
private:
void DrawSprites(std::list<std::shared_ptr<RenderJob>>&jobs, RenderScene& scene);
@@ -56,18 +116,21 @@ private:
Texture* m_GreyTexture;
Texture* m_ErrorTexture;
FrameBuffer m_FinalPassFrameBuffer;
FrameBuffer m_ShieldDepthFrameBuffer;
FrameBuffer* m_FinalPassFrameBuffer = nullptr;
FrameBuffer* m_ShieldDepthFrameBuffer = nullptr;
FrameBuffer* m_AntiAliasedFrameBuffer = nullptr;
GLuint m_BloomTexture = 0;
GLuint m_SceneTexture = 0;
GLuint m_DepthBuffer = 0;
GLuint m_ShieldBuffer = 0;
GLuint m_CubeMapTexture = 0;
GLuint m_FullBlurredTexture;
GLuint m_CombinedTexture; //This can be removed for less memory usage, just set m_sceneTexture to the return from m_BlurHUDPass.CombineTextures
GLuint m_FullBlurredTexture = 0;
GLuint m_CombinedTexture = 0; //This can be removed for less memory usage, just set m_sceneTexture to the return from m_BlurHUDPass.CombineTextures
GLuint m_AntiAliasedTexture = 0; //Is only used when MSAA is active;
//maqke this component based i guess?
GLuint m_ShieldPixelRate = 16;
unsigned int m_MSAA = 0;
const IRenderer* m_Renderer;
const LightCullingPass* m_LightCullingPass;
include/Engine/Rendering/ExplosionEffectJob.h
+14 -10
View File
@@ -18,15 +18,17 @@ struct ExplosionEffectJob : ModelJob
ExplosionEffectJob(ComponentWrapper explosionEffectComponent, ::Model* model, Camera* camera, glm::mat4 matrix, ::RawModel::MaterialProperties matGroup, ComponentWrapper modelComponent, ::World* world, glm::vec4 fillColor, float fillPercentage, bool isShielded, bool shadow)
: ModelJob(model, camera, matrix, matGroup, modelComponent, world, fillColor, fillPercentage, isShielded, shadow)
{
ExplosionOrigin = (glm::vec3)explosionEffectComponent["ExplosionOrigin"];
TimeSinceDeath = (double)explosionEffectComponent["TimeSinceDeath"];
ExplosionDuration = (double)explosionEffectComponent["ExplosionDuration"];
EndColor = (glm::vec4)explosionEffectComponent["EndColor"];
Randomness = (bool)explosionEffectComponent["Randomness"];
RandomnessScalar = (double)explosionEffectComponent["RandomnessScalar"];
Velocity = (glm::vec2)explosionEffectComponent["Velocity"];
ColorByDistance = (bool)explosionEffectComponent["ColorByDistance"];
ExponentialAccelaration = (bool)explosionEffectComponent["ExponentialAccelaration"];
ExplosionOrigin = (Field<glm::vec3>)explosionEffectComponent["ExplosionOrigin"];
TimeSinceDeath = (Field<double>)explosionEffectComponent["TimeSinceDeath"];
ExplosionDuration = (Field<double>)explosionEffectComponent["ExplosionDuration"];
EndColor = (Field<glm::vec4>)explosionEffectComponent["EndColor"];
Randomness = (Field<bool>)explosionEffectComponent["Randomness"];
RandomnessScalar = (Field<double>)explosionEffectComponent["RandomnessScalar"];
Velocity = (Field<glm::vec2>)explosionEffectComponent["Velocity"];
ColorByDistance = (Field<bool>)explosionEffectComponent["ColorByDistance"];
ExponentialAccelaration = (Field<bool>)explosionEffectComponent["ExponentialAccelaration"];
Reverse = (Field<bool>)explosionEffectComponent["Reverse"];Reverse = (bool)explosionEffectComponent["Reverse"];
ColorDistanceScalar = (Field<double>)explosionEffectComponent["ColorDistanceScalar"];ColorDistanceScalar = (double)explosionEffectComponent["ColorDistanceScalar"];
};
glm::vec3 ExplosionOrigin;
@@ -38,12 +40,14 @@ struct ExplosionEffectJob : ModelJob
glm::vec4 EndColor;
bool Randomness = false;
float RandomnessScalar = 1.f;
double RandomnessScalar = 1.f;
glm::vec2 Velocity;
bool ColorByDistance = false;
//bool ReverseAnimation = false;
//bool Wireframe = false;
bool ExponentialAccelaration = false;
bool Reverse = false;
double ColorDistanceScalar = 1.f;
std::array<float, 50> RandomNumbers = {
0.3257552917701f,
include/Engine/Rendering/FrameBuffer.h
+22 -7
View File
@@ -7,12 +7,13 @@
class BufferResource
{
public:
BufferResource(GLuint* resourceHandle, GLenum resourceType, GLenum attachment, GLuint mipMapLod);
BufferResource(GLuint* resourceHandle, GLenum resourceType, GLenum attachment, GLuint mipMapLod, bool multiSampling);
GLuint* m_ResourceHandle;
GLenum m_ResourceType;
GLenum m_Attachment;
GLuint m_MipMapLod = 0;
bool m_MultiSampling = false;
private:
};
@@ -21,24 +22,33 @@ template <GLenum RESOURCETYPE>
class ResourceType : public BufferResource
{
public:
ResourceType(GLuint* resourceHandle, GLenum attachment, GLuint mipMapLod)
: BufferResource(resourceHandle, RESOURCETYPE, attachment, mipMapLod) { }
ResourceType(GLuint* resourceHandle, GLenum attachment, GLuint mipMapLod, bool multiSampling)
: BufferResource(resourceHandle, RESOURCETYPE, attachment, mipMapLod, multiSampling) { }
};
class Texture2D : public ResourceType<GL_TEXTURE_2D>
{
public:
Texture2D(GLuint* resourceHandle, GLenum attachment, GLuint mipMapLod = 0)
: ResourceType(resourceHandle, attachment, mipMapLod) { };
: ResourceType(resourceHandle, attachment, mipMapLod, false) { };
~Texture2D();
};
class Texture2DMultiSample : public ResourceType<GL_TEXTURE_2D_MULTISAMPLE>
{
public:
Texture2DMultiSample(GLuint* resourceHandle, GLenum attachment, GLuint mipMapLod = 0)
: ResourceType(resourceHandle, attachment, mipMapLod, true) { };
~Texture2DMultiSample();
};
class RenderBuffer : public ResourceType<GL_RENDERBUFFER>
{
public:
RenderBuffer(GLuint* resourceHandle, GLenum attachment)
: ResourceType(resourceHandle, attachment, 0)
RenderBuffer(GLuint* resourceHandle, GLenum attachment, bool multiSampling = false)
: ResourceType(resourceHandle, attachment, 0, multiSampling)
{ };
~RenderBuffer();
@@ -48,12 +58,13 @@ class Texture2DArray : public ResourceType<GL_TEXTURE_2D_ARRAY>
{
public:
Texture2DArray(GLuint* resourceHandle, GLenum attachment)
: ResourceType(resourceHandle, attachment, 0)
: ResourceType(resourceHandle, attachment, 0, false)
{ };
~Texture2DArray();
};
class FrameBuffer
{
public:
@@ -65,9 +76,13 @@ public:
void Generate();
void Bind();
void Unbind();
void Read();
void Draw();
GLuint GetHandle();
bool MultiSampling() { return m_MultiSampling; };
private:
bool m_MultiSampling = true;
GLuint m_BufferHandle;
std::vector<std::shared_ptr<BufferResource>> m_Resources;
};
include/Engine/Rendering/Image.h
+2
View File
@@ -3,6 +3,8 @@
struct Image
{
virtual ~Image() = default;
enum class ImageFormat
{
Unknown,
include/Engine/Rendering/ModelJob.h
+2 -19
View File
@@ -12,7 +12,7 @@
#include "../Core/ResourceManager.h"
#include "Camera.h"
#include "../Core/World.h"
#include "../Core/Transform.h"
#include "../Core/TransformSystem.h"
#include "Skeleton.h"
#include "ShaderProgram.h"
#include "BlendTree.h"
@@ -26,24 +26,13 @@ struct ModelJob : RenderJob
ModelID = model->ResourceID;
Type = matProp.type;
::RawModel::MaterialBasic* matGroup = matProp.material;
ShaderID = matProp.ShaderID;
switch(matProp.type){
case ::RawModel::MaterialType::Basic:
if (Model->IsSkinned()) {
ShaderID = ResourceManager::Load<ShaderProgram>("#ForwardPlusSkinnedProgram")->ResourceID;
}
else {
ShaderID = ResourceManager::Load<ShaderProgram>("#ForwardPlusProgram")->ResourceID;
}
TextureID = 0;
break;
case ::RawModel::MaterialType::SingleTextures:
{
if (Model->IsSkinned()) {
ShaderID = ResourceManager::Load<ShaderProgram>("#ForwardPlusSkinnedProgram")->ResourceID;
}
else {
ShaderID = ResourceManager::Load<ShaderProgram>("#ForwardPlusProgram")->ResourceID;
}
::RawModel::MaterialSingleTextures* singleTextures = static_cast<::RawModel::MaterialSingleTextures*>(matProp.material);
TextureID = (singleTextures->ColorMap.Texture) ? singleTextures->ColorMap.Texture->ResourceID : 0;
if (modelComponent["DiffuseTexture"]) {
@@ -65,12 +54,6 @@ struct ModelJob : RenderJob
break;
case ::RawModel::MaterialType::SplatMapping:
{
if (Model->IsSkinned()) {
ShaderID = ResourceManager::Load<ShaderProgram>("#ForwardPlusSplatMapSkinnedProgram")->ResourceID;
}
else {
ShaderID = ResourceManager::Load<ShaderProgram>("#ForwardPlusSplatMapProgram")->ResourceID;
}
::RawModel::MaterialSplatMapping* SplatTextures = static_cast<::RawModel::MaterialSplatMapping*>(matProp.material);
SplatMap = &SplatTextures->SplatMap;
include/Engine/Rendering/PointLightJob.h
+2 -2
View File
@@ -7,7 +7,7 @@
#include "../GLM.h"
#include "../Core/ComponentWrapper.h"
#include "RenderJob.h"
#include "../Core/Transform.h"
#include "../Core/TransformSystem.h"
#include "../Core/World.h"
struct PointLightJob : RenderJob
@@ -16,7 +16,7 @@ struct PointLightJob : RenderJob
: RenderJob()
{
Position = glm::vec4((glm::vec3)transformComponent["Position"], 1.0f);
Position = glm::vec4(Transform::AbsolutePosition(m_World, transformComponent.EntityID), 1.f);
Position = glm::vec4(TransformSystem::AbsolutePosition(m_World, transformComponent.EntityID), 1.f);
Color = (glm::vec4)pointLightComponent["Color"];
Radius = (double)pointLightComponent["Radius"];
Intensity = (double)pointLightComponent["Intensity"];
include/Engine/Rendering/RawModelCustom.h
+2
View File
@@ -18,6 +18,7 @@
#include "../Core/ResourceManager.h"
#include "Texture.h"
#include "Skeleton.h"
#include "ShaderProgram.h"
#include "boost\endian\buffers.hpp"
@@ -87,6 +88,7 @@ public:
struct MaterialProperties {
MaterialType type;
MaterialBasic* material;
unsigned int ShaderID = 0;
};
const Vertex* Vertices() const {
include/Engine/Rendering/RenderSystem.h
+1 -1
View File
@@ -14,7 +14,7 @@
#include "ModelJob.h"
#include "Renderer.h"
#include "PointLightJob.h"
#include "../Core/Transform.h"
#include "../Core/TransformSystem.h"
#include "../Core/EPlayerSpawned.h"
#include "../Core/Octree.h"
#include "../Collision/EntityAABB.h"
include/Engine/Rendering/Renderer.h
+2 -1
View File
@@ -22,7 +22,7 @@
#include "../Core/EventBroker.h"
#include "ImGuiRenderPass.h"
#include "Camera.h"
#include "../Core/Transform.h"
#include "../Core/TransformSystem.h"
#include "imgui/imgui.h"
#include "TextPass.h"
#include "Util/CommonFunctions.h"
@@ -71,6 +71,7 @@ private:
bool m_ResizeWindow = false;
int m_SSAO_Quality = 0;
int m_GLOW_Quality = 2;
unsigned int m_MSAA_Level = 0;
PickingPass* m_PickingPass;
LightCullingPass* m_LightCullingPass;
include/Engine/Rendering/Skeleton.h
+4 -1
View File
@@ -20,11 +20,14 @@ public:
, Parent(parent)
, Name(name)
, OffsetMatrix(offsetMatrix)
{ }
{
BindTransformMatrix = glm::inverse(offsetMatrix);
}
std::string Name;
glm::mat4 OffsetMatrix;
int ID;
glm::mat4 BindTransformMatrix;
Bone* Parent;
std::vector<Bone*> Children;
include/Engine/Rendering/SpriteJob.h
+5 -3
View File
@@ -13,7 +13,7 @@
#include "../Core/ResourceManager.h"
#include "Camera.h"
#include "../Core/World.h"
#include "../Core/Transform.h"
#include "../Core/TransformSystem.h"
#include "Skeleton.h"
struct SpriteJob : RenderJob
@@ -29,6 +29,7 @@ struct SpriteJob : RenderJob
IncandescenceTexture = CommonFunctions::TryLoadResource<TextureSprite, true>(cSprite["GlowMap"]);
Linear = (bool)cSprite["Linear"];
ClampToBorder = (bool)cSprite["ClampToBorder"];
StartIndex = matProp.material->StartIndex;
EndIndex = matProp.material->EndIndex;
@@ -37,7 +38,7 @@ struct SpriteJob : RenderJob
BlurBackground = (bool)cSprite["BlurBackground"];
Entity = cSprite.EntityID;
Position = Transform::AbsolutePosition(world, cSprite.EntityID);
Position = TransformSystem::AbsolutePosition(world, cSprite.EntityID);
Depth = 0;
if (depthSorted) {
glm::vec3 viewpos = glm::vec3(camera->ViewMatrix() * glm::vec4(Position, 1));
@@ -50,7 +51,7 @@ struct SpriteJob : RenderJob
FillColor = fillColor;
FillPercentage = fillPercentage;
glm::vec3 scale = Transform::AbsoluteScale(world, cSprite.EntityID);
glm::vec3 scale = TransformSystem::AbsoluteScale(world, cSprite.EntityID);
if((bool)cSprite["KeepRatio"] == true) {
if(scale.y >= scale.x) {
@@ -93,6 +94,7 @@ struct SpriteJob : RenderJob
float ScaleX = 1;
float ScaleY = 1;
bool Linear = false;
bool ClampToBorder = false;
glm::vec4 FillColor = glm::vec4(0);
float FillPercentage = 0.0;
include/Engine/Rendering/TextJob.h
+2 -2
View File
@@ -17,8 +17,8 @@ struct TextJob : RenderJob
: RenderJob()
{
Matrix = matrix;
Color = (glm::vec4)textComponent["Color"];
Content = (std::string)textComponent["Content"];
Color = (const glm::vec4&)textComponent["Color"];
Content = (const std::string&)textComponent["Content"];
Resource = font;
if ((int)textComponent["Alignment"] == textComponent["Alignment"].Enum("Left")) {
include/Engine/Rendering/TextPass.h
+1
View File
@@ -23,6 +23,7 @@ public:
private:
void renderText(std::string text, Font* font, TextJob::AlignmentEnum alignment, glm::vec4 color, glm::mat4 modelMatrix, glm::mat4 projectionMatrix, glm::mat4 viewMatrix);
std::string parseColors(std::string text, std::map<int, glm::vec4>& colorChanges, glm::vec4 originalColor);
Font* font;
GLuint VAO, VBO;
include/Engine/Rendering/TextureSprite.h
-2
View File
@@ -14,8 +14,6 @@ protected:
TextureSprite(std::string path);
public:
~TextureSprite();
void Bind(GLenum textureUnit = GL_TEXTURE0);
GLuint m_Texture = 0;
include/Engine/Rendering/Util/CommonFunctions.h
+1 -1
View File
@@ -27,7 +27,7 @@ Texture* TryLoadResource(std::string path)
void GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type);
void GenerateMultiSampleTexture(GLuint* texture, int numSamples, glm::vec2 dimensions, GLint internalFormat);
void GenerateMipMapTexture(GLuint* texture, GLenum wrapping, glm::vec2 dimensions, GLint format, GLenum type, GLint numMipMaps);
void GenerateMipMapTexture(GLuint* texture, GLenum wrapping, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type, GLint numMipMaps, GLint MAGFilter, GLint MINFilter);
void DeleteTexture(GLuint* texture);
};
include/Engine/Sound/EChangeBGM.h
+16
View File
@@ -0,0 +1,16 @@
#ifndef Events_ChangeBGM_h__
#define Events_ChangeBGM_h__
#include <string>
#include "../Engine/Core/EventBroker.h"
namespace Events
{
struct ChangeBGM : Event
{
std::string FilePath = "";
};
}
#endif // Events_ChangeBGM_h__
include/Engine/Sound/EPlayAnnouncerVoice.h
+17
View File
@@ -0,0 +1,17 @@
#ifndef Events_PlayAnnouncerVoice_h__
#define Events_PlayAnnouncerVoice_h__
#include <string>
#include "../Engine/Core/EventBroker.h"
namespace Events
{
struct PlayAnonuncerVoice : public Event
{
std::string FilePath = "";
};
}
#endif
include/Engine/Sound/EPlaySoundOnEntity.h
+2 -1
View File
@@ -12,7 +12,8 @@ namespace Events
// Sound behavior is thereby specified in the SoundEmitter component.
struct PlaySoundOnEntity : public Event
{
EntityID EmitterID = 0;
EntityWrapper Emitter = EntityWrapper::Invalid;
float Gain = 1.f;
std::string FilePath = "";
};
include/Engine/Sound/ESetAnnouncerGain.h
+16
View File
@@ -0,0 +1,16 @@
#ifndef Events_SetAnnouncerGain_h__
#define Events_SetAnnouncerGain_h__
#include "../Engine/Core/EventBroker.h"
namespace Events
{
struct SetAnnouncerGain : public Event
{
float Gain = 1;
};
}
#endif //
include/Engine/Sound/SoundManager.h
+37 -18
View File
@@ -9,32 +9,36 @@
#include "OpenAL/al.h"
#include "OpenAL/alc.h"
#include "imgui/imgui.h"
#include "Core/World.h"
#include "Core/EventBroker.h"
#include "../Engine/Core/World.h"
#include "../Engine/Core/EventBroker.h"
#include "../Engine/Core/ResourceManager.h"
#include "../Engine/Core/ConfigFile.h"
#include "Core/Transform.h" // Absolute transform
#include "Sound/Sound.h"
#include "../Engine/Core/TransformSystem.h"
#include "../Engine/Sound/Sound.h"
#include "../Engine/Sound/EPlayQueueOnEntity.h"
#include "Sound/EPlaySoundOnEntity.h"
#include "Sound/EPlaySoundOnPosition.h"
#include "Sound/EPlayBackgroundMusic.h"
#include "Sound/EPauseSound.h"
#include "Sound/EContinueSound.h"
#include "Sound/EStopSound.h"
#include "Sound/ESetBGMGain.h"
#include "Sound/ESetSFXGain.h"
#include "Core/EPause.h"
#include "Core/EComponentAttached.h"
#include "../Engine/Sound/EPlaySoundOnEntity.h"
#include "../Engine/Sound/EPlaySoundOnPosition.h"
#include "../Engine/Sound/EPlayBackgroundMusic.h"
#include "../Engine/Sound/EPlayAnnouncerVoice.h"
#include "../Engine/Sound/EPauseSound.h"
#include "../Engine/Sound/EContinueSound.h"
#include "../Engine/Sound/EStopSound.h"
#include "../Engine/Sound/ESetBGMGain.h"
#include "../Engine/Sound/ESetSFXGain.h"
#include "../Engine/Sound/ESetAnnouncerGain.h"
#include "../Engine/Sound/EChangeBGM.h"
#include "../Engine/Core/EPause.h"
#include "../Engine/Core/EComponentAttached.h"
#include "../Core/EPlayerSpawned.h"
#include "../Rendering/ESetCamera.h"
typedef std::pair<ALuint, std::vector<ALuint>> QueuedBuffers;
enum class SoundType {
SFX,
BGM
BGM,
Announcer
};
struct Source
@@ -43,6 +47,7 @@ struct Source
Sound* SoundResource = nullptr;
ALuint ALsource;
SoundType Type;
float Duration;
};
class SoundManager
@@ -74,14 +79,19 @@ private:
ALenum getSourceState(ALuint source);
void setGain(Source* source, float gain);
void setSoundProperties(Source* source, ComponentWrapper* soundComponent);
float getDurationSeconds(Source* source);
float getTimeOffsetSeconds(Source* source);
// Specific logic
void playSound(Source* source);
// Need to be the same format (sample rate etc)
// Needs to be the same format (sample rate etc)
void playQueue(QueuedBuffers qb);
void stopSound(Source* source);
Source* createSource(std::string filePath);
std::unordered_map<EntityID, Source*> m_Sources;
void matchBGMLoop();
Source* m_CurrentBGM = nullptr;
Source* m_CurrentBGMCombo = nullptr;
// Logic
World* m_World = nullptr;
@@ -93,6 +103,7 @@ private:
float m_BGMVolumeChannel = 1.0f;
float m_SFXVolumeChannel = 1.0f;
float m_AnnouncerVolumeChannel = 1.0f;
EntityWrapper m_LocalPlayer = EntityWrapper();
// Events
@@ -102,6 +113,8 @@ private:
bool OnPlaySoundOnPosition(const Events::PlaySoundOnPosition &e);
EventRelay<SoundManager, Events::PlayBackgroundMusic> m_EPlayBackgroundMusic;
bool OnPlayBackgroundMusic(const Events::PlayBackgroundMusic &e);
EventRelay<SoundManager, Events::PlayAnonuncerVoice> m_EPlayAnnouncerVoice;
bool OnPlayAnnouncerVoice(const Events::PlayAnonuncerVoice& e);
EventRelay<SoundManager, Events::PauseSound> m_EPauseSound;
bool OnPauseSound(const Events::PauseSound &e);
EventRelay<SoundManager, Events::StopSound> m_EStopSound;
@@ -112,6 +125,8 @@ private:
bool OnSetBGMGain(const Events::SetBGMGain &e);
EventRelay<SoundManager, Events::SetSFXGain> m_ESetSFXGain;
bool OnSetSFXGain(const Events::SetSFXGain &e);
EventRelay<SoundManager, Events::SetAnnouncerGain> m_ESetAnnouncerGain;
bool OnSetAnnouncerGain(const Events::SetAnnouncerGain& e);
EventRelay<SoundManager, Events::ComponentAttached> m_EComponentAttached;
bool OnComponentAttached(const Events::ComponentAttached &e);
EventRelay<SoundManager, Events::Pause> m_EPause;
@@ -122,6 +137,10 @@ private:
bool OnPlayerSpawned(const Events::PlayerSpawned &e);
EventRelay<SoundManager, Events::PlayQueueOnEntity> m_EPlayQueueOnEntity;
bool OnPlayQueueOnEntity(const Events::PlayQueueOnEntity &e);
EventRelay<SoundManager, Events::ChangeBGM> m_EChangeBGM;
bool OnChangeBGM(const Events::ChangeBGM &e);
EventRelay<SoundManager, Events::SetCamera> m_ESetCamera;
bool OnSetCamera(const Events::SetCamera& e);
};