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

Merge branch 'NDK-ShadowMapping'

Browse Source 
Former-commit-id: 0fcd92b113069d2ee1edc74cf9be471cd6d97267
This commit is contained in:
Lynix
2016-05-13 13:06:23 +02:00
parent 6274692108 43c1243b75
commit 6c8d2ed03a
39 changed files with 2338 additions and 690 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
include/Nazara/Core/ObjectRef.hpp
View File

@@ -17,8 +17,6 @@ namespace Nz
template<typename T>
class ObjectRef
{
static_assert(std::is_base_of<RefCounted, T>::value, "ObjectRef shall only be used with RefCounted-derived type");
public:
ObjectRef();
ObjectRef(T* object);

5
include/Nazara/Graphics/AbstractRenderQueue.hpp
View File

@@ -62,7 +62,9 @@ namespace Nz
struct DirectionalLight
{
Color color;
Matrix4f transformMatrix;
Vector3f direction;
Texture* shadowMap;
float ambientFactor;
float diffuseFactor;
};
@@ -71,6 +73,7 @@ namespace Nz
{
Color color;
Vector3f position;
Texture* shadowMap;
float ambientFactor;
float attenuation;
float diffuseFactor;
@@ -81,8 +84,10 @@ namespace Nz
struct SpotLight
{
Color color;
Matrix4f transformMatrix;
Vector3f direction;
Vector3f position;
Texture* shadowMap;
float ambientFactor;
float attenuation;
float diffuseFactor;

53
include/Nazara/Graphics/DepthRenderQueue.hpp Normal file
View File

@@ -0,0 +1,53 @@
// 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_DEPTHRENDERQUEUE_HPP
#define NAZARA_DEPTHRENDERQUEUE_HPP
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Core/Color.hpp>
#include <Nazara/Graphics/AbstractRenderQueue.hpp>
#include <Nazara/Graphics/ForwardRenderQueue.hpp>
#include <Nazara/Math/Box.hpp>
#include <Nazara/Math/Matrix4.hpp>
#include <Nazara/Utility/IndexBuffer.hpp>
#include <Nazara/Utility/VertexBuffer.hpp>
#include <map>
#include <tuple>
namespace Nz
{
class NAZARA_GRAPHICS_API DepthRenderQueue : public ForwardRenderQueue
{
public:
DepthRenderQueue();
~DepthRenderQueue() = default;
void AddBillboard(int renderOrder, const Material* material, const Vector3f& position, const Vector2f& size, const Vector2f& sinCos = Vector2f(0.f, 1.f), const Color& color = Color::White) override;
void AddBillboards(int renderOrder, const Material* material, unsigned int count, SparsePtr<const Vector3f> positionPtr, SparsePtr<const Vector2f> sizePtr, SparsePtr<const Vector2f> sinCosPtr = nullptr, SparsePtr<const Color> colorPtr = nullptr) override;
void AddBillboards(int renderOrder, const Material* material, unsigned int count, SparsePtr<const Vector3f> positionPtr, SparsePtr<const Vector2f> sizePtr, SparsePtr<const Vector2f> sinCosPtr, SparsePtr<const float> alphaPtr) override;
void AddBillboards(int renderOrder, const Material* material, unsigned int count, SparsePtr<const Vector3f> positionPtr, SparsePtr<const Vector2f> sizePtr, SparsePtr<const float> anglePtr, SparsePtr<const Color> colorPtr = nullptr) override;
void AddBillboards(int renderOrder, const Material* material, unsigned int count, SparsePtr<const Vector3f> positionPtr, SparsePtr<const Vector2f> sizePtr, SparsePtr<const float> anglePtr, SparsePtr<const float> alphaPtr) override;
void AddBillboards(int renderOrder, const Material* material, unsigned int count, SparsePtr<const Vector3f> positionPtr, SparsePtr<const float> sizePtr, SparsePtr<const Vector2f> sinCosPtr = nullptr, SparsePtr<const Color> colorPtr = nullptr) override;
void AddBillboards(int renderOrder, const Material* material, unsigned int count, SparsePtr<const Vector3f> positionPtr, SparsePtr<const float> sizePtr, SparsePtr<const Vector2f> sinCosPtr, SparsePtr<const float> alphaPtr) override;
void AddBillboards(int renderOrder, const Material* material, unsigned int count, SparsePtr<const Vector3f> positionPtr, SparsePtr<const float> sizePtr, SparsePtr<const float> anglePtr, SparsePtr<const Color> colorPtr = nullptr) override;
void AddBillboards(int renderOrder, const Material* material, unsigned int count, SparsePtr<const Vector3f> positionPtr, SparsePtr<const float> sizePtr, SparsePtr<const float> anglePtr, SparsePtr<const float> alphaPtr) override;
void AddDirectionalLight(const DirectionalLight& light) override;
void AddMesh(int renderOrder, const Material* material, const MeshData& meshData, const Boxf& meshAABB, const Matrix4f& transformMatrix) override;
void AddPointLight(const PointLight& light) override;
void AddSpotLight(const SpotLight& light) override;
void AddSprites(int renderOrder, const Material* material, const VertexStruct_XYZ_Color_UV* vertices, unsigned int spriteCount, const Texture* overlay = nullptr) override;
private:
inline bool IsMaterialSuitable(const Material* material) const;
MaterialRef m_baseMaterial;
};
}
#include <Nazara/Graphics/DepthRenderQueue.inl>
#endif // NAZARA_DEPTHRENDERQUEUE_HPP

17
include/Nazara/Graphics/DepthRenderQueue.inl Normal file
View File

@@ -0,0 +1,17 @@
// 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
#include <Nazara/Graphics/Debug.hpp>
namespace Nz
{
bool DepthRenderQueue::IsMaterialSuitable(const Material* material) const
{
NazaraAssert(material, "Invalid material");
return material->HasDepthMaterial() || (material->IsEnabled(RendererParameter_DepthBuffer) && material->IsEnabled(RendererParameter_DepthWrite) && material->IsShadowCastingEnabled());
}
}
#include <Nazara/Graphics/DebugOff.hpp>

79
include/Nazara/Graphics/DepthRenderTechnique.hpp Normal file
View File

@@ -0,0 +1,79 @@
// 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_DEPTHRENDERTECHNIQUE_HPP
#define NAZARA_DEPTHRENDERTECHNIQUE_HPP
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Graphics/AbstractRenderTechnique.hpp>
#include <Nazara/Graphics/Config.hpp>
#include <Nazara/Graphics/DepthRenderQueue.hpp>
#include <Nazara/Graphics/Light.hpp>
#include <Nazara/Renderer/Shader.hpp>
#include <Nazara/Utility/IndexBuffer.hpp>
#include <Nazara/Utility/VertexBuffer.hpp>
namespace Nz
{
class NAZARA_GRAPHICS_API DepthRenderTechnique : public AbstractRenderTechnique
{
public:
DepthRenderTechnique();
~DepthRenderTechnique() = default;
void Clear(const SceneData& sceneData) const override;
bool Draw(const SceneData& sceneData) const override;
AbstractRenderQueue* GetRenderQueue() override;
RenderTechniqueType GetType() const override;
static bool Initialize();
static void Uninitialize();
private:
struct ShaderUniforms;
void DrawBasicSprites(const SceneData& sceneData, ForwardRenderQueue::Layer& layer) const;
void DrawBillboards(const SceneData& sceneData, ForwardRenderQueue::Layer& layer) const;
void DrawOpaqueModels(const SceneData& sceneData, ForwardRenderQueue::Layer& layer) const;
const ShaderUniforms* GetShaderUniforms(const Shader* shader) const;
void OnShaderInvalidated(const Shader* shader) const;
struct LightIndex
{
LightType type;
float score;
unsigned int index;
};
struct ShaderUniforms
{
NazaraSlot(Shader, OnShaderUniformInvalidated, shaderUniformInvalidatedSlot);
NazaraSlot(Shader, OnShaderRelease, shaderReleaseSlot);
// Autre uniformes
int eyePosition;
int sceneAmbient;
int textureOverlay;
};
mutable std::unordered_map<const Shader*, ShaderUniforms> m_shaderUniforms;
Buffer m_vertexBuffer;
mutable DepthRenderQueue m_renderQueue;
VertexBuffer m_billboardPointBuffer;
VertexBuffer m_spriteBuffer;
static IndexBuffer s_quadIndexBuffer;
static VertexBuffer s_quadVertexBuffer;
static VertexDeclaration s_billboardInstanceDeclaration;
static VertexDeclaration s_billboardVertexDeclaration;
};
}
#include <Nazara/Graphics/dEPTHRenderTechnique.inl>
#endif // NAZARA_DEPTHRENDERTECHNIQUE_HPP

3
include/Nazara/Graphics/DepthRenderTechnique.inl Normal file
View File

@@ -0,0 +1,3 @@
// 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

1
include/Nazara/Graphics/Enums.hpp
View File

@@ -108,6 +108,7 @@ namespace Nz
RenderTechniqueType_AdvancedForward, // AdvancedForwardRenderTechnique
RenderTechniqueType_BasicForward, // BasicForwardRenderTechnique
RenderTechniqueType_DeferredShading, // DeferredRenderTechnique
RenderTechniqueType_Depth, // DepthRenderTechnique
RenderTechniqueType_LightPrePass, // LightPrePassRenderTechnique
RenderTechniqueType_User,

5
include/Nazara/Graphics/ForwardRenderTechnique.hpp
View File

@@ -36,7 +36,7 @@ namespace Nz
static bool Initialize();
static void Uninitialize();
private:
protected:
struct ShaderUniforms;
void ChooseLights(const Spheref& object, bool includeDirectionalLights = true) const;
@@ -46,7 +46,7 @@ namespace Nz
void DrawTransparentModels(const SceneData& sceneData, ForwardRenderQueue::Layer& layer) const;
const ShaderUniforms* GetShaderUniforms(const Shader* shader) const;
void OnShaderInvalidated(const Shader* shader) const;
void SendLightUniforms(const Shader* shader, const LightUniforms& uniforms, unsigned int index, unsigned int uniformOffset) const;
void SendLightUniforms(const Shader* shader, const LightUniforms& uniforms, unsigned int index, unsigned int uniformOffset, UInt8 availableTextureUnit) const;
static float ComputeDirectionalLightScore(const Spheref& object, const AbstractRenderQueue::DirectionalLight& light);
static float ComputePointLightScore(const Spheref& object, const AbstractRenderQueue::PointLight& light);
@@ -89,6 +89,7 @@ namespace Nz
unsigned int m_maxLightPassPerObject;
static IndexBuffer s_quadIndexBuffer;
static TextureSampler s_shadowSampler;
static VertexBuffer s_quadVertexBuffer;
static VertexDeclaration s_billboardInstanceDeclaration;
static VertexDeclaration s_billboardVertexDeclaration;

56
include/Nazara/Graphics/ForwardRenderTechnique.inl
View File

@@ -2,10 +2,16 @@
// This file is part of the "Nazara Engine - Graphics module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Renderer/Renderer.hpp>
namespace Nz
{
inline void ForwardRenderTechnique::SendLightUniforms(const Shader* shader, const LightUniforms& uniforms, unsigned int index, unsigned int uniformOffset) const
inline void ForwardRenderTechnique::SendLightUniforms(const Shader* shader, const LightUniforms& uniforms, unsigned int index, unsigned int uniformOffset, UInt8 availableTextureUnit) const
{
// If anyone got a better idea..
int dummyCubemap = Renderer::GetMaxTextureUnits() - 1;
int dummyTexture = Renderer::GetMaxTextureUnits() - 2;
if (index < m_lights.size())
{
const LightIndex& lightIndex = m_lights[index];
@@ -21,6 +27,20 @@ namespace Nz
shader->SendColor(uniforms.locations.color + uniformOffset, light.color);
shader->SendVector(uniforms.locations.factors + uniformOffset, Vector2f(light.ambientFactor, light.diffuseFactor));
shader->SendVector(uniforms.locations.parameters1 + uniformOffset, Vector4f(light.direction));
shader->SendBoolean(uniforms.locations.shadowMapping + uniformOffset, light.shadowMap != nullptr);
if (light.shadowMap)
{
Renderer::SetTexture(availableTextureUnit, light.shadowMap);
Renderer::SetTextureSampler(availableTextureUnit, s_shadowSampler);
shader->SendMatrix(uniforms.locations.lightViewProjMatrix + index, light.transformMatrix);
shader->SendInteger(uniforms.locations.directionalSpotLightShadowMap + index, availableTextureUnit);
}
else
shader->SendInteger(uniforms.locations.directionalSpotLightShadowMap + index, dummyTexture);
shader->SendInteger(uniforms.locations.pointLightShadowMap + index, dummyCubemap);
break;
}
@@ -32,6 +52,19 @@ namespace Nz
shader->SendVector(uniforms.locations.factors + uniformOffset, Vector2f(light.ambientFactor, light.diffuseFactor));
shader->SendVector(uniforms.locations.parameters1 + uniformOffset, Vector4f(light.position, light.attenuation));
shader->SendVector(uniforms.locations.parameters2 + uniformOffset, Vector4f(0.f, 0.f, 0.f, light.invRadius));
shader->SendBoolean(uniforms.locations.shadowMapping + uniformOffset, light.shadowMap != nullptr);
if (light.shadowMap)
{
Renderer::SetTexture(availableTextureUnit, light.shadowMap);
Renderer::SetTextureSampler(availableTextureUnit, s_shadowSampler);
shader->SendInteger(uniforms.locations.pointLightShadowMap + index, availableTextureUnit);
}
else
shader->SendInteger(uniforms.locations.pointLightShadowMap + index, dummyCubemap);
shader->SendInteger(uniforms.locations.directionalSpotLightShadowMap + index, dummyTexture);
break;
}
@@ -44,12 +77,31 @@ namespace Nz
shader->SendVector(uniforms.locations.parameters1 + uniformOffset, Vector4f(light.position, light.attenuation));
shader->SendVector(uniforms.locations.parameters2 + uniformOffset, Vector4f(light.direction, light.invRadius));
shader->SendVector(uniforms.locations.parameters3 + uniformOffset, Vector2f(light.innerAngleCosine, light.outerAngleCosine));
shader->SendBoolean(uniforms.locations.shadowMapping + uniformOffset, light.shadowMap != nullptr);
if (light.shadowMap)
{
Renderer::SetTexture(availableTextureUnit, light.shadowMap);
Renderer::SetTextureSampler(availableTextureUnit, s_shadowSampler);
shader->SendMatrix(uniforms.locations.lightViewProjMatrix + index, light.transformMatrix);
shader->SendInteger(uniforms.locations.directionalSpotLightShadowMap + index, availableTextureUnit);
}
else
shader->SendInteger(uniforms.locations.directionalSpotLightShadowMap + index, dummyTexture);
shader->SendInteger(uniforms.locations.pointLightShadowMap + index, dummyCubemap);
break;
}
}
}
else
{
shader->SendInteger(uniforms.locations.type + uniformOffset, -1); //< Disable the light in the shader
shader->SendInteger(uniforms.locations.directionalSpotLightShadowMap + index, dummyTexture);
shader->SendInteger(uniforms.locations.pointLightShadowMap + index, dummyCubemap);
}
}
inline float ForwardRenderTechnique::ComputeDirectionalLightScore(const Spheref& object, const AbstractRenderQueue::DirectionalLight& light)
@@ -78,7 +130,7 @@ namespace Nz
NazaraUnused(object);
NazaraUnused(light);
// Directional light are always suitables
// Directional light are always suitable
return true;
}

