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

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

Browse Source
This commit is contained in:
stiffly
2016-03-11 11:06:23 +01:00
parent 9cc8124847 0869afd529
commit 03493df213
199 changed files with 36728 additions and 12844 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/Engine/Collision/Collision.h
+12
View File
@@ -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/EntityWrapper.h
+1 -1
View File
@@ -23,7 +23,7 @@ struct EntityWrapper
static const EntityWrapper Invalid;
const std::string Name();
const std::string Name() const;
bool HasComponent(const std::string& componentType);
void AttachComponent(const char* componentName);
EntityWrapper Parent();
include/Engine/GUI/MainMenuSystem.h
-33
View File
@@ -1,33 +0,0 @@
#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/Input/FirstPersonInputController.h
+112 -46
View File
@@ -7,6 +7,7 @@
#include "../Game/Events/EDashAbility.h"
#include "InputHandler.h"
#include "Rendering/EAutoAnimationBlend.h"
#include "Rendering/ESetBlendWeight.h"
template <typename EventContext>
class FirstPersonInputController : public InputController<EventContext>
@@ -18,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;
@@ -43,9 +45,9 @@ 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;
double m_DashEffectResetTimer = 0.0;
//i will let m_AssaultDashDoubleTapSensitivityTimer stay hardcoded, its not really a gamevariable (more an inputvariable),
//and its very unlikely that someone wants to change that value
const float m_AssaultDashDoubleTapSensitivityTimer = 0.25f;
@@ -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>
@@ -110,7 +113,6 @@ bool FirstPersonInputController<EventContext>::OnCommand(const Events::InputComm
if (e.Command == "Pitch") {
float val = glm::radians(e.Value);
m_Rotation.x += -val;
//m_Rotation.x = glm::clamp(m_Rotation.x, -glm::half_pi<float>(), glm::half_pi<float>());
}
if (e.Command == "Yaw") {
@@ -123,22 +125,11 @@ bool FirstPersonInputController<EventContext>::OnCommand(const Events::InputComm
float val = glm::clamp(e.Value, -1.f, 1.f);
m_Movement.z = -val;
//Animation
if (m_PlayerEntity.Valid()) {
EntityWrapper playerModel = m_PlayerEntity.FirstChildByName("PlayerModel");
if (playerModel.Valid()) {
if (val > 0) {
Events::AutoAnimationBlend aeb;
aeb.Duration = 0.1;
if(m_Crouching) {
aeb.NodeName = "Walk";
} else {
aeb.NodeName = "Run";
}
aeb.RootNode = playerModel;
aeb.Start = true;
m_EventBroker->Publish(aeb);
} else if (val < 0) {
if (val > 0) { // Walk/Run
Events::AutoAnimationBlend aeb;
aeb.Duration = 0.1;
if (m_Crouching) {
@@ -148,10 +139,46 @@ bool FirstPersonInputController<EventContext>::OnCommand(const Events::InputComm
}
aeb.RootNode = playerModel;
aeb.Start = true;
aeb.SingleLevelBlend = true;
m_EventBroker->Publish(aeb);
} else if (val < 0) { // Walk/run Backwards
Events::AutoAnimationBlend aeb;
aeb.Duration = 0.1;
if (m_Crouching) {
aeb.NodeName = "Walk";
} else {
aeb.NodeName = "Run";
}
aeb.RootNode = playerModel;
aeb.Start = true;
aeb.SingleLevelBlend = true;
aeb.Reverse = true;
m_EventBroker->Publish(aeb);
} else {
}
}
EntityWrapper firstPersonModel = m_PlayerEntity.FirstChildByName("Hands");
if (firstPersonModel.Valid()) {
if (val > 0) { // Walk/Run
if (!m_Crouching) {
Events::AutoAnimationBlend aeb;
aeb.Duration = 0.1;
aeb.NodeName = "Run";
aeb.RootNode = firstPersonModel;
aeb.Start = true;
m_EventBroker->Publish(aeb);
}
} else if (val < 0) { // Walk/run Backwards
if (!m_Crouching) {
Events::AutoAnimationBlend aeb;
aeb.Duration = 0.1;
aeb.NodeName = "Run";
aeb.RootNode = firstPersonModel;
aeb.Start = true;
aeb.Reverse = true;
m_EventBroker->Publish(aeb);
}
}
}
}
@@ -160,49 +187,92 @@ bool FirstPersonInputController<EventContext>::OnCommand(const Events::InputComm
float val = glm::clamp(e.Value, -1.f, 1.f);
m_Movement.x = val;
//Animation
if (m_PlayerEntity.Valid()) {
EntityWrapper playerModel = m_PlayerEntity.FirstChildByName("PlayerModel");
if (playerModel.Valid()) {
if (playerModel.Valid()) { //Right Strafe
if (val > 0) {
Events::AutoAnimationBlend aeb;
aeb.Duration = 0.1;
aeb.NodeName = "Right";
aeb.RootNode = playerModel;
aeb.SingleLevelBlend = true;
aeb.Start = true;
m_EventBroker->Publish(aeb);
} else if (val < 0) {
} else if (val < 0) { //LeftStrafe
Events::AutoAnimationBlend aeb;
aeb.Duration = 0.1;
aeb.NodeName = "Left";
aeb.RootNode = playerModel;
aeb.SingleLevelBlend = true;
aeb.Start = true;
m_EventBroker->Publish(aeb);
} else {
}
}
}
}
if (glm::length2(m_Movement) > 0) {
m_Movement = glm::normalize(m_Movement);
} else {
if (m_PlayerEntity.Valid()) {
EntityWrapper playerModel = m_PlayerEntity.FirstChildByName("PlayerModel");
if (playerModel.Valid()) {
Events::AutoAnimationBlend aeb;
aeb.Duration = 0.1;
aeb.NodeName = "Idle";
aeb.RootNode = playerModel;
m_EventBroker->Publish(aeb);
}
}
}
}
//Animation
if (glm::length2(m_Movement) < 0.25f) {
//Blend to Idle
if (m_PlayerEntity.Valid()) {
EntityWrapper playerModel = m_PlayerEntity.FirstChildByName("PlayerModel");
if (playerModel.Valid()) {
Events::AutoAnimationBlend aeb;
aeb.Duration = 0.1;
aeb.NodeName = "Idle";
aeb.RootNode = playerModel;
aeb.Start = true;
m_EventBroker->Publish(aeb);
}
EntityWrapper firstPersonModel = m_PlayerEntity.FirstChildByName("Hands");
if (firstPersonModel.Valid()) {
Events::AutoAnimationBlend aeb;
aeb.Duration = 0.1;
aeb.NodeName = "Idle";
aeb.RootNode = firstPersonModel;
aeb.Start = true;
m_EventBroker->Publish(aeb);
}
}
} else {
//Blend to movement
if (m_PlayerEntity.Valid()) {
EntityWrapper playerModel = m_PlayerEntity.FirstChildByName("PlayerModel");
if (playerModel.Valid()) {
Events::AutoAnimationBlend aeb;
aeb.Duration = 0.1;
aeb.NodeName = "DirectionBlend";
aeb.RootNode = playerModel;
m_EventBroker->Publish(aeb);
}
}
}
if (glm::length2(m_Movement) > 0) {
m_Movement = glm::normalize(m_Movement);
//Animation
// movement direction blend
if (m_PlayerEntity.Valid()) {
EntityWrapper playerModel = m_PlayerEntity.FirstChildByName("PlayerModel");
if (playerModel.Valid()) {
glm::vec2 direction = glm::normalize(glm::vec2(m_Movement.x, m_Movement.z));
double weight = glm::abs(glm::dot(glm::vec2(1, 0), direction));
Events::SetBlendWeight sbw;
sbw.NodeName = "DirectionBlend";
sbw.Weight = weight;
sbw.RootNode = playerModel;
m_EventBroker->Publish(sbw);
}
}
}
if (e.Command == "Forward" || e.Command == "Right") {
if (e.Value != 0) {
m_CurrentDirectionVector = e.Command == "Right" ? (e.Value > 0 ? "Right" : "Left") : (e.Value > 0 ? "Forward" : "Backward");
@@ -235,6 +305,8 @@ bool FirstPersonInputController<EventContext>::OnCommand(const Events::InputComm
if (e.Command == "Crouch") {
m_Crouching = e.Value > 0;
//Animation
if (m_PlayerEntity.Valid()) {
EntityWrapper playerModel = m_PlayerEntity.FirstChildByName("PlayerModel");
if (playerModel.Valid()) {
@@ -288,17 +360,10 @@ bool FirstPersonInputController<EventContext>::OnLockMouse(const Events::LockMou
template <typename EventContext>
void FirstPersonInputController<EventContext>::AssaultDashCheck(double dt, bool isJumping, double assaultDashCoolDownMaxTimer, double& assaultDashCoolDownTimer, EntityID playerID) {
m_AssaultDashDoubleTapDeltaTime += dt;
m_DashEffectResetTimer += dt;
assaultDashCoolDownTimer -= dt;
//cooldown = assaultDashCoolDownMaxTimer sec, pretend the dash lasts 0.25 sec (for friction to do its work)
if (assaultDashCoolDownTimer > (assaultDashCoolDownMaxTimer - 0.25f)) {
m_PlayerIsDashing = true;
if (m_DashEffectResetTimer > 0.05) {
Events::DashAbility e;
e.Player = playerID;
m_EventBroker->Publish(e);
m_DashEffectResetTimer = 0.0;
}
} else {
m_PlayerIsDashing = false;
}
@@ -310,6 +375,7 @@ void FirstPersonInputController<EventContext>::AssaultDashCheck(double dt, bool
assaultDashCoolDownTimer = assaultDashCoolDownMaxTimer;
m_AssaultDashDoubleTapped = true;
m_AssaultDashDoubleTapDeltaTime = 0.f;
Events::DashAbility e;
e.Player = playerID;
m_EventBroker->Publish(e);
include/Engine/Input/InputProxy.h
+1 -1
View File
@@ -18,7 +18,7 @@ public:
void LoadBindings(std::string file);
void Update(double dt);
void Process();
void Process(bool suppressNewEvents = false);
template <typename T>
void AddHandler();
void Publish(const Events::InputCommand& e);
include/Engine/Network/Client.h
+7 -13
View File
@@ -17,6 +17,7 @@
#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"
@@ -29,19 +30,8 @@
#include "Core/EAmmoPickup.h"
#include "Network/ESearchForServers.h"
#include "../Game/Events/EDashAbility.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;
};
#include "Network/EDisplayServerlist.h"
#include "Network/EConnectRequest.h"
class Client : public Network
{
public:
@@ -119,6 +109,8 @@ private:
void sendLocalPlayerTransform();
void becomePlayer();
void displayServerlist();
void removeWorld();
void createMainMenu();
// Mapping Logic
// Returns if local EntityID exist in map
bool clientServerMapsHasEntity(EntityID clientEntityID);
@@ -139,6 +131,8 @@ private:
bool OnDoubleJump(Events::DoubleJump & e);
EventRelay<Client, Events::DashAbility> m_EDashAbility;
bool OnDashAbility(const Events::DashAbility& e);
EventRelay<Client, Events::ConnectRequest> m_EConnectRequest;
bool OnConnectRequest(const Events::ConnectRequest& e);
bool OnSearchForServers(const Events::SearchForServers& e);
UDPClient m_ServerlistRequest;
include/Engine/Network/EConnectRequest.h
+17
View File
@@ -0,0 +1,17 @@
#ifndef Events_ConnectRequest_h__
#define Events_ConnectRequest_h__
#include "Core/EventBroker.h"
namespace Events
{
struct ConnectRequest : public Event
{
std::string IP = "";
int Port = 0;
};
}
#endif
include/Engine/Network/EDisplayServerlist.h
+29
View File
@@ -0,0 +1,29 @@
#ifndef Events_DisplayServerlist_h__
#define Events_DisplayServerlist_h__
#include <string>
#include <vector>
#include "Core/Event.h"
struct ServerInfo
{
ServerInfo(std::string address, int port, std::string name, int players)
{
Address = address; Port = port; Name = name; PlayersConnected = players;
}
std::string Address = "";
int Port = 0;
std::string Name = "";
int PlayersConnected = 0;
};
namespace Events
{
struct DisplayServerlist : public Event
{
std::vector<ServerInfo> Serverlist;
};
}
#endif
include/Engine/Network/NetworkClient.h
+1 -1
View File
@@ -11,7 +11,7 @@ class NetworkClient
public:
NetworkClient();
virtual ~NetworkClient();
virtual void Connect(std::string playerName, std::string address, int port) = 0;
virtual bool 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;
include/Engine/Network/Server.h
+1
View File
@@ -60,6 +60,7 @@ private:
std::vector<Events::InputCommand> m_InputCommandsToBroadcast;
//Timers
std::clock_t m_StartPingTime;
std::string m_ServerName = "";
// Packet loss logic
PacketID m_PacketID = 0;
include/Engine/Network/TCPClient.h
+1 -1
View File
@@ -10,7 +10,7 @@ public:
TCPClient();
~TCPClient();
void Connect(std::string playerName, std::string address, int port);
bool Connect(std::string playerName, std::string address, int port);
void Disconnect();
void Receive(Packet& packet);
void Send(Packet & packet);
include/Engine/Network/UDPClient.h
+1 -1
View File
@@ -10,7 +10,7 @@ public:
UDPClient();
~UDPClient();
void Connect(std::string playerName, std::string address, int port);
bool Connect(std::string playerName, std::string address, int port);
void Disconnect();
void Receive(Packet& packet);
void Send(Packet & packet);
include/Engine/Rendering/AnimationSystem.h
+9
View File
@@ -13,6 +13,8 @@
#include "../Core/EntityWrapper.h"
#include "Rendering/AutoBlendQueue.h"
#include "../Input/EInputCommand.h"
#include "../Core/EEntityDeleted.h"
#include "Rendering/ESetBlendWeight.h"
#include "imgui/imgui.h"
class AnimationSystem : public ImpureSystem
@@ -28,6 +30,13 @@ private:
EventRelay<AnimationSystem, Events::AutoAnimationBlend> m_EAutoAnimationBlend;
bool OnAutoAnimationBlend(Events::AutoAnimationBlend& e);
EventRelay<AnimationSystem, Events::EntityDeleted> m_EEntityDeleted;
bool OnEntityDeleted(Events::EntityDeleted& e);
EventRelay<AnimationSystem, Events::SetBlendWeight> m_ESetBlendWeight;
bool OnSetBlendWeight(Events::SetBlendWeight& e);
std::unordered_map<EntityWrapper, AutoBlendQueue> m_AutoBlendQueues;
};
include/Engine/Rendering/AutoBlendQueue.h
+2
View File
@@ -37,6 +37,8 @@ public:
std::shared_ptr<BlendTree> GetBlendTree();
AutoBlendQueue::AutoBlendJob& GetActiveBlendJob();
bool Empty() { return m_BlendQueue.empty(); }
private:
std::list<AutoblendNode> m_BlendQueue;
include/Engine/Rendering/BlendTree.h
+6 -3
View File
@@ -75,7 +75,6 @@ public:
std::vector<glm::mat4> GetFinalPose() { return m_FinalPose; }
glm::mat4 GetBoneTransform(int boneID);
bool IsValid() { return (m_Root == nullptr ? false : true); }
void PrintTree();
BlendTree::AutoBlendInfo AutoBlendStep(AutoBlendInfo blendInfo);
@@ -84,16 +83,20 @@ public:
EntityWrapper GetSubTreeRoot(std::string nodeName);
std::vector<EntityWrapper> GetSingleLevelRoots(std::string name);
std::vector<EntityWrapper> GetEntitesByName(std::string name);
void SetWeightByName(std::string name, double weight);
private:
Skeleton* m_Skeleton = nullptr;
Node* m_Root = nullptr;
std::vector<glm::mat4> m_FinalPose;
std::map<int, glm::mat4> m_FinalBoneTransforms;
std::vector<BlendTree::Node*> FindNodesByName(std::string name);
std::vector<glm::mat4> AccumulateFinalPose();
BlendTree::Node* FillTreeByName(Node* parentNode, std::string name, EntityWrapper parentEntity);
std::vector<BlendTree::Node*> FindNodesByName(std::string name);
void Blend(std::map<int, Skeleton::PoseData>& pose);
};
include/Engine/Rendering/BlurHUD.h
+70
View File
@@ -0,0 +1,70 @@
#ifndef BlurHUD_h__
#define BlurHUD_h__
#include "IRenderer.h"
#include "DrawBloomPassState.h"
//#include "LightCullingPass.h" Finalpass om den skall skickas in
#include "FrameBuffer.h"
#include "ShaderProgram.h"
//#include "Util/UnorderedMapVec2.h"
#include "Texture.h"
class BlurHUD
{
public:
BlurHUD(IRenderer* renderer);
~BlurHUD() { }
void InitializeTextures();
void InitializeFrameBuffers();
void InitializeShaderPrograms();
void InitializeBuffers();
void ClearBuffer();
void FillGaussianBuffer(FrameBuffer* fb);
GLuint Draw(GLuint texture, RenderScene& scene);
void OnWindowResize();
void FillStencil(RenderScene& scene);
GLuint CombineTextures(GLuint texture1, GLuint texture2);
//Getters
//Return the blurred result of the texture that was sent into draw
GLuint GaussianTexture() const {
if (m_Quality == 0) {
return m_BlackTexture->m_Texture;
} else {
return m_GaussianTexture_vert;
}
}
private:
Texture* m_BlackTexture;
Model* m_ScreenQuad;
const IRenderer* m_Renderer;
ConfigFile* m_Config;
//const LightCullingPass* m_LightCullingPass
int m_Iterations = 3;
int m_Quality = 0;
float m_BlurQuality = 4.f;
GLuint m_GaussianTexture_horiz = 0;
GLuint m_GaussianTexture_vert = 0;
GLuint m_DepthStencil_horiz = 0;
GLuint m_DepthStencil_vert = 0;
GLuint m_CombinedTexture = 0;
FrameBuffer m_GaussianFrameBuffer_horiz;
FrameBuffer m_GaussianFrameBuffer_vert;
FrameBuffer m_CombinedTextureBuffer;
ShaderProgram* m_GaussianProgram_horiz;
ShaderProgram* m_GaussianProgram_vert;
ShaderProgram* m_FillDepthStencilProgram;
ShaderProgram* m_CombineTexturesProgram;
};
#endif
include/Engine/Rendering/CubeMapPass.h
+1 -1
View File
@@ -15,7 +15,7 @@ public:
void GenerateCubeMapTexture();
//GLuint CubeMapTexture() const { return m_CubeMapTexture; }
GLuint m_CubeMapTexture = -1;
GLuint m_CubeMapTexture = 0;
private:
IRenderer* m_Renderer;
include/Engine/Rendering/DrawBloomPass.h
+10 -4
View File
@@ -13,7 +13,7 @@ class DrawBloomPass
{
public:
DrawBloomPass(IRenderer* renderer, ConfigFile* config);
~DrawBloomPass() { }
~DrawBloomPass();
void InitializeTextures();
void InitializeFrameBuffers();
void InitializeShaderPrograms();
@@ -33,12 +33,14 @@ public:
if (m_Quality == 0) {
return m_BlackTexture->m_Texture;
} else {
return m_GaussianTexture_vert;
return m_FinalGaussianTexture;
}
}
private:
void GaussianLodPass(GLuint mipMap, GLuint texture);
void CombineGaussianBlur();
Texture* m_BlackTexture;
Model* m_ScreenQuad;
@@ -47,15 +49,19 @@ private:
//const LightCullingPass* m_LightCullingPass
int m_Iterations;
int m_Quality = 0;
int m_BloomLod = 5;
GLuint m_GaussianTexture_horiz = 0;
GLuint m_GaussianTexture_vert = 0;
GLuint m_FinalGaussianTexture = 0;
FrameBuffer m_GaussianFrameBuffer_horiz;
FrameBuffer m_GaussianFrameBuffer_vert;
FrameBuffer* m_GaussianFrameBuffer_horiz = nullptr;
FrameBuffer* m_GaussianFrameBuffer_vert = nullptr;
FrameBuffer m_GaussianCombineBuffer;
ShaderProgram* m_GaussianProgram_horiz;
ShaderProgram* m_GaussianProgram_vert;
ShaderProgram* m_GaussianCombineProgram;
};
include/Engine/Rendering/DrawFinalPass.h
+17 -8
View File
@@ -11,16 +11,18 @@
#include "Util/UnorderedMapVec2.h"
#include "Util/CommonFunctions.h"
#include "Texture.h"
#include "ShadowPass.h"
#include "BlurHUD.h"
class DrawFinalPass
{
public:
DrawFinalPass(IRenderer* renderer, LightCullingPass* lightCullingPass, CubeMapPass* cubeMapPass, SSAOPass* ssaoPass);
~DrawFinalPass() { }
DrawFinalPass(IRenderer* renderer, LightCullingPass* lightCullingPass, CubeMapPass* cubeMapPass, SSAOPass* ssaoPass, ShadowPass* shadowPass);
~DrawFinalPass();
void InitializeTextures();
void InitializeFrameBuffers();
void InitializeShaderPrograms();
void Draw(RenderScene& scene);
void Draw(RenderScene& scene, BlurHUD* blurHUDPass);
void ClearBuffer();
void OnWindowResize();
@@ -28,6 +30,10 @@ public:
GLuint BloomTexture() const { return m_BloomTexture; }
//Return the texture with diffuse and lighting of the scene.
GLuint SceneTexture() const { return m_SceneTexture; }
//Return the SceneTexture with the blurred HUD bits.
GLuint CombinedSceneTexture() const { return m_CombinedTexture; }
//Return the blurred scene texture.
GLuint FullBlurredTexture() const { return m_FullBlurredTexture; }
//Return the framebuffer used in the scene rendering stage.
FrameBuffer* FinalPassFrameBuffer() { return &m_FinalPassFrameBuffer; }
@@ -52,11 +58,13 @@ private:
FrameBuffer m_FinalPassFrameBuffer;
FrameBuffer m_ShieldDepthFrameBuffer;
GLuint m_BloomTexture;
GLuint m_SceneTexture;
GLuint m_DepthBuffer;
GLuint m_ShieldBuffer;
GLuint m_CubeMapTexture;
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
//maqke this component based i guess?
GLuint m_ShieldPixelRate = 16;
@@ -65,6 +73,7 @@ private:
const LightCullingPass* m_LightCullingPass;
const CubeMapPass* m_CubeMapPass;
const SSAOPass* m_SSAOPass;
const ShadowPass* m_ShadowPass;
ShaderProgram* m_ForwardPlusProgram;
ShaderProgram* m_ExplosionEffectProgram;
include/Engine/Rendering/EAutoAnimationBlend.h
-1
View File
@@ -18,7 +18,6 @@ struct AutoAnimationBlend : Event
bool Reverse = false;
bool Restart = false;
bool SingleLevelBlend = false;
double Weight = -1.0;
EntityWrapper AnimationEntity = EntityWrapper::Invalid;
include/Engine/Rendering/EResolutionChanged.h
+19
View File
@@ -0,0 +1,19 @@
#ifndef EResolutionChanged_h__
#define EResolutionChanged_h__
#include "../Core/Event.h"
#include "../Core/Util/Rectangle.h"
namespace Events
{
// Fired when the framebuffer size changes
struct ResolutionChanged : Event
{
Rectangle OldResolution;
Rectangle NewResolution;
};
}
#endif
include/Engine/Rendering/ESetBlendWeight.h
+20
View File
@@ -0,0 +1,20 @@
#ifndef Events_SetBlendWeight_h__
#define Events_SetBlendWeight_h__
#include "../Core/EventBroker.h"
#include "../Core/EntityWrapper.h"
namespace Events
{
//Sets the blend weight for all nodes with "NodeName"
struct SetBlendWeight : Event
{
EntityWrapper RootNode = EntityWrapper::Invalid;
std::string NodeName;
double Weight;
};
}
#endif
include/Engine/Rendering/ExplosionEffectJob.h
+2 -2
View File
@@ -15,8 +15,8 @@
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)
: ModelJob(model, camera, matrix, matGroup, modelComponent, world, fillColor, fillPercentage, isShielded)
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"];
include/Engine/Rendering/FrameBuffer.h
+17 -6
View File
@@ -7,11 +7,12 @@
class BufferResource
{
public:
BufferResource(GLuint* resourceHandle, GLenum resourceType, GLenum attachment);
BufferResource(GLuint* resourceHandle, GLenum resourceType, GLenum attachment, GLuint mipMapLod);
GLuint* m_ResourceHandle;
GLenum m_ResourceType;
GLenum m_Attachment;
GLuint m_MipMapLod = 0;
private:
};
@@ -20,15 +21,15 @@ template <GLenum RESOURCETYPE>
class ResourceType : public BufferResource
{
public:
ResourceType(GLuint* resourceHandle, GLenum attachment)
: BufferResource(resourceHandle, RESOURCETYPE, attachment) { }
ResourceType(GLuint* resourceHandle, GLenum attachment, GLuint mipMapLod)
: BufferResource(resourceHandle, RESOURCETYPE, attachment, mipMapLod) { }
};
class Texture2D : public ResourceType<GL_TEXTURE_2D>
{
public:
Texture2D(GLuint* resourceHandle, GLenum attachment)
: ResourceType(resourceHandle, attachment) { };
Texture2D(GLuint* resourceHandle, GLenum attachment, GLuint mipMapLod = 0)
: ResourceType(resourceHandle, attachment, mipMapLod) { };
~Texture2D();
};
@@ -37,12 +38,22 @@ class RenderBuffer : public ResourceType<GL_RENDERBUFFER>
{
public:
RenderBuffer(GLuint* resourceHandle, GLenum attachment)
: ResourceType(resourceHandle, attachment)
: ResourceType(resourceHandle, attachment, 0)
{ };
~RenderBuffer();
};
class Texture2DArray : public ResourceType<GL_TEXTURE_2D_ARRAY>
{
public:
Texture2DArray(GLuint* resourceHandle, GLenum attachment)
: ResourceType(resourceHandle, attachment, 0)
{ };
~Texture2DArray();
};
class FrameBuffer
{
public:
include/Engine/Rendering/LightCullingPass.h
+3 -3
View File
@@ -54,7 +54,7 @@ private:
struct Frustum {
Plane Planes[4];
};
Frustum* m_Frustums;
Frustum* m_Frustums = nullptr;
//This should be a component
struct LightSource {
@@ -74,11 +74,11 @@ private:
glm::vec2 Padding = glm::vec2(1.f, 2.f);
};
LightGrid* m_LightGrid;
LightGrid* m_LightGrid = nullptr;
int m_LightOffset = 0;
float* m_LightIndex;
float* m_LightIndex = nullptr;
};
include/Engine/Rendering/ModelJob.h
+8 -3
View File
@@ -19,7 +19,7 @@
struct ModelJob : RenderJob
{
ModelJob(Model* model, Camera* camera, glm::mat4 matrix, ::RawModel::MaterialProperties matProp, ComponentWrapper modelComponent, World* world, glm::vec4 fillColor, float fillPercentage, bool isShielded)
ModelJob(Model* model, Camera* camera, glm::mat4 matrix, ::RawModel::MaterialProperties matProp, ComponentWrapper modelComponent, World* world, glm::vec4 fillColor, float fillPercentage, bool isShielded, bool shadow)
: RenderJob()
{
Model = model;
@@ -111,10 +111,11 @@ struct ModelJob : RenderJob
Color = modelComponent["Color"];
GlowIntensity = ((double)modelComponent["GlowIntensity"]);
Entity = modelComponent.EntityID;
glm::vec3 abspos = Transform::AbsolutePosition(world, modelComponent.EntityID);
glm::vec3 abspos = glm::vec3(matrix[3][0], matrix[3][1], matrix[3][2]);
glm::vec3 worldpos = glm::vec3(camera->ViewMatrix() * glm::vec4(abspos, 1));
Depth = worldpos.z;
World = world;
Shadow = shadow;
FillColor = fillColor;
FillPercentage = fillPercentage;
@@ -162,9 +163,13 @@ struct ModelJob : RenderJob
glm::vec4 FillColor = glm::vec4(0);
float FillPercentage = 0.0;
bool IsShielded;
bool Shadow;
void CalculateHash() override
{
Hash = ShaderID << 20 + ModelID << 10 + TextureID;
Hash = TextureID;
Hash += ModelID << 10;
Hash += ShaderID << 20;
}
};
include/Engine/Rendering/PickingPass.h
+2 -2
View File
@@ -52,8 +52,8 @@ private:
std::unordered_map<glm::ivec2, PickingInfo> m_PickingColorsToEntity;
GLuint m_PickingTexture;
GLuint m_DepthBuffer;
GLuint m_PickingTexture = 0;
GLuint m_DepthBuffer = 0;
FrameBuffer m_PickingBuffer;
include/Engine/Rendering/RenderJob.h
+5 -6
View File
@@ -16,16 +16,15 @@ struct RenderJob
public:
float Depth;
bool operator<(const RenderJob& rhs)
{
return this->Hash < rhs.Hash;
}
protected:
uint64_t Hash;
virtual void CalculateHash() = 0;
bool operator<(const RenderJob& rhs)
{
return this->Hash < rhs.Hash;
}
};
#endif
include/Engine/Rendering/RenderQueue.h
+1
View File
@@ -33,6 +33,7 @@ struct RenderScene
Rectangle Viewport;
bool ClearDepth = false;
bool ShouldBlur = false;
glm::vec4 AmbientColor;
void Clear()
include/Engine/Rendering/RenderSystem.h
+3
View File
@@ -19,6 +19,7 @@
#include "../Core/Octree.h"
#include "../Collision/EntityAABB.h"
#include "../Core/ConfigFile.h"
#include "EResolutionChanged.h"
class RenderSystem : public ImpureSystem
{
@@ -36,6 +37,8 @@ private:
EntityWrapper m_LocalPlayer = EntityWrapper::Invalid;
Octree<EntityAABB>* m_Octree;
EventRelay<RenderSystem, Events::ResolutionChanged> m_EResolutionChanged;
bool OnResolutionChanged(Events::ResolutionChanged &event);
EventRelay<RenderSystem, Events::SetCamera> m_ESetCamera;
bool OnSetCamera(Events::SetCamera &event);
EventRelay<RenderSystem, Events::InputCommand> m_EInputCommand;
include/Engine/Rendering/Renderer.h
+13 -2
View File
@@ -18,6 +18,7 @@
#include "DrawColorCorrectionPass.h"
#include "SSAOPass.h"
#include "CubeMapPass.h"
#include "BlurHUD.h"
#include "../Core/EventBroker.h"
#include "ImGuiRenderPass.h"
#include "Camera.h"
@@ -26,16 +27,22 @@
#include "TextPass.h"
#include "Util/CommonFunctions.h"
#include "Core/PerformanceTimer.h"
#include "ShadowPass.h"
#include "EResolutionChanged.h"
class Renderer : public IRenderer
{
static void glfwFrameBufferCallback(GLFWwindow* window, int width, int height);
static void glfwWindowSizeCallback(GLFWwindow* window, int width, int height);
public:
Renderer(EventBroker* eventBroker, ConfigFile* config)
: m_EventBroker(eventBroker)
, m_Config(config)
{ }
~Renderer();
virtual void SetResolution(const Rectangle& resolution) override;
virtual void Initialize() override;
virtual void Update(double dt) override;
@@ -43,7 +50,6 @@ public:
virtual PickData Pick(glm::vec2 screenCoord) override;
private:
//----------------------Variables----------------------//
@@ -75,6 +81,8 @@ private:
DrawColorCorrectionPass* m_DrawColorCorrectionPass;
SSAOPass* m_SSAOPass;
CubeMapPass* m_CubeMapPass;
ShadowPass* m_ShadowPass;
BlurHUD* m_BlurHUDPass;
//----------------------Functions----------------------//
void InitializeWindow();
@@ -85,11 +93,14 @@ private:
void InputUpdate(double dt);
//void PickingPass(RenderQueueCollection& rq);
//void DrawScreenQuad(GLuint textureToDraw);
void setWindowSize(Rectangle size);
void updateFramebufferSize();
static bool DepthSort(const std::shared_ptr<RenderJob> &i, const std::shared_ptr<RenderJob> &j) { return (i->Depth < j->Depth); }
void SortRenderJobsByDepth(RenderScene &scene);
void GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type);
//--------------------ShaderPrograms-------------------//
//--------------------ShaderPrograms-------------------//
ShaderProgram* m_BasicForwardProgram;
ShaderProgram* m_ExplosionEffectProgram;
include/Engine/Rendering/SSAOPass.h
+1 -1
View File
@@ -14,7 +14,7 @@ class SSAOPass
{
public:
SSAOPass(IRenderer* renderer, ConfigFile* config);
~SSAOPass() { };
~SSAOPass();
void ChangeQuality(int quality);
include/Engine/Rendering/ShaderProgram.h
+2
View File
@@ -21,6 +21,8 @@ public:
std::string GetFileName() const;
GLuint GetHandle() const;
bool IsCompiled() const;
static std::string ReadFile(std::string fileName);
private:
protected:
GLenum m_ShaderType;
std::string m_FileName;
include/Engine/Rendering/ShadowPass.h
+88
View File
@@ -0,0 +1,88 @@
#ifndef ShadowPass_h__
#define ShadowPass_h__
#include "IRenderer.h"
#include "FrameBuffer.h"
#include "ShaderProgram.h"
#include "../Core/EventBroker.h"
#include "../Core/World.h"
#include "ShadowPassState.h"
#include "imgui/imgui.h"
#define MAX_SPLITS 4
enum NearFar { NEAR = 0, FAR = 1 };
enum LRBT { LEFT = 0, RIGHT = 1, BOTTOM = 2, TOP = 3 };
struct ShadowFrustum
{
float NearClip;
float FarClip;
float FOV;
float AspectRatio;
glm::vec3 MiddlePoint;
float Radius;
std::array<float, 4> LRBT;
std::array<glm::vec3, 8> CornerPoint;
};
class ShadowPass
{
public:
ShadowPass(IRenderer* renderer);
ShadowPass(IRenderer * renderer, int ShadowResX, int ShadowResY);
~ShadowPass();
void InitializeFrameBuffers();
void InitializeShaderPrograms();
void ClearBuffer();
void Draw(RenderScene& scene);
void DebugGUI();
GLuint DepthMap() const { return m_DepthMap; }
std::array<glm::mat4, MAX_SPLITS> LightP() const { return m_LightProjection; }
std::array<glm::mat4, MAX_SPLITS> LightV() const { return m_LightView; }
std::array<float, MAX_SPLITS> FarDistance() const { std::array<float, MAX_SPLITS> f; for (int i = 0; i < MAX_SPLITS; i++) f[i] = m_shadowFrusta[i].FarClip; return f; }
int CurrentNrOfSplits() const { return m_CurrentNrOfSplits; }
void SetSplitWeight(float split_weight) { m_SplitWeight = split_weight; };
private:
void InitializeCameras(RenderScene & scene);
void UpdateSplitDist(std::array<ShadowFrustum, MAX_SPLITS>& frusta, float near_distance, float far_distance);
void UpdateFrustumPoints(ShadowFrustum& frustum, glm::vec3 camera_position, glm::vec3 view_dir);
void UpdateFrustumPoints(ShadowFrustum& frustum, glm::mat4 p, glm::mat4 v);
void PointsToLightspace(ShadowFrustum& frustum, glm::mat4 v);
float FindRadius(ShadowFrustum& frustum);
void RadiusToLightspace(ShadowFrustum& frustum);
EventBroker* m_EventBroker;
const IRenderer* m_Renderer;
GLuint m_DepthMap;
FrameBuffer m_DepthBuffer;
ShaderProgram* m_ShadowProgram;
ShaderProgram* m_ShadowProgramSkinned;
std::array<glm::mat4, MAX_SPLITS> m_LightProjection;
std::array<glm::mat4, MAX_SPLITS> m_LightView;
GLfloat m_NearFarPlane[2] = { -34.f, 27.f };
GLuint m_ResolutionSizeWidth = 1024 * 2;
GLuint m_ResolutionSizeHeight = 1024 * 2;
bool m_TransparentObjects = false;
bool m_TexturedShadows = false;
bool m_EnableShadows = true;
int m_CurrentNrOfSplits = 4;
float m_SplitWeight = 0.962f;
std::array<ShadowFrustum, MAX_SPLITS> m_shadowFrusta;
Texture* m_WhiteTexture = ResourceManager::Load<Texture>("Textures/Core/White.png");
};
#endif
include/Engine/Rendering/ShadowPassState.h
+15
View File
@@ -0,0 +1,15 @@
#ifndef ShadowPassState_h_
#define ShadowPassState_h_
#include "Rendering/RenderState.h"
class ShadowPassState : public RenderState
{
public:
ShadowPassState(GLuint frameBuffer);
~ShadowPassState();
private:
};
#endif
include/Engine/Rendering/SpriteJob.h
+31 -3
View File
@@ -7,6 +7,7 @@
#include "../GLM.h"
#include "../Core/ComponentWrapper.h"
#include "Texture.h"
#include "TextureSprite.h"
#include "Model.h"
#include "RenderJob.h"
#include "../Core/ResourceManager.h"
@@ -20,18 +21,21 @@ struct SpriteJob : RenderJob
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");
Model = ResourceManager::Load<::Model>((std::string)cSprite["Model"]);
::RawModel::MaterialProperties matProp = Model->MaterialGroups().front();
TextureID = 0;
DiffuseTexture = CommonFunctions::LoadTexture(cSprite["DiffuseTexture"], true);
DiffuseTexture = CommonFunctions::TryLoadResource<TextureSprite, true>(cSprite["DiffuseTexture"]);
IncandescenceTexture = CommonFunctions::TryLoadResource<TextureSprite, true>(cSprite["GlowMap"]);
IncandescenceTexture = CommonFunctions::LoadTexture(cSprite["GlowMap"], true);
Linear = (bool)cSprite["Linear"];
StartIndex = matProp.material->StartIndex;
EndIndex = matProp.material->EndIndex;
Matrix = matrix;
Color = cSprite["Color"];
BlurBackground = (bool)cSprite["BlurBackground"];
Entity = cSprite.EntityID;
Position = Transform::AbsolutePosition(world, cSprite.EntityID);
Depth = 0;
@@ -45,6 +49,26 @@ struct SpriteJob : RenderJob
FillColor = fillColor;
FillPercentage = fillPercentage;
glm::vec3 scale = Transform::AbsoluteScale(world, cSprite.EntityID);
if((bool)cSprite["KeepRatio"] == true) {
if(scale.y >= scale.x) {
ScaleY = (scale.x)/(scale.y);
ScaleX = 1.f;
} else {
ScaleY = 1.f;
ScaleX = (scale.x)/(scale.y);
}
} else {
if ((bool)cSprite["KeepRatioX"] == true) {
ScaleX = scale.x;
}
if ((bool)cSprite["KeepRatioY"] == true) {
ScaleY = scale.y;
}
}
};
unsigned int TextureID;
@@ -65,6 +89,10 @@ struct SpriteJob : RenderJob
bool Pickable;
bool IsIndicator = false;
bool BlurBackground = false;
float ScaleX = 1;
float ScaleY = 1;
bool Linear = false;
glm::vec4 FillColor = glm::vec4(0);
float FillPercentage = 0.0;
include/Engine/Rendering/Texture.h
+1 -1
View File
@@ -9,7 +9,7 @@ class Texture : public BaseTexture
{
friend class ResourceManager;
private:
protected:
Texture(std::string path);
public:
include/Engine/Rendering/TextureSprite.h
+26
View File
@@ -0,0 +1,26 @@
#ifndef TextureSprite_h__
#define TextureSprite_h__
#include "../OpenGL.h"
#include "BaseTexture.h"
#include "Texture.h"
#include "PNG.h"
class TextureSprite : public Texture
{
friend class ResourceManager;
protected:
TextureSprite(std::string path);
public:
~TextureSprite();
void Bind(GLenum textureUnit = GL_TEXTURE0);
GLuint m_Texture = 0;
unsigned char* Data = nullptr;
};
#endif
include/Engine/Rendering/Util/CommonFunctions.h
+17 -1
View File
@@ -8,7 +8,23 @@
namespace CommonFunctions
{
Texture* LoadTexture(std::string path, bool threaded);
//Loads Texture/SpriteTexture and return null if it fails
template <typename T, bool threaded>
Texture* TryLoadResource(std::string path)
{
Texture* img;
try {
img = ResourceManager::Load<T, threaded>(path);
} catch (const Resource::StillLoadingException&) {
img = ResourceManager::Load<T>("Textures/Core/ErrorTexture.png");
} catch (const std::exception&) {
img = nullptr;
}
return img;
}
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);
include/Engine/Rendering/Util/GLError.h
+4
View File
@@ -16,7 +16,11 @@ inline bool _GLERROR(const char* info, const char* file, const char* func, unsig
return false;
}
#ifdef DEBUG
#define GLERROR(function) \
_GLERROR(function, __BASE_FILE__, __func__, __LINE__)
#else
#define GLERROR(function) false
#endif
#endif