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

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

Browse Source 
# Conflicts:
#	resources/Schema/Components.xsd
#	resources/Schema/Entities/RenderingWorld.xml
#	src/Engine/Rendering/DrawFinalPass.cpp
#	src/Engine/Rendering/PickingPass.cpp
#	src/Engine/Rendering/Skeleton.cpp
This commit is contained in:
viktorljung
2016-02-09 22:50:19 +01:00
parent 3c22dcc165 060e674a6f
commit c09c2f4783
115 changed files with 4572 additions and 930 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/Engine/Rendering/DrawColorCorrectionPass.h
+2 -2
View File
@@ -7,6 +7,7 @@
#include "ShaderProgram.h"
//#include "Util/UnorderedMapVec2.h"
#include "Texture.h"
#include "imgui/imgui.h"
class DrawColorCorrectionPass
{
@@ -16,14 +17,13 @@ public:
void InitializeFrameBuffers();
void InitializeShaderPrograms();
void Draw(GLuint sceneTexture, GLuint bloomTexture);
void Draw(GLuint sceneTexture, GLuint bloomTexture, GLfloat gamma, GLfloat exposure);
private:
const IRenderer* m_Renderer;
ShaderProgram* m_ColorCorrectionProgram;
Model* m_ScreenQuad;
GLfloat m_Exposure;
};
#endif
include/Engine/Rendering/DrawFinalPass.h
+10 -2
View File
@@ -35,8 +35,8 @@ private:
void BindExplosionUniforms(GLuint shaderHandle, std::shared_ptr<ExplosionEffectJob>& job, RenderScene& scene);
void BindModelUniforms(GLuint shaderHandle, std::shared_ptr<ModelJob>& job, RenderScene& scene);
void BindExplosionTextures(std::shared_ptr<ExplosionEffectJob>& job);
void BindModelTextures(std::shared_ptr<ModelJob>& job);
void BindExplosionTextures(GLuint shaderHandle, std::shared_ptr<ExplosionEffectJob>& job);
void BindModelTextures(GLuint shaderHandle, std::shared_ptr<ModelJob>& job);
Texture* m_WhiteTexture;
Texture* m_BlackTexture;
@@ -53,6 +53,14 @@ private:
ShaderProgram* m_ForwardPlusProgram;
ShaderProgram* m_ExplosionEffectProgram;
ShaderProgram* m_ExplosionEffectSplatMapProgram;
ShaderProgram* m_ForwardPlusSplatMapProgram;
ShaderProgram* m_ForwardPlusSkinnedProgram;
ShaderProgram* m_ExplosionEffectSkinnedProgram;
ShaderProgram* m_ExplosionEffectSplatMapSkinnedProgram;
ShaderProgram* m_ForwardPlusSplatMapSkinnedProgram;
};
#endif
include/Engine/Rendering/ExplosionEffectJob.h
+1 -1
View File
@@ -15,7 +15,7 @@
struct ExplosionEffectJob : ModelJob
{
ExplosionEffectJob(ComponentWrapper explosionEffectComponent, ::Model* model, Camera* camera, glm::mat4 matrix, ::RawModel::MaterialGroup matGroup, ComponentWrapper modelComponent, ::World* world, glm::vec4 fillColor, float fillPercentage)
ExplosionEffectJob(ComponentWrapper explosionEffectComponent, ::Model* model, Camera* camera, glm::mat4 matrix, ::RawModel::MaterialProperties matGroup, ComponentWrapper modelComponent, ::World* world, glm::vec4 fillColor, float fillPercentage)
: ModelJob(model, camera, matrix, matGroup, modelComponent, world, fillColor, fillPercentage)
{
ExplosionOrigin = (glm::vec3)explosionEffectComponent["ExplosionOrigin"];
include/Engine/Rendering/IRenderer.h
+7 -11
View File
@@ -25,27 +25,23 @@ class IRenderer
{
public:
GLFWwindow* Window() const { return m_Window; }
//Returns screensize including window border and header
//Returns screen size including window border and header
Rectangle Resolution() const { return m_Resolution; }
void SetResolution(const Rectangle& resolution) { m_Resolution = resolution; }
virtual void SetResolution(const Rectangle& resolution) { m_Resolution = resolution; }
bool Fullscreen() { return m_Fullscreen; }
void SetFullscreen(bool fullscreen) { m_Fullscreen = fullscreen; }
virtual void SetFullscreen(bool fullscreen) { m_Fullscreen = fullscreen; }
bool VSYNC() const { return m_VSYNC; }
void SetVSYNC(bool vsync) { m_VSYNC = vsync; }
//Returns screensize excluding window border and header
Rectangle GetViewPortSize() const { return m_ViewPortWidth; }
void SetViewPortSize(const Rectangle& viewportWidth) { m_ViewPortWidth = viewportWidth; }
virtual void SetVSYNC(bool vsync) { m_VSYNC = vsync; }
//Returns screen size excluding window border and header
Rectangle GetViewportSize() const { return m_ViewportSize; }
virtual void Initialize() = 0;
virtual void Update(double dt) = 0;
virtual void Draw(RenderFrame& rq) = 0;
virtual PickData Pick(glm::vec2 screenCord) = 0;
World* m_World; //Temp world, untill viktor merge.
protected:
Rectangle m_Resolution = Rectangle::Rectangle(1280, 720);
Rectangle m_ViewPortWidth = Rectangle::Rectangle(1280, 720);
Rectangle m_ViewportSize = Rectangle::Rectangle(1280, 720);
bool m_Fullscreen = false;
bool m_VSYNC = false;
int m_GLVersion[2];
include/Engine/Rendering/Model.h
+2 -2
View File
@@ -14,11 +14,11 @@ private:
public:
~Model();
const std::vector<RawModel::MaterialGroup>& MaterialGroups() const { return m_RawModel->MaterialGroups; }
const std::vector<RawModel::MaterialProperties>& MaterialGroups() const { return m_RawModel->m_Materials; }
const glm::mat4& Matrix() const { return m_RawModel->m_Matrix; }
const RawModel::Vertex* Vertices() const { return m_RawModel->Vertices(); }
unsigned int NumberOfVertices() const { return m_RawModel->NumVertices(); }
bool isSkined() const { return m_RawModel->isSkined; }
bool isSkined() const { return m_RawModel->isSkined(); }
GLuint VAO;
GLuint ElementBuffer;
RawModel* m_RawModel;
include/Engine/Rendering/ModelJob.h
+94 -32
View File
@@ -14,39 +14,98 @@
#include "../Core/World.h"
#include "../Core/Transform.h"
#include "Skeleton.h"
#include "ShaderProgram.h"
struct ModelJob : RenderJob
{
ModelJob(Model* model, Camera* camera, glm::mat4 matrix, ::RawModel::MaterialGroup matGroup, ComponentWrapper modelComponent, World* world, glm::vec4 fillColor, float fillPercentage)
ModelJob(Model* model, Camera* camera, glm::mat4 matrix, ::RawModel::MaterialProperties matProp, ComponentWrapper modelComponent, World* world, glm::vec4 fillColor, float fillPercentage)
: RenderJob()
{
Model = model;
TextureID = (matGroup.Texture) ? matGroup.Texture->ResourceID : 0;
if (modelComponent["DiffuseTexture"]) {
DiffuseTexture = matGroup.Texture.get();
} else {
DiffuseTexture = nullptr;
}
if (modelComponent["NormalMap"]) {
NormalTexture = matGroup.NormalMap.get();
} else {
NormalTexture = nullptr;
}
if (modelComponent["SpecularMap"]) {
SpecularTexture = matGroup.SpecularMap.get();
} else {
SpecularTexture = nullptr;
}
if (modelComponent["GlowMap"]) {
IncandescenceTexture = matGroup.IncandescenceMap.get();
} else {
IncandescenceTexture = nullptr;
}
DiffuseColor = matGroup.DiffuseColor;
SpecularColor = matGroup.SpecularColor;
IncandescenceColor = matGroup.IncandescenceColor;
StartIndex = matGroup.StartIndex;
EndIndex = matGroup.EndIndex;
ModelID = model->ResourceID;
Type = matProp.type;
::RawModel::MaterialBasic* matGroup = matProp.material;
switch(matProp.type){
case ::RawModel::MaterialType::Basic:
if (Model->isSkined()) {
ShaderID = ResourceManager::Load<ShaderProgram>("#ForwardPlusSkinnedProgram")->ResourceID;
}
else {
ShaderID = ResourceManager::Load<ShaderProgram>("#ForwardPlusProgram")->ResourceID;
}
TextureID = 0;
break;
case ::RawModel::MaterialType::SingleTextures:
{
if (Model->isSkined()) {
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"]) {
DiffuseTexture.push_back(&singleTextures->ColorMap);
}
if (modelComponent["NormalMap"]) {
NormalTexture.push_back(&singleTextures->NormalMap);
}
if (modelComponent["SpecularMap"]) {
SpecularTexture.push_back(&singleTextures->SpecularMap);
}
if (modelComponent["GlowMap"]) {
IncandescenceTexture.push_back(&singleTextures->IncandescenceMap);
}
}
break;
case ::RawModel::MaterialType::SplatMapping:
{
if (Model->isSkined()) {
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;
TextureID = (SplatTextures->ColorMaps[0].Texture) ? SplatTextures->ColorMaps[0].Texture->ResourceID : 0;
if (modelComponent["DiffuseTexture"]) {
for (auto& texture : SplatTextures->ColorMaps) {
DiffuseTexture.push_back(&texture);
}
}
if (modelComponent["NormalMap"]) {
for (auto& texture : SplatTextures->NormalMaps) {
NormalTexture.push_back(&texture);
}
}
if (modelComponent["SpecularMap"]) {
for (auto& texture : SplatTextures->SpecularMaps) {
SpecularTexture.push_back(&texture);
}
}
if (modelComponent["GlowMap"]) {
for (auto& texture : SplatTextures->IncandescenceMaps) {
IncandescenceTexture.push_back(&texture);
}
}
}
break;
}
DiffuseColor = matGroup->DiffuseColor;
SpecularColor = matGroup->SpecularColor;
IncandescenceColor = matGroup->IncandescenceColor;
StartIndex = matGroup->StartIndex;
EndIndex = matGroup->EndIndex;
Matrix = matrix;
Color = modelComponent["Color"];
Entity = modelComponent.EntityID;
@@ -89,13 +148,16 @@ struct ModelJob : RenderJob
unsigned int TextureID;
unsigned int ShaderID;
unsigned int ModelID;
::RawModel::MaterialType Type;
EntityID Entity;
glm::mat4 Matrix;
const Texture* DiffuseTexture;
const Texture* NormalTexture;
const Texture* SpecularTexture;
const Texture* IncandescenceTexture;
const ::RawModel::TextureProperties* SplatMap;
std::vector<const ::RawModel::TextureProperties*> DiffuseTexture;
std::vector<const ::RawModel::TextureProperties*> NormalTexture;
std::vector<const ::RawModel::TextureProperties*> SpecularTexture;
std::vector<const ::RawModel::TextureProperties*> IncandescenceTexture;
float Shininess = 0.f;
glm::vec4 Color;
const ::Model* Model = nullptr;
@@ -119,7 +181,7 @@ struct ModelJob : RenderJob
void CalculateHash() override
{
Hash = TextureID;
Hash = TextureID + ModelID << 10 + ShaderID << 20;
}
};
include/Engine/Rendering/PickingPass.h
+1
View File
@@ -40,6 +40,7 @@ private:
const IRenderer* m_Renderer;
ShaderProgram* m_PickingProgram;
ShaderProgram* m_PickingSkinnedProgram;
Camera* m_Camera;
struct PickingInfo
include/Engine/Rendering/RawModelCustom.h
+61 -25
View File
@@ -46,8 +46,14 @@ public:
glm::vec4 BoneIndices;
glm::vec4 BoneWeights;
};
struct TextureProperties {
std::string TexturePath;
glm::vec2 UVRepeat;
std::shared_ptr<::Texture> Texture;
};
struct MaterialGroup
struct MaterialBasic
{
float SpecularExponent;
float ReflectionFactor;
@@ -57,60 +63,90 @@ public:
unsigned int StartIndex;
unsigned int EndIndex;
//float Transparency;
std::string TexturePath;
std::shared_ptr<::Texture> Texture;
std::string NormalMapPath;
std::shared_ptr<::Texture> NormalMap;
std::string SpecularMapPath;
std::shared_ptr<::Texture> SpecularMap;
std::string IncandescenceMapPath;
std::shared_ptr<::Texture> IncandescenceMap;
};
struct MaterialSplatMapping : public MaterialBasic
{
TextureProperties SplatMap;
std::vector<TextureProperties> ColorMaps;
std::vector<TextureProperties> NormalMaps;
std::vector<TextureProperties> SpecularMaps;
std::vector<TextureProperties> IncandescenceMaps;
};
struct MaterialSingleTextures : public MaterialBasic
{
TextureProperties ColorMap;
TextureProperties NormalMap;
TextureProperties SpecularMap;
TextureProperties IncandescenceMap;
};
enum class MaterialType { Basic = 1, SplatMapping, SingleTextures };
struct MaterialProperties {
MaterialType type;
MaterialBasic* material;
};
const Vertex* Vertices() const {
if (isSkined) {
if (hasSkin) {
return m_SkinedVertices.data();
} else {
return m_Vertices.data();
}
};
unsigned int VertexSize() const {
if (hasSkin) {
return sizeof(SkinedVertex);
}
else {
return sizeof(Vertex);
}
};
unsigned int NumVertices() const {
if (isSkined) {
if (hasSkin) {
return m_SkinedVertices.size();
} else {
return m_Vertices.size();
}
};
std::vector<MaterialGroup> MaterialGroups;
bool isSkined;
bool isSkined() const { return hasSkin; };
std::vector<MaterialProperties> m_Materials;
std::vector<unsigned int> m_Indices;
Skeleton* m_Skeleton = nullptr;
glm::mat4 m_Matrix;
private:
bool hasSkin;
std::vector<Vertex> m_Vertices;
std::vector<SkinedVertex> m_SkinedVertices;
void ReadMeshFile(std::string filePath);
void ReadMeshFileHeader(unsigned int& offset, char* fileData, unsigned int& fileByteSize);
void ReadMesh(unsigned int& offset, char* fileData, unsigned int& fileByteSize);
void ReadVertices(unsigned int& offset, char* fileData, unsigned int& fileByteSize);
void ReadIndices(unsigned int& offset, char* fileData, unsigned int& fileByteSize);
void ReadMeshFileHeader(std::size_t& offset, char* fileData);
void ReadMesh(std::size_t& offset, char* fileData, const unsigned int& fileByteSize);
void ReadVertices(std::size_t& offset, char* fileData, const unsigned int& fileByteSize);
void ReadIndices(std::size_t& offset, char* fileData, const unsigned int& fileByteSize);
void ReadMaterialFile(std::string filePath);
void ReadMaterials(unsigned int &offset, char* fileData, unsigned int& fileByteSize);
void ReadMaterialSingle(unsigned int &offset, char* fileData, unsigned int& fileByteSize);
void ReadMaterials(std::size_t& offset, char* fileData, const unsigned int& fileByteSize);
void ReadMaterialSingle(std::size_t& offset, char* fileData, const unsigned int& fileByteSize);
void ReadMaterialBasic(MaterialBasic* Material, std::size_t& offset, char* fileData, const unsigned int& fileByteSize);
void ReadMaterialSingleTexture(MaterialSingleTextures* Material, std::size_t& offset, char* fileData, const unsigned int& fileByteSize);
void ReadMaterialSplatMapping(MaterialSplatMapping* Material, std::size_t& offset, char* fileData, const unsigned int& fileByteSize);
void ReadMaterialTextureProperties(TextureProperties& texture, std::size_t& offset, char* fileData, const unsigned int& fileByteSize);
void ReadAnimationFile(std::string filePath);
void ReadAnimationBindPoses(unsigned int &offset, char* fileData, unsigned int& fileByteSize);
void ReadAnimationJoint(unsigned int &offset, char* fileData, unsigned int& fileByteSize);
void ReadAnimationClips(unsigned int &offset, char* fileData, unsigned int& fileByteSize, unsigned int numberOfClips);
void ReadAnimationClipSingle(unsigned int &offset, char* fileData, unsigned int& fileByteSize, unsigned int clipIndex);
void ReadAnimationKeyFrame(unsigned int &offset, char* fileData, unsigned int& fileByteSize, std::vector<Skeleton::Animation::Keyframe>& animation);
void ReadAnimationBindPoses(std::size_t& offset, char* fileData, const unsigned int& fileByteSize);
void ReadAnimationJoint(std::size_t& offset, char* fileData, const unsigned int& fileByteSize);
void ReadAnimationClips(std::size_t& offset, char* fileData, const unsigned int& fileByteSize, unsigned int numberOfClips);
void ReadAnimationClipSingle(std::size_t& offset, char* fileData, const unsigned int& fileByteSize, unsigned int clipIndex);
void ReadAnimationKeyFrame(std::size_t& offset, char* fileData, const unsigned int& fileByteSize, std::vector<Skeleton::Animation::Keyframe>& animation);
//void CreateSkeleton(std::vector<std::tuple<std::string, glm::mat4>> &boneInfo, std::map<std::string, int> &boneNameMapping, aiNode* node, int parentID);
};
include/Engine/Rendering/RenderQueue.h
+4
View File
@@ -26,6 +26,7 @@ struct RenderScene
std::list<std::shared_ptr<RenderJob>> DirectionalLightJobs;
Rectangle Viewport;
bool ClearDepth = false;
glm::vec4 AmbientColor;
void Clear()
{
@@ -40,6 +41,9 @@ struct RenderScene
struct RenderFrame
{
public:
//TODO: Getters
GLfloat Gamma = 2.2f;
GLfloat Exposure = 1.f;
void Add(RenderScene &scene)
{
include/Engine/Rendering/RenderSystem.h
-1
View File
@@ -47,7 +47,6 @@ private:
void fillLight(std::list<std::shared_ptr<RenderJob>>& jobs);
bool isChildOfACamera(EntityWrapper entity);
bool isChildOfCurrentCamera(EntityWrapper entity);
};
#endif
include/Engine/Rendering/Util/GLError.h
+1 -1
View File
@@ -9,7 +9,7 @@ inline bool _GLERROR(const char* info, const char* file, const char* func, unsig
GLenum error = glGetError();
if (error != GL_NO_ERROR)
{
_LOG(LOG_LEVEL_ERROR, file, func, line, "GL Error: %s, %i, %s", info, error, gluErrorString(error));
_LOG(LOG_LEVEL_ERROR, file, func, line, "GL Error: %s\nError code: %i, %s\n", info, error, gluErrorString(error));
return true;
}