Mirrors/overte-AleziaKurdis
3
0
Fork 0
mirror of https://github.com/AleziaKurdis/overte.git synced 2025-08-08 06:06:49 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

fix everything

Browse source
This commit is contained in:
SamGondelman 2018-09-12 14:28:39 -07:00
parent 1a36693161
commit 2b2091290e
3 changed files with 44 additions and 37 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
libraries/fbx/src/FBX.h
View file

@ -240,7 +240,6 @@ public:
QVector<glm::vec3> vertices; QVector<glm::vec3> vertices;
QVector<glm::vec3> normals; QVector<glm::vec3> normals;
QVector<glm::vec3> tangents; QVector<glm::vec3> tangents;
mutable QVector<NormalType> normalsAndTangents; // Populated later if needed for blendshapes
QVector<glm::vec3> colors; QVector<glm::vec3> colors;
QVector<glm::vec2> texCoords; QVector<glm::vec2> texCoords;
QVector<glm::vec2> texCoords1; QVector<glm::vec2> texCoords1;

72
libraries/render-utils/src/Model.cpp
View file

@ -317,6 +317,7 @@ bool Model::updateGeometry() {
needFullUpdate = true; needFullUpdate = true;
emit rigReady(); emit rigReady();
} }
return needFullUpdate; return needFullUpdate;
} }
@ -1033,6 +1034,10 @@ void Model::removeFromScene(const render::ScenePointer& scene, render::Transacti
_modelMeshMaterialNames.clear(); _modelMeshMaterialNames.clear();
_modelMeshRenderItemShapes.clear(); _modelMeshRenderItemShapes.clear();
_blendedVertexBuffers.clear();
_normalsAndTangents.clear();
_blendedVertexBuffersInitialized = false;
_addedToScene = false; _addedToScene = false;
_renderInfoVertexCount = 0; _renderInfoVertexCount = 0;
@ -1299,25 +1304,26 @@ Blender::Blender(ModelPointer model, int blendNumber, const Geometry::WeakPointe
} }
void Blender::run() { void Blender::run() {
DETAILED_PROFILE_RANGE_EX(simulation_animation, __FUNCTION__, 0xFFFF0000, 0, { { "url", _model->getURL().toString() } });
QVector<glm::vec3> vertices; QVector<glm::vec3> vertices;
QVector<NormalType> normalsAndTangents; QVector<NormalType> normalsAndTangents;
auto geometry = _geometry.lock(); if (_model && _model->isLoaded()) {
if (_model && geometry) { DETAILED_PROFILE_RANGE_EX(simulation_animation, __FUNCTION__, 0xFFFF0000, 0, { { "url", _model->getURL().toString() } });
int offset = 0; int offset = 0;
int normalsAndTangentsOffset = 0; int normalsAndTangentsOffset = 0;
auto meshes = geometry->getFBXGeometry().meshes; auto meshes = _model->getFBXGeometry().meshes;
int meshIndex = 0;
foreach (const FBXMesh& mesh, meshes) { foreach (const FBXMesh& mesh, meshes) {
if (mesh.blendshapes.isEmpty()) { auto modelMeshNormalsAndTangents = _model->_normalsAndTangents.find(meshIndex++);
if (mesh.blendshapes.isEmpty() || modelMeshNormalsAndTangents == _model->_normalsAndTangents.end()) {
continue; continue;
} }
vertices += mesh.vertices; vertices += mesh.vertices;
normalsAndTangents += mesh.normalsAndTangents; normalsAndTangents += modelMeshNormalsAndTangents->second;
glm::vec3* meshVertices = vertices.data() + offset; glm::vec3* meshVertices = vertices.data() + offset;
NormalType* meshNormalsAndTangents = normalsAndTangents.data() + normalsAndTangentsOffset; NormalType* meshNormalsAndTangents = normalsAndTangents.data() + normalsAndTangentsOffset;
offset += mesh.vertices.size(); offset += mesh.vertices.size();
normalsAndTangentsOffset += mesh.normalsAndTangents.size(); normalsAndTangentsOffset += modelMeshNormalsAndTangents->second.size();
const float NORMAL_COEFFICIENT_SCALE = 0.01f; const float NORMAL_COEFFICIENT_SCALE = 0.01f;
for (int i = 0, n = qMin(_blendshapeCoefficients.size(), mesh.blendshapes.size()); i < n; i++) { for (int i = 0, n = qMin(_blendshapeCoefficients.size(), mesh.blendshapes.size()); i < n; i++) {
float vertexCoefficient = _blendshapeCoefficients.at(i); float vertexCoefficient = _blendshapeCoefficients.at(i);
@ -1357,9 +1363,8 @@ void Blender::run() {
} }
// post the result to the ModelBlender, which will dispatch to the model if still alive // post the result to the ModelBlender, which will dispatch to the model if still alive
QMetaObject::invokeMethod(DependencyManager::get<ModelBlender>().data(), "setBlendedVertices", QMetaObject::invokeMethod(DependencyManager::get<ModelBlender>().data(), "setBlendedVertices",
Q_ARG(ModelPointer, _model), Q_ARG(int, _blendNumber), Q_ARG(ModelPointer, _model), Q_ARG(int, _blendNumber), Q_ARG(QVector<glm::vec3>, vertices),
Q_ARG(const Geometry::WeakPointer&, _geometry), Q_ARG(const QVector<glm::vec3>&, vertices), Q_ARG(QVector<NormalType>, normalsAndTangents));
Q_ARG(const QVector<NormalType>&, normalsAndTangents));
} }
void Model::setScaleToFit(bool scaleToFit, const glm::vec3& dimensions, bool forceRescale) { void Model::setScaleToFit(bool scaleToFit, const glm::vec3& dimensions, bool forceRescale) {
@ -1537,19 +1542,18 @@ bool Model::maybeStartBlender() {
return false; return false;
} }
void Model::setBlendedVertices(int blendNumber, const Geometry::WeakPointer& geometry, void Model::setBlendedVertices(int blendNumber, const QVector<glm::vec3>& vertices, const QVector<NormalType>& normalsAndTangents) {
const QVector<glm::vec3>& vertices, const QVector<NormalType>& normalsAndTangents) { if (!isLoaded() || blendNumber < _appliedBlendNumber || !_blendedVertexBuffersInitialized) {
auto geometryRef = geometry.lock();
if (!geometryRef || _renderGeometry != geometryRef || blendNumber < _appliedBlendNumber || !_blendedVertexBuffersInitialized) {
return; return;
} }
_appliedBlendNumber = blendNumber; _appliedBlendNumber = blendNumber;
const FBXGeometry& fbxGeometry = geometryRef->getFBXGeometry(); const FBXGeometry& fbxGeometry = getFBXGeometry();
int index = 0; int index = 0;
int normalAndTangentIndex = 0; int normalAndTangentIndex = 0;
for (int i = 0; i < fbxGeometry.meshes.size(); i++) { for (int i = 0; i < fbxGeometry.meshes.size(); i++) {
const FBXMesh& mesh = fbxGeometry.meshes.at(i); const FBXMesh& mesh = fbxGeometry.meshes.at(i);
if (mesh.blendshapes.isEmpty()) { auto meshNormalsAndTangents = _normalsAndTangents.find(i);
if (mesh.blendshapes.isEmpty() || meshNormalsAndTangents == _normalsAndTangents.end()) {
continue; continue;
} }
@ -1557,18 +1561,19 @@ void Model::setBlendedVertices(int blendNumber, const Geometry::WeakPointer& geo
const auto verticesSize = vertexCount * sizeof(glm::vec3); const auto verticesSize = vertexCount * sizeof(glm::vec3);
const auto& buffer = _blendedVertexBuffers.find(i); const auto& buffer = _blendedVertexBuffers.find(i);
assert(buffer != _blendedVertexBuffers.end()); assert(buffer != _blendedVertexBuffers.end());
buffer->second->resize(mesh.vertices.size() * sizeof(glm::vec3) + mesh.normalsAndTangents.size() * sizeof(NormalType)); buffer->second->resize(mesh.vertices.size() * sizeof(glm::vec3) + meshNormalsAndTangents->second.size() * sizeof(NormalType));
buffer->second->setSubData(0, verticesSize, (gpu::Byte*) vertices.constData() + index * sizeof(glm::vec3)); buffer->second->setSubData(0, verticesSize, (gpu::Byte*) vertices.constData() + index * sizeof(glm::vec3));
buffer->second->setSubData(verticesSize, mesh.normalsAndTangents.size() * sizeof(NormalType), (const gpu::Byte*) normalsAndTangents.data() + normalAndTangentIndex * sizeof(NormalType)); buffer->second->setSubData(verticesSize, meshNormalsAndTangents->second.size() * sizeof(NormalType), (const gpu::Byte*) normalsAndTangents.data() + normalAndTangentIndex * sizeof(NormalType));
index += vertexCount; index += vertexCount;
normalAndTangentIndex += mesh.normalsAndTangents.size(); normalAndTangentIndex += meshNormalsAndTangents->second.size();
} }
} }
void Model::deleteGeometry() { void Model::deleteGeometry() {
_deleteGeometryCounter++; _deleteGeometryCounter++;
_blendedVertexBuffers.clear(); _blendedVertexBuffers.clear();
_normalsAndTangents.clear();
_blendedVertexBuffersInitialized = false; _blendedVertexBuffersInitialized = false;
_meshStates.clear(); _meshStates.clear();
_rig.destroyAnimGraph(); _rig.destroyAnimGraph();
@ -1634,7 +1639,7 @@ void Model::initializeBlendshapes(const FBXMesh& mesh, int index) {
_blendedVertexBuffers[index]->resize(mesh.vertices.size() * sizeof(glm::vec3) + normalsAndTangents.size() * sizeof(NormalType)); _blendedVertexBuffers[index]->resize(mesh.vertices.size() * sizeof(glm::vec3) + normalsAndTangents.size() * sizeof(NormalType));
_blendedVertexBuffers[index]->setSubData(0, verticesSize, (const gpu::Byte*) mesh.vertices.constData()); _blendedVertexBuffers[index]->setSubData(0, verticesSize, (const gpu::Byte*) mesh.vertices.constData());
_blendedVertexBuffers[index]->setSubData(verticesSize, normalsAndTangents.size() * sizeof(NormalType), (const gpu::Byte*) normalsAndTangents.data()); _blendedVertexBuffers[index]->setSubData(verticesSize, normalsAndTangents.size() * sizeof(NormalType), (const gpu::Byte*) normalsAndTangents.data());
mesh.normalsAndTangents = normalsAndTangents; _normalsAndTangents[index] = normalsAndTangents;
} }
void Model::createRenderItemSet() { void Model::createRenderItemSet() {
@ -1778,35 +1783,38 @@ ModelBlender::~ModelBlender() {
} }
void ModelBlender::noteRequiresBlend(ModelPointer model) { void ModelBlender::noteRequiresBlend(ModelPointer model) {
Lock lock(_mutex);
if (_pendingBlenders < QThread::idealThreadCount()) { if (_pendingBlenders < QThread::idealThreadCount()) {
if (model->maybeStartBlender()) { if (model->maybeStartBlender()) {
_pendingBlenders++; _pendingBlenders++;
return;
} }
return;
} }
{ _modelsRequiringBlends.insert(model);
Lock lock(_mutex);
_modelsRequiringBlends.insert(model);
}
} }
void ModelBlender::setBlendedVertices(ModelPointer model, int blendNumber, const Geometry::WeakPointer& geometry, void ModelBlender::setBlendedVertices(ModelPointer model, int blendNumber, QVector<glm::vec3> vertices, QVector<NormalType> normalsAndTangents) {
const QVector<glm::vec3>& vertices, const QVector<NormalType>& normalsAndTangents) {
if (model) { if (model) {
model->setBlendedVertices(blendNumber, geometry, vertices, normalsAndTangents); model->setBlendedVertices(blendNumber, vertices, normalsAndTangents);
} }
_pendingBlenders--;
{ {
Lock lock(_mutex); Lock lock(_mutex);
for (auto i = _modelsRequiringBlends.begin(); i != _modelsRequiringBlends.end();) { _pendingBlenders--;
_modelsRequiringBlends.erase(model);
std::set<ModelWeakPointer, std::owner_less<ModelWeakPointer>> modelsToErase;
for (auto i = _modelsRequiringBlends.begin(); i != _modelsRequiringBlends.end(); i++) {
auto weakPtr = *i; auto weakPtr = *i;
_modelsRequiringBlends.erase(i++); // remove front of the set
ModelPointer nextModel = weakPtr.lock(); ModelPointer nextModel = weakPtr.lock();
if (nextModel && nextModel->maybeStartBlender()) { if (nextModel && nextModel->maybeStartBlender()) {
_pendingBlenders++; _pendingBlenders++;
return; break;
} else {
modelsToErase.insert(weakPtr);
} }
} }
for (auto& weakPtr : modelsToErase) {
_modelsRequiringBlends.erase(weakPtr);
}
} }
} }

8
libraries/render-utils/src/Model.h
View file

@ -144,8 +144,7 @@ public:
bool maybeStartBlender(); bool maybeStartBlender();
/// Sets blended vertices computed in a separate thread. /// Sets blended vertices computed in a separate thread.
void setBlendedVertices(int blendNumber, const Geometry::WeakPointer& geometry, void setBlendedVertices(int blendNumber, const QVector<glm::vec3>& vertices, const QVector<NormalType>& normalsAndTangents);
const QVector<glm::vec3>& vertices, const QVector<NormalType>& normalsAndTangents);
bool isLoaded() const { return (bool)_renderGeometry && _renderGeometry->isGeometryLoaded(); } bool isLoaded() const { return (bool)_renderGeometry && _renderGeometry->isGeometryLoaded(); }
bool isAddedToScene() const { return _addedToScene; } bool isAddedToScene() const { return _addedToScene; }
@ -345,6 +344,8 @@ public:
void addMaterial(graphics::MaterialLayer material, const std::string& parentMaterialName); void addMaterial(graphics::MaterialLayer material, const std::string& parentMaterialName);
void removeMaterial(graphics::MaterialPointer material, const std::string& parentMaterialName); void removeMaterial(graphics::MaterialPointer material, const std::string& parentMaterialName);
std::unordered_map<int, QVector<NormalType>> _normalsAndTangents;
public slots: public slots:
void loadURLFinished(bool success); void loadURLFinished(bool success);
@ -519,8 +520,7 @@ public:
bool shouldComputeBlendshapes() { return _computeBlendshapes; } bool shouldComputeBlendshapes() { return _computeBlendshapes; }
public slots: public slots:
void setBlendedVertices(ModelPointer model, int blendNumber, const Geometry::WeakPointer& geometry, void setBlendedVertices(ModelPointer model, int blendNumber, QVector<glm::vec3> vertices, QVector<NormalType> normalsAndTangents);
const QVector<glm::vec3>& vertices, const QVector<NormalType>& normalsAndTangents);
void setComputeBlendshapes(bool computeBlendshapes) { _computeBlendshapes = computeBlendshapes; } void setComputeBlendshapes(bool computeBlendshapes) { _computeBlendshapes = computeBlendshapes; }
private: private: