sid/NazaraEngine
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'refs/remotes/origin/master' into vulkan

Browse Source 
Former-commit-id: 12d5722252889558981b1e0b7e4a4538f6884e75 [formerly d4af159fa65c936f375e9e145bacba8ac38fdaa4] [formerly fee7f096c0bd0fb40fc03d663d74f2e847d06156 [formerly 6463645a926ad288de74646a470c3c4b7f8482c8]]
Former-commit-id: ad1e056ead3806ea657842b21d2a19d488ab52e1 [formerly 904fb40602ee4e6d936da58bbbca27acf6f89d82]
Former-commit-id: 7fe9d74b7100cf561c6cdd7445721e686da87f23
This commit is contained in:
Lynix
2016-08-16 13:02:07 +02:00
parent 228fd188eb f3c57a5417
commit 7dca3f1ab9
50 changed files with 653 additions and 140 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
include/Nazara/Core/Algorithm.inl
View File

@@ -124,7 +124,7 @@ namespace Nz
template<typename T, std::size_t N>
constexpr std::size_t CountOf(T(&name)[N]) noexcept
{
NazaraUnused(name);
// NazaraUnused(name); //< Because "body of function is not a return-statement" >.>
return N;
}

1
include/Nazara/Core/Signal.inl
View File

@@ -2,6 +2,7 @@
// This file is part of the "Nazara Engine - Core module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Core/Signal.hpp>
#include <Nazara/Core/Error.hpp>
#include <utility>
#include <Nazara/Core/Debug.hpp>

2
include/Nazara/Graphics/DeferredRenderPass.hpp
View File

@@ -47,9 +47,9 @@ namespace Nz
Vector2ui m_dimensions;
DeferredRenderTechnique* m_deferredTechnique;
DeferredRenderQueue* m_renderQueue;
RenderBuffer* m_depthStencilBuffer;
RenderTexture* m_GBufferRTT;
RenderTexture* m_workRTT;
Texture* m_depthStencilTexture;
Texture* m_GBuffer[4];
Texture* m_workTextures[2];

6
include/Nazara/Graphics/DeferredRenderTechnique.hpp
View File

@@ -37,7 +37,7 @@ namespace Nz
void EnablePass(RenderPassType renderPass, int position, bool enable);
RenderBuffer* GetDepthStencilBuffer() const;
Texture* GetDepthStencilTexture() const;
Texture* GetGBuffer(unsigned int i) const;
RenderTexture* GetGBufferRTT() const;
const ForwardRenderTechnique* GetForwardTechnique() const;
@@ -69,14 +69,14 @@ namespace Nz
std::map<RenderPassType, std::map<int, std::unique_ptr<DeferredRenderPass>>, RenderPassComparator> m_passes;
ForwardRenderTechnique m_forwardTechnique; // Must be initialized before the RenderQueue
DeferredRenderQueue m_renderQueue;
mutable RenderBufferRef m_depthStencilBuffer;
mutable TextureRef m_depthStencilTexture;
mutable RenderTexture m_GBufferRTT;
mutable RenderTexture m_workRTT;
mutable TextureRef m_GBuffer[4];
mutable TextureRef m_workTextures[2];
mutable Vector2ui m_GBufferSize;
const RenderTarget* m_viewerTarget;
};
};
}
#endif // NAZARA_FORWARDRENDERTECHNIQUE_HPP

6
include/Nazara/Graphics/MaterialPipeline.inl
View File

@@ -61,7 +61,7 @@ namespace Nz
if (!operator==(static_cast<const RenderStates&>(lhs), static_cast<const RenderStates&>(rhs)))
return false;
#define NazaraPipelineMember(field) if (lhs.##field != rhs.##field) return false
#define NazaraPipelineMember(field) if (lhs.field != rhs.field) return false
#define NazaraPipelineBoolMember NazaraPipelineMember
NazaraPipelineBoolMember(alphaTest);
@@ -115,8 +115,8 @@ namespace std
Nz::UInt16 parameterHash = 0;
Nz::UInt16 parameterIndex = 0;
#define NazaraPipelineMember(member) Nz::HashCombine(seed, pipelineInfo.##member)
#define NazaraPipelineBoolMember(member) parameterHash |= ((pipelineInfo.##member) ? 1U : 0U) << (parameterIndex++)
#define NazaraPipelineMember(member) Nz::HashCombine(seed, pipelineInfo.member)
#define NazaraPipelineBoolMember(member) parameterHash |= ((pipelineInfo.member) ? 1U : 0U) << (parameterIndex++)
NazaraPipelineBoolMember(alphaTest);
NazaraPipelineBoolMember(depthSorting);

