From 6ea4b660b747745bde7c3466c3721713f6ee99c7 Mon Sep 17 00:00:00 2001 From: humbletim Date: Fri, 23 Feb 2018 07:47:39 -0500 Subject: [PATCH] CR feedback; remove ok bool pointer and all metadata; cleanup --- interface/src/ui/overlays/Base3DOverlay.h | 2 +- interface/src/ui/overlays/ModelOverlay.cpp | 8 +- interface/src/ui/overlays/ModelOverlay.h | 2 +- interface/src/ui/overlays/Shape3DOverlay.cpp | 7 +- interface/src/ui/overlays/Shape3DOverlay.h | 2 +- .../src/avatars-renderer/Avatar.cpp | 17 +- .../src/avatars-renderer/Avatar.h | 2 +- .../src/RenderableEntityItem.h | 2 +- .../src/RenderableModelEntityItem.cpp | 8 +- .../src/RenderableModelEntityItem.h | 2 +- .../src/RenderablePolyLineEntityItem.cpp | 4 +- .../src/RenderablePolyLineEntityItem.h | 2 +- .../src/RenderablePolyVoxEntityItem.cpp | 7 +- .../src/RenderablePolyVoxEntityItem.h | 6 +- .../src/RenderableShapeEntityItem.cpp | 11 +- .../src/RenderableShapeEntityItem.h | 2 +- .../src/graphics-scripting/Forward.h | 26 +-- .../GraphicsScriptingInterface.cpp | 174 +++++++++++------- .../GraphicsScriptingInterface.h | 22 ++- .../GraphicsScriptingUtil.h | 22 +-- .../src/graphics-scripting/ScriptableMesh.cpp | 149 ++++++--------- .../src/graphics-scripting/ScriptableMesh.h | 68 ++----- .../graphics-scripting/ScriptableModel.cpp | 41 ++--- .../src/graphics-scripting/ScriptableModel.h | 15 +- .../src/graphics/BufferViewHelpers.cpp | 42 +---- libraries/render-utils/src/Model.cpp | 53 +++--- libraries/render-utils/src/Model.h | 2 +- .../src/Model_temporary_hack.cpp.h | 46 +---- tools/jsdoc/package-lock.json | 138 -------------- 29 files changed, 307 insertions(+), 575 deletions(-) delete mode 100644 tools/jsdoc/package-lock.json diff --git a/interface/src/ui/overlays/Base3DOverlay.h b/interface/src/ui/overlays/Base3DOverlay.h index 25bacf2e7e..bbf064fddd 100644 --- a/interface/src/ui/overlays/Base3DOverlay.h +++ b/interface/src/ui/overlays/Base3DOverlay.h @@ -36,7 +36,7 @@ public: virtual bool is3D() const override { return true; } virtual uint32_t fetchMetaSubItems(render::ItemIDs& subItems) const override { subItems.push_back(getRenderItemID()); return (uint32_t) subItems.size(); } - virtual scriptable::ScriptableModelBase getScriptableModel(bool* ok = nullptr) override { return scriptable::ModelProvider::modelUnavailableError(ok); } + virtual scriptable::ScriptableModelBase getScriptableModel() override { return scriptable::ScriptableModelBase(); } // TODO: consider implementing registration points in this class glm::vec3 getCenter() const { return getWorldPosition(); } diff --git a/interface/src/ui/overlays/ModelOverlay.cpp b/interface/src/ui/overlays/ModelOverlay.cpp index 4ff5499a12..ffcc18032c 100644 --- a/interface/src/ui/overlays/ModelOverlay.cpp +++ b/interface/src/ui/overlays/ModelOverlay.cpp @@ -665,11 +665,11 @@ void ModelOverlay::processMaterials() { } } -scriptable::ScriptableModelBase ModelOverlay::getScriptableModel(bool* ok) { +scriptable::ScriptableModelBase ModelOverlay::getScriptableModel() { if (!_model || !_model->isLoaded()) { - return Base3DOverlay::getScriptableModel(ok); + return Base3DOverlay::getScriptableModel(); } - auto result = _model->getScriptableModel(ok); + auto result = _model->getScriptableModel(); result.objectID = getID(); return result; -} \ No newline at end of file +} diff --git a/interface/src/ui/overlays/ModelOverlay.h b/interface/src/ui/overlays/ModelOverlay.h index 60b970425d..fa399d40f9 100644 --- a/interface/src/ui/overlays/ModelOverlay.h +++ b/interface/src/ui/overlays/ModelOverlay.h @@ -62,7 +62,7 @@ public: void addMaterial(graphics::MaterialLayer material, const std::string& parentMaterialName) override; void removeMaterial(graphics::MaterialPointer material, const std::string& parentMaterialName) override; - virtual scriptable::ScriptableModelBase getScriptableModel(bool* ok = nullptr) override; + virtual scriptable::ScriptableModelBase getScriptableModel() override; protected: Transform evalRenderTransform() override; diff --git a/interface/src/ui/overlays/Shape3DOverlay.cpp b/interface/src/ui/overlays/Shape3DOverlay.cpp index 04557bcf5d..8f7f8b70d9 100644 --- a/interface/src/ui/overlays/Shape3DOverlay.cpp +++ b/interface/src/ui/overlays/Shape3DOverlay.cpp @@ -180,14 +180,13 @@ Transform Shape3DOverlay::evalRenderTransform() { return transform; } -scriptable::ScriptableModelBase Shape3DOverlay::getScriptableModel(bool* ok) { +scriptable::ScriptableModelBase Shape3DOverlay::getScriptableModel() { auto geometryCache = DependencyManager::get(); auto vertexColor = ColorUtils::toVec3(_color); scriptable::ScriptableModelBase result; result.objectID = getID(); - result.append(geometryCache->meshFromShape(_shape, vertexColor), {{ "shape", shapeStrings[_shape] }}); - if (ok) { - *ok = true; + if (auto mesh = geometryCache->meshFromShape(_shape, vertexColor)) { + result.append(mesh); } return result; } diff --git a/interface/src/ui/overlays/Shape3DOverlay.h b/interface/src/ui/overlays/Shape3DOverlay.h index f5246d95ac..447ee47e13 100644 --- a/interface/src/ui/overlays/Shape3DOverlay.h +++ b/interface/src/ui/overlays/Shape3DOverlay.h @@ -37,7 +37,7 @@ public: void setProperties(const QVariantMap& properties) override; QVariant getProperty(const QString& property) override; - virtual scriptable::ScriptableModelBase getScriptableModel(bool* ok = nullptr) override; + virtual scriptable::ScriptableModelBase getScriptableModel() override; protected: Transform evalRenderTransform() override; diff --git a/libraries/avatars-renderer/src/avatars-renderer/Avatar.cpp b/libraries/avatars-renderer/src/avatars-renderer/Avatar.cpp index 48f0c70dfa..25ddfba670 100644 --- a/libraries/avatars-renderer/src/avatars-renderer/Avatar.cpp +++ b/libraries/avatars-renderer/src/avatars-renderer/Avatar.cpp @@ -1795,22 +1795,11 @@ void Avatar::processMaterials() { } } -scriptable::ScriptableModelBase Avatar::getScriptableModel(bool* ok) { +scriptable::ScriptableModelBase Avatar::getScriptableModel() { if (!_skeletonModel || !_skeletonModel->isLoaded()) { - return scriptable::ModelProvider::modelUnavailableError(ok); + return scriptable::ScriptableModelBase(); } - scriptable::ScriptableModelBase result = _skeletonModel->getScriptableModel(ok); + auto result = _skeletonModel->getScriptableModel(); result.objectID = getSessionUUID(); - result.mixin({{ "textures", _skeletonModel->getTextures() }}); - // FIXME: for now access to attachment models are merged into the main avatar ScriptableModel set - for (int i = 0; i < (int)_attachmentModels.size(); i++) { - auto& model = _attachmentModels.at(i); - if (model->isLoaded()) { - result.append(model->getScriptableModel(ok), _attachmentData.at(i).toVariant().toMap()); - } - } - if (ok) { - *ok = true; - } return result; } \ No newline at end of file diff --git a/libraries/avatars-renderer/src/avatars-renderer/Avatar.h b/libraries/avatars-renderer/src/avatars-renderer/Avatar.h index 3b3917ad4d..bf0adc5c05 100644 --- a/libraries/avatars-renderer/src/avatars-renderer/Avatar.h +++ b/libraries/avatars-renderer/src/avatars-renderer/Avatar.h @@ -276,7 +276,7 @@ public: void addMaterial(graphics::MaterialLayer material, const std::string& parentMaterialName) override; void removeMaterial(graphics::MaterialPointer material, const std::string& parentMaterialName) override; - virtual scriptable::ScriptableModelBase getScriptableModel(bool* ok = nullptr) override; + virtual scriptable::ScriptableModelBase getScriptableModel() override; public slots: diff --git a/libraries/entities-renderer/src/RenderableEntityItem.h b/libraries/entities-renderer/src/RenderableEntityItem.h index 5526927c13..d34a1127ae 100644 --- a/libraries/entities-renderer/src/RenderableEntityItem.h +++ b/libraries/entities-renderer/src/RenderableEntityItem.h @@ -58,7 +58,7 @@ public: virtual void addMaterial(graphics::MaterialLayer material, const std::string& parentMaterialName); virtual void removeMaterial(graphics::MaterialPointer material, const std::string& parentMaterialName); - virtual scriptable::ScriptableModelBase getScriptableModel(bool* ok = nullptr) override { return scriptable::ModelProvider::modelUnavailableError(ok); } + virtual scriptable::ScriptableModelBase getScriptableModel() override { return scriptable::ScriptableModelBase(); } protected: virtual bool needsRenderUpdateFromEntity() const final { return needsRenderUpdateFromEntity(_entity); } diff --git a/libraries/entities-renderer/src/RenderableModelEntityItem.cpp b/libraries/entities-renderer/src/RenderableModelEntityItem.cpp index 6eed62522f..f3c99cde2d 100644 --- a/libraries/entities-renderer/src/RenderableModelEntityItem.cpp +++ b/libraries/entities-renderer/src/RenderableModelEntityItem.cpp @@ -960,15 +960,15 @@ bool RenderableModelEntityItem::getMeshes(MeshProxyList& result) { return !result.isEmpty(); } -scriptable::ScriptableModelBase render::entities::ModelEntityRenderer::getScriptableModel(bool* ok) { +scriptable::ScriptableModelBase render::entities::ModelEntityRenderer::getScriptableModel() { ModelPointer model; withReadLock([&] { model = _model; }); if (!model || !model->isLoaded()) { - return scriptable::ModelProvider::modelUnavailableError(ok); + return scriptable::ScriptableModelBase(); } - auto result = _model->getScriptableModel(ok); + auto result = _model->getScriptableModel(); result.objectID = getEntity()->getID(); return result; } @@ -981,7 +981,7 @@ bool render::entities::ModelEntityRenderer::replaceScriptableModelMeshPart(scrip return false; } - return model->replaceScriptableModelMeshPart(newModel, meshIndex, partIndex); + return model->replaceScriptableModelMeshPart(newModel, meshIndex, partIndex); } void RenderableModelEntityItem::simulateRelayedJoints() { diff --git a/libraries/entities-renderer/src/RenderableModelEntityItem.h b/libraries/entities-renderer/src/RenderableModelEntityItem.h index dc73add823..7edaef264d 100644 --- a/libraries/entities-renderer/src/RenderableModelEntityItem.h +++ b/libraries/entities-renderer/src/RenderableModelEntityItem.h @@ -142,7 +142,7 @@ class ModelEntityRenderer : public TypedEntityRenderer PolyLineEntityRenderer::updateVertic return vertices; } -scriptable::ScriptableModelBase PolyLineEntityRenderer::getScriptableModel(bool *ok) { +scriptable::ScriptableModelBase PolyLineEntityRenderer::getScriptableModel() { // TODO: adapt polyline into a triangles mesh... - return EntityRenderer::getScriptableModel(ok); + return EntityRenderer::getScriptableModel(); } void PolyLineEntityRenderer::doRender(RenderArgs* args) { diff --git a/libraries/entities-renderer/src/RenderablePolyLineEntityItem.h b/libraries/entities-renderer/src/RenderablePolyLineEntityItem.h index d9d770e64f..f460baac59 100644 --- a/libraries/entities-renderer/src/RenderablePolyLineEntityItem.h +++ b/libraries/entities-renderer/src/RenderablePolyLineEntityItem.h @@ -25,7 +25,7 @@ class PolyLineEntityRenderer : public TypedEntityRenderer { public: PolyLineEntityRenderer(const EntityItemPointer& entity); - virtual scriptable::ScriptableModelBase getScriptableModel(bool* ok = nullptr) override; + virtual scriptable::ScriptableModelBase getScriptableModel() override; protected: virtual bool needsRenderUpdateFromTypedEntity(const TypedEntityPointer& entity) const override; virtual void doRenderUpdateSynchronousTyped(const ScenePointer& scene, diff --git a/libraries/entities-renderer/src/RenderablePolyVoxEntityItem.cpp b/libraries/entities-renderer/src/RenderablePolyVoxEntityItem.cpp index 37e03b2590..2b1de8d11b 100644 --- a/libraries/entities-renderer/src/RenderablePolyVoxEntityItem.cpp +++ b/libraries/entities-renderer/src/RenderablePolyVoxEntityItem.cpp @@ -1451,9 +1451,9 @@ bool RenderablePolyVoxEntityItem::getMeshes(MeshProxyList& result) { return success; } -scriptable::ScriptableModelBase RenderablePolyVoxEntityItem::getScriptableModel(bool * ok) { +scriptable::ScriptableModelBase RenderablePolyVoxEntityItem::getScriptableModel() { if (!updateDependents() || !_mesh) { - return scriptable::ModelProvider::modelUnavailableError(ok); + return scriptable::ScriptableModelBase(); } bool success = false; @@ -1479,9 +1479,6 @@ scriptable::ScriptableModelBase RenderablePolyVoxEntityItem::getScriptableModel( )); } }); - if (ok) { - *ok = success; - } return result; } diff --git a/libraries/entities-renderer/src/RenderablePolyVoxEntityItem.h b/libraries/entities-renderer/src/RenderablePolyVoxEntityItem.h index 295a4066ba..0a00d1cb73 100644 --- a/libraries/entities-renderer/src/RenderablePolyVoxEntityItem.h +++ b/libraries/entities-renderer/src/RenderablePolyVoxEntityItem.h @@ -114,7 +114,7 @@ public: void setVolDataDirty() { withWriteLock([&] { _volDataDirty = true; _meshReady = false; }); } bool getMeshes(MeshProxyList& result) override; // deprecated - virtual scriptable::ScriptableModelBase getScriptableModel(bool* ok = nullptr) override; + virtual scriptable::ScriptableModelBase getScriptableModel() override; private: bool updateOnCount(const ivec3& v, uint8_t toValue); @@ -164,8 +164,8 @@ class PolyVoxEntityRenderer : public TypedEntityRenderer()->getScriptableModel(ok); + virtual scriptable::ScriptableModelBase getScriptableModel() override { + return asTypedEntity()->getScriptableModel(); } protected: diff --git a/libraries/entities-renderer/src/RenderableShapeEntityItem.cpp b/libraries/entities-renderer/src/RenderableShapeEntityItem.cpp index 2e65eba5e5..22cd98b08a 100644 --- a/libraries/entities-renderer/src/RenderableShapeEntityItem.cpp +++ b/libraries/entities-renderer/src/RenderableShapeEntityItem.cpp @@ -164,22 +164,17 @@ void ShapeEntityRenderer::doRender(RenderArgs* args) { args->_details._trianglesRendered += (int)triCount; } -scriptable::ScriptableModelBase ShapeEntityRenderer::getScriptableModel(bool* ok) { +scriptable::ScriptableModelBase ShapeEntityRenderer::getScriptableModel() { scriptable::ScriptableModelBase result; - result.objectID = getEntity()->getID(); auto geometryCache = DependencyManager::get(); auto geometryShape = geometryCache->getShapeForEntityShape(_shape); glm::vec3 vertexColor; if (_materials["0"].top().material) { vertexColor = _materials["0"].top().material->getAlbedo(); } - auto success = false; if (auto mesh = geometryCache->meshFromShape(geometryShape, vertexColor)) { - result.append({ mesh, {{ "shape", entity::stringFromShape(_shape) }}}); - success = true; - } - if (ok) { - *ok = success; + result.objectID = getEntity()->getID(); + result.append(mesh); } return result; } diff --git a/libraries/entities-renderer/src/RenderableShapeEntityItem.h b/libraries/entities-renderer/src/RenderableShapeEntityItem.h index bd6c77d81d..de855ce0c6 100644 --- a/libraries/entities-renderer/src/RenderableShapeEntityItem.h +++ b/libraries/entities-renderer/src/RenderableShapeEntityItem.h @@ -22,7 +22,7 @@ class ShapeEntityRenderer : public TypedEntityRenderer { public: ShapeEntityRenderer(const EntityItemPointer& entity); - virtual scriptable::ScriptableModelBase getScriptableModel(bool* ok = nullptr) override; + virtual scriptable::ScriptableModelBase getScriptableModel() override; private: virtual bool needsRenderUpdate() const override; diff --git a/libraries/graphics-scripting/src/graphics-scripting/Forward.h b/libraries/graphics-scripting/src/graphics-scripting/Forward.h index 7b2126cf8f..94a96446a0 100644 --- a/libraries/graphics-scripting/src/graphics-scripting/Forward.h +++ b/libraries/graphics-scripting/src/graphics-scripting/Forward.h @@ -36,16 +36,14 @@ namespace scriptable { public: WeakModelProviderPointer provider; ScriptableModelBasePointer model; - WeakMeshPointer mesh; - MeshPointer ownedMesh; - QVariantMap metadata; - ScriptableMeshBase(WeakModelProviderPointer provider, ScriptableModelBasePointer model, WeakMeshPointer mesh, const QVariantMap& metadata); - ScriptableMeshBase(WeakMeshPointer mesh = WeakMeshPointer()); - ScriptableMeshBase(MeshPointer mesh, const QVariantMap& metadata); - ScriptableMeshBase(const ScriptableMeshBase& other) : QObject() { *this = other; } + WeakMeshPointer weakMesh; + MeshPointer strongMesh; + ScriptableMeshBase(WeakModelProviderPointer provider, ScriptableModelBasePointer model, WeakMeshPointer weakMesh, QObject* parent); + ScriptableMeshBase(WeakMeshPointer weakMesh = WeakMeshPointer(), QObject* parent = nullptr); + ScriptableMeshBase(const ScriptableMeshBase& other, QObject* parent = nullptr) : QObject(parent) { *this = other; } ScriptableMeshBase& operator=(const ScriptableMeshBase& view); virtual ~ScriptableMeshBase(); - Q_INVOKABLE const scriptable::MeshPointer getMeshPointer() const { return mesh.lock(); } + Q_INVOKABLE const scriptable::MeshPointer getMeshPointer() const { return weakMesh.lock(); } Q_INVOKABLE const scriptable::ModelProviderPointer getModelProviderPointer() const { return provider.lock(); } Q_INVOKABLE const scriptable::ScriptableModelBasePointer getModelBasePointer() const { return model; } }; @@ -56,18 +54,15 @@ namespace scriptable { public: WeakModelProviderPointer provider; QUuid objectID; // spatially nestable ID - QVariantMap metadata; QVector meshes; ScriptableModelBase(QObject* parent = nullptr) : QObject(parent) {} - ScriptableModelBase(const ScriptableModelBase& other) : QObject() { *this = other; } + ScriptableModelBase(const ScriptableModelBase& other) : QObject(other.parent()) { *this = other; } ScriptableModelBase& operator=(const ScriptableModelBase& other); virtual ~ScriptableModelBase(); - void mixin(const QVariantMap& other); - void append(const ScriptableModelBase& other, const QVariantMap& modelMetadata = QVariantMap()); - void append(scriptable::WeakMeshPointer mesh, const QVariantMap& metadata = QVariantMap()); - void append(const ScriptableMeshBase& mesh, const QVariantMap& metadata = QVariantMap()); + void append(const ScriptableMeshBase& mesh); + void append(scriptable::WeakMeshPointer mesh); // TODO: in future containers for these could go here // QVariantMap shapes; // QVariantMap materials; @@ -78,8 +73,7 @@ namespace scriptable { class ModelProvider { public: NestableType modelProviderType; - static scriptable::ScriptableModelBase modelUnavailableError(bool* ok) { if (ok) { *ok = false; } return {}; } - virtual scriptable::ScriptableModelBase getScriptableModel(bool* ok = nullptr) = 0; + virtual scriptable::ScriptableModelBase getScriptableModel() = 0; virtual bool replaceScriptableModelMeshPart(scriptable::ScriptableModelBasePointer model, int meshIndex, int partIndex) { return false; } }; diff --git a/libraries/graphics-scripting/src/graphics-scripting/GraphicsScriptingInterface.cpp b/libraries/graphics-scripting/src/graphics-scripting/GraphicsScriptingInterface.cpp index 01e68c5328..c336e77762 100644 --- a/libraries/graphics-scripting/src/graphics-scripting/GraphicsScriptingInterface.cpp +++ b/libraries/graphics-scripting/src/graphics-scripting/GraphicsScriptingInterface.cpp @@ -9,7 +9,6 @@ // #include "GraphicsScriptingInterface.h" -#include "BaseScriptEngine.h" #include "BufferViewScripting.h" #include "GraphicsScriptingUtil.h" #include "OBJWriter.h" @@ -24,86 +23,119 @@ #include #include -#include "GraphicsScriptingInterface.moc" - GraphicsScriptingInterface::GraphicsScriptingInterface(QObject* parent) : QObject(parent), QScriptable() { if (auto scriptEngine = qobject_cast(parent)) { this->registerMetaTypes(scriptEngine); } } -bool GraphicsScriptingInterface::updateMeshes(QUuid uuid, const scriptable::ScriptableMeshPointer mesh, int meshIndex, int partIndex) { - auto model = scriptable::make_qtowned(); - if (mesh) { - model->append(*mesh); - } - return updateMeshes(uuid, model.get()); -} - -bool GraphicsScriptingInterface::updateMeshes(QUuid uuid, const scriptable::ScriptableModelPointer model) { - auto appProvider = DependencyManager::get(); - scriptable::ModelProviderPointer provider = appProvider ? appProvider->lookupModelProvider(uuid) : nullptr; - QString providerType = provider ? SpatiallyNestable::nestableTypeToString(provider->modelProviderType) : QString(); - if (providerType.isEmpty()) { - providerType = "unknown"; - } - bool success = false; - if (provider) { - auto scriptableMeshes = provider->getScriptableModel(&success); - if (success) { - const scriptable::ScriptableModelBasePointer base = model->operator scriptable::ScriptableModelBasePointer(); - if (base) { - success = provider->replaceScriptableModelMeshPart(base, -1, -1); - } - } - } - return success; -} - -QScriptValue GraphicsScriptingInterface::getMeshes(QUuid uuid) { - scriptable::ScriptableModel* meshes{ nullptr }; - bool success = false; - QString error; - - auto appProvider = DependencyManager::get(); - qCDebug(graphics_scripting) << "appProvider" << appProvider.data(); - scriptable::ModelProviderPointer provider = appProvider ? appProvider->lookupModelProvider(uuid) : nullptr; - QString providerType = provider ? SpatiallyNestable::nestableTypeToString(provider->modelProviderType) : QString(); - if (providerType.isEmpty()) { - providerType = "unknown"; - } - if (provider) { - auto scriptableMeshes = provider->getScriptableModel(&success); - if (success) { - meshes = scriptable::make_scriptowned(scriptableMeshes); - if (meshes->objectName().isEmpty()) { - meshes->setObjectName(providerType+"::meshes"); - } - if (meshes->objectID.isNull()) { - meshes->objectID = uuid.toString(); - } - meshes->metadata["provider"] = SpatiallyNestable::nestableTypeToString(provider->modelProviderType); - } - } - if (!success) { - error = QString("failed to get meshes from %1 provider for uuid %2").arg(providerType).arg(uuid.toString()); - } - - QPointer scriptEngine = dynamic_cast(engine()); - QScriptValue result = error.isEmpty() ? scriptEngine->toScriptValue(meshes) : scriptEngine->makeError(error); - if (result.isError()) { - qCWarning(graphics_scripting) << "GraphicsScriptingInterface::getMeshes ERROR" << result.toString(); - if (context()) { - context()->throwValue(error); +bool GraphicsScriptingInterface::updateModelObject(QUuid uuid, const scriptable::ScriptableModelPointer model) { + if (auto provider = getModelProvider(uuid)) { + if (auto base = model->operator scriptable::ScriptableModelBasePointer()) { +#ifdef SCRIPTABLE_MESH_DEBUG + qDebug() << "replaceScriptableModelMeshPart" << model->toString() << -1 << -1; +#endif + return provider->replaceScriptableModelMeshPart(base, -1, -1); } else { - qCWarning(graphics_scripting) << "GraphicsScriptingInterface::getMeshes ERROR" << result.toString(); + qDebug() << "replaceScriptableModelMeshPart -- !base" << model << base << -1 << -1; } - return QScriptValue::NullValue; + } else { + qDebug() << "replaceScriptableModelMeshPart -- !provider"; } - return scriptEngine->toScriptValue(meshes); + + return false; } -QString GraphicsScriptingInterface::meshToOBJ(const scriptable::ScriptableModel& _in) { +scriptable::ModelProviderPointer GraphicsScriptingInterface::getModelProvider(QUuid uuid) { + QString error; + if (auto appProvider = DependencyManager::get()) { + if (auto provider = appProvider->lookupModelProvider(uuid)) { + return provider; + } else { + error = "provider unavailable for " + uuid.toString(); + } + } else { + error = "appProvider unavailable"; + } + if (context()) { + context()->throwError(error); + } else { + qCWarning(graphics_scripting) << "GraphicsScriptingInterface::getModelProvider ERROR" << error; + } + return nullptr; +} + +scriptable::ScriptableModelPointer GraphicsScriptingInterface::newModelObject(QVector meshes) { + auto modelWrapper = scriptable::make_scriptowned(); + modelWrapper->setObjectName("js::model"); + if (meshes.isEmpty()) { + if (context()) { + context()->throwError("expected [meshes] array as first argument"); + } + } else { + int i = 0; + for (const auto& mesh : meshes) { + if (mesh) { + modelWrapper->append(*mesh); + } else if (context()) { + context()->throwError(QString("invalid mesh at index: %1").arg(i)); + } + i++; + } + } + return modelWrapper; +} + +scriptable::ScriptableModelPointer GraphicsScriptingInterface::getModelObject(QUuid uuid) { + QString error, providerType = "unknown"; + if (auto provider = getModelProvider(uuid)) { + providerType = SpatiallyNestable::nestableTypeToString(provider->modelProviderType); + auto modelObject = provider->getScriptableModel(); + if (modelObject.objectID == uuid) { + if (modelObject.meshes.size()) { + auto modelWrapper = scriptable::make_scriptowned(modelObject); + modelWrapper->setObjectName(providerType+"::"+uuid.toString()+"::model"); + return modelWrapper; + } else { + error = "no meshes available: " + modelObject.objectID.toString(); + } + } else { + error = "objectID mismatch: " + modelObject.objectID.toString(); + } + } else { + error = "provider unavailable"; + } + auto errorMessage = QString("failed to get meshes from %1 provider for uuid %2 (%3)").arg(providerType).arg(uuid.toString()).arg(error); + qCWarning(graphics_scripting) << "GraphicsScriptingInterface::getModelObject ERROR" << errorMessage; + if (context()) { + context()->throwError(errorMessage); + } + return nullptr; +} + +#ifdef SCRIPTABLE_MESH_TODO +bool GraphicsScriptingInterface::updateMeshPart(scriptable::ScriptableMeshPointer mesh, scriptable::ScriptableMeshPartPointer part) { + Q_ASSERT(mesh); + Q_ASSERT(part); + Q_ASSERT(part->parentMesh); + auto tmp = exportMeshPart(mesh, part->partIndex); + if (part->parentMesh == mesh) { +#ifdef SCRIPTABLE_MESH_DEBUG + qCInfo(graphics_scripting) << "updateMeshPart -- update via clone" << mesh << part; +#endif + tmp->replaceMeshData(part->cloneMeshPart()); + return false; + } else { +#ifdef SCRIPTABLE_MESH_DEBUG + qCInfo(graphics_scripting) << "updateMeshPart -- update via inplace" << mesh << part; +#endif + tmp->replaceMeshData(part); + return true; + } +} +#endif + +QString GraphicsScriptingInterface::exportModelToOBJ(const scriptable::ScriptableModel& _in) { const auto& in = _in.getConstMeshes(); if (in.size()) { QList meshes; @@ -152,3 +184,5 @@ MeshPointer GraphicsScriptingInterface::getMeshPointer(scriptable::ScriptableMes } return mesh; } + +#include "GraphicsScriptingInterface.moc" diff --git a/libraries/graphics-scripting/src/graphics-scripting/GraphicsScriptingInterface.h b/libraries/graphics-scripting/src/graphics-scripting/GraphicsScriptingInterface.h index ab2e5467db..9866b5585c 100644 --- a/libraries/graphics-scripting/src/graphics-scripting/GraphicsScriptingInterface.h +++ b/libraries/graphics-scripting/src/graphics-scripting/GraphicsScriptingInterface.h @@ -29,16 +29,24 @@ public: public slots: /**jsdoc - * Returns the meshes associated with a UUID (entityID, overlayID, or avatarID) + * Returns the model/meshes associated with a UUID (entityID, overlayID, or avatarID) * - * @function GraphicsScriptingInterface.getMeshes - * @param {EntityID} entityID The ID of the entity whose meshes are to be retrieve + * @function GraphicsScriptingInterface.getModel + * @param {UUID} The objectID of the model whose meshes are to be retrieve */ - QScriptValue getMeshes(QUuid uuid); - bool updateMeshes(QUuid uuid, const scriptable::ScriptableModelPointer model); - bool updateMeshes(QUuid uuid, const scriptable::ScriptableMeshPointer mesh, int meshIndex=0, int partIndex=0); + scriptable::ModelProviderPointer getModelProvider(QUuid uuid); + scriptable::ScriptableModelPointer getModelObject(QUuid uuid); + bool updateModelObject(QUuid uuid, const scriptable::ScriptableModelPointer model); + scriptable::ScriptableModelPointer newModelObject(QVector meshes); - QString meshToOBJ(const scriptable::ScriptableModel& in); +#ifdef SCRIPTABLE_MESH_TODO + scriptable::ScriptableMeshPartPointer exportMeshPart(scriptable::ScriptableMeshPointer mesh, int part=0) { + return scriptable::make_scriptowned(mesh, part); + } + bool updateMeshPart(scriptable::ScriptableMeshPointer mesh, scriptable::ScriptableMeshPartPointer part); +#endif + + QString exportModelToOBJ(const scriptable::ScriptableModel& in); private: scriptable::MeshPointer getMeshPointer(scriptable::ScriptableMeshPointer meshProxy); diff --git a/libraries/graphics-scripting/src/graphics-scripting/GraphicsScriptingUtil.h b/libraries/graphics-scripting/src/graphics-scripting/GraphicsScriptingUtil.h index 594e09bb32..9b86ddee82 100644 --- a/libraries/graphics-scripting/src/graphics-scripting/GraphicsScriptingUtil.h +++ b/libraries/graphics-scripting/src/graphics-scripting/GraphicsScriptingUtil.h @@ -43,23 +43,13 @@ namespace scriptable { return toDebugString(qobject_cast(tmp.get())); } - // C++ > QtOwned instance - template - std::shared_ptr make_qtowned(Rest... rest) { - T* tmp = new T(rest...); - if (tmp) { - tmp->metadata["__ownership__"] = QScriptEngine::QtOwnership; - } - return std::shared_ptr(tmp); - } - - // C++ > ScriptOwned JS instance + // Helper for creating C++ > ScriptOwned JS instances + // (NOTE: this also helps track in the code where we need to update later if switching to + // std::shared_ptr's -- something currently non-trivial given mixed JS/C++ object ownership) template QPointer make_scriptowned(Rest... rest) { - T* tmp = new T(rest...); - if (tmp) { - tmp->metadata["__ownership__"] = QScriptEngine::ScriptOwnership; - } - return QPointer(tmp); + auto instance = QPointer(new T(rest...)); + Q_ASSERT(instance && instance->parent()); + return instance; } } diff --git a/libraries/graphics-scripting/src/graphics-scripting/ScriptableMesh.cpp b/libraries/graphics-scripting/src/graphics-scripting/ScriptableMesh.cpp index 643debf475..52cd225fba 100644 --- a/libraries/graphics-scripting/src/graphics-scripting/ScriptableMesh.cpp +++ b/libraries/graphics-scripting/src/graphics-scripting/ScriptableMesh.cpp @@ -5,6 +5,8 @@ // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html // +#include "Forward.h" + #include "ScriptableMesh.h" #include "BufferViewScripting.h" @@ -19,7 +21,7 @@ #include #include -#include "ScriptableMesh.moc" +// #define SCRIPTABLE_MESH_DEBUG 1 scriptable::ScriptableMeshPart::ScriptableMeshPart(scriptable::ScriptableMeshPointer parentMesh, int partIndex) : QObject(), parentMesh(parentMesh), partIndex(partIndex) { @@ -77,7 +79,9 @@ QVector scriptable::ScriptableMesh::findNearbyIndices(const glm::vec3& QVector scriptable::ScriptableMesh::getIndices() const { QVector result; if (auto mesh = getMeshPointer()) { +#ifdef SCRIPTABLE_MESH_DEBUG qCDebug(graphics_scripting, "getTriangleIndices mesh %p", mesh.get()); +#endif gpu::BufferView indexBufferView = mesh->getIndexBuffer(); if (quint32 count = (quint32)indexBufferView.getNumElements()) { result.resize(count); @@ -121,20 +125,16 @@ QVector scriptable::ScriptableMesh::getAttributeNames() const { return result; } -// override QVariantMap scriptable::ScriptableMesh::getVertexAttributes(quint32 vertexIndex) const { return getVertexAttributes(vertexIndex, getAttributeNames()); } bool scriptable::ScriptableMesh::setVertexAttributes(quint32 vertexIndex, QVariantMap attributes) { - //qCInfo(graphics_scripting) << "setVertexAttributes" << vertexIndex << attributes; - metadata["last-modified"] = QDateTime::currentDateTime().toTimeSpec(Qt::OffsetFromUTC).toString(Qt::ISODate); for (auto& a : buffer_helpers::gatherBufferViews(getMeshPointer())) { const auto& name = a.first; const auto& value = attributes.value(name); if (value.isValid()) { auto& view = a.second; - //qCDebug(graphics_scripting) << "setVertexAttributes" << vertexIndex << name; buffer_helpers::fromVariant(view, vertexIndex, value); } else { //qCDebug(graphics_scripting) << "(skipping) setVertexAttributes" << vertexIndex << name; @@ -269,7 +269,6 @@ quint32 scriptable::ScriptableMesh::mapAttributeValues(QScriptValue _callback) { #endif auto obj = js->newObject(); auto attributeViews = buffer_helpers::gatherBufferViews(mesh, { "normal", "color" }); - metadata["last-modified"] = QDateTime::currentDateTime().toTimeSpec(Qt::OffsetFromUTC).toString(Qt::ISODate); uint32_t i = 0; for (; i < nPositions; i++) { for (const auto& a : attributeViews) { @@ -303,13 +302,13 @@ quint32 scriptable::ScriptableMesh::mapAttributeValues(QScriptValue _callback) { } quint32 scriptable::ScriptableMeshPart::mapAttributeValues(QScriptValue callback) { - return parentMesh ? parentMesh->mapAttributeValues(callback) : 0; + return parentMesh ? parentMesh->mapAttributeValues(callback) : 0; } bool scriptable::ScriptableMeshPart::unrollVertices(bool recalcNormals) { auto mesh = getMeshPointer(); #ifdef SCRIPTABLE_MESH_DEBUG - qCInfo(graphics_scripting) << "ScriptableMeshPart::unrollVertices" << !!mesh<< !!meshProxy; + qCInfo(graphics_scripting) << "ScriptableMeshPart::unrollVertices" << !!mesh<< !!parentMesh; #endif if (!mesh) { return false; @@ -321,8 +320,9 @@ bool scriptable::ScriptableMeshPart::unrollVertices(bool recalcNormals) { auto buffer = new gpu::Buffer(); buffer->resize(numPoints * sizeof(uint32_t)); auto newindices = gpu::BufferView(buffer, { gpu::SCALAR, gpu::UINT32, gpu::INDEX }); - metadata["last-modified"] = QDateTime::currentDateTime().toTimeSpec(Qt::OffsetFromUTC).toString(Qt::ISODate); +#ifdef SCRIPTABLE_MESH_DEBUG qCInfo(graphics_scripting) << "ScriptableMeshPart::unrollVertices numPoints" << numPoints; +#endif auto attributeViews = buffer_helpers::gatherBufferViews(mesh); for (const auto& a : attributeViews) { auto& view = a.second; @@ -330,15 +330,17 @@ bool scriptable::ScriptableMeshPart::unrollVertices(bool recalcNormals) { auto buffer = new gpu::Buffer(); buffer->resize(numPoints * sz); auto points = gpu::BufferView(buffer, view._element); - auto src = (uint8_t*)view._buffer->getData(); - auto dest = (uint8_t*)points._buffer->getData(); auto slot = buffer_helpers::ATTRIBUTES[a.first]; +#ifdef SCRIPTABLE_MESH_DEBUG if (0) { + auto src = (uint8_t*)view._buffer->getData(); + auto dest = (uint8_t*)points._buffer->getData(); qCInfo(graphics_scripting) << "ScriptableMeshPart::unrollVertices buffer" << a.first; qCInfo(graphics_scripting) << "ScriptableMeshPart::unrollVertices source" << view.getNumElements(); qCInfo(graphics_scripting) << "ScriptableMeshPart::unrollVertices dest" << points.getNumElements(); qCInfo(graphics_scripting) << "ScriptableMeshPart::unrollVertices sz" << sz << src << dest << slot; } +#endif auto esize = indices._element.getSize(); const char* hint= a.first.toStdString().c_str(); for(quint32 i = 0; i < numPoints; i++) { @@ -381,8 +383,6 @@ bool scriptable::ScriptableMeshPart::replaceMeshData(scriptable::ScriptableMeshP "target:" << QString::fromStdString(target->displayName) << "attributes:" << attributes; - metadata["last-modified"] = QDateTime::currentDateTime().toTimeSpec(Qt::OffsetFromUTC).toString(Qt::ISODate); - // remove attributes only found on target mesh, unless user has explicitly specified the relevant attribute names if (attributeNames.isEmpty()) { auto attributeViews = buffer_helpers::gatherBufferViews(target); @@ -438,7 +438,6 @@ bool scriptable::ScriptableMeshPart::dedupeVertices(float epsilon) { uniqueVerts.reserve((int)numPositions); QMap remapIndices; - metadata["last-modified"] = QDateTime::currentDateTime().toTimeSpec(Qt::OffsetFromUTC).toString(Qt::ISODate); for (quint32 i = 0; i < numPositions; i++) { const quint32 numUnique = uniqueVerts.size(); const auto& position = positions.get(i); @@ -508,63 +507,51 @@ scriptable::ScriptableMeshPointer scriptable::ScriptableMesh::cloneMesh(bool rec return nullptr; } auto clone = buffer_helpers::cloneMesh(mesh); - + if (recalcNormals) { buffer_helpers::recalculateNormals(clone); } - auto meshPointer = scriptable::make_scriptowned(provider, model, clone, metadata); - clone.reset(); // free local reference - // qCInfo(graphics_scripting) << "========= ScriptableMesh::cloneMesh..." << meshPointer << meshPointer->ownedMesh.use_count(); - //scriptable::MeshPointer* ppMesh = new scriptable::MeshPointer(); - //*ppMesh = clone; - - if (0 && meshPointer) { - scriptable::WeakMeshPointer delme = meshPointer->mesh; - QString debugString = scriptable::toDebugString(meshPointer); - QObject::connect(meshPointer, &QObject::destroyed, meshPointer, [=]() { - // qCWarning(graphics_scripting) << "*************** cloneMesh/Destroy"; - // qCWarning(graphics_scripting) << "*************** " << debugString << delme.lock().get(); - if (!delme.expired()) { - QTimer::singleShot(250, this, [=]{ - if (!delme.expired()) { - qCWarning(graphics_scripting) << "cloneMesh -- potential memory leak..." << debugString << delme.use_count(); - } - }); - } - }); - } - - meshPointer->metadata["last-modified"] = QDateTime::currentDateTime().toTimeSpec(Qt::OffsetFromUTC).toString(Qt::ISODate); + auto meshPointer = scriptable::make_scriptowned(provider, model, clone, nullptr); return scriptable::ScriptableMeshPointer(meshPointer); } -scriptable::ScriptableMeshBase::ScriptableMeshBase(scriptable::WeakModelProviderPointer provider, scriptable::ScriptableModelBasePointer model, scriptable::WeakMeshPointer mesh, const QVariantMap& metadata) - : provider(provider), model(model), mesh(mesh), metadata(metadata) {} -scriptable::ScriptableMeshBase::ScriptableMeshBase(scriptable::WeakMeshPointer mesh) : scriptable::ScriptableMeshBase(scriptable::WeakModelProviderPointer(), nullptr, mesh, QVariantMap()) { } -scriptable::ScriptableMeshBase::ScriptableMeshBase(scriptable::MeshPointer mesh, const QVariantMap& metadata) - : ScriptableMeshBase(WeakModelProviderPointer(), nullptr, mesh, metadata) { - ownedMesh = mesh; + + +// note: we don't always want the JS side to prevent mesh data from being freed + +scriptable::ScriptableMeshBase::ScriptableMeshBase( + scriptable::WeakModelProviderPointer provider, scriptable::ScriptableModelBasePointer model, scriptable::WeakMeshPointer weakMesh, QObject* parent + ) : QObject(parent), provider(provider), model(model), weakMesh(weakMesh) { + if (parent) { + qCDebug(graphics_scripting) << "ScriptableMeshBase -- have parent QObject, creating strong neshref" << weakMesh.lock().get() << parent; + strongMesh = weakMesh.lock(); + } } + +scriptable::ScriptableMeshBase::ScriptableMeshBase(scriptable::WeakMeshPointer weakMesh, QObject* parent) : + scriptable::ScriptableMeshBase(scriptable::WeakModelProviderPointer(), nullptr, weakMesh, parent) { +} + scriptable::ScriptableMeshBase& scriptable::ScriptableMeshBase::operator=(const scriptable::ScriptableMeshBase& view) { provider = view.provider; model = view.model; - mesh = view.mesh; - ownedMesh = view.ownedMesh; - metadata = view.metadata; + weakMesh = view.weakMesh; + strongMesh = view.strongMesh; return *this; } - scriptable::ScriptableMeshBase::~ScriptableMeshBase() { - ownedMesh.reset(); + +scriptable::ScriptableMeshBase::~ScriptableMeshBase() { #ifdef SCRIPTABLE_MESH_DEBUG - qCInfo(graphics_scripting) << "//~ScriptableMeshBase" << this << "ownedMesh:" << ownedMesh.use_count() << "mesh:" << mesh.use_count(); + qCInfo(graphics_scripting) << "//~ScriptableMeshBase" << this << "strongMesh:" << strongMesh.use_count() << "weakMesh:" << weakMesh.use_count(); #endif + strongMesh.reset(); } scriptable::ScriptableMesh::~ScriptableMesh() { - ownedMesh.reset(); #ifdef SCRIPTABLE_MESH_DEBUG - qCInfo(graphics_scripting) << "//~ScriptableMesh" << this << "ownedMesh:" << ownedMesh.use_count() << "mesh:" << mesh.use_count(); + qCInfo(graphics_scripting) << "//~ScriptableMesh" << this << "strongMesh:" << strongMesh.use_count() << "weakMesh:" << weakMesh.use_count(); #endif + strongMesh.reset(); } QString scriptable::ScriptableMeshPart::toOBJ() { @@ -573,7 +560,7 @@ QString scriptable::ScriptableMeshPart::toOBJ() { context()->throwError(QString("null mesh")); } else { qCWarning(graphics_scripting) << "null mesh"; - } + } return QString(); } return writeOBJToString({ getMeshPointer() }); @@ -585,12 +572,7 @@ namespace { if (!object) { return QScriptValue::NullValue; } - auto ownership = object->metadata.value("__ownership__"); - return engine->newQObject( - object, - ownership.isValid() ? static_cast(ownership.toInt()) : QScriptEngine::QtOwnership - //, QScriptEngine::ExcludeDeleteLater | QScriptEngine::ExcludeChildObjects - ); + return engine->newQObject(object, QScriptEngine::QtOwnership, QScriptEngine::ExcludeDeleteLater); } QScriptValue meshPointerToScriptValue(QScriptEngine* engine, const scriptable::ScriptableMeshPointer& in) { @@ -637,7 +619,7 @@ namespace scriptable { qScriptRegisterSequenceMetaType>(engine); qScriptRegisterSequenceMetaType>(engine); qScriptRegisterSequenceMetaType>(engine); - + qScriptRegisterMetaType(engine, qVectorUInt32ToScriptValue, qVectorUInt32FromScriptValue); qScriptRegisterMetaType(engine, modelPointerToScriptValue, modelPointerFromScriptValue); qScriptRegisterMetaType(engine, meshPointerToScriptValue, meshPointerFromScriptValue); @@ -645,50 +627,41 @@ namespace scriptable { return metaTypeIds.size(); } + // callback helper that lets C++ method signatures remain simple (ie: taking a single callback argument) while // still supporting extended Qt signal-like (scope, "methodName") and (scope, function(){}) "this" binding conventions - QScriptValue jsBindCallback(QScriptValue callback) { - if (callback.isObject() && callback.property("callback").isFunction()) { - return callback; + QScriptValue jsBindCallback(QScriptValue value) { + if (value.isObject() && value.property("callback").isFunction()) { + // value is already a bound callback + return value; } - auto engine = callback.engine(); + auto engine = value.engine(); auto context = engine ? engine->currentContext() : nullptr; auto length = context ? context->argumentCount() : 0; QScriptValue scope = context ? context->thisObject() : QScriptValue::NullValue; QScriptValue method; +#ifdef SCRIPTABLE_MESH_DEBUG qCInfo(graphics_scripting) << "jsBindCallback" << engine << length << scope.toQObject() << method.toString(); - int i = 0; - for (; context && i < length; i++) { - if (context->argument(i).strictlyEquals(callback)) { +#endif + + // find position in the incoming JS Function.arguments array (so we can test for the two-argument case) + for (int i = 0; context && i < length; i++) { + if (context->argument(i).strictlyEquals(value)) { method = context->argument(i+1); } } if (method.isFunction() || method.isString()) { - scope = callback; + // interpret as `API.func(..., scope, function callback(){})` or `API.func(..., scope, "methodName")` + scope = value; } else { - method = callback; + // interpret as `API.func(..., function callback(){})` + method = value; } +#ifdef SCRIPTABLE_MESH_DEBUG qCInfo(graphics_scripting) << "scope:" << scope.toQObject() << "method:" << method.toString(); +#endif return ::makeScopedHandlerObject(scope, method); } } -bool scriptable::GraphicsScriptingInterface::updateMeshPart(ScriptableMeshPointer mesh, ScriptableMeshPartPointer part) { - Q_ASSERT(mesh); - Q_ASSERT(part); - Q_ASSERT(part->parentMesh); - auto tmp = exportMeshPart(mesh, part->partIndex); - if (part->parentMesh == mesh) { -#ifdef SCRIPTABLE_MESH_DEBUG - qCInfo(graphics_scripting) << "updateMeshPart -- update via clone" << mesh << part; -#endif - tmp->replaceMeshData(part->cloneMeshPart()); - return false; - } else { -#ifdef SCRIPTABLE_MESH_DEBUG - qCInfo(graphics_scripting) << "updateMeshPart -- update via inplace" << mesh << part; -#endif - tmp->replaceMeshData(part); - return true; - } -} +#include "ScriptableMesh.moc" diff --git a/libraries/graphics-scripting/src/graphics-scripting/ScriptableMesh.h b/libraries/graphics-scripting/src/graphics-scripting/ScriptableMesh.h index 459613135a..f070fdf21e 100644 --- a/libraries/graphics-scripting/src/graphics-scripting/ScriptableMesh.h +++ b/libraries/graphics-scripting/src/graphics-scripting/ScriptableMesh.h @@ -1,3 +1,10 @@ +// +// Copyright 2018 High Fidelity, Inc. +// +// Distributed under the Apache License, Version 2.0. +// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html +// + #pragma once #include "ScriptableModel.h" @@ -26,25 +33,26 @@ namespace scriptable { Q_PROPERTY(uint32 numAttributes READ getNumAttributes) Q_PROPERTY(uint32 numVertices READ getNumVertices) Q_PROPERTY(uint32 numIndices READ getNumIndices) - Q_PROPERTY(QVariantMap metadata MEMBER metadata) Q_PROPERTY(QVector attributeNames READ getAttributeNames) Q_PROPERTY(QVector parts READ getMeshParts) Q_PROPERTY(bool valid READ hasValidMesh) - bool hasValidMesh() const { return (bool)getMeshPointer(); } - Q_PROPERTY(bool validOwned READ hasValidOwnedMesh) - bool hasValidOwnedMesh() const { return (bool)getOwnedMeshPointer(); } + Q_PROPERTY(bool strong READ hasValidStrongMesh) operator const ScriptableMeshBase*() const { return (qobject_cast(this)); } - ScriptableMesh(scriptable::MeshPointer mesh) : ScriptableMeshBase(mesh), QScriptable() { ownedMesh = mesh; } - ScriptableMesh(WeakModelProviderPointer provider, ScriptableModelBasePointer model, MeshPointer mesh, const QVariantMap& metadata) - : ScriptableMeshBase(provider, model, mesh, metadata), QScriptable() { ownedMesh = mesh; } + + ScriptableMesh(WeakModelProviderPointer provider, ScriptableModelBasePointer model, MeshPointer mesh, QObject* parent) + : ScriptableMeshBase(provider, model, mesh, parent), QScriptable() { strongMesh = mesh; } + ScriptableMesh(MeshPointer mesh, QObject* parent) + : ScriptableMeshBase(WeakModelProviderPointer(), nullptr, mesh, parent), QScriptable() { strongMesh = mesh; } ScriptableMesh(const ScriptableMeshBase& other); ScriptableMesh(const ScriptableMesh& other) : ScriptableMeshBase(other), QScriptable() {}; virtual ~ScriptableMesh(); Q_INVOKABLE const scriptable::ScriptableModelPointer getParentModel() const { return qobject_cast(model); } - Q_INVOKABLE const scriptable::MeshPointer getOwnedMeshPointer() const { return ownedMesh; } + Q_INVOKABLE const scriptable::MeshPointer getOwnedMeshPointer() const { return strongMesh; } scriptable::ScriptableMeshPointer getSelf() const { return const_cast(this); } + bool hasValidMesh() const { return !weakMesh.expired(); } + bool hasValidStrongMesh() const { return (bool)strongMesh; } public slots: uint32 getNumParts() const; uint32 getNumVertices() const; @@ -65,9 +73,9 @@ namespace scriptable { int _getSlotNumber(const QString& attributeName) const; - scriptable::ScriptableMeshPointer cloneMesh(bool recalcNormals = false); + scriptable::ScriptableMeshPointer cloneMesh(bool recalcNormals = false); public: - operator bool() const { return !mesh.expired(); } + operator bool() const { return !weakMesh.expired(); } public slots: // QScriptEngine-specific wrappers @@ -88,11 +96,9 @@ namespace scriptable { Q_PROPERTY(uint32 numIndices READ getNumIndices) Q_PROPERTY(QVector attributeNames READ getAttributeNames) - Q_PROPERTY(QVariantMap metadata MEMBER metadata) - ScriptableMeshPart(scriptable::ScriptableMeshPointer parentMesh, int partIndex); ScriptableMeshPart& operator=(const ScriptableMeshPart& view) { parentMesh=view.parentMesh; return *this; }; - ScriptableMeshPart(const ScriptableMeshPart& other) : QObject(), QScriptable(), parentMesh(other.parentMesh), partIndex(other.partIndex) {} + ScriptableMeshPart(const ScriptableMeshPart& other) : QObject(other.parent()), QScriptable(), parentMesh(other.parentMesh), partIndex(other.partIndex) {} public slots: scriptable::ScriptableMeshPointer getParentMesh() const { return parentMesh; } @@ -134,23 +140,10 @@ namespace scriptable { public: scriptable::ScriptableMeshPointer parentMesh; uint32 partIndex; - QVariantMap metadata; protected: int _elementsPerFace{ 3 }; QString _topology{ "triangles" }; - scriptable::MeshPointer getMeshPointer() const { return parentMesh ? parentMesh->getMeshPointer() : nullptr; } - }; - - class GraphicsScriptingInterface : public QObject, QScriptable { - Q_OBJECT - public: - GraphicsScriptingInterface(QObject* parent = nullptr) : QObject(parent), QScriptable() {} - GraphicsScriptingInterface(const GraphicsScriptingInterface& other) : QObject(), QScriptable() {} - public slots: - ScriptableMeshPartPointer exportMeshPart(ScriptableMeshPointer mesh, int part=0) { - return ScriptableMeshPartPointer(new ScriptableMeshPart(mesh, part)); - } - bool updateMeshPart(ScriptableMeshPointer mesh, ScriptableMeshPartPointer part); + scriptable::MeshPointer getMeshPointer() const { return parentMesh ? parentMesh->getMeshPointer() : nullptr; } }; // callback helper that lets C++ method signatures remain simple (ie: taking a single callback argument) while @@ -165,26 +158,5 @@ Q_DECLARE_METATYPE(scriptable::ScriptableMeshPointer) Q_DECLARE_METATYPE(QVector) Q_DECLARE_METATYPE(scriptable::ScriptableMeshPartPointer) Q_DECLARE_METATYPE(QVector) -Q_DECLARE_METATYPE(scriptable::GraphicsScriptingInterface) - -// FIXME: MESHFACES: faces were supported in the original Model.* API -- are they still needed/used/useful for anything yet? -#include - -namespace mesh { - class MeshFace; - using MeshFaces = QVector; - class MeshFace { - public: - MeshFace() {} - MeshFace(QVector vertexIndices) : vertexIndices(vertexIndices) {} - ~MeshFace() {} - - QVector vertexIndices; - // TODO -- material... - }; -}; - -Q_DECLARE_METATYPE(mesh::MeshFace) -Q_DECLARE_METATYPE(QVector) Q_DECLARE_METATYPE(scriptable::uint32) Q_DECLARE_METATYPE(QVector) diff --git a/libraries/graphics-scripting/src/graphics-scripting/ScriptableModel.cpp b/libraries/graphics-scripting/src/graphics-scripting/ScriptableModel.cpp index 229d56adab..306f1b18af 100644 --- a/libraries/graphics-scripting/src/graphics-scripting/ScriptableModel.cpp +++ b/libraries/graphics-scripting/src/graphics-scripting/ScriptableModel.cpp @@ -13,25 +13,13 @@ #include "ScriptableMesh.h" #include -//#include "ScriptableModel.moc" -void scriptable::ScriptableModelBase::mixin(const QVariantMap& modelMetaData) { - for (const auto& key : modelMetaData.keys()) { - const auto& value = modelMetaData[key]; - if (metadata.contains(key) && metadata[key].type() == (QVariant::Type)QMetaType::QVariantList) { - qCDebug(graphics_scripting) << "CONCATENATING" << key << metadata[key].toList().size() << "+" << value.toList().size(); - metadata[key] = metadata[key].toList() + value.toList(); - } else { - metadata[key] = modelMetaData[key]; - } - } -} +// #define SCRIPTABLE_MESH_DEBUG 1 scriptable::ScriptableModelBase& scriptable::ScriptableModelBase::operator=(const scriptable::ScriptableModelBase& other) { provider = other.provider; objectID = other.objectID; - metadata = other.metadata; - for (auto& mesh : other.meshes) { + for (const auto& mesh : other.meshes) { append(mesh); } return *this; @@ -43,36 +31,27 @@ scriptable::ScriptableModelBase::~ScriptableModelBase() { #endif // makes cleanup order more deterministic to help with debugging for (auto& m : meshes) { - m.ownedMesh.reset(); + m.strongMesh.reset(); } meshes.clear(); } -void scriptable::ScriptableModelBase::append(scriptable::WeakMeshPointer mesh, const QVariantMap& metadata) { - meshes << ScriptableMeshBase{ provider, this, mesh, metadata }; +void scriptable::ScriptableModelBase::append(scriptable::WeakMeshPointer mesh) { + meshes << ScriptableMeshBase{ provider, this, mesh, this /*parent*/ }; } -void scriptable::ScriptableModelBase::append(const ScriptableMeshBase& mesh, const QVariantMap& modelMetaData) { +void scriptable::ScriptableModelBase::append(const ScriptableMeshBase& mesh) { if (mesh.provider.lock().get() != provider.lock().get()) { qCDebug(graphics_scripting) << "warning: appending mesh from different provider..." << mesh.provider.lock().get() << " != " << provider.lock().get(); } meshes << mesh; - mixin(modelMetaData); } -void scriptable::ScriptableModelBase::append(const ScriptableModelBase& other, const QVariantMap& modelMetaData) { - for (const auto& mesh : other.meshes) { - append(mesh); - } - mixin(other.metadata); - mixin(modelMetaData); -} - - QString scriptable::ScriptableModel::toString() const { - return QString("[ScriptableModel%1%2]") + return QString("[ScriptableModel%1%2 numMeshes=%3]") .arg(objectID.isNull() ? "" : " objectID="+objectID.toString()) - .arg(objectName().isEmpty() ? "" : " name=" +objectName()); + .arg(objectName().isEmpty() ? "" : " name=" +objectName()) + .arg(meshes.size()); } scriptable::ScriptableModelPointer scriptable::ScriptableModel::cloneModel(const QVariantMap& options) { @@ -131,3 +110,5 @@ quint32 scriptable::ScriptableModel::mapAttributeValues(QScriptValue callback) { } return result; } + +#include "ScriptableModel.moc" diff --git a/libraries/graphics-scripting/src/graphics-scripting/ScriptableModel.h b/libraries/graphics-scripting/src/graphics-scripting/ScriptableModel.h index a78c9a4ef5..4ed1cc9554 100644 --- a/libraries/graphics-scripting/src/graphics-scripting/ScriptableModel.h +++ b/libraries/graphics-scripting/src/graphics-scripting/ScriptableModel.h @@ -1,15 +1,22 @@ +// +// Copyright 2018 High Fidelity, Inc. +// +// Distributed under the Apache License, Version 2.0. +// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html +// + #pragma once #include "Forward.h" #include "GraphicsScriptingUtil.h" class QScriptValue; + namespace scriptable { class ScriptableModel : public ScriptableModelBase { Q_OBJECT public: Q_PROPERTY(QUuid objectID MEMBER objectID CONSTANT) - Q_PROPERTY(QVariantMap metadata MEMBER metadata CONSTANT) Q_PROPERTY(uint32 numMeshes READ getNumMeshes) Q_PROPERTY(QVector meshes READ getMeshes) @@ -27,11 +34,9 @@ namespace scriptable { QVector getMeshes(); const QVector getConstMeshes() const; operator scriptable::ScriptableModelBasePointer() { - QPointer p; - p = qobject_cast(this); - return p; + return QPointer(qobject_cast(this)); } - + // QScriptEngine-specific wrappers Q_INVOKABLE uint32 mapAttributeValues(QScriptValue callback); diff --git a/libraries/graphics/src/graphics/BufferViewHelpers.cpp b/libraries/graphics/src/graphics/BufferViewHelpers.cpp index ddf3d84c89..29dcbd58e3 100644 --- a/libraries/graphics/src/graphics/BufferViewHelpers.cpp +++ b/libraries/graphics/src/graphics/BufferViewHelpers.cpp @@ -28,10 +28,6 @@ namespace glm { using hvec4 = glm::tvec4; } -#ifdef DEBUG_BUFFERVIEW_SCRIPTING -#include "../../graphics-scripting/src/graphics-scripting/DebugNames.h" -#endif - namespace { QLoggingCategory bufferhelper_logging{ "hifi.bufferview" }; } @@ -109,9 +105,7 @@ bool buffer_helpers::fromVariant(const gpu::BufferView& view, quint32 index, con const auto dataType = element.getType(); const auto byteLength = element.getSize(); const auto BYTES_PER_ELEMENT = byteLength / vecN; -#ifdef DEBUG_BUFFERVIEW_SCRIPTING - qCDebug(bufferhelper_logging) << "bufferViewElementFromVariant" << index << DebugNames::stringFrom(dataType) << BYTES_PER_ELEMENT << vecN; -#endif + if (BYTES_PER_ELEMENT == 1) { switch(vecN) { case 2: setBufferViewElement(view, index, v); return true; @@ -176,18 +170,12 @@ QVariant buffer_helpers::toVariant(const gpu::BufferView& view, quint32 index, b auto byteOffset = index * vecN * BYTES_PER_ELEMENT; auto maxByteOffset = (view._size - 1) * vecN * BYTES_PER_ELEMENT; if (byteOffset > maxByteOffset) { -#ifdef DEBUG_BUFFERVIEW_SCRIPTING - qDebug() << "toVariant -- " << DebugNames::stringFrom(dataType) -#endif qDebug() << "toVariant -- byteOffset out of range " << byteOffset << " < " << maxByteOffset; qDebug() << "toVariant -- index: " << index << "numElements" << view.getNumElements(); qDebug() << "toVariant -- vecN: " << vecN << "byteLength" << byteLength << "BYTES_PER_ELEMENT" << BYTES_PER_ELEMENT; } Q_ASSERT(byteOffset <= maxByteOffset); } -#ifdef DEBUG_BUFFERVIEW_SCRIPTING - qCDebug(bufferhelper_logging) << "toVariant -- " << index << DebugNames::stringFrom(dataType) << BYTES_PER_ELEMENT << vecN; -#endif if (BYTES_PER_ELEMENT == 1) { switch(vecN) { case 2: return getBufferViewElement(view, index, asArray); @@ -305,13 +293,8 @@ template struct GpuScalarToGlm; struct GpuToGlmAdapter { static float error(const QString& name, const gpu::BufferView& view, quint32 index, const char *hint) { - QString debugName; -#ifdef DEBUG_BUFFERVIEW_SCRIPTING - debugName = DebugNames::stringFrom(view._element.getType()) -#endif - qDebug() << QString("GpuToGlmAdapter:: unhandled type=%1(element=%2(%3)) size=%4(per=%5) vec%6 hint=%7 #%8") + qDebug() << QString("GpuToGlmAdapter:: unhandled type=%1(element=%2) size=%3(per=%4) vec%5 hint=%6 #%7") .arg(name) - .arg(debugName) .arg(view._element.getType()) .arg(view._element.getSize()) .arg(view._element.getSize() / view._element.getScalarCount()) @@ -404,7 +387,7 @@ struct getVec { } return result; } - static T __to_scalar__(const gpu::BufferView& view, quint32 index, const char *hint) { + static T __to_value__(const gpu::BufferView& view, quint32 index, const char *hint) { assert(boundsCheck(view, index)); return FUNC::get(view, index, hint); } @@ -425,18 +408,18 @@ template <> QVector buffer_helpers::toVector(const gpu::Bu } -// indexed conversion accessors (similar to "view.convert(i)" existed) +// indexed conversion accessors (like the hypothetical "view.convert(i)") template <> int buffer_helpers::convert(const gpu::BufferView& view, quint32 index, const char *hint) { - return getVec,int>::__to_scalar__(view, index, hint); + return getVec,int>::__to_value__(view, index, hint); } template <> glm::vec2 buffer_helpers::convert(const gpu::BufferView& view, quint32 index, const char *hint) { - return getVec,glm::vec2>::__to_scalar__(view, index, hint); + return getVec,glm::vec2>::__to_value__(view, index, hint); } template <> glm::vec3 buffer_helpers::convert(const gpu::BufferView& view, quint32 index, const char *hint) { - return getVec,glm::vec3>::__to_scalar__(view, index, hint); + return getVec,glm::vec3>::__to_value__(view, index, hint); } template <> glm::vec4 buffer_helpers::convert(const gpu::BufferView& view, quint32 index, const char *hint) { - return getVec,glm::vec4>::__to_scalar__(view, index, hint); + return getVec,glm::vec4>::__to_value__(view, index, hint); } gpu::BufferView buffer_helpers::clone(const gpu::BufferView& input) { @@ -492,9 +475,6 @@ namespace { vsize > bufferView._size ); QString hint = QString("%1").arg(slot); -#ifdef DEBUG_BUFFERVIEW_SCRIPTING - hint = DebugNames::stringFrom(slot); -#endif #ifdef DEV_BUILD auto beforeCount = bufferView.getNumElements(); auto beforeTotal = bufferView._size; @@ -519,9 +499,6 @@ namespace { auto afterTotal = bufferView._size; if (beforeTotal != afterTotal || beforeCount != afterCount) { QString typeName = QString("%1").arg(bufferView._element.getType()); -#ifdef DEBUG_BUFFERVIEW_SCRIPTING - typeName = DebugNames::stringFrom(bufferView._element.getType()); -#endif qCDebug(bufferhelper_logging, "NOTE:: _expandedAttributeBuffer.%s vec%d %s (before count=%lu bytes=%lu // after count=%lu bytes=%lu)", hint.toStdString().c_str(), bufferView._element.getScalarCount(), typeName.toStdString().c_str(), beforeCount, beforeTotal, afterCount, afterTotal); @@ -557,9 +534,6 @@ std::map buffer_helpers::gatherBufferViews(graphics::M if (beforeCount > 0) { auto element = view._element; QString typeName = QString("%1").arg(element.getType()); -#ifdef DEBUG_BUFFERVIEW_SCRIPTING - typeName = DebugNames::stringFrom(element.getType()); -#endif attributeViews[name] = getBufferView(mesh, slot); diff --git a/libraries/render-utils/src/Model.cpp b/libraries/render-utils/src/Model.cpp index 783659a6a1..a083b027f3 100644 --- a/libraries/render-utils/src/Model.cpp +++ b/libraries/render-utils/src/Model.cpp @@ -492,7 +492,6 @@ bool Model::findRayIntersectionAgainstSubMeshes(const glm::vec3& origin, const g { "v2", vec3toVariant(bestModelTriangle.v2) }, }; } - } } @@ -591,38 +590,41 @@ MeshProxyList Model::getMeshes() const { // FIXME: temporary workaround that updates the whole FBXGeometry (to keep findRayIntersection in sync) #include "Model_temporary_hack.cpp.h" -bool Model::replaceScriptableModelMeshPart(scriptable::ScriptableModelBasePointer _newModel, int meshIndex, int partIndex) { +bool Model::replaceScriptableModelMeshPart(scriptable::ScriptableModelBasePointer newModel, int meshIndex, int partIndex) { QMutexLocker lock(&_mutex); if (!isLoaded()) { + qDebug() << "!isLoaded" << this; return false; } - { - // FIXME: temporary workaround for updating the whole FBXGeometry (to keep findRayIntersection in sync) - auto newRenderGeometry = new MyGeometryMappingResource( - _url, _renderGeometry, _newModel ? scriptable::make_qtowned(*_newModel) : nullptr - ); - _visualGeometryRequestFailed = false; - deleteGeometry(); - _renderGeometry.reset(newRenderGeometry); - _rig.destroyAnimGraph(); - updateGeometry(); - calculateTriangleSets(); - _needsReload = false; - _needsFixupInScene = true; - setRenderItemsNeedUpdate(); + if (!newModel || !newModel->meshes.size()) { + qDebug() << "!newModel.meshes.size()" << this; + return false; } + + auto resource = new MyGeometryResource(_url, _renderGeometry, newModel); + _needsReload = false; + _needsUpdateTextures = false; + _visualGeometryRequestFailed = false; + _needsFixupInScene = true; + + invalidCalculatedMeshBoxes(); + deleteGeometry(); + _renderGeometry.reset(resource); + updateGeometry(); + calculateTriangleSets(); + setRenderItemsNeedUpdate(); return true; } -scriptable::ScriptableModelBase Model::getScriptableModel(bool* ok) { +scriptable::ScriptableModelBase Model::getScriptableModel() { QMutexLocker lock(&_mutex); scriptable::ScriptableModelBase result; if (!isLoaded()) { qCDebug(renderutils) << "Model::getScriptableModel -- !isLoaded"; - return scriptable::ModelProvider::modelUnavailableError(ok); + return result; } const FBXGeometry& geometry = getFBXGeometry(); @@ -630,22 +632,9 @@ scriptable::ScriptableModelBase Model::getScriptableModel(bool* ok) { for (int i = 0; i < numberOfMeshes; i++) { const FBXMesh& fbxMesh = geometry.meshes.at(i); if (auto mesh = fbxMesh._mesh) { - auto name = geometry.getModelNameOfMesh(i); - result.append(std::const_pointer_cast(mesh), { - { "index", i }, - { "name", name }, - { "meshIndex", fbxMesh.meshIndex }, - { "displayName", QString::fromStdString(mesh->displayName) }, - { "modelName", QString::fromStdString(mesh->modelName) }, - { "modelTransform", buffer_helpers::toVariant(fbxMesh.modelTransform) }, - { "transform", buffer_helpers::toVariant(geometry.offset * fbxMesh.modelTransform) }, - { "extents", buffer_helpers::toVariant(fbxMesh.meshExtents) }, - }); + result.append(mesh); } } - if (ok) { - *ok = true; - } return result; } diff --git a/libraries/render-utils/src/Model.h b/libraries/render-utils/src/Model.h index 5cbdb2d300..603153d535 100644 --- a/libraries/render-utils/src/Model.h +++ b/libraries/render-utils/src/Model.h @@ -317,7 +317,7 @@ public: int getResourceDownloadAttempts() { return _renderWatcher.getResourceDownloadAttempts(); } int getResourceDownloadAttemptsRemaining() { return _renderWatcher.getResourceDownloadAttemptsRemaining(); } - virtual scriptable::ScriptableModelBase getScriptableModel(bool* ok = nullptr) override; + virtual scriptable::ScriptableModelBase getScriptableModel() override; virtual bool replaceScriptableModelMeshPart(scriptable::ScriptableModelBasePointer model, int meshIndex, int partIndex) override; void scaleToFit(); diff --git a/libraries/render-utils/src/Model_temporary_hack.cpp.h b/libraries/render-utils/src/Model_temporary_hack.cpp.h index 9b0e0bcf9a..51318656e0 100644 --- a/libraries/render-utils/src/Model_temporary_hack.cpp.h +++ b/libraries/render-utils/src/Model_temporary_hack.cpp.h @@ -1,9 +1,9 @@ #include #include -class MyGeometryMappingResource : public GeometryResource { +class MyGeometryResource : public GeometryResource { public: shared_ptr fbxGeometry; - MyGeometryMappingResource(const QUrl& url, Geometry::Pointer originalGeometry, std::shared_ptr newModel) : GeometryResource(url) { + MyGeometryResource(const QUrl& url, Geometry::Pointer originalGeometry, scriptable::ScriptableModelBasePointer newModel) : GeometryResource(url) { fbxGeometry = std::make_shared(); FBXGeometry& geometry = *fbxGeometry.get(); const FBXGeometry* original; @@ -15,41 +15,12 @@ public: original = tmpGeometry.get(); } geometry.originalURL = original->originalURL; + geometry.bindExtents = original->bindExtents; - geometry.author = original->author; - geometry.applicationName = original->applicationName; for (const auto &j : original->joints) { geometry.joints << j; } - geometry.jointIndices = QHash{ original->jointIndices }; - - geometry.animationFrames = QVector{ original->animationFrames }; - geometry.meshIndicesToModelNames = QHash{ original->meshIndicesToModelNames }; - geometry.blendshapeChannelNames = QList{ original->blendshapeChannelNames }; - - geometry.hasSkeletonJoints = original->hasSkeletonJoints; - geometry.offset = original->offset; - geometry.leftEyeJointIndex = original->leftEyeJointIndex; - geometry.rightEyeJointIndex = original->rightEyeJointIndex; - geometry.neckJointIndex = original->neckJointIndex; - geometry.rootJointIndex = original->rootJointIndex; - geometry.leanJointIndex = original->leanJointIndex; - geometry.headJointIndex = original->headJointIndex; - geometry.leftHandJointIndex = original->leftHandJointIndex; - geometry.rightHandJointIndex = original->rightHandJointIndex; - geometry.leftToeJointIndex = original->leftToeJointIndex; - geometry.rightToeJointIndex = original->rightToeJointIndex; - geometry.leftEyeSize = original->leftEyeSize; - geometry.rightEyeSize = original->rightEyeSize; - geometry.humanIKJointIndices = original->humanIKJointIndices; - geometry.palmDirection = original->palmDirection; - geometry.neckPivot = original->neckPivot; - geometry.bindExtents = original->bindExtents; - - // Copy materials - QHash materialIDAtlas; for (const FBXMaterial& material : original->materials) { - materialIDAtlas[material.materialID] = _materials.size(); _materials.push_back(std::make_shared(material, _textureBaseUrl)); } std::shared_ptr meshes = std::make_shared(); @@ -58,6 +29,7 @@ public: if (newModel) { geometry.meshExtents.reset(); for (const auto& newMesh : newModel->meshes) { + // qDebug() << "newMesh #" << meshID; FBXMesh mesh; if (meshID < original->meshes.size()) { mesh = original->meshes.at(meshID); // copy @@ -73,7 +45,7 @@ public: mesh.createBlendShapeTangents(false); geometry.meshes << mesh; // Copy mesh pointers - meshes->emplace_back(newMesh.getMeshPointer());//buffer_helpers::cloneMesh(ptr)); + meshes->emplace_back(newMesh.getMeshPointer()); int partID = 0; const auto oldParts = mesh.parts; mesh.parts.clear(); @@ -83,7 +55,7 @@ public: // Construct local parts part.triangleIndices = buffer_helpers::toVector(mesh._mesh->getIndexBuffer(), "part.triangleIndices"); mesh.parts << part; - auto p = std::make_shared(meshID, partID, (int)materialIDAtlas[part.materialID]); + auto p = std::make_shared(meshID, partID, 0); parts->push_back(p); partID++; } @@ -94,20 +66,18 @@ public: glm::vec3 transformedVertex = glm::vec3(mesh.modelTransform * glm::vec4(vertex, 1.0f)); geometry.meshExtents.minimum = glm::min(geometry.meshExtents.minimum, transformedVertex); geometry.meshExtents.maximum = glm::max(geometry.meshExtents.maximum, transformedVertex); - + mesh.meshExtents.minimum = glm::min(mesh.meshExtents.minimum, transformedVertex); mesh.meshExtents.maximum = glm::max(mesh.meshExtents.maximum, transformedVertex); } } - meshID++; } } _meshes = meshes; _meshParts = parts; - _animGraphOverrideUrl = originalGeometry ? originalGeometry->getAnimGraphOverrideUrl() : QUrl(); _loaded = true; _fbxGeometry = fbxGeometry; - }; + }; }; diff --git a/tools/jsdoc/package-lock.json b/tools/jsdoc/package-lock.json deleted file mode 100644 index 073bbf60f6..0000000000 --- a/tools/jsdoc/package-lock.json +++ /dev/null @@ -1,138 +0,0 @@ -{ - "name": "hifiJSDoc", - "requires": true, - "lockfileVersion": 1, - "dependencies": { - "babylon": { - "version": "7.0.0-beta.19", - "resolved": "https://registry.npmjs.org/babylon/-/babylon-7.0.0-beta.19.tgz", - "integrity": "sha512-Vg0C9s/REX6/WIXN37UKpv5ZhRi6A4pjHlpkE34+8/a6c2W1Q692n3hmc+SZG5lKRnaExLUbxtJ1SVT+KaCQ/A==" - }, - "bluebird": { - "version": "3.5.1", - "resolved": "https://registry.npmjs.org/bluebird/-/bluebird-3.5.1.tgz", - "integrity": "sha512-MKiLiV+I1AA596t9w1sQJ8jkiSr5+ZKi0WKrYGUn6d1Fx+Ij4tIj+m2WMQSGczs5jZVxV339chE8iwk6F64wjA==" - }, - "catharsis": { - "version": "0.8.9", - "resolved": "https://registry.npmjs.org/catharsis/-/catharsis-0.8.9.tgz", - "integrity": "sha1-mMyJDKZS3S7w5ws3klMQ/56Q/Is=", - "requires": { - "underscore-contrib": "0.3.0" - } - }, - "escape-string-regexp": { - "version": "1.0.5", - "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz", - "integrity": "sha1-G2HAViGQqN/2rjuyzwIAyhMLhtQ=" - }, - "graceful-fs": { - "version": "4.1.11", - "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.1.11.tgz", - "integrity": "sha1-Dovf5NHduIVNZOBOp8AOKgJuVlg=" - }, - "js2xmlparser": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/js2xmlparser/-/js2xmlparser-3.0.0.tgz", - "integrity": "sha1-P7YOqgicVED5MZ9RdgzNB+JJlzM=", - "requires": { - "xmlcreate": "1.0.2" - } - }, - "jsdoc": { - "version": "3.5.5", - "resolved": "https://registry.npmjs.org/jsdoc/-/jsdoc-3.5.5.tgz", - "integrity": "sha512-6PxB65TAU4WO0Wzyr/4/YhlGovXl0EVYfpKbpSroSj0qBxT4/xod/l40Opkm38dRHRdQgdeY836M0uVnJQG7kg==", - "requires": { - "babylon": "7.0.0-beta.19", - "bluebird": "3.5.1", - "catharsis": "0.8.9", - "escape-string-regexp": "1.0.5", - "js2xmlparser": "3.0.0", - "klaw": "2.0.0", - "marked": "0.3.12", - "mkdirp": "0.5.1", - "requizzle": "0.2.1", - "strip-json-comments": "2.0.1", - "taffydb": "2.6.2", - "underscore": "1.8.3" - } - }, - "klaw": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/klaw/-/klaw-2.0.0.tgz", - "integrity": "sha1-WcEo4Nxc5BAgEVEZTuucv4WGUPY=", - "requires": { - "graceful-fs": "4.1.11" - } - }, - "marked": { - "version": "0.3.12", - "resolved": "https://registry.npmjs.org/marked/-/marked-0.3.12.tgz", - "integrity": "sha512-k4NaW+vS7ytQn6MgJn3fYpQt20/mOgYM5Ft9BYMfQJDz2QT6yEeS9XJ8k2Nw8JTeWK/znPPW2n3UJGzyYEiMoA==" - }, - "minimist": { - "version": "0.0.8", - "resolved": "https://registry.npmjs.org/minimist/-/minimist-0.0.8.tgz", - "integrity": "sha1-hX/Kv8M5fSYluCKCYuhqp6ARsF0=" - }, - "mkdirp": { - "version": "0.5.1", - "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.1.tgz", - "integrity": "sha1-MAV0OOrGz3+MR2fzhkjWaX11yQM=", - "requires": { - "minimist": "0.0.8" - } - }, - "requizzle": { - "version": "0.2.1", - "resolved": "https://registry.npmjs.org/requizzle/-/requizzle-0.2.1.tgz", - "integrity": "sha1-aUPDUwxNmn5G8c3dUcFY/GcM294=", - "requires": { - "underscore": "1.6.0" - }, - "dependencies": { - "underscore": { - "version": "1.6.0", - "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.6.0.tgz", - "integrity": "sha1-izixDKze9jM3uLJOT/htRa6lKag=" - } - } - }, - "strip-json-comments": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-2.0.1.tgz", - "integrity": "sha1-PFMZQukIwml8DsNEhYwobHygpgo=" - }, - "taffydb": { - "version": "2.6.2", - "resolved": "https://registry.npmjs.org/taffydb/-/taffydb-2.6.2.tgz", - "integrity": "sha1-fLy2S1oUG2ou/CxdLGe04VCyomg=" - }, - "underscore": { - "version": "1.8.3", - "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.8.3.tgz", - "integrity": "sha1-Tz+1OxBuYJf8+ctBCfKl6b36UCI=" - }, - "underscore-contrib": { - "version": "0.3.0", - "resolved": "https://registry.npmjs.org/underscore-contrib/-/underscore-contrib-0.3.0.tgz", - "integrity": "sha1-ZltmwkeD+PorGMn4y7Dix9SMJsc=", - "requires": { - "underscore": "1.6.0" - }, - "dependencies": { - "underscore": { - "version": "1.6.0", - "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.6.0.tgz", - "integrity": "sha1-izixDKze9jM3uLJOT/htRa6lKag=" - } - } - }, - "xmlcreate": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/xmlcreate/-/xmlcreate-1.0.2.tgz", - "integrity": "sha1-+mv3YqYKQT+z3Y9LA8WyaSONMI8=" - } - } -}