Mirrors/overte
3
0
Fork 0
mirror of https://github.com/overte-org/overte.git synced 2025-08-09 01:17:14 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

use const reference for ScenePointer when possible

Browse source
This commit is contained in:
Andrew Meadows 2017-04-12 14:46:31 -07:00
parent 0cc6763617
commit 31bfc98b87
22 changed files with 79 additions and 85 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
interface/src/avatar/Avatar.cpp
View file

@ -507,7 +507,7 @@ static TextRenderer3D* textRenderer(TextRendererType type) {
return displayNameRenderer; return displayNameRenderer;
} }
void Avatar::addToScene(AvatarSharedPointer self, std::shared_ptr<render::Scene> scene, render::Transaction& transaction) { void Avatar::addToScene(AvatarSharedPointer self, const render::ScenePointer& scene, render::Transaction& transaction) {
auto avatarPayload = new render::Payload<AvatarData>(self); auto avatarPayload = new render::Payload<AvatarData>(self);
auto avatarPayloadPointer = Avatar::PayloadPointer(avatarPayload); auto avatarPayloadPointer = Avatar::PayloadPointer(avatarPayload);
_renderItemID = scene->allocateID(); _renderItemID = scene->allocateID();
@ -519,7 +519,7 @@ void Avatar::addToScene(AvatarSharedPointer self, std::shared_ptr<render::Scene>
} }
} }
void Avatar::removeFromScene(AvatarSharedPointer self, std::shared_ptr<render::Scene> scene, render::Transaction& transaction) { void Avatar::removeFromScene(AvatarSharedPointer self, const render::ScenePointer& scene, render::Transaction& transaction) {
transaction.removeItem(_renderItemID); transaction.removeItem(_renderItemID);
render::Item::clearID(_renderItemID); render::Item::clearID(_renderItemID);
_skeletonModel->removeFromScene(scene, transaction); _skeletonModel->removeFromScene(scene, transaction);
@ -693,7 +693,7 @@ glm::quat Avatar::computeRotationFromBodyToWorldUp(float proportion) const {
return glm::angleAxis(angle * proportion, axis); return glm::angleAxis(angle * proportion, axis);
} }
void Avatar::fixupModelsInScene(render::ScenePointer scene) { void Avatar::fixupModelsInScene(const render::ScenePointer& scene) {
_attachmentsToDelete.clear(); _attachmentsToDelete.clear();
// check to see if when we added our models to the scene they were ready, if they were not ready, then // check to see if when we added our models to the scene they were ready, if they were not ready, then
@ -1470,7 +1470,7 @@ QList<QVariant> Avatar::getSkeleton() {
return QList<QVariant>(); return QList<QVariant>();
} }
void Avatar::addToScene(AvatarSharedPointer myHandle, render::ScenePointer scene) { void Avatar::addToScene(AvatarSharedPointer myHandle, const render::ScenePointer& scene) {
if (scene) { if (scene) {
render::Transaction transaction; render::Transaction transaction;
auto nodelist = DependencyManager::get<NodeList>(); auto nodelist = DependencyManager::get<NodeList>();
@ -1485,7 +1485,7 @@ void Avatar::addToScene(AvatarSharedPointer myHandle, render::ScenePointer scene
} }
} }
void Avatar::ensureInScene(AvatarSharedPointer self, render::ScenePointer scene) { void Avatar::ensureInScene(AvatarSharedPointer self, const render::ScenePointer& scene) {
if (!render::Item::isValidID(_renderItemID)) { if (!render::Item::isValidID(_renderItemID)) {
addToScene(self, scene); addToScene(self, scene);
} }

10
interface/src/avatar/Avatar.h
View file

@ -79,10 +79,10 @@ public:
virtual void render(RenderArgs* renderArgs); virtual void render(RenderArgs* renderArgs);
void addToScene(AvatarSharedPointer self, std::shared_ptr<render::Scene> scene, void addToScene(AvatarSharedPointer self, const render::ScenePointer& scene,
render::Transaction& transaction); render::Transaction& transaction);
void removeFromScene(AvatarSharedPointer self, std::shared_ptr<render::Scene> scene, void removeFromScene(AvatarSharedPointer self, const render::ScenePointer& scene,
render::Transaction& transaction); render::Transaction& transaction);
void updateRenderItem(render::Transaction& transaction); void updateRenderItem(render::Transaction& transaction);
@ -303,7 +303,7 @@ protected:
Transform calculateDisplayNameTransform(const ViewFrustum& view, const glm::vec3& textPosition) const; Transform calculateDisplayNameTransform(const ViewFrustum& view, const glm::vec3& textPosition) const;
void renderDisplayName(gpu::Batch& batch, const ViewFrustum& view, const glm::vec3& textPosition) const; void renderDisplayName(gpu::Batch& batch, const ViewFrustum& view, const glm::vec3& textPosition) const;
virtual bool shouldRenderHead(const RenderArgs* renderArgs) const; virtual bool shouldRenderHead(const RenderArgs* renderArgs) const;
virtual void fixupModelsInScene(render::ScenePointer scene); virtual void fixupModelsInScene(const render::ScenePointer& scene);
virtual void updatePalms(); virtual void updatePalms();
@ -314,8 +314,8 @@ protected:
ThreadSafeValueCache<glm::vec3> _rightPalmPositionCache { glm::vec3() }; ThreadSafeValueCache<glm::vec3> _rightPalmPositionCache { glm::vec3() };
ThreadSafeValueCache<glm::quat> _rightPalmRotationCache { glm::quat() }; ThreadSafeValueCache<glm::quat> _rightPalmRotationCache { glm::quat() };
void addToScene(AvatarSharedPointer self, render::ScenePointer scene); void addToScene(AvatarSharedPointer self, const render::ScenePointer& scene);
void ensureInScene(AvatarSharedPointer self, render::ScenePointer scene); void ensureInScene(AvatarSharedPointer self, const render::ScenePointer& scene);
bool isInScene() const { return render::Item::isValidID(_renderItemID); } bool isInScene() const { return render::Item::isValidID(_renderItemID); }
// Some rate tracking support // Some rate tracking support

11
interface/src/avatar/MyAvatar.cpp
View file

@ -925,8 +925,7 @@ void MyAvatar::setEnableDebugDrawIKTargets(bool isEnabled) {
} }
void MyAvatar::setEnableMeshVisible(bool isEnabled) { void MyAvatar::setEnableMeshVisible(bool isEnabled) {
render::ScenePointer scene = qApp->getMain3DScene(); _skeletonModel->setVisibleInScene(isEnabled, qApp->getMain3DScene());
_skeletonModel->setVisibleInScene(isEnabled, scene);
} }
void MyAvatar::setUseAnimPreAndPostRotations(bool isEnabled) { void MyAvatar::setUseAnimPreAndPostRotations(bool isEnabled) {
@ -1223,8 +1222,7 @@ void MyAvatar::clearJointsData() {
void MyAvatar::setSkeletonModelURL(const QUrl& skeletonModelURL) { void MyAvatar::setSkeletonModelURL(const QUrl& skeletonModelURL) {
Avatar::setSkeletonModelURL(skeletonModelURL); Avatar::setSkeletonModelURL(skeletonModelURL);
render::ScenePointer scene = qApp->getMain3DScene(); _skeletonModel->setVisibleInScene(true, qApp->getMain3DScene());
_skeletonModel->setVisibleInScene(true, scene);
_headBoneSet.clear(); _headBoneSet.clear();
} }
@ -1538,7 +1536,7 @@ void MyAvatar::attach(const QString& modelURL, const QString& jointName,
Avatar::attach(modelURL, jointName, translation, rotation, scale, isSoft, allowDuplicates, useSaved); Avatar::attach(modelURL, jointName, translation, rotation, scale, isSoft, allowDuplicates, useSaved);
} }
void MyAvatar::setVisibleInSceneIfReady(Model* model, render::ScenePointer scene, bool visible) { void MyAvatar::setVisibleInSceneIfReady(Model* model, const render::ScenePointer& scene, bool visible) {
if (model->isActive() && model->isRenderable()) { if (model->isActive() && model->isRenderable()) {
model->setVisibleInScene(visible, scene); model->setVisibleInScene(visible, scene);
} }
@ -1632,8 +1630,7 @@ void MyAvatar::postUpdate(float deltaTime) {
Avatar::postUpdate(deltaTime); Avatar::postUpdate(deltaTime);
render::ScenePointer scene = qApp->getMain3DScene(); if (DependencyManager::get<SceneScriptingInterface>()->shouldRenderAvatars() && _skeletonModel->initWhenReady(qApp->getMain3DScene())) {
if (DependencyManager::get<SceneScriptingInterface>()->shouldRenderAvatars() && _skeletonModel->initWhenReady(scene)) {
initHeadBones(); initHeadBones();
_skeletonModel->setCauterizeBoneSet(_headBoneSet); _skeletonModel->setCauterizeBoneSet(_headBoneSet);
_fstAnimGraphOverrideUrl = _skeletonModel->getGeometry()->getAnimGraphOverrideUrl(); _fstAnimGraphOverrideUrl = _skeletonModel->getGeometry()->getAnimGraphOverrideUrl();

2
interface/src/avatar/MyAvatar.h
View file

@ -551,7 +551,7 @@ private:
// These are made private for MyAvatar so that you will use the "use" methods instead // These are made private for MyAvatar so that you will use the "use" methods instead
virtual void setSkeletonModelURL(const QUrl& skeletonModelURL) override; virtual void setSkeletonModelURL(const QUrl& skeletonModelURL) override;
void setVisibleInSceneIfReady(Model* model, render::ScenePointer scene, bool visiblity); void setVisibleInSceneIfReady(Model* model, const render::ScenePointer& scene, bool visiblity);
// derive avatar body position and orientation from the current HMD Sensor location. // derive avatar body position and orientation from the current HMD Sensor location.
// results are in HMD frame // results are in HMD frame

4
interface/src/ui/overlays/ModelOverlay.cpp
View file

@ -58,13 +58,13 @@ void ModelOverlay::update(float deltatime) {
_isLoaded = _model->isActive(); _isLoaded = _model->isActive();
} }
bool ModelOverlay::addToScene(Overlay::Pointer overlay, std::shared_ptr<render::Scene> scene, render::Transaction& transaction) { bool ModelOverlay::addToScene(Overlay::Pointer overlay, const render::ScenePointer& scene, render::Transaction& transaction) {
Volume3DOverlay::addToScene(overlay, scene, transaction); Volume3DOverlay::addToScene(overlay, scene, transaction);
_model->addToScene(scene, transaction); _model->addToScene(scene, transaction);
return true; return true;
} }
void ModelOverlay::removeFromScene(Overlay::Pointer overlay, std::shared_ptr<render::Scene> scene, render::Transaction& transaction) { void ModelOverlay::removeFromScene(Overlay::Pointer overlay, const render::ScenePointer& scene, render::Transaction& transaction) {
Volume3DOverlay::removeFromScene(overlay, scene, transaction); Volume3DOverlay::removeFromScene(overlay, scene, transaction);
_model->removeFromScene(scene, transaction); _model->removeFromScene(scene, transaction);
} }

4
interface/src/ui/overlays/ModelOverlay.h
View file

@ -36,8 +36,8 @@ public:
virtual ModelOverlay* createClone() const override; virtual ModelOverlay* createClone() const override;
virtual bool addToScene(Overlay::Pointer overlay, std::shared_ptr<render::Scene> scene, render::Transaction& transaction) override; virtual bool addToScene(Overlay::Pointer overlay, const render::ScenePointer& scene, render::Transaction& transaction) override;
virtual void removeFromScene(Overlay::Pointer overlay, std::shared_ptr<render::Scene> scene, render::Transaction& transaction) override; virtual void removeFromScene(Overlay::Pointer overlay, const render::ScenePointer& scene, render::Transaction& transaction) override;
void locationChanged(bool tellPhysics) override; void locationChanged(bool tellPhysics) override;

4
interface/src/ui/overlays/Overlay.cpp
View file

@ -196,13 +196,13 @@ float Overlay::updatePulse() {
return _pulse; return _pulse;
} }
bool Overlay::addToScene(Overlay::Pointer overlay, std::shared_ptr<render::Scene> scene, render::Transaction& transaction) { bool Overlay::addToScene(Overlay::Pointer overlay, const render::ScenePointer& scene, render::Transaction& transaction) {
_renderItemID = scene->allocateID(); _renderItemID = scene->allocateID();
transaction.resetItem(_renderItemID, std::make_shared<Overlay::Payload>(overlay)); transaction.resetItem(_renderItemID, std::make_shared<Overlay::Payload>(overlay));
return true; return true;
} }
void Overlay::removeFromScene(Overlay::Pointer overlay, std::shared_ptr<render::Scene> scene, render::Transaction& transaction) { void Overlay::removeFromScene(Overlay::Pointer overlay, const render::ScenePointer& scene, render::Transaction& transaction) {
transaction.removeItem(_renderItemID); transaction.removeItem(_renderItemID);
render::Item::clearID(_renderItemID); render::Item::clearID(_renderItemID);
} }

4
interface/src/ui/overlays/Overlay.h
View file

@ -48,8 +48,8 @@ public:
virtual AABox getBounds() const = 0; virtual AABox getBounds() const = 0;
virtual bool supportsGetProperty() const { return true; } virtual bool supportsGetProperty() const { return true; }
virtual bool addToScene(Overlay::Pointer overlay, std::shared_ptr<render::Scene> scene, render::Transaction& transaction); virtual bool addToScene(Overlay::Pointer overlay, const render::ScenePointer& scene, render::Transaction& transaction);
virtual void removeFromScene(Overlay::Pointer overlay, std::shared_ptr<render::Scene> scene, render::Transaction& transaction); virtual void removeFromScene(Overlay::Pointer overlay, const render::ScenePointer& scene, render::Transaction& transaction);
virtual const render::ShapeKey getShapeKey() { return render::ShapeKey::Builder::ownPipeline(); } virtual const render::ShapeKey getShapeKey() { return render::ShapeKey::Builder::ownPipeline(); }

8
libraries/entities-renderer/src/RenderableEntityItem.h
View file

@ -54,7 +54,7 @@ namespace render {
// Mixin class for implementing basic single item rendering // Mixin class for implementing basic single item rendering
class SimpleRenderableEntityItem { class SimpleRenderableEntityItem {
public: public:
bool addToScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene, render::Transaction& transaction) { bool addToScene(EntityItemPointer self, const render::ScenePointer& scene, render::Transaction& transaction) {
_myItem = scene->allocateID(); _myItem = scene->allocateID();
auto renderData = std::make_shared<RenderableEntityItemProxy>(self, _myItem); auto renderData = std::make_shared<RenderableEntityItemProxy>(self, _myItem);
@ -69,7 +69,7 @@ public:
return true; return true;
} }
void removeFromScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene, render::Transaction& transaction) { void removeFromScene(EntityItemPointer self, const render::ScenePointer& scene, render::Transaction& transaction) {
transaction.removeItem(_myItem); transaction.removeItem(_myItem);
render::Item::clearID(_myItem); render::Item::clearID(_myItem);
} }
@ -99,8 +99,8 @@ private:
#define SIMPLE_RENDERABLE() \ #define SIMPLE_RENDERABLE() \
public: \ public: \
virtual bool addToScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene, render::Transaction& transaction) override { return _renderHelper.addToScene(self, scene, transaction); } \ virtual bool addToScene(EntityItemPointer self, const render::ScenePointer& scene, render::Transaction& transaction) override { return _renderHelper.addToScene(self, scene, transaction); } \
virtual void removeFromScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene, render::Transaction& transaction) override { _renderHelper.removeFromScene(self, scene, transaction); } \ virtual void removeFromScene(EntityItemPointer self, const render::ScenePointer& scene, render::Transaction& transaction) override { _renderHelper.removeFromScene(self, scene, transaction); } \
virtual void locationChanged(bool tellPhysics = true) override { EntityItem::locationChanged(tellPhysics); _renderHelper.notifyChanged(); } \ virtual void locationChanged(bool tellPhysics = true) override { EntityItem::locationChanged(tellPhysics); _renderHelper.notifyChanged(); } \
virtual void dimensionsChanged() override { EntityItem::dimensionsChanged(); _renderHelper.notifyChanged(); } \ virtual void dimensionsChanged() override { EntityItem::dimensionsChanged(); _renderHelper.notifyChanged(); } \
void checkFading() { \ void checkFading() { \

4
libraries/entities-renderer/src/RenderableLightEntityItem.cpp
View file

@ -27,7 +27,7 @@ RenderableLightEntityItem::RenderableLightEntityItem(const EntityItemID& entityI
{ {
} }
bool RenderableLightEntityItem::addToScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene, render::Transaction& transaction) { bool RenderableLightEntityItem::addToScene(EntityItemPointer self, const render::ScenePointer& scene, render::Transaction& transaction) {
_myItem = scene->allocateID(); _myItem = scene->allocateID();
auto renderItem = std::make_shared<LightPayload>(); auto renderItem = std::make_shared<LightPayload>();
@ -51,7 +51,7 @@ void RenderableLightEntityItem::somethingChangedNotification() {
LightEntityItem::somethingChangedNotification(); LightEntityItem::somethingChangedNotification();
} }
void RenderableLightEntityItem::removeFromScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene, render::Transaction& transaction) { void RenderableLightEntityItem::removeFromScene(EntityItemPointer self, const render::ScenePointer& scene, render::Transaction& transaction) {
transaction.removeItem(_myItem); transaction.removeItem(_myItem);
render::Item::clearID(_myItem); render::Item::clearID(_myItem);
} }

4
libraries/entities-renderer/src/RenderableLightEntityItem.h
View file

@ -30,10 +30,10 @@ public:
void updateLightFromEntity(render::Transaction& transaction); void updateLightFromEntity(render::Transaction& transaction);
virtual bool addToScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene, render::Transaction& transaction) override; virtual bool addToScene(EntityItemPointer self, const render::ScenePointer& scene, render::Transaction& transaction) override;
virtual void somethingChangedNotification() override; virtual void somethingChangedNotification() override;
virtual void removeFromScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene, render::Transaction& transaction) override; virtual void removeFromScene(EntityItemPointer self, const render::ScenePointer& scene, render::Transaction& transaction) override;
virtual void locationChanged(bool tellPhysics = true) override; virtual void locationChanged(bool tellPhysics = true) override;

37
libraries/entities-renderer/src/RenderableModelEntityItem.cpp
View file

@ -91,13 +91,13 @@ bool RenderableModelEntityItem::setProperties(const EntityItemProperties& proper
return somethingChanged; return somethingChanged;
} }
int RenderableModelEntityItem::readEntitySubclassDataFromBuffer(const unsigned char* data, int bytesLeftToRead, int RenderableModelEntityItem::readEntitySubclassDataFromBuffer(const unsigned char* data, int bytesLeftToRead,
ReadBitstreamToTreeParams& args, ReadBitstreamToTreeParams& args,
EntityPropertyFlags& propertyFlags, bool overwriteLocalData, EntityPropertyFlags& propertyFlags, bool overwriteLocalData,
bool& somethingChanged) { bool& somethingChanged) {
QString oldModelURL = getModelURL(); QString oldModelURL = getModelURL();
int bytesRead = ModelEntityItem::readEntitySubclassDataFromBuffer(data, bytesLeftToRead, int bytesRead = ModelEntityItem::readEntitySubclassDataFromBuffer(data, bytesLeftToRead,
args, propertyFlags, args, propertyFlags,
overwriteLocalData, somethingChanged); overwriteLocalData, somethingChanged);
if (oldModelURL != getModelURL()) { if (oldModelURL != getModelURL()) {
_needsModelReload = true; _needsModelReload = true;
@ -137,7 +137,7 @@ void RenderableModelEntityItem::remapTextures() {
if (!_model) { if (!_model) {
return; // nothing to do if we don't have a model return; // nothing to do if we don't have a model
} }
if (!_model->isLoaded()) { if (!_model->isLoaded()) {
return; // nothing to do if the model has not yet loaded return; // nothing to do if the model has not yet loaded
} }
@ -189,16 +189,16 @@ public:
RenderableModelEntityItemMeta(EntityItemPointer entity) : entity(entity){ } RenderableModelEntityItemMeta(EntityItemPointer entity) : entity(entity){ }
typedef render::Payload<RenderableModelEntityItemMeta> Payload; typedef render::Payload<RenderableModelEntityItemMeta> Payload;
typedef Payload::DataPointer Pointer; typedef Payload::DataPointer Pointer;
EntityItemPointer entity; EntityItemPointer entity;
}; };
namespace render { namespace render {
template <> const ItemKey payloadGetKey(const RenderableModelEntityItemMeta::Pointer& payload) { template <> const ItemKey payloadGetKey(const RenderableModelEntityItemMeta::Pointer& payload) {
return ItemKey::Builder::opaqueShape().withTypeMeta(); return ItemKey::Builder::opaqueShape().withTypeMeta();
} }
template <> const Item::Bound payloadGetBound(const RenderableModelEntityItemMeta::Pointer& payload) { template <> const Item::Bound payloadGetBound(const RenderableModelEntityItemMeta::Pointer& payload) {
if (payload && payload->entity) { if (payload && payload->entity) {
bool success; bool success;
auto result = payload->entity->getAABox(success); auto result = payload->entity->getAABox(success);
@ -228,7 +228,7 @@ namespace render {
} }
} }
bool RenderableModelEntityItem::addToScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene, bool RenderableModelEntityItem::addToScene(EntityItemPointer self, const render::ScenePointer& scene,
render::Transaction& transaction) { render::Transaction& transaction) {
_myMetaItem = scene->allocateID(); _myMetaItem = scene->allocateID();
@ -249,7 +249,7 @@ bool RenderableModelEntityItem::addToScene(EntityItemPointer self, std::shared_p
return true; return true;
} }
void RenderableModelEntityItem::removeFromScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene, void RenderableModelEntityItem::removeFromScene(EntityItemPointer self, const render::ScenePointer& scene,
render::Transaction& transaction) { render::Transaction& transaction) {
transaction.removeItem(_myMetaItem); transaction.removeItem(_myMetaItem);
render::Item::clearID(_myMetaItem); render::Item::clearID(_myMetaItem);
@ -437,7 +437,7 @@ void RenderableModelEntityItem::render(RenderArgs* args) {
_model->renderDebugMeshBoxes(batch); _model->renderDebugMeshBoxes(batch);
#endif #endif
render::ScenePointer scene = AbstractViewStateInterface::instance()->getMain3DScene(); const render::ScenePointer& scene = AbstractViewStateInterface::instance()->getMain3DScene();
// FIXME: this seems like it could be optimized if we tracked our last known visible state in // FIXME: this seems like it could be optimized if we tracked our last known visible state in
// the renderable item. As it stands now the model checks it's visible/invisible state // the renderable item. As it stands now the model checks it's visible/invisible state
@ -502,11 +502,11 @@ ModelPointer RenderableModelEntityItem::getModel(QSharedPointer<EntityTreeRender
_myRenderer = renderer; _myRenderer = renderer;
} }
assert(_myRenderer == renderer); // you should only ever render on one renderer assert(_myRenderer == renderer); // you should only ever render on one renderer
if (!_myRenderer || QThread::currentThread() != _myRenderer->thread()) { if (!_myRenderer || QThread::currentThread() != _myRenderer->thread()) {
return _model; return _model;
} }
_needsModelReload = false; // this is the reload _needsModelReload = false; // this is the reload
// If we have a URL, then we will want to end up returning a model... // If we have a URL, then we will want to end up returning a model...
@ -526,7 +526,7 @@ ModelPointer RenderableModelEntityItem::getModel(QSharedPointer<EntityTreeRender
// If we have no URL, then we can delete any model we do have... // If we have no URL, then we can delete any model we do have...
} else if (_model) { } else if (_model) {
// remove from scene // remove from scene
render::ScenePointer scene = AbstractViewStateInterface::instance()->getMain3DScene(); const render::ScenePointer& scene = AbstractViewStateInterface::instance()->getMain3DScene();
render::Transaction transaction; render::Transaction transaction;
_model->removeFromScene(scene, transaction); _model->removeFromScene(scene, transaction);
scene->enqueueTransaction(transaction); scene->enqueueTransaction(transaction);
@ -552,7 +552,7 @@ void RenderableModelEntityItem::update(const quint64& now) {
properties.setLastEdited(usecTimestampNow()); // we must set the edit time since we're editing it properties.setLastEdited(usecTimestampNow()); // we must set the edit time since we're editing it
auto extents = _model->getMeshExtents(); auto extents = _model->getMeshExtents();
properties.setDimensions(extents.maximum - extents.minimum); properties.setDimensions(extents.maximum - extents.minimum);
qCDebug(entitiesrenderer) << "Autoresizing" << (!getName().isEmpty() ? getName() : getModelURL()) qCDebug(entitiesrenderer) << "Autoresizing" << (!getName().isEmpty() ? getName() : getModelURL())
<< "from mesh extents"; << "from mesh extents";
QMetaObject::invokeMethod(DependencyManager::get<EntityScriptingInterface>().data(), "editEntity", QMetaObject::invokeMethod(DependencyManager::get<EntityScriptingInterface>().data(), "editEntity",
Qt::QueuedConnection, Qt::QueuedConnection,
@ -594,8 +594,8 @@ bool RenderableModelEntityItem::supportsDetailedRayIntersection() const {
return _model && _model->isLoaded(); return _model && _model->isLoaded();
} }
bool RenderableModelEntityItem::findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction, bool RenderableModelEntityItem::findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
bool& keepSearching, OctreeElementPointer& element, float& distance, BoxFace& face, bool& keepSearching, OctreeElementPointer& element, float& distance, BoxFace& face,
glm::vec3& surfaceNormal, void** intersectedObject, bool precisionPicking) const { glm::vec3& surfaceNormal, void** intersectedObject, bool precisionPicking) const {
if (!_model) { if (!_model) {
return true; return true;
@ -1239,11 +1239,10 @@ void RenderableModelEntityItem::locationChanged(bool tellPhysics) {
return; return;
} }
render::ScenePointer scene = AbstractViewStateInterface::instance()->getMain3DScene();
render::Transaction transaction; render::Transaction transaction;
transaction.updateItem(myMetaItem); transaction.updateItem(myMetaItem);
scene->enqueueTransaction(transaction); AbstractViewStateInterface::instance()->getMain3DScene()->enqueueTransaction(transaction);
}); });
} }
} }

4
libraries/entities-renderer/src/RenderableModelEntityItem.h
View file

@ -40,8 +40,8 @@ public:
void doInitialModelSimulation(); void doInitialModelSimulation();
virtual bool addToScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene, render::Transaction& transaction) override; virtual bool addToScene(EntityItemPointer self, const render::ScenePointer& scene, render::Transaction& transaction) override;
virtual void removeFromScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene, render::Transaction& transaction) override; virtual void removeFromScene(EntityItemPointer self, const render::ScenePointer& scene, render::Transaction& transaction) override;
void updateModelBounds(); void updateModelBounds();

6
libraries/entities-renderer/src/RenderableParticleEffectEntityItem.cpp
View file

@ -161,7 +161,7 @@ RenderableParticleEffectEntityItem::RenderableParticleEffectEntityItem(const Ent
} }
bool RenderableParticleEffectEntityItem::addToScene(EntityItemPointer self, bool RenderableParticleEffectEntityItem::addToScene(EntityItemPointer self,
render::ScenePointer scene, const render::ScenePointer& scene,
render::Transaction& transaction) { render::Transaction& transaction) {
_scene = scene; _scene = scene;
_renderItemId = _scene->allocateID(); _renderItemId = _scene->allocateID();
@ -176,7 +176,7 @@ bool RenderableParticleEffectEntityItem::addToScene(EntityItemPointer self,
} }
void RenderableParticleEffectEntityItem::removeFromScene(EntityItemPointer self, void RenderableParticleEffectEntityItem::removeFromScene(EntityItemPointer self,
render::ScenePointer scene, const render::ScenePointer& scene,
render::Transaction& transaction) { render::Transaction& transaction) {
transaction.removeItem(_renderItemId); transaction.removeItem(_renderItemId);
_scene = nullptr; _scene = nullptr;
@ -323,4 +323,4 @@ void RenderableParticleEffectEntityItem::notifyBoundChanged() {
}); });
_scene->enqueueTransaction(transaction); _scene->enqueueTransaction(transaction);
} }

4
libraries/entities-renderer/src/RenderableParticleEffectEntityItem.h
View file

@ -25,8 +25,8 @@ public:
void updateRenderItem(); void updateRenderItem();
virtual bool addToScene(EntityItemPointer self, render::ScenePointer scene, render::Transaction& transaction) override; virtual bool addToScene(EntityItemPointer self, const render::ScenePointer& scene, render::Transaction& transaction) override;
virtual void removeFromScene(EntityItemPointer self, render::ScenePointer scene, render::Transaction& transaction) override; virtual void removeFromScene(EntityItemPointer self, const render::ScenePointer& scene, render::Transaction& transaction) override;
protected: protected:
virtual void locationChanged(bool tellPhysics = true) override { EntityItem::locationChanged(tellPhysics); notifyBoundChanged(); } virtual void locationChanged(bool tellPhysics = true) override { EntityItem::locationChanged(tellPhysics); notifyBoundChanged(); }

4
libraries/entities-renderer/src/RenderablePolyVoxEntityItem.cpp
View file

@ -816,7 +816,7 @@ void RenderablePolyVoxEntityItem::render(RenderArgs* args) {
} }
bool RenderablePolyVoxEntityItem::addToScene(EntityItemPointer self, bool RenderablePolyVoxEntityItem::addToScene(EntityItemPointer self,
std::shared_ptr<render::Scene> scene, const render::ScenePointer& scene,
render::Transaction& transaction) { render::Transaction& transaction) {
_myItem = scene->allocateID(); _myItem = scene->allocateID();
@ -834,7 +834,7 @@ bool RenderablePolyVoxEntityItem::addToScene(EntityItemPointer self,
} }
void RenderablePolyVoxEntityItem::removeFromScene(EntityItemPointer self, void RenderablePolyVoxEntityItem::removeFromScene(EntityItemPointer self,
std::shared_ptr<render::Scene> scene, const render::ScenePointer& scene,
render::Transaction& transaction) { render::Transaction& transaction) {
transaction.removeItem(_myItem); transaction.removeItem(_myItem);
render::Item::clearID(_myItem); render::Item::clearID(_myItem);

4
libraries/entities-renderer/src/RenderablePolyVoxEntityItem.h
View file

@ -106,10 +106,10 @@ public:
virtual void setZTextureURL(const QString& zTextureURL) override; virtual void setZTextureURL(const QString& zTextureURL) override;
virtual bool addToScene(EntityItemPointer self, virtual bool addToScene(EntityItemPointer self,
std::shared_ptr<render::Scene> scene, const render::ScenePointer& scene,
render::Transaction& transaction) override; render::Transaction& transaction) override;
virtual void removeFromScene(EntityItemPointer self, virtual void removeFromScene(EntityItemPointer self,
std::shared_ptr<render::Scene> scene, const render::ScenePointer& scene,
render::Transaction& transaction) override; render::Transaction& transaction) override;
virtual void setXNNeighborID(const EntityItemID& xNNeighborID) override; virtual void setXNNeighborID(const EntityItemID& xNNeighborID) override;

4
libraries/entities-renderer/src/RenderableZoneEntityItem.cpp
View file

@ -217,7 +217,7 @@ namespace render {
} }
} }
bool RenderableZoneEntityItem::addToScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene, bool RenderableZoneEntityItem::addToScene(EntityItemPointer self, const render::ScenePointer& scene,
render::Transaction& transaction) { render::Transaction& transaction) {
_myMetaItem = scene->allocateID(); _myMetaItem = scene->allocateID();
@ -232,7 +232,7 @@ bool RenderableZoneEntityItem::addToScene(EntityItemPointer self, std::shared_pt
return true; return true;
} }
void RenderableZoneEntityItem::removeFromScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene, void RenderableZoneEntityItem::removeFromScene(EntityItemPointer self, const render::ScenePointer& scene,
render::Transaction& transaction) { render::Transaction& transaction) {
transaction.removeItem(_myMetaItem); transaction.removeItem(_myMetaItem);
render::Item::clearID(_myMetaItem); render::Item::clearID(_myMetaItem);

4
libraries/entities-renderer/src/RenderableZoneEntityItem.h
View file

@ -38,8 +38,8 @@ public:
virtual void render(RenderArgs* args) override; virtual void render(RenderArgs* args) override;
virtual bool contains(const glm::vec3& point) const override; virtual bool contains(const glm::vec3& point) const override;
virtual bool addToScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene, render::Transaction& transaction) override; virtual bool addToScene(EntityItemPointer self, const render::ScenePointer& scene, render::Transaction& transaction) override;
virtual void removeFromScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene, render::Transaction& transaction) override; virtual void removeFromScene(EntityItemPointer self, const render::ScenePointer& scene, render::Transaction& transaction) override;
render::ItemID getRenderItemID() const { return _myMetaItem; } render::ItemID getRenderItemID() const { return _myMetaItem; }

4
libraries/entities/src/EntityItem.h
View file

@ -151,9 +151,9 @@ public:
bool& somethingChanged) bool& somethingChanged)
{ somethingChanged = false; return 0; } { somethingChanged = false; return 0; }
virtual bool addToScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene, virtual bool addToScene(EntityItemPointer self, const render::ScenePointer& scene,
render::Transaction& transaction) { return false; } // by default entity items don't add to scene render::Transaction& transaction) { return false; } // by default entity items don't add to scene
virtual void removeFromScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene, virtual void removeFromScene(EntityItemPointer self, const render::ScenePointer& scene,
render::Transaction& transaction) { } // by default entity items don't add to scene render::Transaction& transaction) { } // by default entity items don't add to scene
virtual void render(RenderArgs* args) { } // by default entity items don't know how to render virtual void render(RenderArgs* args) { } // by default entity items don't know how to render

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

@ -231,8 +231,6 @@ void Model::updateRenderItems() {
// We need to update them here so we can correctly update the bounding box. // We need to update them here so we can correctly update the bounding box.
self->updateClusterMatrices(); self->updateClusterMatrices();
render::ScenePointer scene = AbstractViewStateInterface::instance()->getMain3DScene();
uint32_t deleteGeometryCounter = self->_deleteGeometryCounter; uint32_t deleteGeometryCounter = self->_deleteGeometryCounter;
render::Transaction transaction; render::Transaction transaction;
@ -266,7 +264,7 @@ void Model::updateRenderItems() {
}); });
} }
scene->enqueueTransaction(transaction); AbstractViewStateInterface::instance()->getMain3DScene()->enqueueTransaction(transaction);
}); });
} }
@ -534,7 +532,7 @@ void Model::calculateTriangleSets() {
} }
} }
void Model::setVisibleInScene(bool newValue, std::shared_ptr<render::Scene> scene) { void Model::setVisibleInScene(bool newValue, const render::ScenePointer& scene) {
if (_isVisible != newValue) { if (_isVisible != newValue) {
_isVisible = newValue; _isVisible = newValue;
@ -550,7 +548,7 @@ void Model::setVisibleInScene(bool newValue, std::shared_ptr<render::Scene> scen
} }
void Model::setLayeredInFront(bool layered, std::shared_ptr<render::Scene> scene) { void Model::setLayeredInFront(bool layered, const render::ScenePointer& scene) {
if (_isLayeredInFront != layered) { if (_isLayeredInFront != layered) {
_isLayeredInFront = layered; _isLayeredInFront = layered;
@ -565,7 +563,7 @@ void Model::setLayeredInFront(bool layered, std::shared_ptr<render::Scene> scene
} }
} }
bool Model::addToScene(std::shared_ptr<render::Scene> scene, bool Model::addToScene(const render::ScenePointer& scene,
render::Transaction& transaction, render::Transaction& transaction,
render::Item::Status::Getters& statusGetters) { render::Item::Status::Getters& statusGetters) {
bool readyToRender = _collisionGeometry || isLoaded(); bool readyToRender = _collisionGeometry || isLoaded();
@ -622,7 +620,7 @@ bool Model::addToScene(std::shared_ptr<render::Scene> scene,
return somethingAdded; return somethingAdded;
} }
void Model::removeFromScene(std::shared_ptr<render::Scene> scene, render::Transaction& transaction) { void Model::removeFromScene(const render::ScenePointer& scene, render::Transaction& transaction) {
foreach (auto item, _modelMeshRenderItemsMap.keys()) { foreach (auto item, _modelMeshRenderItemsMap.keys()) {
transaction.removeItem(item); transaction.removeItem(item);
} }
@ -795,7 +793,7 @@ void Model::setURL(const QUrl& url) {
{ {
render::Transaction transaction; render::Transaction transaction;
render::ScenePointer scene = AbstractViewStateInterface::instance()->getMain3DScene(); const render::ScenePointer& scene = AbstractViewStateInterface::instance()->getMain3DScene();
if (scene) { if (scene) {
removeFromScene(scene, transaction); removeFromScene(scene, transaction);
scene->enqueueTransaction(transaction); scene->enqueueTransaction(transaction);
@ -1271,7 +1269,7 @@ bool Model::isRenderable() const {
return !_meshStates.isEmpty() || (isLoaded() && _renderGeometry->getMeshes().empty()); return !_meshStates.isEmpty() || (isLoaded() && _renderGeometry->getMeshes().empty());
} }
bool Model::initWhenReady(render::ScenePointer scene) { bool Model::initWhenReady(const render::ScenePointer& scene) {
// NOTE: this only called by SkeletonModel // NOTE: this only called by SkeletonModel
if (_addedToScene || !isRenderable()) { if (_addedToScene || !isRenderable()) {
return false; return false;

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

@ -81,21 +81,21 @@ public:
const QUrl& getURL() const { return _url; } const QUrl& getURL() const { return _url; }
// new Scene/Engine rendering support // new Scene/Engine rendering support
void setVisibleInScene(bool newValue, std::shared_ptr<render::Scene> scene); void setVisibleInScene(bool newValue, const render::ScenePointer& scene);
void setLayeredInFront(bool layered, std::shared_ptr<render::Scene> scene); void setLayeredInFront(bool layered, const render::ScenePointer& scene);
bool needsFixupInScene() const; bool needsFixupInScene() const;
bool needsReload() const { return _needsReload; } bool needsReload() const { return _needsReload; }
bool initWhenReady(render::ScenePointer scene); bool initWhenReady(const render::ScenePointer& scene);
bool addToScene(std::shared_ptr<render::Scene> scene, bool addToScene(const render::ScenePointer& scene,
render::Transaction& transaction) { render::Transaction& transaction) {
auto getters = render::Item::Status::Getters(0); auto getters = render::Item::Status::Getters(0);
return addToScene(scene, transaction, getters); return addToScene(scene, transaction, getters);
} }
bool addToScene(std::shared_ptr<render::Scene> scene, bool addToScene(const render::ScenePointer& scene,
render::Transaction& transaction, render::Transaction& transaction,
render::Item::Status::Getters& statusGetters); render::Item::Status::Getters& statusGetters);
void removeFromScene(std::shared_ptr<render::Scene> scene, render::Transaction& transaction); void removeFromScene(const render::ScenePointer& scene, render::Transaction& transaction);
bool isRenderable() const; bool isRenderable() const;
bool isVisible() const { return _isVisible; } bool isVisible() const { return _isVisible; }