2
include/Nazara/Graphics/ParticleDeclaration.inl
View File

@@ -11,6 +11,8 @@ namespace Nz
ParticleDeclarationRef ParticleDeclaration::New(Args&&... args)
{
std::unique_ptr<ParticleDeclaration> object(new ParticleDeclaration(std::forward<Args>(args)...));
object->SetPersistent(false);
return object.release();
}
}

45
include/Nazara/Graphics/ParticleFunctionController.hpp Normal file
View File

@@ -0,0 +1,45 @@
// Copyright (C) 2015 Jérôme Leclercq
// This file is part of the "Nazara Engine - Graphics module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#pragma once
#ifndef NAZARA_PARTICLEFUNCTIONCONTROLLER_HPP
#define NAZARA_PARTICLEFUNCTIONCONTROLLER_HPP
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Graphics/ParticleController.hpp>
#include <functional>
namespace Nz
{
class ParticleFunctionController;
using ParticleFunctionControllerConstRef = ObjectRef<const ParticleFunctionController>;
using ParticleFunctionControllerRef = ObjectRef<ParticleFunctionController>;
class NAZARA_GRAPHICS_API ParticleFunctionController : public ParticleController
{
public:
using Controller = std::function<void(ParticleGroup& /*group*/, ParticleMapper& /*mapper*/, unsigned int /*startId*/, unsigned int /*endId*/, float /*elapsedTime*/)>;
inline ParticleFunctionController(Controller controller);
ParticleFunctionController(const ParticleFunctionController&) = default;
~ParticleFunctionController() = default;
void Apply(ParticleGroup& group, ParticleMapper& mapper, unsigned int startId, unsigned int endId, float elapsedTime) override final;
inline const Controller& GetController() const;
inline void SetController(Controller controller);
template<typename... Args> static ParticleFunctionControllerRef New(Args&&... args);
private:
Controller m_controller;
};
}
#include <Nazara/Graphics/ParticleFunctionController.inl>
#endif // NAZARA_PARTICLEFUNCTIONCONTROLLER_HPP

46
include/Nazara/Graphics/ParticleFunctionController.inl Normal file
View File

@@ -0,0 +1,46 @@
// Copyright (C) 2016 Jérôme Leclercq
// This file is part of the "Nazara Engine - Graphics module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Graphics/ParticleFunctionController.hpp>
#include <memory>
#include <Nazara/Graphics/Debug.hpp>
namespace Nz
{
inline ParticleFunctionController::ParticleFunctionController(Controller controller) :
m_controller(std::move(controller))
{
}
/*!
* \brief Gets the controller function
*
* \return Controller function responsible for particle update
*/
inline const ParticleFunctionController::Controller& ParticleFunctionController::GetController() const
{
return m_controller;
}
/*!
* \brief Sets the controller function
*
* \remark The controller function must be valid
*/
inline void ParticleFunctionController::SetController(Controller controller)
{
m_controller = std::move(controller);
}
template<typename... Args>
ParticleFunctionControllerRef ParticleFunctionController::New(Args&&... args)
{
std::unique_ptr<ParticleFunctionController> object(new ParticleFunctionController(std::forward<Args>(args)...));
object->SetPersistent(false);
return object.release();
}
}
#include <Nazara/Graphics/DebugOff.hpp>

45
include/Nazara/Graphics/ParticleFunctionGenerator.hpp Normal file
View File

