diff --git a/include/Nazara/Graphics/SkinningManager.hpp b/include/Nazara/Graphics/SkinningManager.hpp new file mode 100644 index 000000000..5b015c066 --- /dev/null +++ b/include/Nazara/Graphics/SkinningManager.hpp @@ -0,0 +1,36 @@ +// Copyright (C) 2014 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_SKINNINGMANAGER_HPP +#define NAZARA_SKINNINGMANAGER_HPP + +#include + +class NzSkeleton; +class NzSkeletalMesh; +class NzVertexBuffer; + +class NAZARA_API NzSkinningManager +{ + friend class NzGraphics; + + public: + using SkinFunction = void (*)(const NzSkeletalMesh* mesh, const NzSkeleton* skeleton, NzVertexBuffer* buffer); + + NzSkinningManager() = delete; + ~NzSkinningManager() = delete; + + static NzVertexBuffer* GetBuffer(const NzSkeletalMesh* mesh, const NzSkeleton* skeleton); + static void Skin(); + + private: + static bool Initialize(); + static void Uninitialize(); + + static SkinFunction s_skinFunc; +}; + +#endif // NAZARA_SKINNINGMANAGER_HPP diff --git a/include/Nazara/Utility/Algorithm.hpp b/include/Nazara/Utility/Algorithm.hpp index da9326cff..d168cbe94 100644 --- a/include/Nazara/Utility/Algorithm.hpp +++ b/include/Nazara/Utility/Algorithm.hpp @@ -14,6 +14,16 @@ #include #include #include +#include + +struct NzSkinningData +{ + const NzJoint* joints; + const NzMeshVertex* inputVertex; + NzMeshVertex* outputVertex; + const NzVertexWeight* vertexWeights; + const NzWeight* weights; +}; NAZARA_API void NzComputeBoxIndexVertexCount(const NzVector3ui& subdivision, unsigned int* indexCount, unsigned int* vertexCount); NAZARA_API unsigned int NzComputeCacheMissCount(NzIndexIterator indices, unsigned int indexCount); @@ -33,6 +43,10 @@ NAZARA_API void NzGenerateUvSphere(float size, unsigned int sliceCount, unsigned NAZARA_API void NzOptimizeIndices(NzIndexIterator indices, unsigned int indexCount); +NAZARA_API void NzSkinPosition(const NzSkinningData& data, unsigned int startVertex, unsigned int vertexCount); +NAZARA_API void NzSkinPositionNormal(const NzSkinningData& data, unsigned int startVertex, unsigned int vertexCount); +NAZARA_API void NzSkinPositionNormalTangent(const NzSkinningData& data, unsigned int startVertex, unsigned int vertexCount); + template void NzTransformVertices(T* vertices, unsigned int vertexCount, const NzMatrix4f& matrix); #include diff --git a/include/Nazara/Utility/Joint.hpp b/include/Nazara/Utility/Joint.hpp index 6740d1e52..64f48f034 100644 --- a/include/Nazara/Utility/Joint.hpp +++ b/include/Nazara/Utility/Joint.hpp @@ -21,18 +21,26 @@ class NAZARA_API NzJoint : public NzNode NzJoint(const NzJoint& joint); ~NzJoint() = default; - NzMatrix4f GetInverseBindMatrix() const; + void EnsureSkinningMatrixUpdate() const; + + const NzMatrix4f& GetInverseBindMatrix() const; NzString GetName() const; NzSkeleton* GetSkeleton(); const NzSkeleton* GetSkeleton() const; + const NzMatrix4f& GetSkinningMatrix() const; void SetInverseBindMatrix(const NzMatrix4f& matrix); void SetName(const NzString& name); private: + void InvalidateNode(); + void UpdateSkinningMatrix() const; + NzMatrix4f m_inverseBindMatrix; + mutable NzMatrix4f m_skinningMatrix; NzString m_name; NzSkeleton* m_skeleton; + mutable bool m_skinningMatrixUpdated; }; #endif // NAZARA_JOINT_HPP diff --git a/include/Nazara/Utility/SkeletalMesh.hpp b/include/Nazara/Utility/SkeletalMesh.hpp index 1237d6db9..c8c60a19c 100644 --- a/include/Nazara/Utility/SkeletalMesh.hpp +++ b/include/Nazara/Utility/SkeletalMesh.hpp @@ -55,9 +55,6 @@ class NAZARA_API NzSkeletalMesh final : public NzSubMesh bool IsAnimated() const final; bool IsValid() const; - void Skin(NzMeshVertex* outputBuffer) const; - void Skin(NzMeshVertex* outputBuffer, const NzSkeleton* skeleton) const; - void SetIndexBuffer(const NzIndexBuffer* indexBuffer); private: diff --git a/src/Nazara/Graphics/Graphics.cpp b/src/Nazara/Graphics/Graphics.cpp index 333162fb1..cc23fa2a6 100644 --- a/src/Nazara/Graphics/Graphics.cpp +++ b/src/Nazara/Graphics/Graphics.cpp @@ -11,6 +11,7 @@ #include #include #include +#include #include #include #include @@ -39,7 +40,13 @@ bool NzGraphics::Initialize() if (!NzMaterial::Initialize()) { - NazaraError("Failed to create material"); + NazaraError("Failed to initialize materials"); + return false; + } + + if (!NzSkinningManager::Initialize()) + { + NazaraError("Failed to initialize skinning cache"); return false; } @@ -89,9 +96,9 @@ void NzGraphics::Uninitialize() NzLoaders_OBJ_Unregister(); NzLoaders_Texture_Unregister(); - NzMaterial::Uninitialize(); - NzDeferredRenderTechnique::Uninitialize(); + NzMaterial::Uninitialize(); + NzSkinningManager::Uninitialize(); NazaraNotice("Uninitialized: Graphics module"); diff --git a/src/Nazara/Graphics/Scene.cpp b/src/Nazara/Graphics/Scene.cpp index 8c01521d1..2c9f286a8 100644 --- a/src/Nazara/Graphics/Scene.cpp +++ b/src/Nazara/Graphics/Scene.cpp @@ -10,6 +10,7 @@ #include #include #include +#include #include #include #include @@ -33,7 +34,7 @@ struct NzSceneImpl NzSceneRoot root; NzAbstractViewer* viewer = nullptr; bool backgroundEnabled = true; - bool update; + bool update = false; float frameTime; float updateTime; int renderTechniqueRanking; @@ -99,8 +100,18 @@ void NzScene::Draw() catch (const std::exception& e) { NzString oldName = m_impl->renderTechnique->GetName(); - m_impl->renderTechnique.reset(NzRenderTechniques::GetByRanking(m_impl->renderTechniqueRanking-1, &m_impl->renderTechniqueRanking)); - NazaraError("Render technique \"" + oldName + "\" failed, switched to \"" + m_impl->renderTechnique->GetName() + '"'); + + if (m_impl->renderTechniqueRanking > 0) + { + m_impl->renderTechnique.reset(NzRenderTechniques::GetByRanking(m_impl->renderTechniqueRanking-1, &m_impl->renderTechniqueRanking)); + NazaraError("Render technique \"" + oldName + "\" failed, fallback to \"" + m_impl->renderTechnique->GetName() + '"'); + } + else + { + NzErrorFlags errFlags(nzErrorFlag_ThrowException); + NazaraError("Render technique \"" + oldName + "\" failed and no fallback is available"); + } + return; } } @@ -230,6 +241,8 @@ void NzScene::Update() void NzScene::UpdateVisible() { + NzSkinningManager::Skin(); + if (m_impl->update) { for (NzUpdatable* node : m_impl->visibleUpdateList) diff --git a/src/Nazara/Graphics/SkinningManager.cpp b/src/Nazara/Graphics/SkinningManager.cpp new file mode 100644 index 000000000..9a756ea03 --- /dev/null +++ b/src/Nazara/Graphics/SkinningManager.cpp @@ -0,0 +1,237 @@ +// Copyright (C) 2014 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace +{ + enum ResourceType + { + ResourceType_SkeletalMesh, + ResourceType_Skeleton, + }; + + struct BufferData + { + NzVertexBufferRef buffer; + bool updated; + }; + + struct SkinningData + { + const NzSkeletalMesh* mesh; + const NzSkeleton* skeleton; + NzVertexBuffer* buffer; + }; + + using MeshMap = std::unordered_map; + using SkeletonMap = std::unordered_map; + SkeletonMap s_cache; + std::vector s_skinningQueue; + + class ResourceListener : public NzResourceListener + { + public: + bool OnResourceDestroy(const NzResource* resource, int index) + { + switch (index) + { + case ResourceType_SkeletalMesh: + { + for (auto& pair : s_cache) + { + MeshMap& meshMap = pair.second; + meshMap.erase(static_cast(resource)); + } + break; + } + + case ResourceType_Skeleton: + s_cache.erase(static_cast(resource)); + break; + } + + return false; + } + + bool OnResourceModified(const NzResource* resource, int index, unsigned int code) + { + NazaraUnused(code); + + switch (index) + { + case ResourceType_SkeletalMesh: + { + for (auto& pair : s_cache) + { + MeshMap& meshMap = pair.second; + for (auto& pair2 : meshMap) + pair2.second.updated = false; + } + break; + } + + case ResourceType_Skeleton: + { + for (auto& pair : s_cache.at(static_cast(resource))) + pair.second.updated = false; + break; + } + } + + return true; + } + + void OnResourceReleased(const NzResource* resource, int index) + { + OnResourceDestroy(resource, index); + } + }; + + ResourceListener listener; + + void Skin_MonoCPU(const NzSkeletalMesh* mesh, const NzSkeleton* skeleton, NzVertexBuffer* buffer) + { + NzBufferMapper mapper(buffer, nzBufferAccess_DiscardAndWrite); + + NzSkinningData skinningData; + skinningData.inputVertex = mesh->GetBindPoseBuffer(); + skinningData.outputVertex = static_cast(mapper.GetPointer()); + skinningData.joints = skeleton->GetJoints(); + skinningData.vertexWeights = mesh->GetVertexWeight(0); + skinningData.weights = mesh->GetWeight(0); + + NzSkinPositionNormalTangent(skinningData, 0, mesh->GetVertexCount()); + } + + void Skin_MultiCPU(const NzSkeletalMesh* mesh, const NzSkeleton* skeleton, NzVertexBuffer* buffer) + { + NzBufferMapper mapper(buffer, nzBufferAccess_DiscardAndWrite); + + NzSkinningData skinningData; + skinningData.inputVertex = mesh->GetBindPoseBuffer(); + skinningData.outputVertex = static_cast(mapper.GetPointer()); + skinningData.joints = skeleton->GetJoints(); + skinningData.vertexWeights = mesh->GetVertexWeight(0); + skinningData.weights = mesh->GetWeight(0); + + // Afin d'empêcher les différents threads de vouloir mettre à jour la même matrice en même temps, + // on se charge de la mettre à jour avant de les lancer + unsigned int jointCount = skeleton->GetJointCount(); + for (unsigned int i = 0; i < jointCount; ++i) + skinningData.joints[i].EnsureSkinningMatrixUpdate(); + + unsigned int workerCount = NzTaskScheduler::GetWorkerCount(); + + std::ldiv_t div = std::ldiv(mesh->GetVertexCount(), workerCount); + for (unsigned int i = 0; i < workerCount; ++i) + NzTaskScheduler::AddTask(NzSkinPositionNormalTangent, skinningData, i*div.quot, (i == workerCount-1) ? div.quot + div.rem : div.quot); + + NzTaskScheduler::Run(); + NzTaskScheduler::WaitForTasks(); + } +} + +NzVertexBuffer* NzSkinningManager::GetBuffer(const NzSkeletalMesh* mesh, const NzSkeleton* skeleton) +{ + #if NAZARA_GRAPHICS_SAFE + if (!mesh) + { + NazaraError("Invalid mesh"); + return nullptr; + } + + if (!skeleton) + { + NazaraError("Invalid skeleton"); + return nullptr; + } + #endif + + NzErrorFlags flags(nzErrorFlag_ThrowException); + + SkeletonMap::iterator it = s_cache.find(skeleton); + if (it == s_cache.end()) + { + it = s_cache.insert(std::make_pair(skeleton, SkeletonMap::mapped_type())).first; + skeleton->AddResourceListener(&listener, ResourceType_Skeleton); + } + + NzVertexBuffer* buffer; + + MeshMap& meshMap = it->second; + MeshMap::iterator it2 = meshMap.find(mesh); + if (it2 == meshMap.end()) + { + std::unique_ptr vertexBuffer(new NzVertexBuffer); + vertexBuffer->SetPersistent(false); + vertexBuffer->Reset(NzVertexDeclaration::Get(nzVertexLayout_XYZ_Normal_UV_Tangent), mesh->GetVertexCount(), nzBufferStorage_Hardware, nzBufferUsage_Dynamic); + + BufferData data({vertexBuffer.get(), true}); + meshMap.insert(std::make_pair(mesh, data)); + + mesh->AddResourceListener(&listener, ResourceType_SkeletalMesh); + + s_skinningQueue.push_back(SkinningData{mesh, skeleton, vertexBuffer.get()}); + + buffer = vertexBuffer.release(); + } + else + { + BufferData& data = it2->second; + if (!data.updated) + { + s_skinningQueue.push_back(SkinningData{mesh, skeleton, data.buffer}); + data.updated = true; + } + + buffer = data.buffer; + } + + return buffer; +} + +void NzSkinningManager::Skin() +{ + for (SkinningData& data : s_skinningQueue) + s_skinFunc(data.mesh, data.skeleton, data.buffer); + + s_skinningQueue.clear(); +} + +bool NzSkinningManager::Initialize() +{ + ///TODO: GPU Skinning + if (NzTaskScheduler::Initialize()) + s_skinFunc = Skin_MultiCPU; + else + s_skinFunc = Skin_MonoCPU; + + return true; // Rien de particulier à faire +} + +void NzSkinningManager::Uninitialize() +{ + for (auto& pair : s_cache) + { + pair.first->RemoveResourceListener(&listener); + MeshMap& meshMap = pair.second; + for (auto& pair2 : meshMap) + pair2.first->RemoveResourceListener(&listener); + } + s_cache.clear(); + s_skinningQueue.clear(); +} + +NzSkinningManager::SkinFunction NzSkinningManager::s_skinFunc = nullptr; diff --git a/src/Nazara/Renderer/Win32/ContextImpl.cpp b/src/Nazara/Renderer/Win32/ContextImpl.cpp index ee78e81a6..1ae61bd3e 100644 --- a/src/Nazara/Renderer/Win32/ContextImpl.cpp +++ b/src/Nazara/Renderer/Win32/ContextImpl.cpp @@ -5,6 +5,7 @@ // Code inspiré de NeHe (Lesson1) et de la SFML par Laurent Gomila #include +#include #include #include #include @@ -42,11 +43,16 @@ bool NzContextImpl::Create(NzContextParameters& parameters) m_ownsWindow = true; } + // En cas d'exception, la ressource sera quand même libérée + NzCallOnExit onExit([this] () + { + Destroy(); + }); + m_deviceContext = GetDC(m_window); if (!m_deviceContext) { NazaraError("Failed to get device context"); - Destroy(); return false; } @@ -116,8 +122,6 @@ bool NzContextImpl::Create(NzContextParameters& parameters) if (pixelFormat == 0) { NazaraError("Failed to choose pixel format"); - Destroy(); - return false; } } @@ -125,7 +129,6 @@ bool NzContextImpl::Create(NzContextParameters& parameters) if (!SetPixelFormat(m_deviceContext, pixelFormat, &descriptor)) { NazaraError("Failed to set pixel format"); - Destroy(); return false; } @@ -191,10 +194,11 @@ bool NzContextImpl::Create(NzContextParameters& parameters) if (!m_context) { NazaraError("Failed to create context"); - Destroy(); return false; } + onExit.Reset(); + return true; } diff --git a/src/Nazara/Utility/Algorithm.cpp b/src/Nazara/Utility/Algorithm.cpp index e7559a3b9..d1f203977 100644 --- a/src/Nazara/Utility/Algorithm.cpp +++ b/src/Nazara/Utility/Algorithm.cpp @@ -818,7 +818,7 @@ void NzGenerateCone(float length, float radius, unsigned int subdivision, const NzVector3f lExtend = NzVector3f::Left()*radius; NzVector3f fExtend = NzVector3f::Forward()*radius; - // Et on ajoute ensuite les quatres extrémités de la pyramide + // Et on ajoute ensuite les quatres extrémités de la pyramide aabb->ExtendTo(base + lExtend + fExtend); aabb->ExtendTo(base + lExtend - fExtend); aabb->ExtendTo(base - lExtend + fExtend); @@ -961,7 +961,7 @@ void NzGenerateUvSphere(float size, unsigned int sliceCount, unsigned int stackC } } -/************************************Autres***********************************/ +/************************************NzOptimize***********************************/ void NzOptimizeIndices(NzIndexIterator indices, unsigned int indexCount) { @@ -969,3 +969,106 @@ void NzOptimizeIndices(NzIndexIterator indices, unsigned int indexCount) if (optimizer.Optimize(indices, indexCount) != VertexCacheOptimizer::Success) NazaraWarning("Indices optimizer failed"); } + +/************************************NzSkin***********************************/ + +void NzSkinPosition(const NzSkinningData& data, unsigned int startVertex, unsigned int vertexCount) +{ + const NzMeshVertex* inputVertex = &data.inputVertex[startVertex]; + NzMeshVertex* outputVertex = &data.outputVertex[startVertex]; + + unsigned int endVertex = startVertex + vertexCount - 1; + for (unsigned int i = startVertex; i <= endVertex; ++i) + { + NzVector3f finalPosition(NzVector3f::Zero()); + + unsigned int weightCount = data.vertexWeights[i].weights.size(); + for (unsigned int j = 0; j < weightCount; ++j) + { + const NzWeight& weight = data.weights[data.vertexWeights[i].weights[j]]; + + NzMatrix4f mat(data.joints[weight.jointIndex].GetSkinningMatrix()); + mat *= weight.weight; + + finalPosition += mat.Transform(inputVertex->position); + } + + outputVertex->position = finalPosition; + outputVertex->uv = inputVertex->uv; + + inputVertex++; + outputVertex++; + } +} + +void NzSkinPositionNormal(const NzSkinningData& skinningInfos, unsigned int startVertex, unsigned int vertexCount) +{ + const NzMeshVertex* inputVertex = &skinningInfos.inputVertex[startVertex]; + NzMeshVertex* outputVertex = &skinningInfos.outputVertex[startVertex]; + + unsigned int endVertex = startVertex + vertexCount - 1; + for (unsigned int i = startVertex; i <= endVertex; ++i) + { + NzVector3f finalPosition(NzVector3f::Zero()); + NzVector3f finalNormal(NzVector3f::Zero()); + + unsigned int weightCount = skinningInfos.vertexWeights[i].weights.size(); + for (unsigned int j = 0; j < weightCount; ++j) + { + const NzWeight& weight = skinningInfos.weights[skinningInfos.vertexWeights[i].weights[j]]; + + NzMatrix4f mat(skinningInfos.joints[weight.jointIndex].GetSkinningMatrix()); + mat *= weight.weight; + + finalPosition += mat.Transform(inputVertex->position); + finalNormal += mat.Transform(inputVertex->normal, 0.f); + } + + finalNormal.Normalize(); + + outputVertex->normal = finalNormal; + outputVertex->position = finalPosition; + outputVertex->uv = inputVertex->uv; + + inputVertex++; + outputVertex++; + } +} + +void NzSkinPositionNormalTangent(const NzSkinningData& skinningInfos, unsigned int startVertex, unsigned int vertexCount) +{ + const NzMeshVertex* inputVertex = &skinningInfos.inputVertex[startVertex]; + NzMeshVertex* outputVertex = &skinningInfos.outputVertex[startVertex]; + + unsigned int endVertex = startVertex + vertexCount - 1; + for (unsigned int i = startVertex; i <= endVertex; ++i) + { + NzVector3f finalPosition(NzVector3f::Zero()); + NzVector3f finalNormal(NzVector3f::Zero()); + NzVector3f finalTangent(NzVector3f::Zero()); + + unsigned int weightCount = skinningInfos.vertexWeights[i].weights.size(); + for (unsigned int j = 0; j < weightCount; ++j) + { + const NzWeight& weight = skinningInfos.weights[skinningInfos.vertexWeights[i].weights[j]]; + + NzMatrix4f mat(skinningInfos.joints[weight.jointIndex].GetSkinningMatrix()); + mat *= weight.weight; + + finalPosition += mat.Transform(inputVertex->position); + finalNormal += mat.Transform(inputVertex->normal, 0.f); + finalTangent += mat.Transform(inputVertex->tangent, 0.f); + } + + finalNormal.Normalize(); + finalTangent.Normalize(); + + outputVertex->normal = finalNormal; + outputVertex->position = finalPosition; + outputVertex->tangent = finalTangent; + outputVertex->uv = inputVertex->uv; + + inputVertex++; + outputVertex++; + } +} diff --git a/src/Nazara/Utility/Joint.cpp b/src/Nazara/Utility/Joint.cpp index 060b5eb52..8a46ff227 100644 --- a/src/Nazara/Utility/Joint.cpp +++ b/src/Nazara/Utility/Joint.cpp @@ -7,7 +7,8 @@ #include NzJoint::NzJoint(NzSkeleton* skeleton) : -m_skeleton(skeleton) +m_skeleton(skeleton), +m_skinningMatrixUpdated(false) { } @@ -15,11 +16,18 @@ NzJoint::NzJoint(const NzJoint& joint) : NzNode(joint), m_inverseBindMatrix(joint.m_inverseBindMatrix), m_name(joint.m_name), -m_skeleton(joint.m_skeleton) +m_skeleton(joint.m_skeleton), +m_skinningMatrixUpdated(false) { } -NzMatrix4f NzJoint::GetInverseBindMatrix() const +void NzJoint::EnsureSkinningMatrixUpdate() const +{ + if (!m_skinningMatrixUpdated) + UpdateSkinningMatrix(); +} + +const NzMatrix4f& NzJoint::GetInverseBindMatrix() const { return m_inverseBindMatrix; } @@ -39,9 +47,18 @@ const NzSkeleton* NzJoint::GetSkeleton() const return m_skeleton; } +const NzMatrix4f& NzJoint::GetSkinningMatrix() const +{ + if (!m_skinningMatrixUpdated) + UpdateSkinningMatrix(); + + return m_skinningMatrix; +} + void NzJoint::SetInverseBindMatrix(const NzMatrix4f& matrix) { m_inverseBindMatrix = matrix; + m_skinningMatrixUpdated = false; } void NzJoint::SetName(const NzString& name) @@ -50,3 +67,20 @@ void NzJoint::SetName(const NzString& name) m_skeleton->InvalidateJointMap(); } + +void NzJoint::InvalidateNode() +{ + NzNode::InvalidateNode(); + + m_skinningMatrixUpdated = false; +} + +void NzJoint::UpdateSkinningMatrix() const +{ + if (!m_transformMatrixUpdated) + UpdateTransformMatrix(); + + m_skinningMatrix.Set(m_inverseBindMatrix); + m_skinningMatrix.ConcatenateAffine(m_transformMatrix); + m_skinningMatrixUpdated = true; +} diff --git a/src/Nazara/Utility/SkeletalMesh.cpp b/src/Nazara/Utility/SkeletalMesh.cpp index 735f30b33..314d0a46a 100644 --- a/src/Nazara/Utility/SkeletalMesh.cpp +++ b/src/Nazara/Utility/SkeletalMesh.cpp @@ -2,135 +2,13 @@ // This file is part of the "Nazara Engine - Utility module" // For conditions of distribution and use, see copyright notice in Config.hpp -#include - #include -#include -#include #include #include -#include -#include #include #include #include -namespace -{ - struct SkinningInfos - { - const NzJoint* joints; - const NzMeshVertex* inputVertex; - NzMeshVertex* outputVertex; - const NzVertexWeight* vertexWeights; - const NzWeight* weights; - }; - - void Skin_Position(const SkinningInfos& skinningInfos, unsigned int startVertex, unsigned int vertexCount) - { - const NzMeshVertex* inputVertex = &skinningInfos.inputVertex[startVertex]; - NzMeshVertex* outputVertex = &skinningInfos.outputVertex[startVertex]; - - unsigned int endVertex = startVertex + vertexCount - 1; - for (unsigned int i = startVertex; i <= endVertex; ++i) - { - NzVector3f finalPosition(NzVector3f::Zero()); - - unsigned int weightCount = skinningInfos.vertexWeights[i].weights.size(); - for (unsigned int j = 0; j < weightCount; ++j) - { - const NzWeight& weight = skinningInfos.weights[skinningInfos.vertexWeights[i].weights[j]]; - - NzMatrix4f mat(skinningInfos.joints[weight.jointIndex].GetInverseBindMatrix()); - mat.ConcatenateAffine(skinningInfos.joints[weight.jointIndex].GetTransformMatrix()); - mat *= weight.weight; - - finalPosition += mat.Transform(inputVertex->position); - } - - outputVertex->position = finalPosition; - outputVertex->uv = inputVertex->uv; - - inputVertex++; - outputVertex++; - } - } - - void Skin_PositionNormal(const SkinningInfos& skinningInfos, unsigned int startVertex, unsigned int vertexCount) - { - const NzMeshVertex* inputVertex = &skinningInfos.inputVertex[startVertex]; - NzMeshVertex* outputVertex = &skinningInfos.outputVertex[startVertex]; - - unsigned int endVertex = startVertex + vertexCount - 1; - for (unsigned int i = startVertex; i <= endVertex; ++i) - { - NzVector3f finalPosition(NzVector3f::Zero()); - NzVector3f finalNormal(NzVector3f::Zero()); - - unsigned int weightCount = skinningInfos.vertexWeights[i].weights.size(); - for (unsigned int j = 0; j < weightCount; ++j) - { - const NzWeight& weight = skinningInfos.weights[skinningInfos.vertexWeights[i].weights[j]]; - - NzMatrix4f mat(skinningInfos.joints[weight.jointIndex].GetInverseBindMatrix()); - mat.ConcatenateAffine(skinningInfos.joints[weight.jointIndex].GetTransformMatrix()); - mat *= weight.weight; - - finalPosition += mat.Transform(inputVertex->position); - finalNormal += mat.Transform(inputVertex->normal, 0.f); - } - - finalNormal.Normalize(); - - outputVertex->normal = finalNormal; - outputVertex->position = finalPosition; - outputVertex->uv = inputVertex->uv; - - inputVertex++; - outputVertex++; - } - } - - void Skin_PositionNormalTangent(const SkinningInfos& skinningInfos, unsigned int startVertex, unsigned int vertexCount) - { - const NzMeshVertex* inputVertex = &skinningInfos.inputVertex[startVertex]; - NzMeshVertex* outputVertex = &skinningInfos.outputVertex[startVertex]; - - unsigned int endVertex = startVertex + vertexCount - 1; - for (unsigned int i = startVertex; i <= endVertex; ++i) - { - NzVector3f finalPosition(NzVector3f::Zero()); - NzVector3f finalNormal(NzVector3f::Zero()); - NzVector3f finalTangent(NzVector3f::Zero()); - - unsigned int weightCount = skinningInfos.vertexWeights[i].weights.size(); - for (unsigned int j = 0; j < weightCount; ++j) - { - const NzWeight& weight = skinningInfos.weights[skinningInfos.vertexWeights[i].weights[j]]; - - NzMatrix4f mat(skinningInfos.joints[weight.jointIndex].GetInverseBindMatrix()); - mat.ConcatenateAffine(skinningInfos.joints[weight.jointIndex].GetTransformMatrix()); - mat *= weight.weight; - - finalPosition += mat.Transform(inputVertex->position); - finalNormal += mat.Transform(inputVertex->normal, 0.f); - finalTangent += mat.Transform(inputVertex->tangent, 0.f); - } - - finalNormal.Normalize(); - finalTangent.Normalize(); - - outputVertex->normal = finalNormal; - outputVertex->position = finalPosition; - outputVertex->tangent = finalTangent; - outputVertex->uv = inputVertex->uv; - - inputVertex++; - outputVertex++; - } - } -} - struct NzSkeletalMeshImpl { std::unique_ptr bindPoseBuffer; @@ -336,56 +214,6 @@ bool NzSkeletalMesh::IsValid() const return m_impl != nullptr; } -void NzSkeletalMesh::Skin(NzMeshVertex* outputBuffer) const -{ - #if NAZARA_UTILITY_SAFE - if (!m_impl) - { - NazaraError("Skeletal mesh not created"); - return; - } - #endif - - Skin(outputBuffer, m_parent->GetSkeleton()); -} - -void NzSkeletalMesh::Skin(NzMeshVertex* outputBuffer, const NzSkeleton* skeleton) const -{ - #if NAZARA_UTILITY_SAFE - if (!m_impl) - { - NazaraError("Skeletal mesh not created"); - return; - } - #endif - - SkinningInfos skinningInfos; - skinningInfos.inputVertex = m_impl->bindPoseBuffer.get(); - skinningInfos.outputVertex = outputBuffer; - skinningInfos.joints = skeleton->GetJoints(); - skinningInfos.vertexWeights = &m_impl->vertexWeights[0]; - skinningInfos.weights = &m_impl->weights[0]; - - #if NAZARA_UTILITY_MULTITHREADED_SKINNING - unsigned int jointCount = skeleton->GetJointCount(); - for (unsigned int i = 0; i < jointCount; ++i) - skinningInfos.joints[i].EnsureTransformMatrixUpdate(); - - unsigned int workerCount = NzTaskScheduler::GetWorkerCount(); - - std::ldiv_t div = std::ldiv(m_impl->vertexCount, workerCount); // Qui sait, peut-être que ça permet des optimisations plus efficaces - for (unsigned int i = 0; i < workerCount; ++i) - NzTaskScheduler::AddTask(Skin_PositionNormalTangent, skinningInfos, i*div.quot, (i == workerCount-1) ? div.quot + div.rem : div.quot); - - NzTaskScheduler::Run(); - NzTaskScheduler::WaitForTasks(); - #else - Skin_PositionNormalTangent(skinningInfos, 0, m_impl->vertexCount); - #endif - - m_impl->aabb = skeleton->GetAABB(); ///FIXME: Qu'est-ce que ça fait encore là ça ? -} - void NzSkeletalMesh::SetIndexBuffer(const NzIndexBuffer* indexBuffer) { m_impl->indexBuffer = indexBuffer; diff --git a/src/Nazara/Utility/Win32/WindowImpl.cpp b/src/Nazara/Utility/Win32/WindowImpl.cpp index 2fd43ee54..43cf89fb2 100644 --- a/src/Nazara/Utility/Win32/WindowImpl.cpp +++ b/src/Nazara/Utility/Win32/WindowImpl.cpp @@ -36,6 +36,30 @@ namespace { + LPTSTR windowsCursors[] = + { + IDC_CROSS, // nzWindowCursor_Crosshair + IDC_ARROW, // nzWindowCursor_Default + IDC_HAND, // nzWindowCursor_Hand + IDC_HAND, // nzWindowCursor_Pointer + IDC_HELP, // nzWindowCursor_Help + IDC_SIZEALL, // nzWindowCursor_Move + nullptr, // nzWindowCursor_None + IDC_APPSTARTING, // nzWindowCursor_Progress + IDC_SIZENS, // nzWindowCursor_ResizeN + IDC_SIZENS, // nzWindowCursor_ResizeS + IDC_SIZENWSE, // nzWindowCursor_ResizeNW + IDC_SIZENWSE, // nzWindowCursor_ResizeSE + IDC_SIZENESW, // nzWindowCursor_ResizeNE + IDC_SIZENESW, // nzWindowCursor_ResizeSW + IDC_SIZEWE, // nzWindowCursor_ResizeE + IDC_SIZEWE, // nzWindowCursor_ResizeW + IDC_IBEAM, // nzWindowCursor_Text + IDC_WAIT // nzWindowCursor_Wait + }; + + static_assert(sizeof(windowsCursors)/sizeof(LPTSTR) == nzWindowCursor_Max+1, "Cursor type array is incomplete"); + const wchar_t* className = L"Nazara Window"; NzWindowImpl* fullscreenWindow = nullptr; } @@ -307,65 +331,18 @@ void NzWindowImpl::ProcessEvents(bool block) void NzWindowImpl::SetCursor(nzWindowCursor cursor) { - switch (cursor) + #ifdef NAZARA_DEBUG + if (cursor > nzWindowCursor_Max) { - case nzWindowCursor_Crosshair: - m_cursor = reinterpret_cast(LoadImage(nullptr, IDC_CROSS, IMAGE_CURSOR, 0, 0, LR_SHARED)); - break; - - case nzWindowCursor_Default: - m_cursor = reinterpret_cast(LoadImage(nullptr, IDC_ARROW, IMAGE_CURSOR, 0, 0, LR_SHARED)); - break; - - case nzWindowCursor_Hand: - case nzWindowCursor_Pointer: - m_cursor = reinterpret_cast(LoadImage(nullptr, IDC_HAND, IMAGE_CURSOR, 0, 0, LR_SHARED)); - break; - - case nzWindowCursor_Help: - m_cursor = reinterpret_cast(LoadImage(nullptr, IDC_HELP, IMAGE_CURSOR, 0, 0, LR_SHARED)); - break; - - case nzWindowCursor_Move: - m_cursor = reinterpret_cast(LoadImage(nullptr, IDC_SIZEALL, IMAGE_CURSOR, 0, 0, LR_SHARED)); - break; - - case nzWindowCursor_None: - m_cursor = nullptr; - break; - - case nzWindowCursor_Progress: - m_cursor = reinterpret_cast(LoadImage(nullptr, IDC_APPSTARTING, IMAGE_CURSOR, 0, 0, LR_SHARED)); - break; - - case nzWindowCursor_ResizeN: - case nzWindowCursor_ResizeS: - m_cursor = reinterpret_cast(LoadImage(nullptr, IDC_SIZENS, IMAGE_CURSOR, 0, 0, LR_SHARED)); - break; - - case nzWindowCursor_ResizeNW: - case nzWindowCursor_ResizeSE: - m_cursor = reinterpret_cast(LoadImage(nullptr, IDC_SIZENWSE, IMAGE_CURSOR, 0, 0, LR_SHARED)); - break; - - case nzWindowCursor_ResizeNE: - case nzWindowCursor_ResizeSW: - m_cursor = reinterpret_cast(LoadImage(nullptr, IDC_SIZENESW, IMAGE_CURSOR, 0, 0, LR_SHARED)); - break; - - case nzWindowCursor_ResizeE: - case nzWindowCursor_ResizeW: - m_cursor = reinterpret_cast(LoadImage(nullptr, IDC_SIZEWE, IMAGE_CURSOR, 0, 0, LR_SHARED)); - break; - - case nzWindowCursor_Text: - m_cursor = reinterpret_cast(LoadImage(nullptr, IDC_IBEAM, IMAGE_CURSOR, 0, 0, LR_SHARED)); - break; - - case nzWindowCursor_Wait: - m_cursor = reinterpret_cast(LoadImage(nullptr, IDC_WAIT, IMAGE_CURSOR, 0, 0, LR_SHARED)); - break; + NazaraError("Window cursor out of enum"); + return false; } + #endif + + if (cursor != nzWindowCursor_None) + m_cursor = reinterpret_cast(LoadImage(nullptr, windowsCursors[cursor], IMAGE_CURSOR, 0, 0, LR_SHARED)); + else + m_cursor = nullptr; // Pas besoin de libérer le curseur par la suite s'il est partagé // http://msdn.microsoft.com/en-us/library/windows/desktop/ms648045(v=vs.85).aspx