72
include/Nazara/Graphics/Light.hpp
View File

@@ -11,6 +11,8 @@
#include <Nazara/Core/Color.hpp>
#include <Nazara/Graphics/Enums.hpp>
#include <Nazara/Graphics/Renderable.hpp>
#include <Nazara/Renderer/RenderTexture.hpp>
#include <Nazara/Renderer/Texture.hpp>
namespace Nz
{
@@ -21,7 +23,8 @@ namespace Nz
{
public:
Light(LightType type = LightType_Point);
Light(const Light& light) = default;
inline Light(const Light& light);
Light(Light&& light) = default;
~Light() = default;
void AddToRenderQueue(AbstractRenderQueue* renderQueue, const Matrix4f& transformMatrix) const override;
@@ -31,37 +34,56 @@ namespace Nz
bool Cull(const Frustumf& frustum, const Matrix4f& transformMatrix) const override;
float GetAmbientFactor() const;
float GetAttenuation() const;
Color GetColor() const;
float GetDiffuseFactor() const;
float GetInnerAngle() const;
float GetInnerAngleCosine() const;
float GetInvRadius() const;
LightType GetLightType() const;
float GetOuterAngle() const;
float GetOuterAngleCosine() const;
float GetOuterAngleTangent() const;
float GetRadius() const;
inline void EnableShadowCasting(bool castShadows);
void SetAmbientFactor(float factor);
void SetAttenuation(float attenuation);
void SetColor(const Color& color);
void SetDiffuseFactor(float factor);
void SetInnerAngle(float innerAngle);
void SetLightType(LightType type);
void SetOuterAngle(float outerAngle);
void SetRadius(float radius);
inline void EnsureShadowMapUpdate() const;
inline float GetAmbientFactor() const;
inline float GetAttenuation() const;
inline Color GetColor() const;
inline float GetDiffuseFactor() const;
inline float GetInnerAngle() const;
inline float GetInnerAngleCosine() const;
inline float GetInvRadius() const;
inline LightType GetLightType() const;
inline float GetOuterAngle() const;
inline float GetOuterAngleCosine() const;
inline float GetOuterAngleTangent() const;
inline float GetRadius() const;
inline TextureRef GetShadowMap() const;
inline PixelFormatType GetShadowMapFormat() const;
inline const Vector2ui& GetShadowMapSize() const;
inline bool IsShadowCastingEnabled() const;
inline void SetAmbientFactor(float factor);
inline void SetAttenuation(float attenuation);
inline void SetColor(const Color& color);
inline void SetDiffuseFactor(float factor);
inline void SetInnerAngle(float innerAngle);
inline void SetLightType(LightType type);
inline void SetOuterAngle(float outerAngle);
inline void SetRadius(float radius);
inline void SetShadowMapFormat(PixelFormatType shadowFormat);
inline void SetShadowMapSize(const Vector2ui& size);
void UpdateBoundingVolume(const Matrix4f& transformMatrix) override;
Light& operator=(const Light& light) = default;
Light& operator=(const Light& light);
Light& operator=(Light&& light) = default;
private:
void MakeBoundingVolume() const override;
inline void InvalidateShadowMap();
void UpdateShadowMap() const;
LightType m_type;
Color m_color;
LightType m_type;
PixelFormatType m_shadowMapFormat;
Vector2ui m_shadowMapSize;
mutable TextureRef m_shadowMap;
bool m_shadowCastingEnabled;
mutable bool m_shadowMapUpdated;
float m_ambientFactor;
float m_attenuation;
float m_diffuseFactor;
@@ -80,10 +102,14 @@ namespace Nz
{
int type;
int color;
int directionalSpotLightShadowMap;
int factors;
int lightViewProjMatrix;
int parameters1;
int parameters2;
int parameters3;
int pointLightShadowMap;
int shadowMapping;
};
bool ubo;

107
include/Nazara/Graphics/Light.inl
View File

@@ -7,6 +7,42 @@
namespace Nz
{
inline Light::Light(const Light& light) :
Renderable(light),
m_type(light.m_type),
m_shadowMapFormat(light.m_shadowMapFormat),
m_color(light.m_color),
m_shadowMapSize(light.m_shadowMapSize),
m_shadowCastingEnabled(light.m_shadowCastingEnabled),
m_shadowMapUpdated(false),
m_ambientFactor(light.m_ambientFactor),
m_attenuation(light.m_attenuation),
m_diffuseFactor(light.m_diffuseFactor),
m_innerAngle(light.m_innerAngle),
m_innerAngleCosine(light.m_innerAngleCosine),
m_invRadius(light.m_invRadius),
m_outerAngle(light.m_outerAngle),
m_outerAngleCosine(light.m_outerAngleCosine),
m_outerAngleTangent(light.m_outerAngleTangent),
m_radius(light.m_radius)
{
}
inline void Light::EnableShadowCasting(bool castShadows)
{
if (m_shadowCastingEnabled != castShadows)
{
m_shadowCastingEnabled = castShadows;
m_shadowMapUpdated = false;
}
}
inline void Light::EnsureShadowMapUpdate() const
{
if (!m_shadowMapUpdated)
UpdateShadowMap();
}
inline float Light::GetAmbientFactor() const
{
return m_ambientFactor;
@@ -67,6 +103,28 @@ namespace Nz
return m_radius;
}
inline TextureRef Light::GetShadowMap() const
{
EnsureShadowMapUpdate();
return m_shadowMap;
}
inline PixelFormatType Light::GetShadowMapFormat() const
{
return m_shadowMapFormat;
}
inline const Vector2ui& Light::GetShadowMapSize() const
{
return m_shadowMapSize;
}
inline bool Light::IsShadowCastingEnabled() const
{
return m_shadowCastingEnabled;
}
inline void Light::SetAmbientFactor(float factor)
{
m_ambientFactor = factor;
@@ -96,6 +154,8 @@ namespace Nz
inline void Light::SetLightType(LightType type)
{
m_type = type;
InvalidateShadowMap();
}
inline void Light::SetOuterAngle(float outerAngle)
@@ -115,6 +175,53 @@ namespace Nz
InvalidateBoundingVolume();
}
inline void Light::SetShadowMapFormat(PixelFormatType shadowFormat)
{
NazaraAssert(PixelFormat::GetType(shadowFormat) == PixelFormatTypeType_Depth, "Shadow format type is not a depth format");
m_shadowMapFormat = shadowFormat;
InvalidateShadowMap();
}
inline void Light::SetShadowMapSize(const Vector2ui& size)
{
NazaraAssert(size.x > 0 && size.y > 0, "Shadow map size must have a positive size");
m_shadowMapSize = size;
InvalidateShadowMap();
}
inline Light& Light::operator=(const Light& light)
{
Renderable::operator=(light);
m_ambientFactor = light.m_ambientFactor;
m_attenuation = light.m_attenuation;
m_color = light.m_color;
m_diffuseFactor = light.m_diffuseFactor;
m_innerAngle = light.m_innerAngle;
m_innerAngleCosine = light.m_innerAngleCosine;
m_invRadius = light.m_invRadius;
m_outerAngle = light.m_outerAngle;
m_outerAngleCosine = light.m_outerAngleCosine;
m_outerAngleTangent = light.m_outerAngleTangent;
m_radius = light.m_radius;
m_shadowCastingEnabled = light.m_shadowCastingEnabled;
m_shadowMapFormat = light.m_shadowMapFormat;
m_shadowMapSize = light.m_shadowMapSize;
m_type = light.m_type;
InvalidateShadowMap();
return *this;
}
inline void Light::InvalidateShadowMap()
{
m_shadowMapUpdated = false;
}
}
#include <Nazara/Renderer/DebugOff.hpp>

158
include/Nazara/Graphics/Material.hpp
View File

@@ -57,92 +57,99 @@ namespace Nz
friend class Graphics;
public:
Material();
Material(const Material& material);
~Material();
inline Material();
inline Material(const Material& material);
inline ~Material();
const Shader* Apply(UInt32 shaderFlags = 0, UInt8 textureUnit = 0, UInt8* lastUsedUnit = nullptr) const;
void BuildFromParameters(const ParameterList& matData, const MaterialParams& matParams = MaterialParams());
void Enable(RendererParameter renderParameter, bool enable);
void EnableAlphaTest(bool alphaTest);
void EnableDepthSorting(bool depthSorting);
void EnableLighting(bool lighting);
void EnableTransform(bool transform);
inline void Enable(RendererParameter renderParameter, bool enable);
inline void EnableAlphaTest(bool alphaTest);
inline void EnableDepthSorting(bool depthSorting);
inline void EnableLighting(bool lighting);
inline void EnableShadowCasting(bool castShadows);
inline void EnableShadowReceive(bool receiveShadows);
inline void EnableTransform(bool transform);
Texture* GetAlphaMap() const;
float GetAlphaThreshold() const;
Color GetAmbientColor() const;
RendererComparison GetDepthFunc() const;
Color GetDiffuseColor() const;
Texture* GetDiffuseMap() const;
TextureSampler& GetDiffuseSampler();
const TextureSampler& GetDiffuseSampler() const;
BlendFunc GetDstBlend() const;
Texture* GetEmissiveMap() const;
FaceSide GetFaceCulling() const;
FaceFilling GetFaceFilling() const;
Texture* GetHeightMap() const;
Texture* GetNormalMap() const;
const RenderStates& GetRenderStates() const;
const UberShader* GetShader() const;
const UberShaderInstance* GetShaderInstance(UInt32 flags = ShaderFlags_None) const;
float GetShininess() const;
Color GetSpecularColor() const;
Texture* GetSpecularMap() const;
TextureSampler& GetSpecularSampler();
const TextureSampler& GetSpecularSampler() const;
BlendFunc GetSrcBlend() const;
inline const TextureRef& GetAlphaMap() const;
inline float GetAlphaThreshold() const;
inline Color GetAmbientColor() const;
inline RendererComparison GetDepthFunc() const;
inline const MaterialRef& GetDepthMaterial() const;
inline Color GetDiffuseColor() const;
inline const TextureRef& GetDiffuseMap() const;
inline TextureSampler& GetDiffuseSampler();
inline const TextureSampler& GetDiffuseSampler() const;
inline BlendFunc GetDstBlend() const;
inline const TextureRef& GetEmissiveMap() const;
inline FaceSide GetFaceCulling() const;
inline FaceFilling GetFaceFilling() const;
inline const TextureRef& GetHeightMap() const;
inline const TextureRef& GetNormalMap() const;
inline const RenderStates& GetRenderStates() const;
inline const UberShader* GetShader() const;
inline const UberShaderInstance* GetShaderInstance(UInt32 flags = ShaderFlags_None) const;
inline float GetShininess() const;
inline Color GetSpecularColor() const;
inline const TextureRef& GetSpecularMap() const;
inline TextureSampler& GetSpecularSampler();
inline const TextureSampler& GetSpecularSampler() const;
inline BlendFunc GetSrcBlend() const;
bool HasAlphaMap() const;
bool HasDiffuseMap() const;
bool HasEmissiveMap() const;
bool HasHeightMap() const;
bool HasNormalMap() const;
bool HasSpecularMap() const;
inline bool HasAlphaMap() const;
inline bool HasDepthMaterial() const;
inline bool HasDiffuseMap() const;
inline bool HasEmissiveMap() const;
inline bool HasHeightMap() const;
inline bool HasNormalMap() const;
inline bool HasSpecularMap() const;
bool IsAlphaTestEnabled() const;
bool IsDepthSortingEnabled() const;
bool IsEnabled(RendererParameter renderParameter) const;
bool IsLightingEnabled() const;
bool IsTransformEnabled() const;
inline bool IsAlphaTestEnabled() const;
inline bool IsDepthSortingEnabled() const;
inline bool IsEnabled(RendererParameter renderParameter) const;
inline bool IsLightingEnabled() const;
inline bool IsShadowCastingEnabled() const;
inline bool IsShadowReceiveEnabled() const;
inline bool IsTransformEnabled() const;
bool LoadFromFile(const String& filePath, const MaterialParams& params = MaterialParams());
bool LoadFromMemory(const void* data, std::size_t size, const MaterialParams& params = MaterialParams());
bool LoadFromStream(Stream& stream, const MaterialParams& params = MaterialParams());
inline bool LoadFromFile(const String& filePath, const MaterialParams& params = MaterialParams());
inline bool LoadFromMemory(const void* data, std::size_t size, const MaterialParams& params = MaterialParams());
inline bool LoadFromStream(Stream& stream, const MaterialParams& params = MaterialParams());
void Reset();
bool SetAlphaMap(const String& textureName);
void SetAlphaMap(TextureRef alphaMap);
void SetAlphaThreshold(float alphaThreshold);
void SetAmbientColor(const Color& ambient);
void SetDepthFunc(RendererComparison depthFunc);
void SetDiffuseColor(const Color& diffuse);
bool SetDiffuseMap(const String& textureName);
void SetDiffuseMap(TextureRef diffuseMap);
void SetDiffuseSampler(const TextureSampler& sampler);
void SetDstBlend(BlendFunc func);
bool SetEmissiveMap(const String& textureName);
void SetEmissiveMap(TextureRef textureName);
void SetFaceCulling(FaceSide faceSide);
void SetFaceFilling(FaceFilling filling);
bool SetHeightMap(const String& textureName);
void SetHeightMap(TextureRef textureName);
bool SetNormalMap(const String& textureName);
void SetNormalMap(TextureRef textureName);
void SetRenderStates(const RenderStates& states);
void SetShader(UberShaderConstRef uberShader);
bool SetShader(const String& uberShaderName);
void SetShininess(float shininess);
void SetSpecularColor(const Color& specular);
bool SetSpecularMap(const String& textureName);
void SetSpecularMap(TextureRef specularMap);
void SetSpecularSampler(const TextureSampler& sampler);
void SetSrcBlend(BlendFunc func);
inline bool SetAlphaMap(const String& textureName);
inline void SetAlphaMap(TextureRef alphaMap);
inline void SetAlphaThreshold(float alphaThreshold);
inline void SetAmbientColor(const Color& ambient);
inline void SetDepthFunc(RendererComparison depthFunc);
inline void SetDepthMaterial(MaterialRef depthMaterial);
inline void SetDiffuseColor(const Color& diffuse);
inline bool SetDiffuseMap(const String& textureName);
inline void SetDiffuseMap(TextureRef diffuseMap);
inline void SetDiffuseSampler(const TextureSampler& sampler);
inline void SetDstBlend(BlendFunc func);
inline bool SetEmissiveMap(const String& textureName);
inline void SetEmissiveMap(TextureRef textureName);
inline void SetFaceCulling(FaceSide faceSide);
inline void SetFaceFilling(FaceFilling filling);
inline bool SetHeightMap(const String& textureName);
inline void SetHeightMap(TextureRef textureName);
inline bool SetNormalMap(const String& textureName);
inline void SetNormalMap(TextureRef textureName);
inline void SetRenderStates(const RenderStates& states);
inline void SetShader(UberShaderConstRef uberShader);
inline bool SetShader(const String& uberShaderName);
inline void SetShininess(float shininess);
inline void SetSpecularColor(const Color& specular);
inline bool SetSpecularMap(const String& textureName);
inline void SetSpecularMap(TextureRef specularMap);
inline void SetSpecularSampler(const TextureSampler& sampler);
inline void SetSrcBlend(BlendFunc func);
Material& operator=(const Material& material);
inline Material& operator=(const Material& material);
static MaterialRef GetDefault();
template<typename... Args> static MaterialRef New(Args&&... args);
@@ -161,7 +168,7 @@ namespace Nz
void Copy(const Material& material);
void GenerateShader(UInt32 flags) const;
void InvalidateShaders();
inline void InvalidateShaders();
static bool Initialize();
static void Uninitialize();
@@ -169,6 +176,7 @@ namespace Nz
Color m_ambientColor;
Color m_diffuseColor;
Color m_specularColor;
MaterialRef m_depthMaterial; //< Materialception
RenderStates m_states;
TextureSampler m_diffuseSampler;
TextureSampler m_specularSampler;
@@ -183,6 +191,8 @@ namespace Nz
bool m_alphaTestEnabled;
bool m_depthSortingEnabled;
bool m_lightingEnabled;
bool m_shadowCastingEnabled;
bool m_shadowReceiveEnabled;
bool m_transformEnabled;
float m_alphaThreshold;
float m_shininess;

507
include/Nazara/Graphics/Material.inl
View File

@@ -7,6 +7,513 @@
namespace Nz
{
inline Material::Material()
{
Reset();
}
inline Material::Material(const Material& material) :
RefCounted(),
Resource(material)
{
Copy(material);
}
inline Material::~Material()
{
OnMaterialRelease(this);
}
inline void Material::Enable(RendererParameter renderParameter, bool enable)
{
NazaraAssert(renderParameter <= RendererParameter_Max, "Renderer parameter out of enum");
m_states.parameters[renderParameter] = enable;
}
inline void Material::EnableAlphaTest(bool alphaTest)
{
m_alphaTestEnabled = alphaTest;
InvalidateShaders();
}
inline void Material::EnableDepthSorting(bool depthSorting)
{
// Has no influence on shaders
m_depthSortingEnabled = depthSorting;
}
inline void Material::EnableLighting(bool lighting)
{
m_lightingEnabled = lighting;
InvalidateShaders();
}
inline void Material::EnableShadowCasting(bool castShadows)
{
// Has no influence on shaders
m_shadowCastingEnabled = castShadows;
}
inline void Material::EnableShadowReceive(bool receiveShadows)
{
m_shadowReceiveEnabled = receiveShadows;
InvalidateShaders();
}
inline void Material::EnableTransform(bool transform)
{
m_transformEnabled = transform;
InvalidateShaders();
}
inline const TextureRef& Material::GetAlphaMap() const
{
return m_alphaMap;
}
inline float Material::GetAlphaThreshold() const
{
return m_alphaThreshold;
}
inline Color Material::GetAmbientColor() const
{
return m_ambientColor;
}
inline RendererComparison Material::GetDepthFunc() const
{
return m_states.depthFunc;
}
inline const MaterialRef& Material::GetDepthMaterial() const
{
return m_depthMaterial;
}
inline Color Material::GetDiffuseColor() const
{
return m_diffuseColor;
}
inline TextureSampler& Material::GetDiffuseSampler()
{
return m_diffuseSampler;
}
inline const TextureSampler& Material::GetDiffuseSampler() const
{
return m_diffuseSampler;
}
const TextureRef& Material::GetDiffuseMap() const
{
return m_diffuseMap;
}
inline BlendFunc Material::GetDstBlend() const
{
return m_states.dstBlend;
}
inline const TextureRef& Material::GetEmissiveMap() const
{
return m_emissiveMap;
}
inline FaceSide Material::GetFaceCulling() const
{
return m_states.faceCulling;
}
inline FaceFilling Material::GetFaceFilling() const
{
return m_states.faceFilling;
}
inline const TextureRef& Material::GetHeightMap() const
{
return m_heightMap;
}
inline const TextureRef& Material::GetNormalMap() const
{
return m_normalMap;
}
inline const RenderStates& Material::GetRenderStates() const
{
return m_states;
}
inline const UberShader* Material::GetShader() const
{
return m_uberShader;
}
inline const UberShaderInstance* Material::GetShaderInstance(UInt32 flags) const
{
const ShaderInstance& instance = m_shaders[flags];
if (!instance.uberInstance)
GenerateShader(flags);
return instance.uberInstance;
}
inline float Material::GetShininess() const
{
return m_shininess;
}
inline Color Material::GetSpecularColor() const
{
return m_specularColor;
}
inline const TextureRef& Material::GetSpecularMap() const
{
return m_specularMap;
}
inline TextureSampler& Material::GetSpecularSampler()
{
return m_specularSampler;
}
inline const TextureSampler& Material::GetSpecularSampler() const
{
return m_specularSampler;
}
inline BlendFunc Material::GetSrcBlend() const
{
return m_states.srcBlend;
}
inline bool Material::HasAlphaMap() const
{
return m_alphaMap.IsValid();
}
inline bool Material::HasDepthMaterial() const
{
return m_depthMaterial.IsValid();
}
inline bool Material::HasDiffuseMap() const
{
return m_diffuseMap.IsValid();
}
inline bool Material::HasEmissiveMap() const
{
return m_emissiveMap.IsValid();
}
inline bool Material::HasHeightMap() const
{
return m_heightMap.IsValid();
}
inline bool Material::HasNormalMap() const
{
return m_normalMap.IsValid();
}
inline bool Material::HasSpecularMap() const
{
return m_specularMap.IsValid();
}
inline bool Material::IsAlphaTestEnabled() const
{
return m_alphaTestEnabled;
}
inline bool Material::IsDepthSortingEnabled() const
{
return m_depthSortingEnabled;
}
inline bool Material::IsEnabled(RendererParameter parameter) const
{
NazaraAssert(parameter <= RendererParameter_Max, "Renderer parameter out of enum");
return m_states.parameters[parameter];
}
inline bool Material::IsLightingEnabled() const
{
return m_lightingEnabled;
}
inline bool Material::IsShadowCastingEnabled() const
{
return m_shadowCastingEnabled;
}
inline bool Material::IsShadowReceiveEnabled() const
{
return m_shadowReceiveEnabled;
}
inline bool Material::IsTransformEnabled() const
{
return m_transformEnabled;
}
inline bool Material::LoadFromFile(const String& filePath, const MaterialParams& params)
{
return MaterialLoader::LoadFromFile(this, filePath, params);
}
inline bool Material::LoadFromMemory(const void* data, std::size_t size, const MaterialParams& params)
{
return MaterialLoader::LoadFromMemory(this, data, size, params);
}
inline bool Material::LoadFromStream(Stream& stream, const MaterialParams& params)
{
return MaterialLoader::LoadFromStream(this, stream, params);
}
inline bool Material::SetAlphaMap(const String& textureName)
{
TextureRef texture = TextureLibrary::Query(textureName);
if (!texture)
{
texture = TextureManager::Get(textureName);
if (!texture)
return false;
}
SetAlphaMap(std::move(texture));
return true;
}
inline void Material::SetAlphaMap(TextureRef alphaMap)
{
m_alphaMap = std::move(alphaMap);
InvalidateShaders();
}
inline void Material::SetAlphaThreshold(float alphaThreshold)
{
m_alphaThreshold = alphaThreshold;
}
inline void Material::SetAmbientColor(const Color& ambient)
{
m_ambientColor = ambient;
}
inline void Material::SetDepthFunc(RendererComparison depthFunc)
{
m_states.depthFunc = depthFunc;
}
inline void Material::SetDepthMaterial(MaterialRef depthMaterial)
{
m_depthMaterial = std::move(depthMaterial);
}
inline void Material::SetDiffuseColor(const Color& diffuse)
{
m_diffuseColor = diffuse;
}
inline bool Material::SetDiffuseMap(const String& textureName)
{
TextureRef texture = TextureLibrary::Query(textureName);
if (!texture)
{
texture = TextureManager::Get(textureName);
if (!texture)
return false;
}
SetDiffuseMap(std::move(texture));
return true;
}
inline void Material::SetDiffuseMap(TextureRef diffuseMap)
{
m_diffuseMap = std::move(diffuseMap);
InvalidateShaders();
}
inline void Material::SetDiffuseSampler(const TextureSampler& sampler)
{
m_diffuseSampler = sampler;
}
inline void Material::SetDstBlend(BlendFunc func)
{
m_states.dstBlend = func;
}
inline bool Material::SetEmissiveMap(const String& textureName)
{
TextureRef texture = TextureLibrary::Query(textureName);
if (!texture)
{
texture = TextureManager::Get(textureName);
if (!texture)
return false;
}
SetEmissiveMap(std::move(texture));
return true;
}
inline void Material::SetEmissiveMap(TextureRef emissiveMap)
{
m_emissiveMap = std::move(emissiveMap);
InvalidateShaders();
}
inline void Material::SetFaceCulling(FaceSide faceSide)
{
m_states.faceCulling = faceSide;
}
inline void Material::SetFaceFilling(FaceFilling filling)
{
m_states.faceFilling = filling;
}
inline bool Material::SetHeightMap(const String& textureName)
{
TextureRef texture = TextureLibrary::Query(textureName);
if (!texture)
{
texture = TextureManager::Get(textureName);
if (!texture)
return false;
}
SetHeightMap(std::move(texture));
return true;
}
inline void Material::SetHeightMap(TextureRef heightMap)
{
m_heightMap = std::move(heightMap);
InvalidateShaders();
}
inline bool Material::SetNormalMap(const String& textureName)
{
TextureRef texture = TextureLibrary::Query(textureName);
if (!texture)
{
texture = TextureManager::Get(textureName);
if (!texture)
return false;
}
SetNormalMap(std::move(texture));
return true;
}
inline void Material::SetNormalMap(TextureRef normalMap)
{
m_normalMap = std::move(normalMap);
InvalidateShaders();
}
inline void Material::SetRenderStates(const RenderStates& states)
{
m_states = states;
}
inline void Material::SetShader(UberShaderConstRef uberShader)
{
m_uberShader = std::move(uberShader);
InvalidateShaders();
}
inline bool Material::SetShader(const String& uberShaderName)
{
UberShaderConstRef uberShader = UberShaderLibrary::Get(uberShaderName);
if (!uberShader)
return false;
SetShader(std::move(uberShader));
return true;
}
inline void Material::SetShininess(float shininess)
{
m_shininess = shininess;
}
inline void Material::SetSpecularColor(const Color& specular)
{
m_specularColor = specular;
}
inline bool Material::SetSpecularMap(const String& textureName)
{
TextureRef texture = TextureLibrary::Query(textureName);
if (!texture)
{
texture = TextureManager::Get(textureName);
if (!texture)
return false;
}
SetSpecularMap(std::move(texture));
return true;
}
inline void Material::SetSpecularMap(TextureRef specularMap)
{
m_specularMap = std::move(specularMap);
InvalidateShaders();
}
inline void Material::SetSpecularSampler(const TextureSampler& sampler)
{
m_specularSampler = sampler;
}
inline void Material::SetSrcBlend(BlendFunc func)
{
m_states.srcBlend = func;
}
inline Material& Material::operator=(const Material& material)
{
Resource::operator=(material);
Copy(material);
return *this;
}
inline MaterialRef Material::GetDefault()
{
return s_defaultMaterial;
}
inline void Material::InvalidateShaders()
{
for (ShaderInstance& instance : m_shaders)
instance.uberInstance = nullptr;
}
template<typename... Args>
MaterialRef Material::New(Args&&... args)
{

22
include/Nazara/Math/Sphere.inl
View File

@@ -132,7 +132,7 @@ namespace Nz
}
/*!
* \brief Returns the distance from the center of the sphere to the point
* \brief Returns the distance from the sphere to the point (is negative when the point is inside the sphere)
* \return Distance to the point
*
* \param X X position of the point
@@ -145,12 +145,11 @@ namespace Nz
template<typename T>
T Sphere<T>::Distance(T X, T Y, T Z) const
{
Vector3<T> distance(X-x, Y-y, Z-z);
return distance.GetLength();
return Distance({X, Y, Z});
}
/*!
* \brief Returns the distance from the center of the sphere to the point
* \brief Returns the distance from the sphere to the point (is negative when the point is inside the sphere)
* \return Distance to the point
*
* \param point Position of the point
@@ -161,7 +160,7 @@ namespace Nz
template<typename T>
T Sphere<T>::Distance(const Vector3<T>& point) const
{
return Distance(point.x, point.y, point.z);
return Vector3f::Distance(point, GetPosition()) - radius;
}
/*!
@@ -305,7 +304,7 @@ namespace Nz
template<typename T>
bool Sphere<T>::Intersect(const Sphere& sphere) const
{
return SquaredDistance(sphere.x, sphere.y, sphere.z) - radius * radius <= sphere.radius * sphere.radius;
return SquaredDistance(sphere.x, sphere.y, sphere.z) <= sphere.radius * sphere.radius;
}
/*!
@@ -460,7 +459,7 @@ namespace Nz
}
/*!
* \brief Returns the squared distance from the center of the sphere to the point
* \brief Returns the squared distance from the sphere to the point (can be negative if the point is inside the sphere)
* \return Squared distance to the point
*
* \param X X position of the point
@@ -469,27 +468,24 @@ namespace Nz
*
* \see Distance
*/
template<typename T>
T Sphere<T>::SquaredDistance(T X, T Y, T Z) const
{
Vector3<T> distance(X - x, Y - y, Z - z);
return distance.GetSquaredLength();
return SquaredDistance({X, Y, Z});
}
/*!
* \brief Returns the squared distance from the center of the sphere to the point
* \brief Returns the squared distance from the sphere to the point (can be negative if the point is inside the sphere)
* \return Squared distance to the point
*
* \param point Position of the point
*
* \see Distance
*/
template<typename T>
T Sphere<T>::SquaredDistance(const Vector3<T>& point) const
{
return SquaredDistance(point.x, point.y, point.z);
return Vector3f::Distance(point, GetPosition()) - radius * radius;
}
/*!

3
include/Nazara/Math/Vector3.hpp
View File

@@ -105,12 +105,15 @@ namespace Nz
static Vector3 Backward();
static Vector3 CrossProduct(const Vector3& vec1, const Vector3& vec2);
static T DotProduct(const Vector3& vec1, const Vector3& vec2);
static T Distance(const Vector3& vec1, const Vector3& vec2);
static float Distancef(const Vector3& vec1, const Vector3& vec2);
static Vector3 Down();
static Vector3 Forward();
static Vector3 Left();
static Vector3 Lerp(const Vector3& from, const Vector3& to, T interpolation);
static Vector3 Normalize(const Vector3& vec);
static Vector3 Right();
static T SquaredDistance(const Vector3& vec1, const Vector3& vec2);
static Vector3 Unit();
static Vector3 UnitX();
static Vector3 UnitY();

49
include/Nazara/Math/Vector3.inl
View File

@@ -1011,6 +1011,40 @@ namespace Nz
return vector;
}
/*!
* \brief Measure the distance between two points
* Shorthand for vec1.Distance(vec2)
*
* param vec1 the first point
* param vec2 the second point
*
* \return The distance between the two vectors
*
* \see SquaredDistance
*/
template<typename T>
T Vector3<T>::Distance(const Vector3& vec1, const Vector3& vec2)
{
return vec1.Distance(vec2);
}
/*!
* \brief Measure the distance between two points as a float
* Shorthand for vec1.Distancef(vec2)
*
* param vec1 the first point
* param vec2 the second point
*
* \return The distance between the two vectors as a float
*
* \see SquaredDistancef
*/
template<typename T>
float Vector3<T>::Distancef(const Vector3& vec1, const Vector3& vec2)
{
return vec1.Distancef(vec2);
}
/*!
* \brief Shorthand for the vector (0, -1, 0)
* \return A vector with components (0, -1, 0)
@@ -1110,6 +1144,21 @@ namespace Nz
return vector;
}
/*!
* \brief Calculates the squared distance between two vectors
* \return The metric distance between two vectors with the squared euclidean norm
*
* \param vec1 The first point to measure the distance with
* \param vec2 The second point to measure the distance with
*
* \see Distance
*/
template<typename T>
T Vector3<T>::SquaredDistance(const Vector3& vec1, const Vector3& vec2)
{
return vec1.SquaredDistance(vec2);
}
/*!
* \brief Shorthand for the vector (1, 1, 1)
* \return A vector with components (1, 1, 1)

1
include/Nazara/Renderer/OpenGL.hpp
View File

@@ -319,6 +319,7 @@ NAZARA_RENDERER_API extern PFNGLUNIFORMMATRIX4DVPROC glUniformMatrix4dv;
NAZARA_RENDERER_API extern PFNGLUNIFORMMATRIX4FVPROC glUniformMatrix4fv;
NAZARA_RENDERER_API extern PFNGLUNMAPBUFFERPROC glUnmapBuffer;
NAZARA_RENDERER_API extern PFNGLUSEPROGRAMPROC glUseProgram;
NAZARA_RENDERER_API extern PFNGLVALIDATEPROGRAMPROC glValidateProgram;
NAZARA_RENDERER_API extern PFNGLVERTEXATTRIB4FPROC glVertexAttrib4f;
NAZARA_RENDERER_API extern PFNGLVERTEXATTRIBDIVISORPROC glVertexAttribDivisor;
NAZARA_RENDERER_API extern PFNGLVERTEXATTRIBPOINTERPROC glVertexAttribPointer;

2
include/Nazara/Renderer/Shader.hpp
View File

@@ -98,6 +98,8 @@ namespace Nz
void SendVectorArray(int location, const Vector4f* vectors, unsigned int count) const;
void SendVectorArray(int location, const Vector4i* vectors, unsigned int count) const;
bool Validate() const;
// Fonctions OpenGL
unsigned int GetOpenGLID() const;

20
include/Nazara/Utility/Image.inl.save-failed Normal file
View File

@@ -0,0 +1,20 @@
// Copyright (C) 2015 Jérôme Leclercq
// This file is part of the "Nazara Engine - Utility module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <memory>
#include <Nazara/Utility/Debug.hpp>
namespace Nz
{
template<typename... Args>
ImageRef Image::New(Args&&... args)
{
std::unique_ptr<Image> object(new Image(std::forward<Args>(args)...));
object->SetPersistent(false);
return object.release();
}
}
#include <Nazara/Utility/DebugOff.hpp>