@@ -0,0 +1,45 @@
// Copyright (C) 2015 Jérôme Leclercq
// This file is part of the "Nazara Engine - Graphics module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#pragma once
#ifndef NAZARA_PARTICLEFUNCTIONGENERATOR_HPP
#define NAZARA_PARTICLEFUNCTIONGENERATOR_HPP
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Graphics/ParticleGenerator.hpp>
#include <functional>
namespace Nz
{
class ParticleFunctionGenerator;
using ParticleFunctionGeneratorConstRef = ObjectRef<const ParticleFunctionGenerator>;
using ParticleFunctionGeneratorRef = ObjectRef<ParticleFunctionGenerator>;
class NAZARA_GRAPHICS_API ParticleFunctionGenerator : public ParticleGenerator
{
public:
using Generator = std::function<void(ParticleGroup& /*group*/, ParticleMapper& /*mapper*/, unsigned int /*startId*/, unsigned int /*endId*/)>;
inline ParticleFunctionGenerator(Generator controller);
ParticleFunctionGenerator(const ParticleFunctionGenerator&) = default;
~ParticleFunctionGenerator() = default;
void Generate(ParticleGroup& group, ParticleMapper& mapper, unsigned int startId, unsigned int endId) override final;
inline const Generator& GetGenerator() const;
inline void SetGenerator(Generator generator);
template<typename... Args> static ParticleFunctionGeneratorRef New(Args&&... args);
private:
Generator m_generator;
};
}
#include <Nazara/Graphics/ParticleFunctionGenerator.inl>
#endif // NAZARA_PARTICLEFUNCTIONGENERATOR_HPP

46
include/Nazara/Graphics/ParticleFunctionGenerator.inl Normal file
View File

@@ -0,0 +1,46 @@
// Copyright (C) 2016 Jérôme Leclercq
// This file is part of the "Nazara Engine - Graphics module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Graphics/ParticleFunctionGenerator.hpp>
#include <memory>
#include <Nazara/Graphics/Debug.hpp>
namespace Nz
{
inline ParticleFunctionGenerator::ParticleFunctionGenerator(Generator generator) :
m_generator(std::move(generator))
{
}
/*!
* \brief Gets the generator function
*
* \return Generator function responsible for particle creation
*/
inline const ParticleFunctionGenerator::Generator& ParticleFunctionGenerator::GetGenerator() const
{
return m_generator;
}
/*!
* \brief Sets the generator function
*
* \remark The generator function must be valid
*/
inline void ParticleFunctionGenerator::SetGenerator(Generator generator)
{
m_generator = std::move(generator);
}
template<typename... Args>
ParticleFunctionGeneratorRef ParticleFunctionGenerator::New(Args&&... args)
{
std::unique_ptr<ParticleFunctionGenerator> object(new ParticleFunctionGenerator(std::forward<Args>(args)...));
object->SetPersistent(false);
return object.release();
}
}
#include <Nazara/Graphics/DebugOff.hpp>

45
include/Nazara/Graphics/ParticleFunctionRenderer.hpp Normal file
View File

@@ -0,0 +1,45 @@
// Copyright (C) 2015 Jérôme Leclercq
// This file is part of the "Nazara Engine - Graphics module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#pragma once
#ifndef NAZARA_PARTICLEFUNCTIONRENDERER_HPP
#define NAZARA_PARTICLEFUNCTIONRENDERER_HPP
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Graphics/ParticleRenderer.hpp>
#include <functional>
namespace Nz
{
class ParticleFunctionRenderer;
using ParticleFunctionRendererConstRef = ObjectRef<const ParticleFunctionRenderer>;
using ParticleFunctionRendererRef = ObjectRef<ParticleFunctionRenderer>;
class NAZARA_GRAPHICS_API ParticleFunctionRenderer : public ParticleRenderer
{
public:
using Renderer = std::function<void(const ParticleGroup& /*group*/, const ParticleMapper& /*mapper*/, unsigned int /*startId*/, unsigned int /*endId*/, AbstractRenderQueue* /*renderQueue*/)>;
inline ParticleFunctionRenderer(Renderer renderer);
ParticleFunctionRenderer(const ParticleFunctionRenderer&) = default;
~ParticleFunctionRenderer() = default;
void Render(const ParticleGroup& group, const ParticleMapper& mapper, unsigned int startId, unsigned int endId, AbstractRenderQueue* renderQueue) override final;
inline const Renderer& GetRenderer() const;
inline void SetRenderer(Renderer renderer);
template<typename... Args> static ParticleFunctionRendererRef New(Args&&... args);
private:
Renderer m_renderer;
};
}
#include <Nazara/Graphics/ParticleFunctionRenderer.inl>
#endif // NAZARA_PARTICLEFUNCTIONRENDERER_HPP

