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

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

Browse Source 
# Conflicts:
#	include/Engine/Rendering/ModelJob.h
#	resources/Schema/Components.xsd
#	resources/Schema/Types/Entity.xsd
#	src/Engine/Rendering/DrawFinalPass.cpp
#	src/Engine/Rendering/PickingPass.cpp
#	src/Engine/Rendering/Renderer.cpp
#	src/Engine/Rendering/Skeleton.cpp
This commit is contained in:
viktorljung
2016-02-26 10:21:22 +01:00
parent af034673f6 f161fce719
commit 5c3b472a4d
176 changed files with 10489 additions and 2114 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/Engine/Collision/Collision.h
+9 -1
View File
@@ -78,13 +78,21 @@ bool AABBvsTriangles(const AABB& box,
bool& isOnGround,
glm::vec3& outResolutionVector);
//Detects collision, but does not resolve.
bool AABBvsTriangles(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.
//Also outputs the minimum translation that box [a] would need in order to resolve collision.
bool AABBVsAABB(const AABB& a, const AABB& b, glm::vec3& minimumTranslation);
// Calculates an absolute AABB from an entity AABB component
// Calculates an absolute AABB from an entity AABB component or Model component.
// if takeModelBox is true, the AABB component will be ignored and box is calculated from Model.
// if takeModelBox is false, the AABB component will be prefered, if it exists.
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
include/Engine/Collision/CollisionSystem.h
+3 -2
View File
@@ -15,15 +15,16 @@ class CollisionSystem : public PureSystem
public:
CollisionSystem(SystemParams params, Octree<EntityAABB>* octree)
: System(params)
, PureSystem("Collidable")
, PureSystem("Physics")
, m_Octree(octree)
{ }
virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt) override;
virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& cPhysics, double dt) override;
private:
Octree<EntityAABB>* m_Octree;
std::vector<EntityAABB> m_OctreeResult;
std::unordered_map<EntityWrapper, glm::vec3> m_PrevPositions;
};
#endif
include/Engine/Core/ComponentInfo.h
+3 -1
View File
@@ -2,6 +2,7 @@
#define ComponentInfo_h__
#include "../Common.h"
#include <boost/shared_array.hpp>
struct ComponentInfo
{
@@ -27,8 +28,9 @@ struct ComponentInfo
std::string Name;
std::unordered_map<std::string, Field_t> Fields;
std::vector<std::string> FieldsInOrder;
std::vector<std::string> StringFields;
unsigned int Stride = 0;
std::shared_ptr<char> Defaults = nullptr;
boost::shared_array<char> Defaults = nullptr;
std::shared_ptr<Meta_t> Meta = nullptr;
};
include/Engine/Core/ComponentPool.h
+3 -1
View File
@@ -1,6 +1,7 @@
#ifndef ComponentPool_h__
#define ComponentPool_h__
#include <set>
#include "MemoryPool.h"
#include "ComponentInfo.h"
#include "ComponentWrapper.h"
@@ -45,7 +46,8 @@ public:
: m_ComponentInfo(ci)
, m_Pool(ci.Meta->Allocation, sizeof(EntityID) + ci.Stride)
{ }
ComponentPool(const ComponentPool& other) = delete;
~ComponentPool();
ComponentPool(const ComponentPool& other);
ComponentPool(const ComponentPool&& other) = delete;
const ::ComponentInfo& ComponentInfo() const { return m_ComponentInfo; }
include/Engine/Core/ComponentWrapper.h
+65 -11
View File
@@ -2,11 +2,29 @@
#define ComponentWrapper_h__
#include <boost/shared_array.hpp>
#include <boost/any.hpp>
#include "../Common.h"
#include "Entity.h"
#include "ComponentInfo.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; }
};
struct ComponentWrapper
{
ComponentWrapper(const ComponentInfo& componentInfo, char* data)
@@ -47,7 +65,31 @@ struct ComponentWrapper
void Copy(ComponentWrapper& destination)
{
memcpy(destination.Data, this->Data, Info.Stride);
// Copy trivial data
memcpy(destination.Data, Data, Info.Stride);
// Duplicate strings
SolidifyStrings(destination);
}
// When component data has been copied, strings need to be reconstructed or they'll refer to the same data!
static void SolidifyStrings(ComponentWrapper& component)
{
for (auto& name : component.Info.StringFields) {
std::size_t offset = component.Info.Fields.at(name).Offset;
std::string value = *reinterpret_cast<const std::string*>(component.Data + offset);
new (component.Data + offset) std::string(value);
}
}
// This needs to be called to properly free component data, because strings.
static void Destroy(ComponentInfo info, char* data)
{
// Call std::string destructors
for (auto& name : info.StringFields) {
std::size_t offset = info.Fields.at(name).Offset;
auto field = reinterpret_cast<std::string*>(data + offset);
field->~basic_string();
}
}
struct SubscriptProxy
@@ -102,26 +144,38 @@ public:
ComponentWrapperFactory(std::string componentTypeName, unsigned int allocation = 0)
{
m_ComponentInfo.Name = componentTypeName;
m_ComponentInfo.Meta = std::make_shared<ComponentInfo::Meta_t>();
m_ComponentInfo.Meta->Allocation = allocation;
}
template <typename T>
void AddProperty(std::string fieldName, T defaultValue)
{
m_DefaultValues.push_back(defaultValue);
m_ComponentInfo.Fields[fieldName].Type = typeid(T).name();
m_ComponentInfo.Fields[fieldName].Offset = m_ComponentInfo.Stride;
m_ComponentInfo.Fields[fieldName].Stride = sizeof(T);
auto& field = m_ComponentInfo.Fields[fieldName];
field.Name = fieldName;
field.Type = typeid(T).name();
field.Offset = m_ComponentInfo.Stride;
field.Stride = sizeof(T);
m_ComponentInfo.FieldsInOrder.push_back(field.Name);
if (field.Type == typeid(std::string).name()) {
field.Type = "string";
m_ComponentInfo.StringFields.push_back(field.Name);
}
m_ComponentInfo.Stride += sizeof(T);
m_DefaultValues.push_back(std::make_pair(field, defaultValue));
}
ComponentInfo& Finalize()
{
m_ComponentInfo.Defaults = std::shared_ptr<char>(new char[m_ComponentInfo.Stride]);
m_ComponentInfo.Defaults = boost::shared_array<char>(new char[m_ComponentInfo.Stride]);
std::size_t offset = 0;
for (auto& val : m_DefaultValues) {
memcpy(m_ComponentInfo.Defaults.get() + offset, val.Data.get(), val.Size);
offset += val.Size;
for (auto& pair : m_DefaultValues) {
if (pair.first.Type == "string") {
new (m_ComponentInfo.Defaults.get() + offset) std::string(*reinterpret_cast<std::string*>(pair.second.Data.get()));
} else {
memcpy(m_ComponentInfo.Defaults.get() + offset, pair.second.Data.get(), pair.second.Size);
}
offset += pair.second.Size;
}
return m_ComponentInfo;
@@ -131,7 +185,7 @@ public:
private:
ComponentInfo m_ComponentInfo;
std::vector<Any> m_DefaultValues;
std::vector<std::pair<ComponentInfo::Field_t, Any>> m_DefaultValues;
};
#endif
include/Engine/Core/EAmmoPickup.h
+18
View File
@@ -0,0 +1,18 @@
#ifndef EAmmoPickup_h__
#define EAmmoPickup_h__
#include "EventBroker.h"
#include "../Core/EntityWrapper.h"
namespace Events
{
struct AmmoPickup : Event
{
EntityWrapper Player;
int AmmoGain;
};
}
#endif
include/Engine/Core/MemoryPool.h
+22 -5
View File
@@ -66,9 +66,25 @@ public:
, m_LowestAllocatedSlot(m_NumSlots)
{ }
//We may get problems with memory being released
//prematurely, etc. if we allow copies.
MemoryPool(const MemoryPool<T>& other) = delete;
MemoryPool(const MemoryPool<T>& other)
: m_StartAddress(new char[other.m_NumSlots*other.m_Stride])
, m_SlotIsAllocated(other.m_SlotIsAllocated)
, m_ExtraMemory()
, m_NumSlots(other.m_NumSlots)
, m_LowestAllocatedSlot(other.m_LowestAllocatedSlot)
, m_NumAllocatedSlots(other.m_NumAllocatedSlots)
, m_Stride(other.m_Stride)
, m_CurrentAllocSlot(other.m_CurrentAllocSlot)
{
// Copy statically allocated pool
memcpy(m_StartAddress, other.m_StartAddress, m_NumSlots*m_Stride);
// Copy dynamically allocated memory
for (char* otherAddr : other.m_ExtraMemory) {
char* addr = (char*)malloc(m_Stride);
memcpy(addr, otherAddr, m_Stride);
m_ExtraMemory.push_back(addr);
}
}
MemoryPool(const MemoryPool<T>&& other) = delete;
//Free all memory that has been allocated.
@@ -78,8 +94,9 @@ public:
delete[] m_StartAddress;
m_StartAddress = nullptr;
}
for (char* addr : m_ExtraMemory)
free(addr);
for (char* addr : m_ExtraMemory) {
free(addr);
}
m_ExtraMemory.clear();
}
include/Engine/Core/PerformanceTimer.h
+25
View File
@@ -0,0 +1,25 @@
#ifndef PerformanceTimer_h__
#define PerformanceTimer_h__
#include "../Common.h"
#include <boost/timer/timer.hpp>
using boost::timer::cpu_timer;
class PerformanceTimer
{
public:
static void StartTimer(std::string nameOfTimer);
static void StartTimerAndStopPrevious(std::string nameOfTimer);
static void StopTimer(std::string nameOfTimer);
static void SetFrameNumber(int frameNumber);
static void ResetAllTimers();
static void CreateExcelData();
private:
static std::map<std::string, cpu_timer> timers;
static cpu_timer m_Timer;
static std::string currentTimerRunning;
};
#endif
include/Engine/Core/SystemPipeline.h
+10 -3
View File
@@ -6,6 +6,7 @@
#include "System.h"
#include "World.h"
#include "EPause.h"
#include "PerformanceTimer.h"
class SystemPipeline
{
@@ -72,7 +73,10 @@ public:
// Update
for (auto& system : group.ImpureSystems) {
auto className = (std::string)typeid(*system).name();
PerformanceTimer::StartTimer(className);
system->Update(dt);
PerformanceTimer::StopTimer(className);
}
for (auto& pair : group.PureSystems) {
const std::string& componentName = pair.first;
@@ -83,7 +87,10 @@ public:
}
for (auto& component : *pool) {
for (auto& system : systems) {
auto className = (std::string)typeid(*system).name();
PerformanceTimer::StartTimer(className);
system->UpdateComponent(EntityWrapper(m_World, component.EntityID), component, dt);
PerformanceTimer::StopTimer(className);
}
}
}
@@ -106,9 +113,9 @@ private:
std::vector<UnorderedSystems> m_OrderedSystemGroups;
EventRelay<SystemPipeline, Events::Pause> m_EPause;
bool OnPause(const Events::Pause& e) {
if (e.World == m_World) {
m_Paused = true;
bool OnPause(const Events::Pause& e) {
if (e.World == m_World) {
m_Paused = true;
}
return true;
}
include/Engine/Core/Util/Any.h
+4 -3
View File
@@ -2,6 +2,7 @@
#define Util_Any_h__
#include <memory>
#include <boost/shared_array.hpp>
struct Any
{
@@ -10,7 +11,7 @@ struct Any
template <typename T>
Any(const T& value)
{
Data = std::shared_ptr<char>(new char[sizeof(T)]);
Data = boost::shared_array<char>(new char[sizeof(T)]);
Size = sizeof(T);
memcpy(Data.get(), &value, Size);
}
@@ -18,7 +19,7 @@ struct Any
template <typename T>
Any(T&& value)
{
Data = std::shared_ptr<char>(new char[sizeof(T)]);
Data = boost::shared_array<char>(new char[sizeof(T)]);
Size = sizeof(T);
memcpy(Data.get(), &value, Size);
}
@@ -35,7 +36,7 @@ struct Any
return Any(value);
}
std::shared_ptr<char> Data = nullptr;
boost::shared_array<char> Data = nullptr;
std::size_t Size = 0;
};
include/Engine/Core/World.h
+1
View File
@@ -15,6 +15,7 @@ public:
: m_EventBroker(eventBroker)
{ }
~World();
World(const World& other);
// Create empty entity
EntityID CreateEntity(EntityID parent = 0);
include/Engine/GUI/Button.h
-165
View File
@@ -1,165 +0,0 @@
#ifndef GUI_BUTTON_H__
#define GUI_BUTTON_H__
#include "GUI/TextureFrame.h"
#include "GUI/EButtonEnter.h"
#include "GUI/EButtonLeave.h"
#include "GUI/EButtonPress.h"
#include "GUI/EButtonRelease.h"
#include "Core/EMouseMove.h"
#include "Core/EMousePress.h"
#include "Core/EMouseRelease.h"
namespace dd
{
namespace GUI
{
class Button : public TextureFrame
{
public:
Button(Frame* parent, std::string name)
: TextureFrame(parent, name)
{
EVENT_SUBSCRIBE_MEMBER(m_EMouseMove, &Button::OnMouseMove);
EVENT_SUBSCRIBE_MEMBER(m_EMousePress, &Button::OnMousePress);
EVENT_SUBSCRIBE_MEMBER(m_EMouseRelease, &Button::OnMouseRelease);
}
void SetTextureHover(std::string resourceName)
{
m_TextureHover = resourceName;
}
void SetTextureReleased(std::string resourceName)
{
m_TextureReleased = resourceName;
SetTexture(resourceName);
}
void SetTexturePressed(std::string resourceName)
{
m_TexturePressed = resourceName;
}
void Draw(RenderScene& rq) override
{
if (m_Texture == nullptr && !m_TextureReleased.empty()) {
SetTexture(m_TextureReleased);
}
TextureFrame::Draw(rq);
}
virtual void OnEnter() { }
virtual void OnLeave() { }
virtual void OnPress() { }
virtual void OnRelease() { }
protected:
bool m_MouseIsOver = false;
bool m_IsDown = false;
virtual bool OnMouseMove(const Events::MouseMove& event)
{
if (Hidden()) {
return false;
}
bool isOver = Rectangle::Intersects(AbsoluteRectangle(), Rectangle(event.X, event.Y, 1, 1));
if (isOver && !m_MouseIsOver) { // Enter
if (!m_IsDown) {
if (!m_TextureHover.empty()) {
SetTexture(m_TextureHover);
}
}
OnEnter();
Events::ButtonEnter e;
e.FrameName = m_Name;
EventBroker->Publish(e);
Events::PlaySound soundEvent;
soundEvent.FilePath = "Sounds/GUI/hover-n.wav";
EventBroker->Publish(soundEvent);
} else if (!isOver && m_MouseIsOver) { // Leave
if (!m_IsDown) {
if (!m_TextureReleased.empty()) {
SetTexture(m_TextureReleased);
}
}
OnLeave();
Events::ButtonLeave e;
e.FrameName = m_Name;
EventBroker->Publish(e);
}
m_MouseIsOver = isOver;
return true;
}
virtual bool OnMousePress(const Events::MousePress& event)
{
if (Hidden()) {
//LOG_DEBUG("Pressed hidden button");
return false;
}
if (!Rectangle::Intersects(AbsoluteRectangle(), Rectangle(event.X, event.Y, 1, 1))) {
return false;
}
if (!m_TexturePressed.empty()) {
SetTexture(m_TexturePressed);
}
m_IsDown = true;
OnPress();
Events::ButtonPress e;
e.FrameName = m_Name;
e.Button = this;
EventBroker->Publish(e);
return true;
}
virtual bool OnMouseRelease(const Events::MouseRelease& event)
{
if (Hidden()) {
//LOG_DEBUG("Released hidden button");
return false;
}
bool isOver = Rectangle::Intersects(AbsoluteRectangle(), Rectangle(event.X, event.Y, 1, 1));
if (!isOver && !m_IsDown) {
return false;
}
if (m_MouseIsOver) {
if (!m_TextureHover.empty()) {
SetTexture(m_TextureHover);
}
} else {
if (!m_TextureReleased.empty()) {
SetTexture(m_TextureReleased);
}
}
m_IsDown = false;
OnRelease();
Events::ButtonRelease e;
e.FrameName = m_Name;
e.Button = this;
EventBroker->Publish(e);
return true;
}
private:
EventRelay<Frame, Events::MouseMove> m_EMouseMove;
EventRelay<Frame, Events::MousePress> m_EMousePress;
EventRelay<Frame, Events::MouseRelease> m_EMouseRelease;
std::string m_TextureHover;
std::string m_TexturePressed;
std::string m_TextureReleased;
};
}
}
#endif
include/Engine/GUI/ButtonSystem.h
+44
View File
@@ -0,0 +1,44 @@
#ifndef ButtonSystem_h__
#define ButtonSystem_h__
#include "../Rendering/IRenderer.h"
#include "../Core/ConfigFile.h"
#include "../Rendering/PickingPass.h"
#include "../Core/ResourceManager.h"
#include "../Core/System.h"
#include "../Core/Event.h"
#include "../Core/EMousePress.h"
#include "../Core/EMouseRelease.h"
#include "../Core/ELockMouse.h"
#include "EButtonPressed.h"
#include "EButtonReleased.h"
#include "EButtonClicked.h"
class ButtonSystem : public PureSystem
{
public:
ButtonSystem(SystemParams params, IRenderer* renderer);
virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt) override;
private:
IRenderer* m_Renderer;
bool m_MouseIsLocked = false;
EntityWrapper m_PickEntity = EntityWrapper::Invalid;
PickData m_PickData;
EventRelay<ButtonSystem, Events::LockMouse> m_EMouseLock;
bool OnMouseLock(const Events::LockMouse& e);
EventRelay<ButtonSystem, Events::UnlockMouse> m_EMouseUnlock;
bool OnMouseUnlock(const Events::UnlockMouse& e);
EventRelay<ButtonSystem, Events::MousePress> m_EMousePress;
bool OnMousePress(const Events::MousePress& e);
EventRelay<ButtonSystem, Events::MouseRelease> m_EMouseRelease;
bool OnMouseRelease(const Events::MouseRelease& e);
};
#endif
include/Engine/GUI/EButtonClicked.h
+16
View File
@@ -0,0 +1,16 @@
#ifndef Events_ButtonClicked_h__
#define Events_ButtonClicked_h__
#include "Core/Event.h"
namespace Events
{
struct ButtonClicked : public Event {
std::string EntityName;
EntityWrapper Entity;
};
}
#endif
include/Engine/GUI/EButtonEnter.h
-17
View File
@@ -1,17 +0,0 @@
#ifndef Events_ButtonEnter_h__
#define Events_ButtonEnter_h__
#include "../Core/EventBroker.h"
namespace Events
{
/** Thrown on GUI button hover. */
struct ButtonEnter : Event
{
std::string FrameName;
};
}
#endif
include/Engine/GUI/EButtonLeave.h
-17
View File
@@ -1,17 +0,0 @@
#ifndef Events_ButtonLeave_h__
#define Events_ButtonLeave_h__
#include "../Core/EventBroker.h"
namespace Events
{
/** Thrown on GUI button hover. */
struct ButtonLeave : Event
{
std::string FrameName;
};
}
#endif
include/Engine/GUI/EButtonPress.h
-20
View File
@@ -1,20 +0,0 @@
#ifndef Events_ButtonPress_h__
#define Events_ButtonPress_h__
#include "../Core/EventBroker.h"
namespace GUI { class Button; }
namespace Events
{
/** Thrown on GUI button press. */
struct ButtonPress : Event
{
std::string FrameName;
GUI::Button* Button;
};
}
#endif
include/Engine/GUI/EButtonPressed.h
+16
View File
@@ -0,0 +1,16 @@
#ifndef Events_ButtonPressed_h__
#define Events_ButtonPressed_h__
#include "Core/Event.h"
namespace Events
{
struct ButtonPressed : public Event {
std::string EntityName;
EntityWrapper Entity;
};
}
#endif
include/Engine/GUI/EButtonRelease.h
-20
View File
@@ -1,20 +0,0 @@
#ifndef Events_ButtonRelease_h__
#define Events_ButtonRelease_h__
#include "../Core/EventBroker.h"
namespace GUI { class Button; }
namespace Events
{
/** Thrown on GUI button release. */
struct ButtonRelease : Event
{
std::string FrameName;
GUI::Button* Button;
};
}
#endif
include/Engine/GUI/EButtonReleased.h
+16
View File
@@ -0,0 +1,16 @@
#ifndef Events_ButtonReleased_h__
#define Events_ButtonReleased_h__
#include "Core/Event.h"
namespace Events
{
struct ButtonReleased : public Event {
std::string EntityName;
EntityWrapper Entity;
};
}
#endif
include/Engine/GUI/Frame.h
-261
View File
@@ -1,261 +0,0 @@
#ifndef GUI_Frame_h__
#define GUI_Frame_h__
#include "../Common.h"
#include "../Core/Util/Rectangle.h"
#include "../Core/EventBroker.h"
#include "../Core/EKeyDown.h"
#include "../Core/EKeyUp.h"
#include "../Core/ResourceManager.h"
#include "../Rendering/RenderQueue.h"
#include "../Rendering/Texture.h"
#include "../Input/EInputCommand.h"
namespace GUI
{
class Frame : public Rectangle
{
public:
enum class Anchor
{
Left,
Right,
Top,
Bottom
};
static const int BaseWidth = 1280;
static const int BaseHeight = 720;
// Set up a base frame with an event broker
Frame(EventBroker* eventBroker)
: m_EventBroker(eventBroker)
, BaseFrame(this)
, m_Name("UIParent")
, Rectangle() { }
// Create a frame as a child
Frame(Frame* parent, std::string name)
: m_Name(name)
{
SetParent(parent);
Width = parent->Width;
Height = parent->Height;
EVENT_SUBSCRIBE_MEMBER(m_EKeyDown, &Frame::OnKeyDown);
EVENT_SUBSCRIBE_MEMBER(m_EKeyUp, &Frame::OnKeyUp);
EVENT_SUBSCRIBE_MEMBER(m_EInputCommand, &Frame::OnCommand);
}
~Frame()
{
/*for (auto layer : m_Children)
{
for (auto child : layer.second)
{
delete child.second;
}
}
if (m_Parent)
{
m_Parent->RemoveChild(this);
}*/
}
Frame* Parent() const { return m_Parent; }
void SetParent(Frame* parent)
{
if (parent == nullptr) {
LOG_ERROR("Failed to parent frame \"%s\": Invalid parent", m_Name.c_str());
return;
}
m_Layer = parent->Layer() + 1;
parent->AddChild(this);
m_Parent = parent;
m_EventBroker = parent->m_EventBroker;
BaseFrame = parent->BaseFrame;
}
void AddChild(Frame* child)
{
m_Children[child->m_Layer].insert(std::make_pair(child->Name(), child));
if (m_Parent) {
m_Parent->AddChild(child);
}
}
void RemoveChild(Frame* child)
{
auto it = m_Children.find(child->m_Layer);
if (it != m_Children.end()) {
m_Children.erase(it);
}
if (m_Parent) {
m_Parent->RemoveChild(child);
}
}
std::string Name() const { return m_Name; }
void SetName(std::string val) { m_Name = val; }
int Layer() const { return m_Layer; }
bool Hidden() const
{
if (m_Parent)
return m_Parent->Hidden() || m_Hidden;
else
return m_Hidden;
}
bool Visible() const
{
return !Hidden();
}
virtual void Hide() { m_Hidden = true; }
virtual void Show() { m_Hidden = false; }
int Left() const override
{
if (m_Parent)
return m_Parent->Left() + X;
else
return X;
}
void SetLeft(int absLeft) override
{
if (m_Parent) {
X = absLeft - m_Parent->Left();
} else {
X = absLeft;
}
}
int Right() const override
{
return Left() + Width;
}
void SetRight(int absRight) override
{
if (m_Parent) {
X = absRight - Width - m_Parent->Left();
} else {
X = absRight - Width;
}
}
int Top() const override
{
if (m_Parent)
return m_Parent->Top() + Y;
else
return Y;
}
void SetTop(int absTop) override
{
if (m_Parent) {
Y = absTop - m_Parent->Top();
} else {
Y = absTop;
}
}
int Bottom() const override
{
return Top() + Height;
}
void SetBottom(int absBottom) override
{
if (m_Parent) {
Y = absBottom - Height - m_Parent->Top();
} else {
Y = absBottom - Height;
}
}
glm::vec2 Scale()
{
if (m_Parent)
return m_Parent->Scale();
else
return glm::vec2(Width, Height) / glm::vec2(BaseWidth, BaseHeight);
}
Rectangle AbsoluteRectangle()
{
int left = Left();
if (m_Parent)
left = std::max(left, m_Parent->Left());
int top = Top();
if (m_Parent)
top = std::max(top, m_Parent->Top());
int width = Right() - left;
int height = Bottom() - top;
return Rectangle(left, top, width, height);
}
void UpdateLayered(double dt)
{
// Update ourselves
this->Update(dt);
// Update children
for (auto& pairLayer : m_Children) {
auto children = pairLayer.second;
for (auto& pairChild : children) {
auto child = pairChild.second;
child->Update(dt);
}
}
}
virtual void Update(double dt) { }
void DrawLayered(RenderScene& rq)
{
if (this->Hidden())
return;
// Draw ourselves
this->Draw(rq);
// Draw children
for (auto& pairLayer : m_Children) {
auto children = pairLayer.second;
for (auto& pairChild : children) {
auto child = pairChild.second;
if (child->Hidden())
continue;
child->Draw(rq);
}
}
}
virtual void Draw(RenderScene& rq) { }
protected:
::EventBroker* m_EventBroker;
Frame* BaseFrame = nullptr;
std::string m_Name = "Unnamed";
int m_Layer = 0;
bool m_Hidden = false;
Frame* m_Parent = nullptr;
typedef std::multimap<std::string, Frame*> Children_t; // name -> frame
std::map<int, Children_t> m_Children; // layer -> Children_t
virtual bool OnKeyDown(const Events::KeyDown& event) { return false; }
virtual bool OnKeyUp(const Events::KeyUp& event) { return false; }
virtual bool OnCommand(const Events::InputCommand& event) { return false; }
private:
EventRelay<Frame, Events::KeyDown> m_EKeyDown;
EventRelay<Frame, Events::KeyUp> m_EKeyUp;
EventRelay<Frame, Events::InputCommand> m_EInputCommand;
};
}
#endif
include/Engine/GUI/MainMenuSystem.h
+33
View File
@@ -0,0 +1,33 @@
#ifndef MainMenuSystem_h__
#define MainMenuSystem_h__
#include "../Core/System.h"
#include "../Rendering/IRenderer.h"
#include "../Core/ResourceManager.h"
#include "../Core/Event.h"
#include "EButtonClicked.h"
#include "EButtonPressed.h"
#include "EButtonReleased.h"
class MainMenuSystem : public ImpureSystem
{
public:
MainMenuSystem(SystemParams params, IRenderer* renderer);
virtual void Update(double dt) override;
private:
IRenderer* m_Renderer;
EventRelay<MainMenuSystem, Events::ButtonClicked> m_EClicked;
bool OnButtonClick(const Events::ButtonClicked& e);
EventRelay<MainMenuSystem, Events::ButtonReleased> m_EReleased;
bool OnButtonRelease(const Events::ButtonReleased& e);
EventRelay<MainMenuSystem, Events::ButtonPressed> m_EPressed;
bool OnButtonPress(const Events::ButtonPressed& e);
};
#endif
include/Engine/GUI/TextureFrame.h
-112
View File
@@ -1,112 +0,0 @@
#ifndef GUI_TextureFrame_h__
#define GUI_TextureFrame_h__
#include "Frame.h"
#include "../Rendering/Texture.h"
#include "../Rendering/Util/CommonFunctions.h"
namespace GUI
{
class TextureFrame : public Frame
{
public:
TextureFrame(Frame* parent, std::string name)
: Frame(parent, name) { }
void EnableScissor() { m_ScissorEnabled = true; }
void DisableScissor() { m_ScissorEnabled = false; }
void Draw(RenderScene& rq) override
{
if (m_Texture == nullptr)
return;
// Texture while fading
if (m_FadeTexture && m_CurrentFade < 1) {
FrameJob job;
job.Scissor = (m_ScissorEnabled) ? m_Parent->AbsoluteRectangle() : Rectangle();
job.Viewport = Rectangle(Left(), Top(), Width, Height);
job.TextureID = m_FadeTexture->ResourceID;
job.DiffuseTexture = m_FadeTexture;
job.Color = glm::vec4(m_Color.r, m_Color.g, m_Color.b, m_Color.a);
job.Name = Name();
rq.GUI.Add(job);
}
// Main texture
{
FrameJob job;
job.Scissor = (m_ScissorEnabled) ? m_Parent->AbsoluteRectangle() : Rectangle();
job.Viewport = Rectangle(Left(), Top(), Width, Height);
job.TextureID = m_Texture->ResourceID;
job.DiffuseTexture = m_Texture;
job.Color = glm::vec4(m_Color.r, m_Color.g, m_Color.b, m_Color.a * m_CurrentFade);
job.Name = Name();
rq.GUI.Add(job);
}
}
std::string Texture() const { return m_TextureName; }
void SetTexture(std::string resourceName)
{
if (resourceName.empty()) {
m_Texture = nullptr;
return;
}
m_Texture = CommonFunctions::LoadTexture(resourceName, false);
m_TextureName = resourceName;
if (m_Texture == nullptr) {
m_Texture = CommonFunctions::LoadTexture("Textures/Core/ErrorTexture.png", false);
}
SizeToTexture();
}
void SizeToTexture()
{
if (m_Texture != nullptr) {
this->Width = m_Texture->Width;
this->Height = m_Texture->Height;
}
}
void FadeToTexture(std::string resourceName, double duration)
{
m_FadeTexture = m_Texture;
SetTexture(resourceName);
m_FadeDuration = duration;
m_CurrentFade = 0.f;
}
void Update(double dt) override
{
if (m_CurrentFade < 1) {
m_CurrentFade += dt / m_FadeDuration;
if (m_CurrentFade > 1) {
m_FadeTexture = nullptr;
m_CurrentFade = 1;
m_FadeDuration = 0;
}
}
}
glm::vec4 Color() const { return m_Color; }
void SetColor(glm::vec4 val) { m_Color = val; }
protected:
bool m_ScissorEnabled = true;
Texture* m_Texture = nullptr;
std::string m_TextureName;
Texture* m_FadeTexture = nullptr;
glm::vec4 m_Color = glm::vec4(1.f, 1.f, 1.f, 1.f);
float m_FadeDuration = 0.f;
float m_CurrentFade = 1.f;
};
}
#endif
include/Engine/Input/FirstPersonInputController.h
+2 -2
View File
@@ -202,7 +202,7 @@ void FirstPersonInputController<EventContext>::AssaultDashCheck(double dt, bool
}
//dashing with shift
if (m_ShiftDashing && m_AssaultDashCoolDownTimer <= 0.0f && !isJumping) {
if (m_ShiftDashing && m_AssaultDashCoolDownTimer <= 0.0f) {
//player is dashing with shift
//the wanted-direction is set in playermovement already so we dont need to check what direction we want to dash in!
m_AssaultDashCoolDownTimer = assaultDashCoolDownMaxTimer;
@@ -227,7 +227,7 @@ void FirstPersonInputController<EventContext>::AssaultDashCheck(double dt, bool
}
m_ValidDoubleTap = false;
if (!(m_AssaultDashCoolDownTimer <= 0.0f && !isJumping)) {
if (!(m_AssaultDashCoolDownTimer <= 0.0f)) {
//if we cant dash at the moment, then just reset the tap-sensitivity-timer
m_AssaultDashDoubleTapDeltaTime = 0.f;
return;
include/Engine/Network/Client.h
+39 -12
View File
@@ -13,15 +13,31 @@
#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/EventBroker.h"
#include "Core/ConfigFile.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 "Network/ESearchForServers.h"
struct ServerInfo
{
ServerInfo(std::string a, int b, std::string c, int d)
{
Address = a; Port = b; Name = c; PlayersConnected = d;
}
std::string Address = "";
int Port = 0;
std::string Name = "";
int PlayersConnected = 0;
};
class Client : public Network
{
@@ -32,18 +48,18 @@ public:
void Connect(std::string address, int port);
void Update() override;
private:
UDPClient m_Unreliable;
TCPClient m_Reliable;
std::vector<Events::PlayerSpawned> m_PlayerSpawnEvents;
void parseSpawnEvents();
// Save for children
std::unique_ptr<SnapshotFilter> m_SnapshotFilter = nullptr;
// Assio UDP logic
boost::asio::ip::udp::endpoint m_ReceiverEndpoint;
boost::asio::io_service m_IOService;
boost::asio::ip::udp::socket m_Socket;
std::string m_Address;
int m_Port = 0;
// Sending message to server logic
size_t bytesRead = 0;
char readBuf[INPUTSIZE] = { 0 };
// Packet loss logic
PacketID m_PacketID = 0;
@@ -72,30 +88,32 @@ private:
std::vector<Events::InputCommand> m_InputCommandBuffer;
// Private member functions
void readFromServer();
size_t receive(char* data);
void send(Packet& packet);
void connect();
void disconnect();
void parseMessageType(Packet& packet);
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 parseUDPConnect(Packet& packet);
void parseTCPConnect(Packet& packet);
void parsePlayerConnected(Packet& packet);
void parsePing();
void parseServerlist(Packet& packet);
void parseKick();
void parsePlayersSpawned(Packet& packet);
void parseEntityDeletion(Packet& packet);
void parsePlayerDamage(Packet& packet);
void parseComponentDeletion(Packet& packet);
void parseDoubleJump(Packet& packet);
void InterpolateFields(Packet & packet, const ComponentInfo & componentInfo, const EntityID & entityID, const std::string & componentType);
void parseSnapshot(Packet& packet);
void identifyPacketLoss();
bool hasServerTimedOut();
void hasServerTimedOut();
EntityID createPlayer();
void sendInputCommands();
void sendLocalPlayerTransform();
void becomePlayer();
void displayServerlist();
// Mapping Logic
// Returns if local EntityID exist in map
bool clientServerMapsHasEntity(EntityID clientEntityID);
@@ -111,6 +129,15 @@ private:
bool OnPlayerDamage(const Events::PlayerDamage& e);
EventRelay<Client, Events::PlayerSpawned> m_EPlayerSpawned;
bool OnPlayerSpawned(const Events::PlayerSpawned& e);
EventRelay< Client, Events::SearchForServers> m_ESearchForServers;
EventRelay<Client, Events::DoubleJump> m_EDoubleJump;
bool OnDoubleJump(Events::DoubleJump & e);
bool OnSearchForServers(const Events::SearchForServers& e);
UDPClient m_ServerlistRequest;
std::vector<ServerInfo> m_Serverlist;
bool m_SearchingForServers = false;
std::clock_t m_StartSearchTime;
double m_SearchingTime = 2000; // Config I guess
};
#endif
include/Engine/Network/ESearchForServers.h
+12
View File
@@ -0,0 +1,12 @@
#ifndef Events_SearchForServers_h__
#define Events_SearchForServers_h__
#include "Core/Event.h"
namespace Events
{
struct SearchForServers : public Event { };
}
#endif
include/Engine/Network/MessageType.h
+4 -1
View File
@@ -18,7 +18,10 @@ enum class MessageType
OnPlayerSpawned,
EntityDeleted,
ComponentDeleted,
PlayerTransform
PlayerTransform,
OnDoubleJump,
ServerlistRequest,
Invalid
};
#endif
include/Engine/Network/Network.h
+3 -1
View File
@@ -12,7 +12,7 @@
#include <fstream>
#include <iostream>
#define INPUTSIZE 32000
#define BUFFERSIZE 32000
typedef unsigned int PlayerID;
typedef unsigned int PacketID;
@@ -35,6 +35,8 @@ protected:
std::clock_t m_SaveDataTimer;
unsigned int m_MaxConnections;
double m_TimeoutMs;
void logSentData(int bytesSent);
void logReceivedData(int bytesReceived);
void saveToFile();
void updateNetworkData();
};
include/Engine/Network/NetworkClient.h
+24
View File
@@ -0,0 +1,24 @@
#ifndef NetworkClient_h__
#define NetworkClient_h__
#include "Network/Packet.h"
#define BUFFERSIZE 64000
typedef unsigned int PlayerID;
typedef unsigned int PacketID;
class NetworkClient
{
public:
NetworkClient();
virtual ~NetworkClient();
virtual void Connect(std::string playerName, std::string address, int port) = 0;
virtual void Disconnect() = 0;
virtual void Receive(Packet& packet) = 0;
virtual void Send(Packet & packet) = 0;
virtual bool IsSocketAvailable() = 0;
protected:
char* m_ReadBuffer;
unsigned int m_BufferSize = BUFFERSIZE;
};
#endif
include/Engine/Network/NetworkServer.h
+24
View File
@@ -0,0 +1,24 @@
#ifndef NetworkServer_h__
#define NetworkServer_h__
#include <boost/asio.hpp>
#include "Network/Packet.h"
#include "Network/PlayerDefinition.h"
#define BUFFERSIZE 64000
typedef unsigned int PlayerID;
typedef unsigned int PacketID;
class NetworkServer
{
public:
NetworkServer();
virtual ~NetworkServer();
virtual void AcceptNewConnections(int& nextPlayerID, std::map<PlayerID, PlayerDefinition>& connectedPlayers) = 0;
virtual void Receive(Packet & packet, PlayerDefinition & playerDefinition) = 0;
virtual void Send(Packet & packet, PlayerDefinition & playerDefinition) = 0;
virtual void Send(Packet & packet) = 0;
protected:
char* m_ReadBuffer;
unsigned int m_BufferSize = BUFFERSIZE;
};
#endif
include/Engine/Network/Packet.h
+6
View File
@@ -49,10 +49,15 @@ public:
void WriteData(char* data, int sizeOfData);
// Pops the first element as if it was a string.
std::string ReadString();
// Construct a packet
void ReconstructFromData(char* data, size_t SizeOfData);
// Update size of packet variable in header
void UpdateSize();
char* ReadData(int SizeOfData);
void ChangePacketID(unsigned int& packetID);
size_t Size() { return m_Offset; };
char* Data() { return m_Data; };
MessageType GetMessageType();
size_t DataReadSize() { return m_ReturnDataOffset; }
size_t MaxSize() { return m_MaxPacketSize; }
size_t HeaderSize() { return m_HeaderSize; }
@@ -64,6 +69,7 @@ private:
size_t m_MaxPacketSize = 512;
size_t m_HeaderSize = 0;
void resizeData();
void resizeData(int size);
};
#endif
include/Engine/Network/PlayerDefinition.h
+5
View File
@@ -2,6 +2,7 @@
#define PlayerDefinition_h__
#include <string>
#include "../Core/Entity.h"
#include <boost/asio.hpp>
struct PlayerDefinition {
::EntityID EntityID = EntityID_Invalid;
@@ -9,6 +10,10 @@ struct PlayerDefinition {
boost::asio::ip::udp::endpoint Endpoint;
unsigned int PacketID;
std::clock_t StopTime;
boost::asio::ip::address TCPAddress;
unsigned short TCPPort;
// use for tcp connections
boost::shared_ptr<boost::asio::ip::tcp::socket> TCPSocket;
};
#endif
include/Engine/Network/Server.h
+31 -21
View File
@@ -5,8 +5,9 @@
#include <ctime>
#include <glm/common.hpp>
#include <boost/asio/ip/udp.hpp>
#include "Network/TCPServer.h"
#include "Network/UDPServer.h"
#include "Network/MessageType.h"
#include "Network/PlayerDefinition.h"
#include "Core/World.h"
@@ -16,6 +17,7 @@
#include "Core/EPlayerDamage.h"
#include "Network/EPlayerDisconnected.h"
#include "Core/EPlayerSpawned.h"
#include "../Game/Events/EDoubleJump.h"
#include "Core/EEntityDeleted.h"
#include "Core/EComponentDeleted.h"
@@ -28,57 +30,64 @@ public:
void Update() override;
private:
// Network channels
TCPServer m_Reliable;
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;
// UDP logic
boost::asio::ip::udp::endpoint m_ReceiverEndpoint;
boost::asio::io_service m_IOService;
std::unique_ptr<boost::asio::ip::udp::socket> m_Socket;
// Sending messages to client logic
std::map<PlayerID, PlayerDefinition> m_ConnectedPlayers;
std::vector<PlayerID> m_PlayersToDisconnect;
// HACK: Fix INPUTSIZE
char readBuffer[INPUTSIZE] = { 0 };
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();
// How often we send messages (milliseconds)
float pingIntervalMs;
float snapshotInterval;
int checkTimeOutInterval = 100;
int m_NextPlayerID = 0;
std::vector<Events::InputCommand> m_InputCommandsToBroadcast;
//Timers
std::clock_t m_StartPingTime;
// Packet loss logic
PacketID m_PacketID = 0;
PacketID m_PreviousPacketID = 0;
// Private member functions
size_t receive(char* data);
void readFromClients();
void send(PlayerID player, Packet& packet);
void send(Packet& packet);
void broadcast(Packet& packet);
//int receive(char* data);
void reliableBroadcast(Packet& packet);
void unreliableBroadcast(Packet& packet);
void sendSnapshot();
void addPlayersToPacket(Packet& packet, EntityID entityID);
void addChildrenToPacket(Packet& packet, EntityID entityID);
void addInputCommandsToPacket(Packet& packet);
void sendPing();
void checkForTimeOuts();
void disconnect(PlayerID playerID);
void parseMessageType(Packet& packet);
void parseOnInputCommand(Packet& packet);
void parseOnPlayerDamage(Packet& packet);
void parseConnect(Packet& packet);
void parseDisconnect();
void parseClientPing();
void parsePing();
void identifyPacketLoss();
void kick(PlayerID player);
PlayerID GetPlayerIDFromEndpoint(boost::asio::ip::udp::endpoint endpoint);
PlayerID GetPlayerIDFromEndpoint();
void parsePlayerTransform(Packet& packet);
void parseOnInputCommand(Packet& packet);
void parseClientPing();
void parsePing();
bool parseDoubleJump(Packet& packet);
void parseUDPConnect(Packet& packet);
void parseTCPConnect(Packet& packet);
void parseDisconnect();
void parseServerlistRequest(boost::asio::ip::udp::endpoint endpoint);
bool shouldSendToClient(EntityWrapper childEntity);
// Debug event
EventRelay<Server, Events::InputCommand> m_EInputCommand;
bool OnInputCommand(const Events::InputCommand& e);
@@ -88,7 +97,8 @@ private:
bool OnEntityDeleted(const Events::EntityDeleted& e);
EventRelay<Server, Events::ComponentDeleted> m_EComponentDeleted;
bool OnComponentDeleted(const Events::ComponentDeleted& e);
void parsePlayerTransform(Packet& packet);
EventRelay<Server, Events::PlayerDamage> m_EPlayerDamage;
bool OnPlayerDamage(const Events::PlayerDamage& e);
};
#endif
include/Engine/Network/TCPClient.h
+28
View File
@@ -0,0 +1,28 @@
#ifndef TCPClient_h__
#define TCPClient_h__
#include <boost/asio.hpp>
#include "NetworkClient.h"
class TCPClient : public NetworkClient
{
public:
TCPClient();
~TCPClient();
void Connect(std::string playerName, std::string address, int port);
void Disconnect();
void Receive(Packet& packet);
void Send(Packet & packet);
bool IsSocketAvailable();
private:
// Assio TCP logic
boost::asio::ip::tcp::endpoint m_Endpoint;
boost::asio::io_service m_IOService;
std::unique_ptr<boost::asio::ip::tcp::socket> m_Socket;
size_t readBuffer();
PacketID m_SendPacketID = 0;
bool m_IsConnected = false;
};
#endif
include/Engine/Network/TCPServer.h
+37
View File
@@ -0,0 +1,37 @@
#ifndef TCPServer_h__
#define TCPServer_h__
#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <map>
#include "NetworkServer.h"
class TCPServer : public NetworkServer
{
public:
TCPServer();
~TCPServer();
void AcceptNewConnections(int& nextPlayerID, std::map<PlayerID, PlayerDefinition>& connectedPlayers);
void Receive(Packet & packet, PlayerDefinition & playerDefinition);
void Send(Packet & packet, PlayerDefinition & playerDefinition);
void Send(Packet & packet);
void Disconnect();
int Port() { return m_Port; }
std::string Address() { return m_Address; }
private:
// TCP logic
boost::asio::io_service m_IOService;
std::unique_ptr<boost::asio::ip::tcp::acceptor> acceptor;
boost::shared_ptr<boost::asio::ip::tcp::socket> lastReceivedSocket;
int readBuffer(PlayerDefinition& playerDefinition);
PlayerID getPlayerIDFromEndpoint(const std::map<PlayerID, PlayerDefinition>& connectedPlayers,
boost::asio::ip::address address, unsigned short port);
int GetPort();
std::string GetAddress();
int m_Port = 0;
std::string m_Address = "";
};
#endif
include/Engine/Network/UDPClient.h
+28
View File
@@ -0,0 +1,28 @@
#ifndef UDPClient_h__
#define UDPClient_h__
#include <boost/asio.hpp>
#include "Network/NetworkClient.h"
class UDPClient : public NetworkClient
{
public:
UDPClient();
~UDPClient();
void Connect(std::string playerName, std::string address, int port);
void Disconnect();
void Receive(Packet& packet);
void Send(Packet & packet);
void Broadcast(Packet& packet, int port);
bool IsSocketAvailable();
private:
// 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 readBuffer();
PacketID m_SendPacketID = 0;
};
#endif
include/Engine/Network/UDPServer.h
+28
View File
@@ -0,0 +1,28 @@
#ifndef UDPServer_h__
#define UDPServer_h__
#include "NetworkServer.h"
#include <boost/asio/ip/udp.hpp>
class UDPServer : public NetworkServer
{
public:
UDPServer();
UDPServer(int port);
~UDPServer();
void AcceptNewConnections(int& nextPlayerID, std::map<PlayerID, PlayerDefinition>& connectedPlayers);
void Receive(Packet & packet, PlayerDefinition & playerDefinition);
void Send(Packet & packet, PlayerDefinition & playerDefinition);
void Send(Packet & packet);
void Send(Packet & packet, boost::asio::ip::udp::endpoint endpoint);
void Broadcast(Packet & packet, int port);
bool IsSocketAvailable();
private:
// UDP logic
boost::asio::io_service m_IOService;
boost::asio::ip::udp::endpoint m_ReceiverEndpoint;
std::unique_ptr<boost::asio::ip::udp::socket> m_Socket;
int readBuffer();
};
#endif
include/Engine/Rendering/CubeMapPass.h
+27
View File
@@ -0,0 +1,27 @@
#ifndef CubeMapPass_h__
#define CubeMapPass_h__
#include "IRenderer.h"
#include "ShaderProgram.h"
class CubeMapPass
{
public:
CubeMapPass(IRenderer* renderer);
~CubeMapPass() { }
void LoadTextures(std::string input);
void FillCubeMap(glm::vec3 originPosition);
void GenerateCubeMapTexture();
//GLuint CubeMapTexture() const { return m_CubeMapTexture; }
GLuint m_CubeMapTexture = -1;
private:
IRenderer* m_Renderer;
std::string m_PreviusCubeMapTexture;
std::vector<Texture*> m_CubeMapTextures;
};
#endif
include/Engine/Rendering/DrawBloomPass.h
+2
View File
@@ -24,6 +24,8 @@ public:
void Draw(GLuint texture);
void OnWindowResize();
//Getters
//Return the blurred result of the texture that was sent into draw
GLuint GaussianTexture() const { return m_GaussianTexture_vert; }
include/Engine/Rendering/DrawFinalPass.h
+7 -4
View File
@@ -4,6 +4,7 @@
#include "IRenderer.h"
#include "DrawFinalPassState.h"
#include "LightCullingPass.h"
#include "CubeMapPass.h"
#include "FrameBuffer.h"
#include "ShaderProgram.h"
#include "Util/UnorderedMapVec2.h"
@@ -13,13 +14,14 @@
class DrawFinalPass
{
public:
DrawFinalPass(IRenderer* renderer, LightCullingPass* lightCullingPass);
DrawFinalPass(IRenderer* renderer, LightCullingPass* lightCullingPass, CubeMapPass* cubeMapPass);
~DrawFinalPass() { }
void InitializeTextures();
void InitializeFrameBuffers();
void InitializeShaderPrograms();
void Draw(RenderScene& scene);
void Draw(RenderScene& scene, GLuint SSAOTexture);
void ClearBuffer();
void OnWindowResize();
//Return the texture that is used in later stages to apply the bloom effect
GLuint BloomTexture() const { return m_BloomTexture; }
@@ -31,13 +33,12 @@ public:
FrameBuffer* FinalPassFrameBuffer() { return &m_FinalPassFrameBuffer; }
FrameBuffer* FinalPassFrameBufferLowRes() { return &m_FinalPassFrameBufferLowRes; }
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 DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene, GLuint SSAOTexture);
void DrawShieldToStencilBuffer(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene);
void DrawShieldedModelRenderQueue(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene);
void DrawToDepthBuffer(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene);
@@ -62,12 +63,14 @@ private:
GLuint m_SceneTextureLowRes;
GLuint m_DepthBuffer;
GLuint m_DepthBufferLowRes;
GLuint m_CubeMapTexture;
//maqke this component based i guess?
GLuint m_ShieldPixelRate = 16;
const IRenderer* m_Renderer;
const LightCullingPass* m_LightCullingPass;
const CubeMapPass* m_CubeMapPass;
ShaderProgram* m_ForwardPlusProgram;
ShaderProgram* m_ExplosionEffectProgram;
include/Engine/Rendering/LightCullingPass.h
+1
View File
@@ -21,6 +21,7 @@ public:
void SetSSBOSizes();
void CullLights(RenderScene& scene);
void FillLightList(RenderScene& scene);
void OnWindowResize();
GLuint FrustumSSBO() const { return m_FrustumSSBO; }
GLuint LightSSBO() const { return m_LightSSBO; }
include/Engine/Rendering/ModelJob.h
+3 -2
View File
@@ -109,6 +109,7 @@ struct ModelJob : RenderJob
EndIndex = matGroup->EndIndex;
Matrix = matrix;
Color = modelComponent["Color"];
GlowIntensity = ((double)modelComponent["GlowIntensity"]);
Entity = modelComponent.EntityID;
glm::vec3 abspos = Transform::AbsolutePosition(world, modelComponent.EntityID);
glm::vec3 worldpos = glm::vec3(camera->ViewMatrix() * glm::vec4(abspos, 1));
@@ -150,7 +151,7 @@ struct ModelJob : RenderJob
const ::Model* Model = nullptr;
::Skeleton* Skeleton = nullptr;
std::shared_ptr<::BlendTree> BlendTree = nullptr;
float GlowIntensity = 8.0;
glm::vec4 DiffuseColor;
glm::vec4 SpecularColor;
glm::vec4 IncandescenceColor;
@@ -163,7 +164,7 @@ struct ModelJob : RenderJob
void CalculateHash() override
{
Hash = TextureID + ModelID << 10 + ShaderID << 20;
Hash = ShaderID << 20 + ModelID << 10 + TextureID;
}
};
include/Engine/Rendering/PickingPass.h
+3 -1
View File
@@ -22,6 +22,8 @@ public:
void Draw(RenderScene& scene);
void ClearPicking();
void OnWindowResize();
//Getters
const ShaderProgram& PickingProgram() const { return *m_PickingProgram; }
//const std::unordered_map<glm::ivec2, EntityID>& PickingColorsToEntity() const { return m_PickingColorsToEntity; }
@@ -40,7 +42,7 @@ private:
const IRenderer* m_Renderer;
ShaderProgram* m_PickingProgram;
ShaderProgram* m_PickingSkinnedProgram;
ShaderProgram* m_PickingSkinnedProgram;
Camera* m_Camera;
struct PickingInfo
include/Engine/Rendering/Renderer.h
+19
View File
@@ -16,6 +16,8 @@
#include "DrawScreenQuadPass.h"
#include "DrawBloomPass.h"
#include "DrawColorCorrectionPass.h"
#include "SSAOPass.h"
#include "CubeMapPass.h"
#include "../Core/EventBroker.h"
#include "ImGuiRenderPass.h"
#include "Camera.h"
@@ -23,9 +25,12 @@
#include "imgui/imgui.h"
#include "TextPass.h"
#include "Util/CommonFunctions.h"
#include "Core/PerformanceTimer.h"
class Renderer : public IRenderer
{
static void glfwFrameBufferCallback(GLFWwindow* window, int width, int height);
public:
Renderer(EventBroker* eventBroker)
: m_EventBroker(eventBroker)
@@ -37,8 +42,12 @@ public:
virtual PickData Pick(glm::vec2 screenCoord) override;
private:
//----------------------Variables----------------------//
static std::unordered_map <GLFWwindow*, Renderer*> m_WindowToRenderer;
EventBroker* m_EventBroker;
TextPass* m_TextPass;
@@ -50,6 +59,14 @@ private:
Model* m_UnitSphere;
int m_DebugTextureToDraw = 0;
int m_CubeMapTexture = 0;
bool m_ResizeWindow = false;
float m_SSAO_Radius = 1.0f;
float m_SSAO_Bias = 0.05f;
float m_SSAO_Contrast = 1.5f;
float m_SSAO_IntensityScale = 1.0f;
int m_SSAO_NumOfSamples = 24;
int m_SSAO_NumOfTurns = 7;
PickingPass* m_PickingPass;
LightCullingPass* m_LightCullingPass;
@@ -58,6 +75,8 @@ private:
DrawScreenQuadPass* m_DrawScreenQuadPass;
DrawBloomPass* m_DrawBloomPass;
DrawColorCorrectionPass* m_DrawColorCorrectionPass;
SSAOPass* m_SSAOPass;
CubeMapPass* m_CubeMapPass;
//----------------------Functions----------------------//
void InitializeWindow();
include/Engine/Rendering/SSAOPass.h
+63
View File
@@ -0,0 +1,63 @@
#ifndef SSAOPass_h__
#define SSAOPass_h__
#include "IRenderer.h"
#include "SSAOPassState.h"
//#include "LightCullingPass.h" Finalpass om den skall skickas in
#include "FrameBuffer.h"
#include "ShaderProgram.h"
#include "DrawBloomPass.h"
//#include "Util/UnorderedMapVec2.h"
#include "Texture.h"
class SSAOPass
{
public:
SSAOPass(IRenderer* rendere);
~SSAOPass() {
delete m_DrawBloomPass;
};
void Draw(GLuint depthBuffer, Camera* camera);
void Setting(float radius, float bias, float contrast, float intensityScale, int numOfSamples, int NumOfTurns);
void ClearBuffer();
void OnWindowResize();
//Return the SSAO of the texture sent to Draw
GLuint SSAOTexture() const { return m_DrawBloomPass->GaussianTexture(); }
private:
void InitializeTexture();
void InitializeFrameBuffer();
void InitializeShaderProgram();
void InitializeBuffer();
void GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type) const;
//void blurHorizontal(GLuint depthBuffer);
//void blurVertical(GLuint depthBuffer);
Model* m_ScreenQuad;
const IRenderer* m_Renderer;
float m_Radius;
float m_Bias;
float m_Contrast;
float m_IntensityScale;
int m_NumOfSamples;
int m_NumOfTurns;
GLuint m_SSAOTexture;
FrameBuffer m_SSAOFramBuffer;
GLuint m_SSAOViewSpaceZTexture;
FrameBuffer m_SSAOViewSpaceZFramBuffer;
ShaderProgram* m_SSAOProgram;
ShaderProgram* m_SSAOViewSpaceZProgram;
DrawBloomPass* m_DrawBloomPass;
};
#endif
include/Engine/Rendering/SSAOPassState.h
+15
View File
@@ -0,0 +1,15 @@
#ifndef SSAOPassState_h__
#define SSAOPassState_h__
#include "Rendering/RenderState.h"
class SSAOPassState : public RenderState
{
public:
SSAOPassState();
~SSAOPassState();
private:
};
#endif
include/Engine/Rendering/SpriteJob.h
+7 -2
View File
@@ -17,7 +17,7 @@
struct SpriteJob : RenderJob
{
SpriteJob(ComponentWrapper cSprite, Camera* camera, glm::mat4 matrix, World* world, glm::vec4 fillColor, float fillPercentage, bool depthSorted)
SpriteJob(ComponentWrapper cSprite, Camera* camera, glm::mat4 matrix, World* world, glm::vec4 fillColor, float fillPercentage, bool depthSorted, bool isIndicator)
: RenderJob()
{
Model = ResourceManager::Load<::Model>("Models/Core/UnitQuad.mesh");
@@ -30,7 +30,7 @@ struct SpriteJob : RenderJob
StartIndex = matProp.material->StartIndex;
EndIndex = matProp.material->EndIndex;
Matrix = matrix;
Matrix = matrix;
Color = cSprite["Color"];
Entity = cSprite.EntityID;
Position = Transform::AbsolutePosition(world, cSprite.EntityID);
@@ -40,6 +40,8 @@ struct SpriteJob : RenderJob
Depth = viewpos.z;
}
World = world;
Pickable = world->HasComponent(cSprite.EntityID, "Button");
IsIndicator = isIndicator;
FillColor = fillColor;
FillPercentage = fillPercentage;
@@ -61,6 +63,9 @@ struct SpriteJob : RenderJob
unsigned int EndIndex = 0;
World* World;
bool Pickable;
bool IsIndicator = false;
glm::vec4 FillColor = glm::vec4(0);
float FillPercentage = 0.0;
include/Engine/Rendering/Texture.h
+1
View File
@@ -18,6 +18,7 @@ public:
void Bind(GLenum textureUnit = GL_TEXTURE0);
GLuint m_Texture = 0;
unsigned char* Data = nullptr;
};