46
include/Nazara/Graphics/ParticleFunctionRenderer.inl Normal file
View File

@@ -0,0 +1,46 @@
// Copyright (C) 2016 Jérôme Leclercq
// This file is part of the "Nazara Engine - Graphics module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Graphics/ParticleFunctionRenderer.hpp>
#include <memory>
#include <Nazara/Graphics/Debug.hpp>
namespace Nz
{
inline ParticleFunctionRenderer::ParticleFunctionRenderer(Renderer renderer) :
m_renderer(std::move(renderer))
{
}
/*!
* \brief Gets the renderer function
*
* \return Renderer function responsible for particle rendering
*/
inline const ParticleFunctionRenderer::Renderer& ParticleFunctionRenderer::GetRenderer() const
{
return m_renderer;
}
/*!
* \brief Sets the renderer function
*
* \remark The renderer function must be valid
*/
inline void ParticleFunctionRenderer::SetRenderer(Renderer renderer)
{
m_renderer = std::move(renderer);
}
template<typename... Args>
ParticleFunctionRendererRef ParticleFunctionRenderer::New(Args&&... args)
{
std::unique_ptr<ParticleFunctionRenderer> object(new ParticleFunctionRenderer(std::forward<Args>(args)...));
object->SetPersistent(false);
return object.release();
}
}
#include <Nazara/Graphics/DebugOff.hpp>

2
include/Nazara/Graphics/ParticleGroup.hpp
View File

@@ -8,7 +8,7 @@
#define NAZARA_PARTICLEGROUP_HPP
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Core/signal.hpp>
#include <Nazara/Core/Signal.hpp>
#include <Nazara/Graphics/ParticleController.hpp>
#include <Nazara/Graphics/ParticleDeclaration.hpp>
#include <Nazara/Graphics/ParticleEmitter.hpp>

76
include/Nazara/Renderer/RenderStates.inl
View File

@@ -12,9 +12,9 @@ namespace Nz
{
bool operator==(const RenderStates& lhs, const RenderStates& rhs)
{
#define NazaraRenderStateMember(field) if (lhs.##field != rhs.##field) return false
#define NazaraRenderStateMember(field) if (lhs.field != rhs.field) return false
#define NazaraRenderStateBoolMember NazaraRenderStateMember
#define NazaraRenderStateFloatMember(field, maxDiff) if (!NumberEquals(lhs.##field, rhs.##field, maxDiff)) return false
#define NazaraRenderStateFloatMember(field, maxDiff) if (!NumberEquals(lhs.field, rhs.field, maxDiff)) return false
NazaraRenderStateBoolMember(blending);
NazaraRenderStateBoolMember(colorWrite);
@@ -81,59 +81,59 @@ namespace std
Nz::UInt8 parameterHash = 0;
Nz::UInt8 parameterIndex = 0;
#define NazaraRenderStateMember(member) Nz::HashCombine(seed, pipelineInfo.##member)
#define NazaraRenderStateBoolMember(member) parameterHash |= ((pipelineInfo.##member) ? 1U : 0U) << (parameterIndex++)
#define NazaraRenderStateBoolMemberDep(dependency, member) parameterHash |= ((pipelineInfo.##dependency && pipelineInfo.##member) ? 1U : 0U) << (parameterIndex++)
#define NazaraRenderStateFloatMember(member, maxDiff) Nz::HashCombine(seed, std::floor(pipelineInfo.##member / maxDiff) * maxDiff)
#define NazaraRenderStateBool(member) parameterHash |= ((pipelineInfo.member) ? 1U : 0U) << (parameterIndex++)
#define NazaraRenderStateBoolDep(dependency, member) parameterHash |= ((pipelineInfo.dependency && pipelineInfo.member) ? 1U : 0U) << (parameterIndex++)
#define NazaraRenderStateEnum(member) Nz::HashCombine(seed, static_cast<Nz::UInt8>(pipelineInfo.member))
#define NazaraRenderStateFloat(member, maxDiff) Nz::HashCombine(seed, std::floor(pipelineInfo.member / maxDiff) * maxDiff)
NazaraRenderStateBoolMember(blending);
NazaraRenderStateBoolMember(colorWrite);
NazaraRenderStateBoolMember(depthBuffer);
NazaraRenderStateBoolMember(faceCulling);
NazaraRenderStateBoolMember(scissorTest);
NazaraRenderStateBoolMember(stencilTest);
NazaraRenderStateBool(blending);
NazaraRenderStateBool(colorWrite);
NazaraRenderStateBool(depthBuffer);
NazaraRenderStateBool(faceCulling);
NazaraRenderStateBool(scissorTest);
NazaraRenderStateBool(stencilTest);
NazaraRenderStateBoolMemberDep(depthBuffer, depthWrite);
NazaraRenderStateBoolDep(depthBuffer, depthWrite);
NazaraRenderStateMember(faceFilling);
NazaraRenderStateEnum(faceFilling);
if (pipelineInfo.blending) //< Remember, at this time we know lhs.blending == rhs.blending
{
NazaraRenderStateMember(dstBlend);
NazaraRenderStateMember(srcBlend);
NazaraRenderStateEnum(dstBlend);
NazaraRenderStateEnum(srcBlend);
}
if (pipelineInfo.depthBuffer)
NazaraRenderStateMember(depthFunc);
NazaraRenderStateEnum(depthFunc);
if (pipelineInfo.faceCulling)
NazaraRenderStateMember(cullingSide);
NazaraRenderStateEnum(cullingSide);
if (pipelineInfo.stencilTest)
{
NazaraRenderStateMember(stencilCompare.back);
NazaraRenderStateMember(stencilCompare.front);
NazaraRenderStateMember(stencilCompareMask.back);
NazaraRenderStateMember(stencilCompareMask.front);
NazaraRenderStateMember(stencilDepthFail.back);
NazaraRenderStateMember(stencilDepthFail.front);
NazaraRenderStateMember(stencilFail.back);
NazaraRenderStateMember(stencilFail.front);
NazaraRenderStateMember(stencilPass.back);
NazaraRenderStateMember(stencilPass.front);
NazaraRenderStateMember(stencilReference.back);
NazaraRenderStateMember(stencilReference.front);
NazaraRenderStateMember(stencilWriteMask.back);
NazaraRenderStateMember(stencilWriteMask.front);
NazaraRenderStateEnum(stencilCompare.back);
NazaraRenderStateEnum(stencilCompare.front);
NazaraRenderStateEnum(stencilCompareMask.back);
NazaraRenderStateEnum(stencilCompareMask.front);
NazaraRenderStateEnum(stencilDepthFail.back);
NazaraRenderStateEnum(stencilDepthFail.front);
NazaraRenderStateEnum(stencilFail.back);
NazaraRenderStateEnum(stencilFail.front);
NazaraRenderStateEnum(stencilPass.back);
NazaraRenderStateEnum(stencilPass.front);
NazaraRenderStateEnum(stencilReference.back);
NazaraRenderStateEnum(stencilReference.front);
NazaraRenderStateEnum(stencilWriteMask.back);
NazaraRenderStateEnum(stencilWriteMask.front);
}
NazaraRenderStateFloatMember(lineWidth, 0.001f);
NazaraRenderStateFloatMember(pointSize, 0.001f);
NazaraRenderStateFloat(lineWidth, 0.001f);
NazaraRenderStateFloat(pointSize, 0.001f);
#undef NazaraRenderStateMember
#undef NazaraRenderStateBoolMember
#undef NazaraRenderStateBoolMemberDep
#undef NazaraRenderStateFloatMember
#undef NazaraRenderStateBool
#undef NazaraRenderStateBoolDep
#undef NazaraRenderStateEnum
#undef NazaraRenderStateFloat
Nz::HashCombine(seed, parameterHash);

2
include/Nazara/Utility/Formats/OBJParser.inl
View File

@@ -179,7 +179,7 @@ namespace Nz
m_errorCount++;
if (m_lineCount > 20 && (m_errorCount * 100 / m_lineCount) > 50)
if (m_errorCount > 10 && (m_errorCount * 100 / m_lineCount) > 50)
{
NazaraError("Aborting parsing because of error percentage");
return false; //< Abort parsing if error percentage is too high