Mirrors/overte-HifiExperiments
3
0
Fork 0
mirror of https://github.com/HifiExperiments/overte.git synced 2025-04-05 20:36:28 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Cleanup and refactoring

Browse source
This commit is contained in:
Brad Davis 2017-06-15 17:52:27 -07:00
parent 0597c3105f
commit fece438602
96 changed files with 495 additions and 605 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
assignment-client/src/Agent.h
View file

@ -23,7 +23,6 @@
#include <EntityEditPacketSender.h>
#include <EntityTree.h>
#include <EntityTreeHeadlessViewer.h>
#include <ScriptEngine.h>
#include <ThreadedAssignment.h>
@ -31,6 +30,7 @@
#include "AudioGate.h"
#include "MixedAudioStream.h"
#include "entities/EntityTreeHeadlessViewer.h"
#include "avatars/ScriptableAvatar.h"
class Agent : public ThreadedAssignment {

0
libraries/entities/src/EntityTreeHeadlessViewer.cpp → assignment-client/src/entities/EntityTreeHeadlessViewer.cpp
View file

2
libraries/entities/src/EntityTreeHeadlessViewer.h → assignment-client/src/entities/EntityTreeHeadlessViewer.h
View file

@ -16,9 +16,9 @@
#include <SharedUtil.h>
#include <Octree.h>
#include <OctreePacketData.h>
#include <OctreeHeadlessViewer.h>
#include <ViewFrustum.h>
#include "../octree/OctreeHeadlessViewer.h"
#include "EntityTree.h"
class EntitySimulation;

13
libraries/octree/src/OctreeHeadlessViewer.cpp → assignment-client/src/octree/OctreeHeadlessViewer.cpp
View file

@ -9,17 +9,14 @@
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
#include <NodeList.h>
#include "OctreeLogging.h"
#include "OctreeHeadlessViewer.h"
OctreeHeadlessViewer::OctreeHeadlessViewer() : OctreeRenderer() {
_viewFrustum.setProjection(glm::perspective(glm::radians(DEFAULT_FIELD_OF_VIEW_DEGREES), DEFAULT_ASPECT_RATIO, DEFAULT_NEAR_CLIP, DEFAULT_FAR_CLIP));
}
#include <NodeList.h>
#include <OctreeLogging.h>
void OctreeHeadlessViewer::init() {
OctreeRenderer::init();
OctreeHeadlessViewer::OctreeHeadlessViewer() {
_viewFrustum.setProjection(glm::perspective(glm::radians(DEFAULT_FIELD_OF_VIEW_DEGREES), DEFAULT_ASPECT_RATIO, DEFAULT_NEAR_CLIP, DEFAULT_FAR_CLIP));
}
void OctreeHeadlessViewer::queryOctree() {

20
libraries/octree/src/OctreeHeadlessViewer.h → assignment-client/src/octree/OctreeHeadlessViewer.h
View file

@ -12,28 +12,17 @@
#ifndef hifi_OctreeHeadlessViewer_h
#define hifi_OctreeHeadlessViewer_h
#include <udt/PacketHeaders.h>
#include <SharedUtil.h>
#include <ViewFrustum.h>
#include <OctreeProcessor.h>
#include <JurisdictionListener.h>
#include <OctreeQuery.h>
#include "JurisdictionListener.h"
#include "Octree.h"
#include "OctreeConstants.h"
#include "OctreeQuery.h"
#include "OctreeRenderer.h"
#include "OctreeSceneStats.h"
#include "Octree.h"
// Generic client side Octree renderer class.
class OctreeHeadlessViewer : public OctreeRenderer {
class OctreeHeadlessViewer : public OctreeProcessor {
Q_OBJECT
public:
OctreeHeadlessViewer();
virtual ~OctreeHeadlessViewer() {};
virtual void renderElement(OctreeElementPointer element, RenderArgs* args) override { /* swallow these */ }
virtual void init() override ;
virtual void render(RenderArgs* renderArgs) override { /* swallow these */ }
void setJurisdictionListener(JurisdictionListener* jurisdictionListener) { _jurisdictionListener = jurisdictionListener; }
@ -71,6 +60,7 @@ private:
JurisdictionListener* _jurisdictionListener = nullptr;
OctreeQuery _octreeQuery;
ViewFrustum _viewFrustum;
float _voxelSizeScale { DEFAULT_OCTREE_SIZE_SCALE };
int _boundaryLevelAdjust { 0 };
int _maxPacketsPerSecond { DEFAULT_MAX_OCTREE_PPS };

2
assignment-client/src/scripts/EntityScriptServer.h
View file

@ -19,10 +19,10 @@
#include <QtCore/QUuid>
#include <EntityEditPacketSender.h>
#include <EntityTreeHeadlessViewer.h>
#include <plugins/CodecPlugin.h>
#include <ScriptEngine.h>
#include <ThreadedAssignment.h>
#include "../entities/EntityTreeHeadlessViewer.h"
class EntityScriptServer : public ThreadedAssignment {
Q_OBJECT

20
interface/src/Application.cpp
View file

@ -578,7 +578,6 @@ Application::Application(int& argc, char** argv, QElapsedTimer& startupTimer, bo
_undoStackScriptingInterface(&_undoStack),
_entitySimulation(new PhysicalEntitySimulation()),
_physicsEngine(new PhysicsEngine(Vectors::ZERO)),
_entityClipboardRenderer(false, this, this),
_entityClipboard(new EntityTree()),
_lastQueriedTime(usecTimestampNow()),
_previousScriptLocation("LastScriptLocation", DESKTOP_LOCATION),
@ -3987,11 +3986,6 @@ void Application::init() {
DependencyManager::get<NodeList>()->sendDomainServerCheckIn();
getEntities()->init();
{
QMutexLocker viewLocker(&_viewMutex);
getEntities()->setViewFrustum(_viewFrustum);
}
getEntities()->setEntityLoadingPriorityFunction([this](const EntityItem& item) {
auto dims = item.getDimensions();
auto maxSize = glm::compMax(dims);
@ -4021,13 +4015,6 @@ void Application::init() {
// of events related clicking, hovering over, and entering entities
getEntities()->connectSignalsToSlots(entityScriptingInterface.data());
_entityClipboardRenderer.init();
{
QMutexLocker viewLocker(&_viewMutex);
_entityClipboardRenderer.setViewFrustum(_viewFrustum);
}
_entityClipboardRenderer.setTree(_entityClipboard);
// Make sure any new sounds are loaded as soon as know about them.
connect(tree.get(), &EntityTree::newCollisionSoundURL, this, [this](QUrl newURL, EntityItemID id) {
EntityTreePointer tree = getEntities()->getTree();
@ -5019,9 +5006,6 @@ QRect Application::getDesirableApplicationGeometry() const {
return applicationGeometry;
}
// FIXME, preprocessor guard this check to occur only in DEBUG builds
static QThread * activeRenderingThread = nullptr;
PickRay Application::computePickRay(float x, float y) const {
vec2 pickPoint { x, y };
PickRay result;
@ -5087,12 +5071,12 @@ namespace render {
void Application::displaySide(RenderArgs* renderArgs, Camera& theCamera, bool selfAvatarOnly) {
#if 1
// FIXME: This preDisplayRender call is temporary until we create a separate render::scene for the mirror rendering.
// Then we can move this logic into the Avatar::simulate call.
auto myAvatar = getMyAvatar();
myAvatar->preDisplaySide(renderArgs);
activeRenderingThread = QThread::currentThread();
PROFILE_RANGE(render, __FUNCTION__);
PerformanceTimer perfTimer("display");
PerformanceWarning warn(Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings), "Application::displaySide()");
@ -5165,8 +5149,8 @@ void Application::displaySide(RenderArgs* renderArgs, Camera& theCamera, bool se
// Before the deferred pass, let's try to use the render engine
_renderEngine->run();
}
#endif
activeRenderingThread = nullptr;
}
void Application::resetSensors(bool andReload) {

2
interface/src/Application.h
View file

@ -181,7 +181,6 @@ public:
QUndoStack* getUndoStack() { return &_undoStack; }
MainWindow* getWindow() const { return _window; }
EntityTreePointer getEntityClipboard() const { return _entityClipboard; }
EntityTreeRenderer* getEntityClipboardRenderer() { return &_entityClipboardRenderer; }
EntityEditPacketSender* getEntityEditPacketSender() { return &_entityEditSender; }
ivec2 getMouse() const;
@ -535,7 +534,6 @@ private:
PhysicalEntitySimulationPointer _entitySimulation;
PhysicsEnginePointer _physicsEngine;
EntityTreeRenderer _entityClipboardRenderer;
EntityTreePointer _entityClipboard;
mutable QMutex _viewMutex { QMutex::Recursive };

2
interface/src/LODManager.h
View file

@ -17,6 +17,7 @@
#include <OctreeConstants.h>
#include <PIDController.h>
#include <SimpleMovingAverage.h>
#include <render/Args.h>
const float DEFAULT_DESKTOP_LOD_DOWN_FPS = 20.0;
const float DEFAULT_HMD_LOD_DOWN_FPS = 20.0;
@ -45,7 +46,6 @@ const float ADJUST_LOD_MAX_SIZE_SCALE = DEFAULT_OCTREE_SIZE_SCALE;
// This controls how low the auto-adjust LOD will go. We want a minimum vision of ~20:500 or 0.04 of default
const float ADJUST_LOD_MIN_SIZE_SCALE = DEFAULT_OCTREE_SIZE_SCALE * 0.04f;
class RenderArgs;
class AABox;
class LODManager : public QObject, public Dependency {

1
interface/src/audio/AudioScope.h
View file

@ -19,7 +19,6 @@
#include <DependencyManager.h>
#include <gpu/Batch.h>
#include <RenderArgs.h>
class AudioScope : public QObject, public Dependency {

6
interface/src/scripting/MenuScriptingInterface.cpp
View file

@ -152,9 +152,13 @@ void MenuScriptingInterface::closeInfoView(const QString& path) {
}
bool MenuScriptingInterface::isInfoViewVisible(const QString& path) {
if (QThread::currentThread() == qApp->thread()) {
return Menu::getInstance()->isInfoViewVisible(path);
}
bool result;
QMetaObject::invokeMethod(Menu::getInstance(), "isInfoViewVisible", Qt::BlockingQueuedConnection,
Q_RETURN_ARG(bool, result), Q_ARG(const QString&, path));
Q_RETURN_ARG(bool, result), Q_ARG(const QString&, path));
return result;
}

4
interface/src/ui/Stats.cpp
View file

@ -16,6 +16,7 @@
#include <glm/gtx/quaternion.hpp>
#include <glm/gtx/vector_angle.hpp>
#include <render/Args.h>
#include <avatar/AvatarManager.h>
#include <Application.h>
#include <AudioClient.h>
@ -33,6 +34,7 @@
#include "SequenceNumberStats.h"
#include "StatTracker.h"
HIFI_QML_DEF(Stats)
using namespace std;
@ -454,7 +456,7 @@ void Stats::updateStats(bool force) {
}
}
void Stats::setRenderDetails(const RenderDetails& details) {
void Stats::setRenderDetails(const render::RenderDetails& details) {
STAT_UPDATE(triangles, details._trianglesRendered);
STAT_UPDATE(materialSwitches, details._materialSwitches);
if (_expanded) {

7
interface/src/ui/Stats.h
View file

@ -9,10 +9,11 @@
#ifndef hifi_Stats_h
#define hifi_Stats_h
#include <QtGui/QVector3D>
#include <OffscreenQmlElement.h>
#include <RenderArgs.h>
#include <QVector3D>
#include <AudioIOStats.h>
#include <render/Args.h>
#define STATS_PROPERTY(type, name, initialValue) \
Q_PROPERTY(type name READ name NOTIFY name##Changed) \
@ -138,7 +139,7 @@ public:
Stats(QQuickItem* parent = nullptr);
bool includeTimingRecord(const QString& name);
void setRenderDetails(const RenderDetails& details);
void setRenderDetails(const render::RenderDetails& details);
const QString& monospaceFont() {
return _monospaceFont;
}

2
interface/src/ui/overlays/Image3DOverlay.cpp
View file

@ -112,7 +112,7 @@ void Image3DOverlay::render(RenderArgs* args) {
_geometryId
);
batch->setResourceTexture(0, args->_whiteTexture); // restore default white color after me
batch->setResourceTexture(0, nullptr); // restore default white color after me
}
const render::ShapeKey Image3DOverlay::getShapeKey() {

50
interface/src/ui/overlays/LocalModelsOverlay.cpp
View file

@ -1,50 +0,0 @@
//
// LocalModelsOverlay.cpp
// interface/src/ui/overlays
//
// Created by Ryan Huffman on 07/08/14.
// Copyright 2014 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
//
#include "LocalModelsOverlay.h"
#include <EntityTreeRenderer.h>
#include <gpu/Batch.h>
QString const LocalModelsOverlay::TYPE = "localmodels";
LocalModelsOverlay::LocalModelsOverlay(EntityTreeRenderer* entityTreeRenderer) :
Volume3DOverlay(),
_entityTreeRenderer(entityTreeRenderer) {
}
LocalModelsOverlay::LocalModelsOverlay(const LocalModelsOverlay* localModelsOverlay) :
Volume3DOverlay(localModelsOverlay),
_entityTreeRenderer(localModelsOverlay->_entityTreeRenderer)
{
}
void LocalModelsOverlay::update(float deltatime) {
_entityTreeRenderer->update();
}
void LocalModelsOverlay::render(RenderArgs* args) {
if (_visible) {
auto batch = args ->_batch;
Transform transform = Transform();
transform.setTranslation(args->getViewFrustum().getPosition() + getPosition());
batch->setViewTransform(transform);
_entityTreeRenderer->render(args);
transform.setTranslation(args->getViewFrustum().getPosition());
batch->setViewTransform(transform);
}
}
LocalModelsOverlay* LocalModelsOverlay::createClone() const {
return new LocalModelsOverlay(this);
}

37
interface/src/ui/overlays/LocalModelsOverlay.h
View file

@ -1,37 +0,0 @@
//
// LocalModelsOverlay.h
// interface/src/ui/overlays
//
// Created by Ryan Huffman on 07/08/14.
// Copyright 2014 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
//
#ifndef hifi_LocalModelsOverlay_h
#define hifi_LocalModelsOverlay_h
#include "Volume3DOverlay.h"
class EntityTreeRenderer;
class LocalModelsOverlay : public Volume3DOverlay {
Q_OBJECT
public:
static QString const TYPE;
virtual QString getType() const override { return TYPE; }
LocalModelsOverlay(EntityTreeRenderer* entityTreeRenderer);
LocalModelsOverlay(const LocalModelsOverlay* localModelsOverlay);
virtual void update(float deltatime) override;
virtual void render(RenderArgs* args) override;
virtual LocalModelsOverlay* createClone() const override;
private:
EntityTreeRenderer* _entityTreeRenderer;
};
#endif // hifi_LocalModelsOverlay_h

3
interface/src/ui/overlays/Overlays.cpp
View file

@ -26,7 +26,6 @@
#include "Shape3DOverlay.h"
#include "ImageOverlay.h"
#include "Line3DOverlay.h"
#include "LocalModelsOverlay.h"
#include "ModelOverlay.h"
#include "Rectangle3DOverlay.h"
#include "Sphere3DOverlay.h"
@ -171,8 +170,6 @@ OverlayID Overlays::addOverlay(const QString& type, const QVariant& properties)
thisOverlay = std::make_shared<Line3DOverlay>();
} else if (type == Grid3DOverlay::TYPE) {
thisOverlay = std::make_shared<Grid3DOverlay>();
} else if (type == LocalModelsOverlay::TYPE) {
thisOverlay = std::make_shared<LocalModelsOverlay>(qApp->getEntityClipboardRenderer());
} else if (type == ModelOverlay::TYPE) {
thisOverlay = std::make_shared<ModelOverlay>();
} else if (type == Web3DOverlay::TYPE) {

1
interface/src/ui/overlays/OverlaysPayload.cpp
View file

@ -21,7 +21,6 @@
#include "Cube3DOverlay.h"
#include "ImageOverlay.h"
#include "Line3DOverlay.h"
#include "LocalModelsOverlay.h"
#include "ModelOverlay.h"
#include "Overlays.h"
#include "Rectangle3DOverlay.h"

2
interface/src/ui/overlays/Web3DOverlay.cpp
View file

@ -319,7 +319,7 @@ void Web3DOverlay::render(RenderArgs* args) {
geometryCache->bindOpaqueWebBrowserProgram(batch, _isAA);
}
geometryCache->renderQuad(batch, halfSize * -1.0f, halfSize, vec2(0), vec2(1), color, _geometryId);
batch.setResourceTexture(0, args->_whiteTexture); // restore default white color after me
batch.setResourceTexture(0, nullptr); // restore default white color after me
}
const render::ShapeKey Web3DOverlay::getShapeKey() {

71
libraries/entities-renderer/src/EntityTreeRenderer.cpp
View file

@ -9,6 +9,8 @@
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
#include "EntityTreeRenderer.h"
#include <glm/gtx/quaternion.hpp>
#include <QEventLoop>
@ -24,7 +26,6 @@
#include <SceneScriptingInterface.h>
#include <ScriptEngine.h>
#include "EntityTreeRenderer.h"
#include "RenderableEntityItem.h"
@ -130,7 +131,12 @@ void EntityTreeRenderer::clear() {
if (scene) {
render::Transaction transaction;
foreach(auto entity, _entitiesInScene) {
entity->removeFromScene(entity, scene, transaction);
auto renderable = entity->getRenderableInterface();
if (!renderable) {
qCWarning(entitiesrenderer) << "EntityTreeRenderer::deletingEntity(), trying to remove non-renderable entity";
continue;
}
renderable->removeFromScene(entity, scene, transaction);
}
scene->enqueueTransaction(transaction);
} else {
@ -141,7 +147,7 @@ void EntityTreeRenderer::clear() {
// reset the zone to the default (while we load the next scene)
_layeredZones.clear();
OctreeRenderer::clear();
OctreeProcessor::clear();
}
void EntityTreeRenderer::reloadEntityScripts() {
@ -155,7 +161,7 @@ void EntityTreeRenderer::reloadEntityScripts() {
}
void EntityTreeRenderer::init() {
OctreeRenderer::init();
OctreeProcessor::init();
EntityTreePointer entityTree = std::static_pointer_cast<EntityTree>(_tree);
entityTree->setFBXService(this);
@ -181,7 +187,7 @@ void EntityTreeRenderer::shutdown() {
}
void EntityTreeRenderer::setTree(OctreePointer newTree) {
OctreeRenderer::setTree(newTree);
OctreeProcessor::setTree(newTree);
std::static_pointer_cast<EntityTree>(_tree)->setFBXService(this);
}
@ -791,24 +797,33 @@ void EntityTreeRenderer::mouseMoveEvent(QMouseEvent* event) {
}
void EntityTreeRenderer::deletingEntity(const EntityItemID& entityID) {
if (!_entitiesInScene.contains(entityID)) {
return;
}
if (_tree && !_shuttingDown && _entitiesScriptEngine) {
_entitiesScriptEngine->unloadEntityScript(entityID, true);
}
auto scene = _viewState->getMain3DScene();
if (!scene) {
qCWarning(entitiesrenderer) << "EntityTreeRenderer::deletingEntity(), Unexpected null scene, possibly during application shutdown";
return;
}
auto entity = _entitiesInScene.take(entityID);
auto renderable = entity->getRenderableInterface();
if (!renderable) {
qCWarning(entitiesrenderer) << "EntityTreeRenderer::deletingEntity(), trying to remove non-renderable entity";
return;
}
forceRecheckEntities(); // reset our state to force checking our inside/outsideness of entities
// here's where we remove the entity payload from the scene
if (_entitiesInScene.contains(entityID)) {
auto entity = _entitiesInScene.take(entityID);
render::Transaction transaction;
auto scene = _viewState->getMain3DScene();
if (scene) {
entity->removeFromScene(entity, scene, transaction);
scene->enqueueTransaction(transaction);
} else {
qCWarning(entitiesrenderer) << "EntityTreeRenderer::deletingEntity(), Unexpected null scene, possibly during application shutdown";
}
}
render::Transaction transaction;
renderable->removeFromScene(entity, scene, transaction);
scene->enqueueTransaction(transaction);
}
void EntityTreeRenderer::addingEntity(const EntityItemID& entityID) {
@ -820,18 +835,25 @@ void EntityTreeRenderer::addingEntity(const EntityItemID& entityID) {
}
}
void EntityTreeRenderer::addEntityToScene(EntityItemPointer entity) {
void EntityTreeRenderer::addEntityToScene(const EntityItemPointer& entity) {
// here's where we add the entity payload to the scene
render::Transaction transaction;
auto scene = _viewState->getMain3DScene();
if (scene) {
if (entity->addToScene(entity, scene, transaction)) {
_entitiesInScene.insert(entity->getEntityItemID(), entity);
}
scene->enqueueTransaction(transaction);
} else {
if (!scene) {
qCWarning(entitiesrenderer) << "EntityTreeRenderer::addEntityToScene(), Unexpected null scene, possibly during application shutdown";
return;
}
auto renderable = entity->getRenderableInterface();
if (!renderable) {
qCWarning(entitiesrenderer) << "EntityTreeRenderer::addEntityToScene(), Unexpected non-renderable entity";
return;
}
render::Transaction transaction;
if (renderable->addToScene(entity, scene, transaction)) {
_entitiesInScene.insert(entity->getEntityItemID(), entity);
}
scene->enqueueTransaction(transaction);
}
@ -1050,3 +1072,4 @@ bool EntityTreeRenderer::LayeredZones::contains(const LayeredZones& other) {
}
return result;
}

7
libraries/entities-renderer/src/EntityTreeRenderer.h
View file

@ -20,9 +20,10 @@
#include <EntityTree.h>
#include <QMouseEvent>
#include <PointerEvent.h>
#include <OctreeRenderer.h>
#include <ScriptCache.h>
#include <TextureCache.h>
#include <OctreeProcessor.h>
#include <render/Forward.h>
class AbstractScriptingServicesInterface;
class AbstractViewStateInterface;
@ -38,7 +39,7 @@ using ModelWeakPointer = std::weak_ptr<Model>;
using CalculateEntityLoadingPriority = std::function<float(const EntityItem& item)>;
// Generic client side Octree renderer class.
class EntityTreeRenderer : public OctreeRenderer, public EntityItemFBXService, public Dependency {
class EntityTreeRenderer : public OctreeProcessor, public EntityItemFBXService, public Dependency {
Q_OBJECT
public:
EntityTreeRenderer(bool wantScripts, AbstractViewStateInterface* viewState,
@ -144,7 +145,7 @@ protected:
private:
void resetEntitiesScriptEngine();
void addEntityToScene(EntityItemPointer entity);
void addEntityToScene(const EntityItemPointer& entity);
bool findBestZoneAndMaybeContainingEntities(QVector<EntityItemID>* entitiesContainingAvatar = nullptr);
bool applyLayeredZones();

2
libraries/entities-renderer/src/RenderableEntityItem.cpp
View file

@ -40,7 +40,7 @@ namespace render {
template <> void payloadRender(const RenderableEntityItemProxy::Pointer& payload, RenderArgs* args) {
if (args) {
if (payload && payload->_entity && payload->_entity->getVisible()) {
payload->_entity->render(args);
payload->_entity->getRenderableInterface()->render(args);
}
}
}

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

@ -34,13 +34,23 @@ enum class RenderItemStatusIcon {
void makeEntityItemStatusGetters(EntityItemPointer entity, render::Item::Status::Getters& statusGetters);
// Renderable entity item interface
class RenderableEntityInterface {
public:
virtual void render(RenderArgs* args) {};
virtual bool addToScene(const EntityItemPointer& self, const render::ScenePointer& scene, render::Transaction& transaction) = 0;
virtual void removeFromScene(const EntityItemPointer& self, const render::ScenePointer& scene, render::Transaction& transaction) = 0;
virtual RenderableEntityInterface* getRenderableInterface() { return nullptr; }
};
class RenderableEntityItemProxy {
public:
RenderableEntityItemProxy(EntityItemPointer entity, render::ItemID metaID) : _entity(entity), _metaID(metaID) { }
RenderableEntityItemProxy(const EntityItemPointer& entity, render::ItemID metaID)
: _entity(entity), _metaID(metaID) {}
typedef render::Payload<RenderableEntityItemProxy> Payload;
typedef Payload::DataPointer Pointer;
EntityItemPointer _entity;
const EntityItemPointer _entity;
render::ItemID _metaID;
};
@ -51,10 +61,11 @@ namespace render {
template <> uint32_t metaFetchMetaSubItems(const RenderableEntityItemProxy::Pointer& payload, ItemIDs& subItems);
}
// Mixin class for implementing basic single item rendering
class SimpleRenderableEntityItem {
class SimplerRenderableEntitySupport : public RenderableEntityInterface {
public:
bool addToScene(EntityItemPointer self, const render::ScenePointer& scene, render::Transaction& transaction) {
bool addToScene(const EntityItemPointer& self, const render::ScenePointer& scene, render::Transaction& transaction) override {
_myItem = scene->allocateID();
auto renderData = std::make_shared<RenderableEntityItemProxy>(self, _myItem);
@ -69,7 +80,7 @@ public:
return true;
}
void removeFromScene(EntityItemPointer self, const render::ScenePointer& scene, render::Transaction& transaction) {
void removeFromScene(const EntityItemPointer& self, const render::ScenePointer& scene, render::Transaction& transaction) override {
transaction.removeItem(_myItem);
render::Item::clearID(_myItem);
}
@ -91,7 +102,6 @@ public:
qCWarning(entitiesrenderer) << "SimpleRenderableEntityItem::notifyChanged(), Unexpected null scene, possibly during application shutdown";
}
}
private:
render::ItemID _myItem { render::Item::INVALID_ITEM_ID };
};
@ -99,20 +109,18 @@ private:
#define SIMPLE_RENDERABLE() \
public: \
virtual bool addToScene(EntityItemPointer self, const render::ScenePointer& scene, render::Transaction& transaction) override { return _renderHelper.addToScene(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 dimensionsChanged() override { EntityItem::dimensionsChanged(); _renderHelper.notifyChanged(); } \
virtual void locationChanged(bool tellPhysics = true) override { EntityItem::locationChanged(tellPhysics); notifyChanged(); } \
virtual void dimensionsChanged() override { EntityItem::dimensionsChanged(); notifyChanged(); } \
virtual RenderableEntityInterface* getRenderableInterface() override { return this; } \
void checkFading() { \
bool transparent = isTransparent(); \
if (transparent != _prevIsTransparent) { \
_renderHelper.notifyChanged(); \
notifyChanged(); \
_isFading = false; \
_prevIsTransparent = transparent; \
} \
} \
private: \
SimpleRenderableEntityItem _renderHelper; \
bool _prevIsTransparent { isTransparent() };

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

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

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

@ -17,11 +17,13 @@
#include "RenderableEntityItem.h"
class RenderableLightEntityItem : public LightEntityItem {
class RenderableLightEntityItem : public LightEntityItem, public RenderableEntityInterface {
public:
static EntityItemPointer factory(const EntityItemID& entityID, const EntityItemProperties& properties);
RenderableLightEntityItem(const EntityItemID& entityItemID);
RenderableEntityInterface* getRenderableInterface() override { return this; }
virtual bool supportsDetailedRayIntersection() const override { return true; }
virtual bool findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
bool& keepSearching, OctreeElementPointer& element, float& distance,
@ -30,10 +32,10 @@ public:
void updateLightFromEntity(render::Transaction& transaction);
virtual bool addToScene(EntityItemPointer self, const render::ScenePointer& scene, render::Transaction& transaction) override;
virtual bool addToScene(const EntityItemPointer& self, const render::ScenePointer& scene, render::Transaction& transaction) override;
virtual void somethingChangedNotification() override;
virtual void removeFromScene(EntityItemPointer self, const render::ScenePointer& scene, render::Transaction& transaction) override;
virtual void removeFromScene(const EntityItemPointer& self, const render::ScenePointer& scene, render::Transaction& transaction) override;
virtual void locationChanged(bool tellPhysics = true) override;

2
libraries/entities-renderer/src/RenderableLineEntityItem.h
View file

@ -16,7 +16,7 @@
#include "RenderableEntityItem.h"
#include <GeometryCache.h>
class RenderableLineEntityItem : public LineEntityItem {
class RenderableLineEntityItem : public LineEntityItem, public SimplerRenderableEntitySupport {
public:
static EntityItemPointer factory(const EntityItemID& entityID, const EntityItemProperties& properties);
RenderableLineEntityItem(const EntityItemID& entityItemID) :

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

@ -213,7 +213,7 @@ namespace render {
if (args) {
if (payload && payload->entity) {
PROFILE_RANGE(render_detail, "MetaModelRender");
payload->entity->render(args);
payload->entity->getRenderableInterface()->render(args);
}
}
}
@ -228,7 +228,7 @@ namespace render {
}
}
bool RenderableModelEntityItem::addToScene(EntityItemPointer self, const render::ScenePointer& scene,
bool RenderableModelEntityItem::addToScene(const EntityItemPointer& self, const render::ScenePointer& scene,
render::Transaction& transaction) {
_myMetaItem = scene->allocateID();
@ -249,7 +249,7 @@ bool RenderableModelEntityItem::addToScene(EntityItemPointer self, const render:
return true;
}
void RenderableModelEntityItem::removeFromScene(EntityItemPointer self, const render::ScenePointer& scene,
void RenderableModelEntityItem::removeFromScene(const EntityItemPointer& self, const render::ScenePointer& scene,
render::Transaction& transaction) {
transaction.removeItem(_myMetaItem);
render::Item::clearID(_myMetaItem);
@ -390,7 +390,7 @@ void RenderableModelEntityItem::render(RenderArgs* args) {
if (!_model || _needsModelReload) {
// TODO: this getModel() appears to be about 3% of model render time. We should optimize
PerformanceTimer perfTimer("getModel");
auto renderer = qSharedPointerCast<EntityTreeRenderer>(args->_renderer);
auto renderer = qSharedPointerCast<EntityTreeRenderer>(args->_renderData);
getModel(renderer);
// Remap textures immediately after loading to avoid flicker

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

@ -20,7 +20,7 @@
class Model;
class EntityTreeRenderer;
class RenderableModelEntityItem : public ModelEntityItem {
class RenderableModelEntityItem : public ModelEntityItem, RenderableEntityInterface {
public:
static EntityItemPointer factory(const EntityItemID& entityID, const EntityItemProperties& properties);
@ -28,6 +28,8 @@ public:
virtual ~RenderableModelEntityItem();
RenderableEntityInterface* getRenderableInterface() override { return this; }
virtual void setDimensions(const glm::vec3& value) override;
virtual void setModelURL(const QString& url) override;
@ -40,8 +42,8 @@ public:
void doInitialModelSimulation();
virtual bool addToScene(EntityItemPointer self, const render::ScenePointer& scene, render::Transaction& transaction) override;
virtual void removeFromScene(EntityItemPointer self, const render::ScenePointer& scene, render::Transaction& transaction) override;
virtual bool addToScene(const EntityItemPointer& self, const render::ScenePointer& scene, render::Transaction& transaction) override;
virtual void removeFromScene(const EntityItemPointer& self, const render::ScenePointer& scene, render::Transaction& transaction) override;
void updateModelBounds();

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

@ -161,7 +161,7 @@ RenderableParticleEffectEntityItem::RenderableParticleEffectEntityItem(const Ent
}
}
bool RenderableParticleEffectEntityItem::addToScene(EntityItemPointer self,
bool RenderableParticleEffectEntityItem::addToScene(const EntityItemPointer& self,
const render::ScenePointer& scene,
render::Transaction& transaction) {
_scene = scene;
@ -176,7 +176,7 @@ bool RenderableParticleEffectEntityItem::addToScene(EntityItemPointer self,
return true;
}
void RenderableParticleEffectEntityItem::removeFromScene(EntityItemPointer self,
void RenderableParticleEffectEntityItem::removeFromScene(const EntityItemPointer& self,
const render::ScenePointer& scene,
render::Transaction& transaction) {
transaction.removeItem(_renderItemId);

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

@ -15,18 +15,20 @@
#include <TextureCache.h>
#include "RenderableEntityItem.h"
class RenderableParticleEffectEntityItem : public ParticleEffectEntityItem {
class RenderableParticleEffectEntityItem : public ParticleEffectEntityItem, public RenderableEntityInterface {
friend class ParticlePayloadData;
public:
static EntityItemPointer factory(const EntityItemID& entityID, const EntityItemProperties& properties);
RenderableParticleEffectEntityItem(const EntityItemID& entityItemID);
RenderableEntityInterface* getRenderableInterface() override { return this; }
virtual void update(const quint64& now) override;
void updateRenderItem();
virtual bool addToScene(EntityItemPointer self, const render::ScenePointer& scene, render::Transaction& transaction) override;
virtual void removeFromScene(EntityItemPointer self, const render::ScenePointer& scene, render::Transaction& transaction) override;
virtual bool addToScene(const EntityItemPointer& self, const render::ScenePointer& scene, render::Transaction& transaction) override;
virtual void removeFromScene(const EntityItemPointer& self, const render::ScenePointer& scene, render::Transaction& transaction) override;
protected:
virtual void locationChanged(bool tellPhysics = true) override { EntityItem::locationChanged(tellPhysics); notifyBoundChanged(); }

2
libraries/entities-renderer/src/RenderablePolyLineEntityItem.cpp
View file

@ -206,7 +206,7 @@ void RenderablePolyLineEntityItem::render(RenderArgs* args) {
if (_texture->isLoaded()) {
batch.setResourceTexture(PAINTSTROKE_TEXTURE_SLOT, _texture->getGPUTexture());
} else {
batch.setResourceTexture(PAINTSTROKE_TEXTURE_SLOT, args->_whiteTexture);
batch.setResourceTexture(PAINTSTROKE_TEXTURE_SLOT, nullptr);
}
batch.setInputFormat(_format);

2
libraries/entities-renderer/src/RenderablePolyLineEntityItem.h
View file

@ -22,7 +22,7 @@
#include <QReadWriteLock>
class RenderablePolyLineEntityItem : public PolyLineEntityItem {
class RenderablePolyLineEntityItem : public PolyLineEntityItem, public SimplerRenderableEntitySupport {
public:
static EntityItemPointer factory(const EntityItemID& entityID, const EntityItemProperties& properties);
static void createPipeline();

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

@ -820,7 +820,7 @@ void RenderablePolyVoxEntityItem::render(RenderArgs* args) {
batch.drawIndexed(gpu::TRIANGLES, (gpu::uint32)mesh->getNumIndices(), 0);
}
bool RenderablePolyVoxEntityItem::addToScene(EntityItemPointer self,
bool RenderablePolyVoxEntityItem::addToScene(const EntityItemPointer& self,
const render::ScenePointer& scene,
render::Transaction& transaction) {
_myItem = scene->allocateID();
@ -838,7 +838,7 @@ bool RenderablePolyVoxEntityItem::addToScene(EntityItemPointer self,
return true;
}
void RenderablePolyVoxEntityItem::removeFromScene(EntityItemPointer self,
void RenderablePolyVoxEntityItem::removeFromScene(const EntityItemPointer& self,
const render::ScenePointer& scene,
render::Transaction& transaction) {
transaction.removeItem(_myItem);
@ -865,7 +865,7 @@ namespace render {
template <> void payloadRender(const PolyVoxPayload::Pointer& payload, RenderArgs* args) {
if (args && payload && payload->_owner) {
payload->_owner->render(args);
payload->_owner->getRenderableInterface()->render(args);
}
}
}

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

@ -41,13 +41,15 @@ namespace render {
}
class RenderablePolyVoxEntityItem : public PolyVoxEntityItem {
class RenderablePolyVoxEntityItem : public PolyVoxEntityItem, public RenderableEntityInterface {
public:
static EntityItemPointer factory(const EntityItemID& entityID, const EntityItemProperties& properties);
RenderablePolyVoxEntityItem(const EntityItemID& entityItemID);
virtual ~RenderablePolyVoxEntityItem();
RenderableEntityInterface* getRenderableInterface() override { return this; }
void initializePolyVox();
virtual void somethingChangedNotification() override {
@ -105,10 +107,10 @@ public:
virtual void setYTextureURL(const QString& yTextureURL) override;
virtual void setZTextureURL(const QString& zTextureURL) override;
virtual bool addToScene(EntityItemPointer self,
virtual bool addToScene(const EntityItemPointer& self,
const render::ScenePointer& scene,
render::Transaction& transaction) override;
virtual void removeFromScene(EntityItemPointer self,
virtual void removeFromScene(const EntityItemPointer& self,
const render::ScenePointer& scene,
render::Transaction& transaction) override;

2
libraries/entities-renderer/src/RenderableShapeEntityItem.h
View file

@ -14,7 +14,7 @@
#include "RenderableEntityItem.h"
class RenderableShapeEntityItem : public ShapeEntityItem {
class RenderableShapeEntityItem : public ShapeEntityItem, private SimplerRenderableEntitySupport {
using Pointer = std::shared_ptr<RenderableShapeEntityItem>;
static Pointer baseFactory(const EntityItemID& entityID, const EntityItemProperties& properties);
public:

2
libraries/entities-renderer/src/RenderableTextEntityItem.h
View file

@ -19,7 +19,7 @@
const int FIXED_FONT_POINT_SIZE = 40;
class RenderableTextEntityItem : public TextEntityItem {
class RenderableTextEntityItem : public TextEntityItem, public SimplerRenderableEntitySupport {
public:
static EntityItemPointer factory(const EntityItemID& entityID, const EntityItemProperties& properties);
RenderableTextEntityItem(const EntityItemID& entityItemID) : TextEntityItem(entityItemID) { }

2
libraries/entities-renderer/src/RenderableWebEntityItem.cpp
View file

@ -198,7 +198,7 @@ void RenderableWebEntityItem::render(RenderArgs* args) {
#endif
if (!_webSurface) {
auto renderer = qSharedPointerCast<EntityTreeRenderer>(args->_renderer);
auto renderer = qSharedPointerCast<EntityTreeRenderer>(args->_renderData);
if (!buildWebSurface(renderer)) {
return;
}

2
libraries/entities-renderer/src/RenderableWebEntityItem.h
View file

@ -27,7 +27,7 @@ class EntityTreeRenderer;
class RenderableWebEntityItem;
class RenderableWebEntityItem : public WebEntityItem {
class RenderableWebEntityItem : public WebEntityItem, SimplerRenderableEntitySupport {
public:
static EntityItemPointer factory(const EntityItemID& entityID, const EntityItemProperties& properties);
RenderableWebEntityItem(const EntityItemID& entityItemID);

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

@ -257,7 +257,7 @@ bool RenderableZoneEntityItem::contains(const glm::vec3& point) const {
return false;
}
bool RenderableZoneEntityItem::addToScene(EntityItemPointer self, const render::ScenePointer& scene,
bool RenderableZoneEntityItem::addToScene(const EntityItemPointer& self, const render::ScenePointer& scene,
render::Transaction& transaction) {
_myMetaItem = scene->allocateID();
@ -277,7 +277,7 @@ bool RenderableZoneEntityItem::addToScene(EntityItemPointer self, const render::
return true;
}
void RenderableZoneEntityItem::removeFromScene(EntityItemPointer self, const render::ScenePointer& scene,
void RenderableZoneEntityItem::removeFromScene(const EntityItemPointer& self, const render::ScenePointer& scene,
render::Transaction& transaction) {
transaction.removeItem(_myMetaItem);
render::Item::clearID(_myMetaItem);

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

@ -14,13 +14,14 @@
#include <Model.h>
#include <ZoneEntityItem.h>
#include "RenderableEntityItem.h"
class NetworkGeometry;
class KeyLightPayload;
class RenderableZoneEntityItemMeta;
class RenderableZoneEntityItem : public ZoneEntityItem {
class RenderableZoneEntityItem : public ZoneEntityItem, public RenderableEntityInterface {
public:
static EntityItemPointer factory(const EntityItemID& entityID, const EntityItemProperties& properties);
@ -30,6 +31,8 @@ public:
_needsInitialSimulation(true)
{ }
RenderableEntityInterface* getRenderableInterface() override { return this; }
virtual bool setProperties(const EntityItemProperties& properties) override;
virtual void somethingChangedNotification() override;
@ -41,8 +44,8 @@ public:
virtual void render(RenderArgs* args) override;
virtual bool contains(const glm::vec3& point) const override;
virtual bool addToScene(EntityItemPointer self, const render::ScenePointer& scene, render::Transaction& transaction) override;
virtual void removeFromScene(EntityItemPointer self, const render::ScenePointer& scene, render::Transaction& transaction) override;
virtual bool addToScene(const EntityItemPointer& self, const render::ScenePointer& scene, render::Transaction& transaction) override;
virtual void removeFromScene(const EntityItemPointer& self, const render::ScenePointer& scene, render::Transaction& transaction) override;
render::ItemID getRenderItemID() const { return _myMetaItem; }

6
libraries/entities/src/AddEntityOperator.cpp
View file

@ -30,7 +30,7 @@ AddEntityOperator::AddEntityOperator(EntityTreePointer tree, EntityItemPointer n
_newEntityBox = queryCube.clamp((float)(-HALF_TREE_SCALE), (float)HALF_TREE_SCALE);
}
bool AddEntityOperator::preRecursion(OctreeElementPointer element) {
bool AddEntityOperator::preRecursion(const OctreeElementPointer& element) {
EntityTreeElementPointer entityTreeElement = std::static_pointer_cast<EntityTreeElement>(element);
// In Pre-recursion, we're generally deciding whether or not we want to recurse this
@ -60,7 +60,7 @@ bool AddEntityOperator::preRecursion(OctreeElementPointer element) {
return keepSearching; // if we haven't yet found it, keep looking
}
bool AddEntityOperator::postRecursion(OctreeElementPointer element) {
bool AddEntityOperator::postRecursion(const OctreeElementPointer& element) {
// Post-recursion is the unwinding process. For this operation, while we
// unwind we want to mark the path as being dirty if we changed it below.
// We might have two paths, one for the old entity and one for the new entity.
@ -74,7 +74,7 @@ bool AddEntityOperator::postRecursion(OctreeElementPointer element) {
return keepSearching; // if we haven't yet found it, keep looking
}
OctreeElementPointer AddEntityOperator::possiblyCreateChildAt(OctreeElementPointer element, int childIndex) {
OctreeElementPointer AddEntityOperator::possiblyCreateChildAt(const OctreeElementPointer& element, int childIndex) {
// If we're getting called, it's because there was no child element at this index while recursing.
// We only care if this happens while still searching for the new entity location.
// Check to see if

6
libraries/entities/src/AddEntityOperator.h
View file

@ -16,9 +16,9 @@ class AddEntityOperator : public RecurseOctreeOperator {
public:
AddEntityOperator(EntityTreePointer tree, EntityItemPointer newEntity);
virtual bool preRecursion(OctreeElementPointer element) override;
virtual bool postRecursion(OctreeElementPointer element) override;
virtual OctreeElementPointer possiblyCreateChildAt(OctreeElementPointer element, int childIndex) override;
virtual bool preRecursion(const OctreeElementPointer& element) override;
virtual bool postRecursion(const OctreeElementPointer& element) override;
virtual OctreeElementPointer possiblyCreateChildAt(const OctreeElementPointer& element, int childIndex) override;
private:
EntityTreePointer _tree;
EntityItemPointer _newEntity;

6
libraries/entities/src/DeleteEntityOperator.cpp
View file

@ -55,7 +55,7 @@ void DeleteEntityOperator::addEntityIDToDeleteList(const EntityItemID& searchEnt
// does this entity tree element contain the old entity
bool DeleteEntityOperator::subTreeContainsSomeEntitiesToDelete(OctreeElementPointer element) {
bool DeleteEntityOperator::subTreeContainsSomeEntitiesToDelete(const OctreeElementPointer& element) {
bool containsEntity = false;
// If we don't have an old entity, then we don't contain the entity, otherwise
@ -72,7 +72,7 @@ bool DeleteEntityOperator::subTreeContainsSomeEntitiesToDelete(OctreeElementPoin
return containsEntity;
}
bool DeleteEntityOperator::preRecursion(OctreeElementPointer element) {
bool DeleteEntityOperator::preRecursion(const OctreeElementPointer& element) {
EntityTreeElementPointer entityTreeElement = std::static_pointer_cast<EntityTreeElement>(element);
// In Pre-recursion, we're generally deciding whether or not we want to recurse this
@ -108,7 +108,7 @@ bool DeleteEntityOperator::preRecursion(OctreeElementPointer element) {
return keepSearching; // if we haven't yet found it, keep looking
}
bool DeleteEntityOperator::postRecursion(OctreeElementPointer element) {
bool DeleteEntityOperator::postRecursion(const OctreeElementPointer& element) {
// Post-recursion is the unwinding process. For this operation, while we
// unwind we want to mark the path as being dirty if we changed it below.
// We might have two paths, one for the old entity and one for the new entity.

6
libraries/entities/src/DeleteEntityOperator.h
View file

@ -36,8 +36,8 @@ public:
~DeleteEntityOperator();
void addEntityIDToDeleteList(const EntityItemID& searchEntityID);
virtual bool preRecursion(OctreeElementPointer element) override;
virtual bool postRecursion(OctreeElementPointer element) override;
virtual bool preRecursion(const OctreeElementPointer& element) override;
virtual bool postRecursion(const OctreeElementPointer& element) override;
const RemovedEntities& getEntities() const { return _entitiesToDelete; }
private:
@ -46,7 +46,7 @@ private:
quint64 _changeTime;
int _foundCount;
int _lookingCount;
bool subTreeContainsSomeEntitiesToDelete(OctreeElementPointer element);
bool subTreeContainsSomeEntitiesToDelete(const OctreeElementPointer& element);
};
#endif // hifi_DeleteEntityOperator_h

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

@ -51,10 +51,6 @@ typedef std::shared_ptr<EntityTreeElement> EntityTreeElementPointer;
using EntityTreeElementExtraEncodeDataPointer = std::shared_ptr<EntityTreeElementExtraEncodeData>;
namespace render {
class Scene;
class Transaction;
}
#define DONT_ALLOW_INSTANTIATION virtual void pureVirtualFunctionPlaceHolder() = 0;
#define ALLOW_INSTANTIATION virtual void pureVirtualFunctionPlaceHolder() override { };
@ -65,6 +61,8 @@ namespace render {
class MeshProxyList;
class RenderableEntityInterface;
/// EntityItem class this is the base class for all entity types. It handles the basic properties and functionality available
/// to all other entity types. In particular: postion, size, rotation, age, lifetime, velocity, gravity. You can not instantiate
@ -83,6 +81,8 @@ public:
EntityItem(const EntityItemID& entityItemID);
virtual ~EntityItem();
virtual RenderableEntityInterface* getRenderableInterface() { return nullptr; }
inline EntityItemPointer getThisPointer() const {
return std::static_pointer_cast<EntityItem>(std::const_pointer_cast<SpatiallyNestable>(shared_from_this()));
}
@ -150,13 +150,6 @@ public:
EntityPropertyFlags& propertyFlags, bool overwriteLocalData,
bool& somethingChanged)
{ somethingChanged = false; return 0; }
virtual bool addToScene(EntityItemPointer self, const render::ScenePointer& scene,
render::Transaction& transaction) { return false; } // by default entity items don't add to scene
virtual void removeFromScene(EntityItemPointer self, const render::ScenePointer& 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
static int expectedBytes();
static void adjustEditPacketForClockSkew(QByteArray& buffer, qint64 clockSkew);

35
libraries/entities/src/EntityTree.cpp
View file

@ -554,7 +554,7 @@ public:
};
bool EntityTree::findNearPointOperation(OctreeElementPointer element, void* extraData) {
bool EntityTree::findNearPointOperation(const OctreeElementPointer& element, void* extraData) {
FindNearPointArgs* args = static_cast<FindNearPointArgs*>(extraData);
EntityTreeElementPointer entityTreeElement = std::static_pointer_cast<EntityTreeElement>(element);
@ -589,7 +589,7 @@ bool EntityTree::findNearPointOperation(OctreeElementPointer element, void* extr
return false;
}
bool findRayIntersectionOp(OctreeElementPointer element, void* extraData) {
bool findRayIntersectionOp(const OctreeElementPointer& element, void* extraData) {
RayArgs* args = static_cast<RayArgs*>(extraData);
bool keepSearching = true;
EntityTreeElementPointer entityTreeElementPointer = std::dynamic_pointer_cast<EntityTreeElement>(element);
@ -625,7 +625,7 @@ bool EntityTree::findRayIntersection(const glm::vec3& origin, const glm::vec3& d
}
EntityItemPointer EntityTree::findClosestEntity(glm::vec3 position, float targetRadius) {
EntityItemPointer EntityTree::findClosestEntity(const glm::vec3& position, float targetRadius) {
FindNearPointArgs args = { position, targetRadius, false, NULL, FLT_MAX };
withReadLock([&] {
// NOTE: This should use recursion, since this is a spatial operation
@ -642,7 +642,7 @@ public:
};
bool EntityTree::findInSphereOperation(OctreeElementPointer element, void* extraData) {
bool EntityTree::findInSphereOperation(const OctreeElementPointer& element, void* extraData) {
FindAllNearPointArgs* args = static_cast<FindAllNearPointArgs*>(extraData);
glm::vec3 penetration;
bool sphereIntersection = element->getAACube().findSpherePenetration(args->position, args->targetRadius, penetration);
@ -678,7 +678,7 @@ public:
QVector<EntityItemPointer> _foundEntities;
};
bool EntityTree::findInCubeOperation(OctreeElementPointer element, void* extraData) {
bool EntityTree::findInCubeOperation(const OctreeElementPointer& element, void* extraData) {
FindEntitiesInCubeArgs* args = static_cast<FindEntitiesInCubeArgs*>(extraData);
if (element->getAACube().touches(args->_cube)) {
EntityTreeElementPointer entityTreeElement = std::static_pointer_cast<EntityTreeElement>(element);
@ -707,7 +707,7 @@ public:
QVector<EntityItemPointer> _foundEntities;
};
bool EntityTree::findInBoxOperation(OctreeElementPointer element, void* extraData) {
bool EntityTree::findInBoxOperation(const OctreeElementPointer& element, void* extraData) {
FindEntitiesInBoxArgs* args = static_cast<FindEntitiesInBoxArgs*>(extraData);
if (element->getAACube().touches(args->_box)) {
EntityTreeElementPointer entityTreeElement = std::static_pointer_cast<EntityTreeElement>(element);
@ -732,7 +732,7 @@ public:
QVector<EntityItemPointer> entities;
};
bool EntityTree::findInFrustumOperation(OctreeElementPointer element, void* extraData) {
bool EntityTree::findInFrustumOperation(const OctreeElementPointer& element, void* extraData) {
FindInFrustumArgs* args = static_cast<FindInFrustumArgs*>(extraData);
if (element->isInView(args->frustum)) {
EntityTreeElementPointer entityTreeElement = std::static_pointer_cast<EntityTreeElement>(element);
@ -1527,15 +1527,15 @@ void EntityTree::debugDumpMap() {
class ContentsDimensionOperator : public RecurseOctreeOperator {
public:
virtual bool preRecursion(OctreeElementPointer element) override;
virtual bool postRecursion(OctreeElementPointer element) override { return true; }
virtual bool preRecursion(const OctreeElementPointer& element) override;
virtual bool postRecursion(const OctreeElementPointer& element) override { return true; }
glm::vec3 getDimensions() const { return _contentExtents.size(); }
float getLargestDimension() const { return _contentExtents.largestDimension(); }
private:
Extents _contentExtents;
};
bool ContentsDimensionOperator::preRecursion(OctreeElementPointer element) {
bool ContentsDimensionOperator::preRecursion(const OctreeElementPointer& element) {
EntityTreeElementPointer entityTreeElement = std::static_pointer_cast<EntityTreeElement>(element);
entityTreeElement->expandExtentsToContents(_contentExtents);
return true;
@ -1555,11 +1555,11 @@ float EntityTree::getContentsLargestDimension() {
class DebugOperator : public RecurseOctreeOperator {
public:
virtual bool preRecursion(OctreeElementPointer element) override;
virtual bool postRecursion(OctreeElementPointer element) override { return true; }
virtual bool preRecursion(const OctreeElementPointer& element) override;
virtual bool postRecursion(const OctreeElementPointer& element) override { return true; }
};
bool DebugOperator::preRecursion(OctreeElementPointer element) {
bool DebugOperator::preRecursion(const OctreeElementPointer& element) {
EntityTreeElementPointer entityTreeElement = std::static_pointer_cast<EntityTreeElement>(element);
qCDebug(entities) << "EntityTreeElement [" << entityTreeElement.get() << "]";
entityTreeElement->debugDump();
@ -1573,11 +1573,11 @@ void EntityTree::dumpTree() {
class PruneOperator : public RecurseOctreeOperator {
public:
virtual bool preRecursion(OctreeElementPointer element) override { return true; }
virtual bool postRecursion(OctreeElementPointer element) override;
virtual bool preRecursion(const OctreeElementPointer& element) override { return true; }
virtual bool postRecursion(const OctreeElementPointer& element) override;
};
bool PruneOperator::postRecursion(OctreeElementPointer element) {
bool PruneOperator::postRecursion(const OctreeElementPointer& element) {
EntityTreeElementPointer entityTreeElement = std::static_pointer_cast<EntityTreeElement>(element);
entityTreeElement->pruneChildren();
return true;
@ -1639,6 +1639,7 @@ QVector<EntityItemID> EntityTree::sendEntities(EntityEditPacketSender* packetSen
// If this is called repeatedly (e.g., multiple pastes with the same data), the new elements will clash unless we
// use new identifiers. We need to keep a map so that we can map parent identifiers correctly.
QHash<EntityItemID, EntityItemID> map;
args.map = &map;
withReadLock([&] {
recurseTreeWithOperation(sendEntitiesOperation, &args);
@ -1692,7 +1693,7 @@ QVector<EntityItemID> EntityTree::sendEntities(EntityEditPacketSender* packetSen
return map.values().toVector();
}
bool EntityTree::sendEntitiesOperation(OctreeElementPointer element, void* extraData) {
bool EntityTree::sendEntitiesOperation(const OctreeElementPointer& element, void* extraData) {
SendEntitiesOperationArgs* args = static_cast<SendEntitiesOperationArgs*>(extraData);
EntityTreeElementPointer entityTreeElement = std::static_pointer_cast<EntityTreeElement>(element);

14
libraries/entities/src/EntityTree.h
View file

@ -136,7 +136,7 @@ public:
/// \param position point of query in world-frame (meters)
/// \param targetRadius radius of query (meters)
EntityItemPointer findClosestEntity(glm::vec3 position, float targetRadius);
EntityItemPointer findClosestEntity(const glm::vec3& position, float targetRadius);
EntityItemPointer findEntityByID(const QUuid& id);
EntityItemPointer findEntityByEntityItemID(const EntityItemID& entityID);
virtual SpatiallyNestablePointer findByID(const QUuid& id) override { return findEntityByID(id); }
@ -294,12 +294,12 @@ protected:
bool updateEntityWithElement(EntityItemPointer entity, const EntityItemProperties& properties,
EntityTreeElementPointer containingElement,
const SharedNodePointer& senderNode = SharedNodePointer(nullptr));
static bool findNearPointOperation(OctreeElementPointer element, void* extraData);
static bool findInSphereOperation(OctreeElementPointer element, void* extraData);
static bool findInCubeOperation(OctreeElementPointer element, void* extraData);
static bool findInBoxOperation(OctreeElementPointer element, void* extraData);
static bool findInFrustumOperation(OctreeElementPointer element, void* extraData);
static bool sendEntitiesOperation(OctreeElementPointer element, void* extraData);
static bool findNearPointOperation(const OctreeElementPointer& element, void* extraData);
static bool findInSphereOperation(const OctreeElementPointer& element, void* extraData);
static bool findInCubeOperation(const OctreeElementPointer& element, void* extraData);
static bool findInBoxOperation(const OctreeElementPointer& element, void* extraData);
static bool findInFrustumOperation(const OctreeElementPointer& element, void* extraData);
static bool sendEntitiesOperation(const OctreeElementPointer& element, void* extraData);
static void bumpTimestamp(EntityItemProperties& properties);
void notifyNewlyCreatedEntity(const EntityItem& newEntity, const SharedNodePointer& senderNode);

2
libraries/entities/src/EntityTypes.h
View file

@ -17,8 +17,6 @@
#include <QHash>
#include <QString>
#include <OctreeRenderer.h> // for RenderArgs
#include "EntitiesLogging.h"
class EntityItem;

8
libraries/entities/src/MovingEntitiesOperator.cpp
View file

@ -109,7 +109,7 @@ void MovingEntitiesOperator::addEntityToMoveList(EntityItemPointer entity, const
}
// does this entity tree element contain the old entity
bool MovingEntitiesOperator::shouldRecurseSubTree(OctreeElementPointer element) {
bool MovingEntitiesOperator::shouldRecurseSubTree(const OctreeElementPointer& element) {
bool containsEntity = false;
// If we don't have an old entity, then we don't contain the entity, otherwise
@ -141,7 +141,7 @@ bool MovingEntitiesOperator::shouldRecurseSubTree(OctreeElementPointer element)
return containsEntity;
}
bool MovingEntitiesOperator::preRecursion(OctreeElementPointer element) {
bool MovingEntitiesOperator::preRecursion(const OctreeElementPointer& element) {
EntityTreeElementPointer entityTreeElement = std::static_pointer_cast<EntityTreeElement>(element);
// In Pre-recursion, we're generally deciding whether or not we want to recurse this
@ -221,7 +221,7 @@ bool MovingEntitiesOperator::preRecursion(OctreeElementPointer element) {
return keepSearching; // if we haven't yet found it, keep looking
}
bool MovingEntitiesOperator::postRecursion(OctreeElementPointer element) {
bool MovingEntitiesOperator::postRecursion(const OctreeElementPointer& element) {
// Post-recursion is the unwinding process. For this operation, while we
// unwind we want to mark the path as being dirty if we changed it below.
// We might have two paths, one for the old entity and one for the new entity.
@ -261,7 +261,7 @@ bool MovingEntitiesOperator::postRecursion(OctreeElementPointer element) {
return keepSearching; // if we haven't yet found it, keep looking
}
OctreeElementPointer MovingEntitiesOperator::possiblyCreateChildAt(OctreeElementPointer element, int childIndex) {
OctreeElementPointer MovingEntitiesOperator::possiblyCreateChildAt(const OctreeElementPointer& element, int childIndex) {
// If we're getting called, it's because there was no child element at this index while recursing.
// We only care if this happens while still searching for the new entity locations.
if (_foundNewCount < _lookingCount) {

8
libraries/entities/src/MovingEntitiesOperator.h
View file

@ -38,9 +38,9 @@ public:
~MovingEntitiesOperator();
void addEntityToMoveList(EntityItemPointer entity, const AACube& newCube);
virtual bool preRecursion(OctreeElementPointer element) override;
virtual bool postRecursion(OctreeElementPointer element) override;
virtual OctreeElementPointer possiblyCreateChildAt(OctreeElementPointer element, int childIndex) override;
virtual bool preRecursion(const OctreeElementPointer& element) override;
virtual bool postRecursion(const OctreeElementPointer& element) override;
virtual OctreeElementPointer possiblyCreateChildAt(const OctreeElementPointer& element, int childIndex) override;
bool hasMovingEntities() const { return _entitiesToMove.size() > 0; }
private:
EntityTreePointer _tree;
@ -49,7 +49,7 @@ private:
int _foundOldCount;
int _foundNewCount;
int _lookingCount;
bool shouldRecurseSubTree(OctreeElementPointer element);
bool shouldRecurseSubTree(const OctreeElementPointer& element);
bool _wantDebug;
};

6
libraries/entities/src/RecurseOctreeToMapOperator.cpp
View file

@ -14,7 +14,7 @@
#include "EntityItemProperties.h"
RecurseOctreeToMapOperator::RecurseOctreeToMapOperator(QVariantMap& map,
OctreeElementPointer top,
const OctreeElementPointer& top,
QScriptEngine* engine,
bool skipDefaultValues,
bool skipThoseWithBadParents) :
@ -34,14 +34,14 @@ RecurseOctreeToMapOperator::RecurseOctreeToMapOperator(QVariantMap& map,
}
};
bool RecurseOctreeToMapOperator::preRecursion(OctreeElementPointer element) {
bool RecurseOctreeToMapOperator::preRecursion(const OctreeElementPointer& element) {
if (element == _top) {
_withinTop = true;
}
return true;
}
bool RecurseOctreeToMapOperator::postRecursion(OctreeElementPointer element) {
bool RecurseOctreeToMapOperator::postRecursion(const OctreeElementPointer& element) {
EntityItemProperties defaultProperties;

6
libraries/entities/src/RecurseOctreeToMapOperator.h
View file

@ -13,10 +13,10 @@
class RecurseOctreeToMapOperator : public RecurseOctreeOperator {
public:
RecurseOctreeToMapOperator(QVariantMap& map, OctreeElementPointer top, QScriptEngine* engine, bool skipDefaultValues,
RecurseOctreeToMapOperator(QVariantMap& map, const OctreeElementPointer& top, QScriptEngine* engine, bool skipDefaultValues,
bool skipThoseWithBadParents);
bool preRecursion(OctreeElementPointer element) override;
bool postRecursion(OctreeElementPointer element) override;
bool preRecursion(const OctreeElementPointer& element) override;
bool postRecursion(const OctreeElementPointer& element) override;
private:
QVariantMap& _map;
OctreeElementPointer _top;

10
libraries/entities/src/UpdateEntityOperator.cpp
View file

@ -77,7 +77,7 @@ UpdateEntityOperator::~UpdateEntityOperator() {
// does this entity tree element contain the old entity
bool UpdateEntityOperator::subTreeContainsOldEntity(OctreeElementPointer element) {
bool UpdateEntityOperator::subTreeContainsOldEntity(const OctreeElementPointer& element) {
// We've found cases where the old entity might be placed in an element that is not actually the best fit
// so when we're searching the tree for the old element, we use the known cube for the known containing element
@ -95,7 +95,7 @@ bool UpdateEntityOperator::subTreeContainsOldEntity(OctreeElementPointer element
return elementContainsOldBox;
}
bool UpdateEntityOperator::subTreeContainsNewEntity(OctreeElementPointer element) {
bool UpdateEntityOperator::subTreeContainsNewEntity(const OctreeElementPointer& element) {
bool elementContainsNewBox = element->getAACube().contains(_newEntityBox);
if (_wantDebug) {
@ -112,7 +112,7 @@ bool UpdateEntityOperator::subTreeContainsNewEntity(OctreeElementPointer element
}
bool UpdateEntityOperator::preRecursion(OctreeElementPointer element) {
bool UpdateEntityOperator::preRecursion(const OctreeElementPointer& element) {
EntityTreeElementPointer entityTreeElement = std::static_pointer_cast<EntityTreeElement>(element);
// In Pre-recursion, we're generally deciding whether or not we want to recurse this
@ -238,7 +238,7 @@ bool UpdateEntityOperator::preRecursion(OctreeElementPointer element) {
return keepSearching; // if we haven't yet found it, keep looking
}
bool UpdateEntityOperator::postRecursion(OctreeElementPointer element) {
bool UpdateEntityOperator::postRecursion(const OctreeElementPointer& element) {
// Post-recursion is the unwinding process. For this operation, while we
// unwind we want to mark the path as being dirty if we changed it below.
// We might have two paths, one for the old entity and one for the new entity.
@ -270,7 +270,7 @@ bool UpdateEntityOperator::postRecursion(OctreeElementPointer element) {
return keepSearching; // if we haven't yet found it, keep looking
}
OctreeElementPointer UpdateEntityOperator::possiblyCreateChildAt(OctreeElementPointer element, int childIndex) {
OctreeElementPointer UpdateEntityOperator::possiblyCreateChildAt(const OctreeElementPointer& element, int childIndex) {
// If we're getting called, it's because there was no child element at this index while recursing.
// We only care if this happens while still searching for the new entity location.
// Check to see if

10
libraries/entities/src/UpdateEntityOperator.h
View file

@ -25,9 +25,9 @@ public:
~UpdateEntityOperator();
virtual bool preRecursion(OctreeElementPointer element) override;
virtual bool postRecursion(OctreeElementPointer element) override;
virtual OctreeElementPointer possiblyCreateChildAt(OctreeElementPointer element, int childIndex) override;
virtual bool preRecursion(const OctreeElementPointer& element) override;
virtual bool postRecursion(const OctreeElementPointer& element) override;
virtual OctreeElementPointer possiblyCreateChildAt(const OctreeElementPointer& element, int childIndex) override;
private:
EntityTreePointer _tree;
EntityItemPointer _existingEntity;
@ -45,8 +45,8 @@ private:
AABox _oldEntityBox; // clamped to domain
AABox _newEntityBox; // clamped to domain
bool subTreeContainsOldEntity(OctreeElementPointer element);
bool subTreeContainsNewEntity(OctreeElementPointer element);
bool subTreeContainsOldEntity(const OctreeElementPointer& element);
bool subTreeContainsNewEntity(const OctreeElementPointer& element);
bool _wantDebug;
};

2
libraries/gpu-gl/src/gpu/gl45/GL45BackendTexture.cpp
View file

@ -123,7 +123,7 @@ GLuint GL45Texture::allocate(const Texture& texture) {
glCreateTextures(getGLTextureType(texture), 1, &result);
#ifdef DEBUG
auto source = texture.source();
glObjectLabel(GL_TEXTURE, result, source.length(), source.data());
glObjectLabel(GL_TEXTURE, result, (GLsizei)source.length(), source.data());
#endif
return result;
}

6
libraries/octree/src/DirtyOctreeElementOperator.cpp
View file

@ -11,20 +11,20 @@
#include "DirtyOctreeElementOperator.h"
DirtyOctreeElementOperator::DirtyOctreeElementOperator(OctreeElementPointer element)
DirtyOctreeElementOperator::DirtyOctreeElementOperator(const OctreeElementPointer& element)
: _element(element) {
assert(_element.get());
_point = _element->getAACube().calcCenter();
}
bool DirtyOctreeElementOperator::preRecursion(OctreeElementPointer element) {
bool DirtyOctreeElementOperator::preRecursion(const OctreeElementPointer& element) {
if (element == _element) {
return false;
}
return element->getAACube().contains(_point);
}
bool DirtyOctreeElementOperator::postRecursion(OctreeElementPointer element) {
bool DirtyOctreeElementOperator::postRecursion(const OctreeElementPointer& element) {
element->markWithChangedTime();
return true;
}

6
libraries/octree/src/DirtyOctreeElementOperator.h
View file

@ -16,12 +16,12 @@
class DirtyOctreeElementOperator : public RecurseOctreeOperator {
public:
DirtyOctreeElementOperator(OctreeElementPointer element);
DirtyOctreeElementOperator(const OctreeElementPointer& element);
~DirtyOctreeElementOperator() {}
virtual bool preRecursion(OctreeElementPointer element) override;
virtual bool postRecursion(OctreeElementPointer element) override;
virtual bool preRecursion(const OctreeElementPointer& element) override;
virtual bool postRecursion(const OctreeElementPointer& element) override;
private:
glm::vec3 _point;
OctreeElementPointer _element;

42
libraries/octree/src/Octree.cpp
View file

@ -74,7 +74,7 @@ Octree::~Octree() {
// non-sorted array
// returns -1 if size exceeded
// originalIndexArray is optional
int insertOctreeElementIntoSortedArrays(OctreeElementPointer value, float key, int originalIndex,
int insertOctreeElementIntoSortedArrays(const OctreeElementPointer& value, float key, int originalIndex,
OctreeElementPointer* valueArray, float* keyArray, int* originalIndexArray,
int currentCount, int maxCount) {
@ -108,17 +108,17 @@ int insertOctreeElementIntoSortedArrays(OctreeElementPointer value, float key, i
// Recurses voxel tree calling the RecurseOctreeOperation function for each element.
// stops recursion if operation function returns false.
void Octree::recurseTreeWithOperation(RecurseOctreeOperation operation, void* extraData) {
void Octree::recurseTreeWithOperation(const RecurseOctreeOperation& operation, void* extraData) {
recurseElementWithOperation(_rootElement, operation, extraData);
}
// Recurses voxel tree calling the RecurseOctreePostFixOperation function for each element in post-fix order.
void Octree::recurseTreeWithPostOperation(RecurseOctreeOperation operation, void* extraData) {
void Octree::recurseTreeWithPostOperation(const RecurseOctreeOperation& operation, void* extraData) {
recurseElementWithPostOperation(_rootElement, operation, extraData);
}
// Recurses voxel element with an operation function
void Octree::recurseElementWithOperation(OctreeElementPointer element, RecurseOctreeOperation operation, void* extraData,
void Octree::recurseElementWithOperation(const OctreeElementPointer& element, const RecurseOctreeOperation& operation, void* extraData,
int recursionCount) {
if (recursionCount > DANGEROUSLY_DEEP_RECURSION) {
static QString repeatedMessage
@ -140,7 +140,7 @@ void Octree::recurseElementWithOperation(OctreeElementPointer element, RecurseOc
}
// Recurses voxel element with an operation function
void Octree::recurseElementWithPostOperation(OctreeElementPointer element, RecurseOctreeOperation operation,
void Octree::recurseElementWithPostOperation(const OctreeElementPointer& element, const RecurseOctreeOperation& operation,
void* extraData, int recursionCount) {
if (recursionCount > DANGEROUSLY_DEEP_RECURSION) {
static QString repeatedMessage
@ -162,14 +162,14 @@ void Octree::recurseElementWithPostOperation(OctreeElementPointer element, Recur
// Recurses voxel tree calling the RecurseOctreeOperation function for each element.
// stops recursion if operation function returns false.
void Octree::recurseTreeWithOperationDistanceSorted(RecurseOctreeOperation operation,
void Octree::recurseTreeWithOperationDistanceSorted(const RecurseOctreeOperation& operation,
const glm::vec3& point, void* extraData) {
recurseElementWithOperationDistanceSorted(_rootElement, operation, point, extraData);
}
// Recurses voxel element with an operation function
void Octree::recurseElementWithOperationDistanceSorted(OctreeElementPointer element, RecurseOctreeOperation operation,
void Octree::recurseElementWithOperationDistanceSorted(const OctreeElementPointer& element, const RecurseOctreeOperation& operation,
const glm::vec3& point, void* extraData, int recursionCount) {
if (recursionCount > DANGEROUSLY_DEEP_RECURSION) {
@ -212,7 +212,7 @@ void Octree::recurseTreeWithOperator(RecurseOctreeOperator* operatorObject) {
recurseElementWithOperator(_rootElement, operatorObject);
}
bool Octree::recurseElementWithOperator(OctreeElementPointer element,
bool Octree::recurseElementWithOperator(const OctreeElementPointer& element,
RecurseOctreeOperator* operatorObject, int recursionCount) {
if (recursionCount > DANGEROUSLY_DEEP_RECURSION) {
static QString repeatedMessage
@ -245,7 +245,7 @@ bool Octree::recurseElementWithOperator(OctreeElementPointer element,
}
OctreeElementPointer Octree::nodeForOctalCode(OctreeElementPointer ancestorElement, const unsigned char* needleCode,
OctreeElementPointer Octree::nodeForOctalCode(const OctreeElementPointer& ancestorElement, const unsigned char* needleCode,
OctreeElementPointer* parentOfFoundElement) const {
// special case for NULL octcode
if (!needleCode) {
@ -281,7 +281,7 @@ OctreeElementPointer Octree::nodeForOctalCode(OctreeElementPointer ancestorEleme
}
// returns the element created!
OctreeElementPointer Octree::createMissingElement(OctreeElementPointer lastParentElement,
OctreeElementPointer Octree::createMissingElement(const OctreeElementPointer& lastParentElement,
const unsigned char* codeToReach, int recursionCount) {
if (recursionCount > DANGEROUSLY_DEEP_RECURSION) {
@ -311,7 +311,7 @@ OctreeElementPointer Octree::createMissingElement(OctreeElementPointer lastParen
}
}
int Octree::readElementData(OctreeElementPointer destinationElement, const unsigned char* nodeData, int bytesAvailable,
int Octree::readElementData(const OctreeElementPointer& destinationElement, const unsigned char* nodeData, int bytesAvailable,
ReadBitstreamToTreeParams& args) {
int bytesLeftToRead = bytesAvailable;
@ -529,7 +529,7 @@ void Octree::deleteOctalCodeFromTree(const unsigned char* codeBuffer, bool colla
});
}
void Octree::deleteOctalCodeFromTreeRecursion(OctreeElementPointer element, void* extraData) {
void Octree::deleteOctalCodeFromTreeRecursion(const OctreeElementPointer& element, void* extraData) {
DeleteOctalCodeFromTreeArgs* args = (DeleteOctalCodeFromTreeArgs*)extraData;
int lengthOfElementCode = numberOfThreeBitSectionsInCode(element->getOctalCode());
@ -703,7 +703,7 @@ public:
void* penetratedObject; /// the type is defined by the type of Octree, the caller is assumed to know the type
};
bool findSpherePenetrationOp(OctreeElementPointer element, void* extraData) {
bool findSpherePenetrationOp(const OctreeElementPointer& element, void* extraData) {
SphereArgs* args = static_cast<SphereArgs*>(extraData);
// coarse check against bounds
@ -765,7 +765,7 @@ public:
CubeList* cubes;
};
bool findCapsulePenetrationOp(OctreeElementPointer element, void* extraData) {
bool findCapsulePenetrationOp(const OctreeElementPointer& element, void* extraData) {
CapsuleArgs* args = static_cast<CapsuleArgs*>(extraData);
// coarse check against bounds
@ -798,7 +798,7 @@ uint qHash(const glm::vec3& point) {
(((quint64)(point.z * RESOLUTION_PER_METER)) % MAX_SCALED_COMPONENT << 2 * BITS_PER_COMPONENT));
}
bool findContentInCubeOp(OctreeElementPointer element, void* extraData) {
bool findContentInCubeOp(const OctreeElementPointer& element, void* extraData) {
ContentArgs* args = static_cast<ContentArgs*>(extraData);
// coarse check against bounds
@ -851,7 +851,7 @@ public:
};
// Find the smallest colored voxel enclosing a point (if there is one)
bool getElementEnclosingOperation(OctreeElementPointer element, void* extraData) {
bool getElementEnclosingOperation(const OctreeElementPointer& element, void* extraData) {
GetElementEnclosingArgs* args = static_cast<GetElementEnclosingArgs*>(extraData);
if (element->getAACube().contains(args->point)) {
if (element->hasContent() && element->isLeaf()) {
@ -885,7 +885,7 @@ OctreeElementPointer Octree::getElementEnclosingPoint(const glm::vec3& point, Oc
int Octree::encodeTreeBitstream(OctreeElementPointer element,
int Octree::encodeTreeBitstream(const OctreeElementPointer& element,
OctreePacketData* packetData, OctreeElementBag& bag,
EncodeBitstreamParams& params) {
@ -979,7 +979,7 @@ int Octree::encodeTreeBitstream(OctreeElementPointer element,
return bytesWritten;
}
int Octree::encodeTreeBitstreamRecursion(OctreeElementPointer element,
int Octree::encodeTreeBitstreamRecursion(const OctreeElementPointer& element,
OctreePacketData* packetData, OctreeElementBag& bag,
EncodeBitstreamParams& params, int& currentEncodeLevel,
const ViewFrustum::intersection& parentLocationThisView) const {
@ -1866,7 +1866,7 @@ bool Octree::readJSONFromStream(unsigned long streamLength, QDataStream& inputSt
return success;
}
bool Octree::writeToFile(const char* fileName, OctreeElementPointer element, QString persistAsFileType) {
bool Octree::writeToFile(const char* fileName, const OctreeElementPointer& element, QString persistAsFileType) {
// make the sure file extension makes sense
QString qFileName = fileNameWithoutExtension(QString(fileName), PERSIST_EXTENSIONS) + "." + persistAsFileType;
QByteArray byteArray = qFileName.toUtf8();
@ -1883,7 +1883,7 @@ bool Octree::writeToFile(const char* fileName, OctreeElementPointer element, QSt
return success;
}
bool Octree::writeToJSONFile(const char* fileName, OctreeElementPointer element, bool doGzip) {
bool Octree::writeToJSONFile(const char* fileName, const OctreeElementPointer& element, bool doGzip) {
QVariantMap entityDescription;
qCDebug(octree, "Saving JSON SVO to file %s...", fileName);
@ -1937,7 +1937,7 @@ unsigned long Octree::getOctreeElementsCount() {
return nodeCount;
}
bool Octree::countOctreeElementsOperation(OctreeElementPointer element, void* extraData) {
bool Octree::countOctreeElementsOperation(const OctreeElementPointer& element, void* extraData) {
(*(unsigned long*)extraData)++;
return true; // keep going
}

42
libraries/octree/src/Octree.h
View file

@ -41,13 +41,13 @@ extern QVector<QString> PERSIST_EXTENSIONS;
/// derive from this class to use the Octree::recurseTreeWithOperator() method
class RecurseOctreeOperator {
public:
virtual bool preRecursion(OctreeElementPointer element) = 0;
virtual bool postRecursion(OctreeElementPointer element) = 0;
virtual OctreeElementPointer possiblyCreateChildAt(OctreeElementPointer element, int childIndex) { return NULL; }
virtual bool preRecursion(const OctreeElementPointer& element) = 0;
virtual bool postRecursion(const OctreeElementPointer& element) = 0;
virtual OctreeElementPointer possiblyCreateChildAt(const OctreeElementPointer& element, int childIndex) { return NULL; }
};
// Callback function, for recuseTreeWithOperation
typedef bool (*RecurseOctreeOperation)(OctreeElementPointer element, void* extraData);
using RecurseOctreeOperation = std::function<bool(const OctreeElementPointer&, void*)>;
typedef enum {GRADIENT, RANDOM, NATURAL} creationMode;
typedef QHash<uint, AACube> CubeList;
@ -233,7 +233,7 @@ public:
void readBitstreamToTree(const unsigned char* bitstream, unsigned long int bufferSizeBytes, ReadBitstreamToTreeParams& args);
void deleteOctalCodeFromTree(const unsigned char* codeBuffer, bool collapseEmptyTrees = DONT_COLLAPSE);
void reaverageOctreeElements(OctreeElementPointer startElement = NULL);
void reaverageOctreeElements(OctreeElementPointer startElement = OctreeElementPointer());
void deleteOctreeElementAt(float x, float y, float z, float s);
@ -248,18 +248,18 @@ public:
OctreeElementPointer getOrCreateChildElementAt(float x, float y, float z, float s);
OctreeElementPointer getOrCreateChildElementContaining(const AACube& box);
void recurseTreeWithOperation(RecurseOctreeOperation operation, void* extraData = NULL);
void recurseTreeWithPostOperation(RecurseOctreeOperation operation, void* extraData = NULL);
void recurseTreeWithOperation(const RecurseOctreeOperation& operation, void* extraData = NULL);
void recurseTreeWithPostOperation(const RecurseOctreeOperation& operation, void* extraData = NULL);
/// \param operation type of operation
/// \param point point in world-frame (meters)
/// \param extraData hook for user data to be interpreted by special context
void recurseTreeWithOperationDistanceSorted(RecurseOctreeOperation operation,
void recurseTreeWithOperationDistanceSorted(const RecurseOctreeOperation& operation,
const glm::vec3& point, void* extraData = NULL);
void recurseTreeWithOperator(RecurseOctreeOperator* operatorObject);
int encodeTreeBitstream(OctreeElementPointer element, OctreePacketData* packetData, OctreeElementBag& bag,
int encodeTreeBitstream(const OctreeElementPointer& element, OctreePacketData* packetData, OctreeElementBag& bag,
EncodeBitstreamParams& params) ;
bool isDirty() const { return _isDirty; }
@ -293,8 +293,8 @@ public:
void loadOctreeFile(const char* fileName);
// Octree exporters
bool writeToFile(const char* filename, OctreeElementPointer element = NULL, QString persistAsFileType = "json.gz");
bool writeToJSONFile(const char* filename, OctreeElementPointer element = NULL, bool doGzip = false);
bool writeToFile(const char* filename, const OctreeElementPointer& element = NULL, QString persistAsFileType = "json.gz");
bool writeToJSONFile(const char* filename, const OctreeElementPointer& element = NULL, bool doGzip = false);
virtual bool writeToMap(QVariantMap& entityDescription, OctreeElementPointer element, bool skipDefaultValues,
bool skipThoseWithBadParents) = 0;
@ -311,18 +311,18 @@ public:
bool getShouldReaverage() const { return _shouldReaverage; }
void recurseElementWithOperation(OctreeElementPointer element, RecurseOctreeOperation operation,
void recurseElementWithOperation(const OctreeElementPointer& element, const RecurseOctreeOperation& operation,
void* extraData, int recursionCount = 0);
/// Traverse child nodes of node applying operation in post-fix order
///
void recurseElementWithPostOperation(OctreeElementPointer element, RecurseOctreeOperation operation,
void recurseElementWithPostOperation(const OctreeElementPointer& element, const RecurseOctreeOperation& operation,
void* extraData, int recursionCount = 0);
void recurseElementWithOperationDistanceSorted(OctreeElementPointer element, RecurseOctreeOperation operation,
void recurseElementWithOperationDistanceSorted(const OctreeElementPointer& element, const RecurseOctreeOperation& operation,
const glm::vec3& point, void* extraData, int recursionCount = 0);
bool recurseElementWithOperator(OctreeElementPointer element, RecurseOctreeOperator* operatorObject, int recursionCount = 0);
bool recurseElementWithOperator(const OctreeElementPointer& element, RecurseOctreeOperator* operatorObject, int recursionCount = 0);
bool getIsViewing() const { return _isViewing; } /// This tree is receiving inbound viewer datagrams.
void setIsViewing(bool isViewing) { _isViewing = isViewing; }
@ -353,18 +353,18 @@ public slots:
protected:
void deleteOctalCodeFromTreeRecursion(OctreeElementPointer element, void* extraData);
void deleteOctalCodeFromTreeRecursion(const OctreeElementPointer& element, void* extraData);
int encodeTreeBitstreamRecursion(OctreeElementPointer element,
int encodeTreeBitstreamRecursion(const OctreeElementPointer& element,
OctreePacketData* packetData, OctreeElementBag& bag,
EncodeBitstreamParams& params, int& currentEncodeLevel,
const ViewFrustum::intersection& parentLocationThisView) const;
static bool countOctreeElementsOperation(OctreeElementPointer element, void* extraData);
static bool countOctreeElementsOperation(const OctreeElementPointer& element, void* extraData);
OctreeElementPointer nodeForOctalCode(OctreeElementPointer ancestorElement, const unsigned char* needleCode, OctreeElementPointer* parentOfFoundElement) const;
OctreeElementPointer createMissingElement(OctreeElementPointer lastParentElement, const unsigned char* codeToReach, int recursionCount = 0);
int readElementData(OctreeElementPointer destinationElement, const unsigned char* nodeData,
OctreeElementPointer nodeForOctalCode(const OctreeElementPointer& ancestorElement, const unsigned char* needleCode, OctreeElementPointer* parentOfFoundElement) const;
OctreeElementPointer createMissingElement(const OctreeElementPointer& lastParentElement, const unsigned char* codeToReach, int recursionCount = 0);
int readElementData(const OctreeElementPointer& destinationElement, const unsigned char* nodeData,
int bufferSizeBytes, ReadBitstreamToTreeParams& args);
OctreeElementPointer _rootElement = nullptr;

4
libraries/octree/src/OctreeElement.cpp
View file

@ -233,7 +233,7 @@ OctreeElementPointer OctreeElement::removeChildAtIndex(int childIndex) {
return returnedChild;
}
bool OctreeElement::isParentOf(OctreeElementPointer possibleChild) const {
bool OctreeElement::isParentOf(const OctreeElementPointer& possibleChild) const {
if (possibleChild) {
for (int childIndex = 0; childIndex < NUMBER_OF_CHILDREN; childIndex++) {
OctreeElementPointer childAt = getChildAtIndex(childIndex);
@ -300,7 +300,7 @@ void OctreeElement::deleteAllChildren() {
}
}
void OctreeElement::setChildAtIndex(int childIndex, OctreeElementPointer child) {
void OctreeElement::setChildAtIndex(int childIndex, const OctreeElementPointer& child) {
#ifdef SIMPLE_CHILD_ARRAY
int previousChildCount = getChildCount();
if (child) {

4
libraries/octree/src/OctreeElement.h
View file

@ -122,7 +122,7 @@ public:
OctreeElementPointer getChildAtIndex(int childIndex) const;
void deleteChildAtIndex(int childIndex);
OctreeElementPointer removeChildAtIndex(int childIndex);
bool isParentOf(OctreeElementPointer possibleChild) const;
bool isParentOf(const OctreeElementPointer& possibleChild) const;
/// handles deletion of all descendants, returns false if delete not approved
bool safeDeepDeleteChildAtIndex(int childIndex, int recursionCount = 0);
@ -222,7 +222,7 @@ public:
protected:
void deleteAllChildren();
void setChildAtIndex(int childIndex, OctreeElementPointer child);
void setChildAtIndex(int childIndex, const OctreeElementPointer& child);
void calculateAACube();

2
libraries/octree/src/OctreeElementBag.cpp
View file

@ -23,7 +23,7 @@ bool OctreeElementBag::isEmpty() {
return _bagElements.empty();
}
void OctreeElementBag::insert(OctreeElementPointer element) {
void OctreeElementBag::insert(const OctreeElementPointer& element) {
_bagElements[element.get()] = element;
}

2
libraries/octree/src/OctreeElementBag.h
View file

@ -24,7 +24,7 @@ class OctreeElementBag {
using Bag = std::unordered_map<OctreeElement*, OctreeElementWeakPointer>;
public:
void insert(OctreeElementPointer element); // put a element into the bag
void insert(const OctreeElementPointer& element); // put a element into the bag
OctreeElementPointer extract(); /// pull a element out of the bag (could come in any order) and if all of the
/// elements have expired, a single null pointer will be returned

58
libraries/octree/src/OctreeRenderer.cpp → libraries/octree/src/OctreeProcessor.cpp
View file

@ -1,5 +1,5 @@
//
// OctreeRenderer.cpp
// OctreeProcessor.cpp
// libraries/octree/src
//
// Created by Brad Hefta-Gaub on 12/6/13.
@ -14,49 +14,48 @@
#include <NumericalConstants.h>
#include <PerfStat.h>
#include <RenderArgs.h>
#include <SharedUtil.h>
#include "OctreeLogging.h"
#include "OctreeRenderer.h"
#include "OctreeProcessor.h"
OctreeRenderer::OctreeRenderer() :
OctreeProcessor::OctreeProcessor() :
_tree(NULL),
_managedTree(false)
{
}
void OctreeRenderer::init() {
void OctreeProcessor::init() {
if (!_tree) {
_tree = createTree();
_managedTree = true;
}
}
OctreeRenderer::~OctreeRenderer() {
OctreeProcessor::~OctreeProcessor() {
}
void OctreeRenderer::setTree(OctreePointer newTree) {
void OctreeProcessor::setTree(OctreePointer newTree) {
_tree = newTree;
}
void OctreeRenderer::processDatagram(ReceivedMessage& message, SharedNodePointer sourceNode) {
void OctreeProcessor::processDatagram(ReceivedMessage& message, SharedNodePointer sourceNode) {
bool extraDebugging = false;
if (extraDebugging) {
qCDebug(octree) << "OctreeRenderer::processDatagram()";
qCDebug(octree) << "OctreeProcessor::processDatagram()";
}
if (!_tree) {
qCDebug(octree) << "OctreeRenderer::processDatagram() called before init, calling init()...";
qCDebug(octree) << "OctreeProcessor::processDatagram() called before init, calling init()...";
this->init();
}
bool showTimingDetails = false; // Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings);
PerformanceWarning warn(showTimingDetails, "OctreeRenderer::processDatagram()", showTimingDetails);
PerformanceWarning warn(showTimingDetails, "OctreeProcessor::processDatagram()", showTimingDetails);
if (message.getType() == getExpectedPacketType()) {
PerformanceWarning warn(showTimingDetails, "OctreeRenderer::processDatagram expected PacketType", showTimingDetails);
PerformanceWarning warn(showTimingDetails, "OctreeProcessor::processDatagram expected PacketType", showTimingDetails);
// if we are getting inbound packets, then our tree is also viewing, and we should remember that fact.
_tree->setIsViewing(true);
@ -79,7 +78,7 @@ void OctreeRenderer::processDatagram(ReceivedMessage& message, SharedNodePointer
OCTREE_PACKET_INTERNAL_SECTION_SIZE sectionLength = 0;
if (extraDebugging) {
qCDebug(octree) << "OctreeRenderer::processDatagram() ... "
qCDebug(octree) << "OctreeProcessor::processDatagram() ... "
"Got Packet Section color:" << packetIsColored <<
"compressed:" << packetIsCompressed <<
"sequence: " << sequence <<
@ -130,7 +129,7 @@ void OctreeRenderer::processDatagram(ReceivedMessage& message, SharedNodePointer
packetData.loadFinalizedContent(reinterpret_cast<const unsigned char*>(message.getRawMessage() + message.getPosition()),
sectionLength);
if (extraDebugging) {
qCDebug(octree) << "OctreeRenderer::processDatagram() ... "
qCDebug(octree) << "OctreeProcessor::processDatagram() ... "
"Got Packet Section color:" << packetIsColored <<
"compressed:" << packetIsCompressed <<
"sequence: " << sequence <<
@ -143,13 +142,13 @@ void OctreeRenderer::processDatagram(ReceivedMessage& message, SharedNodePointer
}
if (extraDebugging) {
qCDebug(octree) << "OctreeRenderer::processDatagram() ******* START _tree->readBitstreamToTree()...";
qCDebug(octree) << "OctreeProcessor::processDatagram() ******* START _tree->readBitstreamToTree()...";
}
startReadBitsteam = usecTimestampNow();
_tree->readBitstreamToTree(packetData.getUncompressedData(), packetData.getUncompressedSize(), args);
endReadBitsteam = usecTimestampNow();
if (extraDebugging) {
qCDebug(octree) << "OctreeRenderer::processDatagram() ******* END _tree->readBitstreamToTree()...";
qCDebug(octree) << "OctreeProcessor::processDatagram() ******* END _tree->readBitstreamToTree()...";
}
});
@ -198,32 +197,7 @@ void OctreeRenderer::processDatagram(ReceivedMessage& message, SharedNodePointer
}
}
bool OctreeRenderer::renderOperation(OctreeElementPointer element, void* extraData) {
RenderArgs* args = static_cast<RenderArgs*>(extraData);
if (element->isInView(args->getViewFrustum())) {
if (element->hasContent()) {
if (element->calculateShouldRender(args->getViewFrustum(), args->_sizeScale, args->_boundaryLevelAdjust)) {
args->_renderer->renderElement(element, args);
} else {
return false; // if we shouldn't render, then we also should stop recursing.
}
}
return true; // continue recursing
}
// if not in view stop recursing
return false;
}
void OctreeRenderer::render(RenderArgs* renderArgs) {
if (_tree) {
renderArgs->_renderer = sharedFromThis();
_tree->withReadLock([&] {
_tree->recurseTreeWithOperation(renderOperation, renderArgs);
});
}
}
void OctreeRenderer::clear() {
void OctreeProcessor::clear() {
if (_tree) {
_tree->withWriteLock([&] {
_tree->eraseAllOctreeElements();

28
libraries/octree/src/OctreeRenderer.h → libraries/octree/src/OctreeProcessor.h
View file

@ -1,5 +1,5 @@
//
// OctreeRenderer.h
// OctreeProcessor.h
// libraries/octree/src
//
// Created by Brad Hefta-Gaub on 12/6/13.
@ -9,8 +9,8 @@
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
#ifndef hifi_OctreeRenderer_h
#define hifi_OctreeRenderer_h
#ifndef hifi_OctreeProcessor_h
#define hifi_OctreeProcessor_h
#include <glm/glm.hpp>
#include <stdint.h>
@ -18,27 +18,22 @@
#include <QObject>
#include <udt/PacketHeaders.h>
#include <RenderArgs.h>
#include <SharedUtil.h>
#include <ViewFrustum.h>
#include "Octree.h"
#include "OctreePacketData.h"
class OctreeRenderer;
// Generic client side Octree renderer class.
class OctreeRenderer : public QObject, public QEnableSharedFromThis<OctreeRenderer> {
class OctreeProcessor : public QObject, public QEnableSharedFromThis<OctreeProcessor> {
Q_OBJECT
public:
OctreeRenderer();
virtual ~OctreeRenderer();
OctreeProcessor();
virtual ~OctreeProcessor();
virtual char getMyNodeType() const = 0;
virtual PacketType getMyQueryMessageType() const = 0;
virtual PacketType getExpectedPacketType() const = 0;
virtual void renderElement(OctreeElementPointer element, RenderArgs* args) { }
virtual void setTree(OctreePointer newTree);
@ -48,14 +43,6 @@ public:
/// initialize and GPU/rendering related resources
virtual void init();
/// render the content of the octree
virtual void render(RenderArgs* renderArgs);
const ViewFrustum& getViewFrustum() const { return _viewFrustum; }
void setViewFrustum(const ViewFrustum& viewFrustum) { _viewFrustum = viewFrustum; }
static bool renderOperation(OctreeElementPointer element, void* extraData);
/// clears the tree
virtual void clear();
@ -75,7 +62,6 @@ protected:
OctreePointer _tree;
bool _managedTree;
ViewFrustum _viewFrustum;
SimpleMovingAverage _elementsPerPacket;
SimpleMovingAverage _entitiesPerPacket;
@ -95,4 +81,4 @@ protected:
};
#endif // hifi_OctreeRenderer_h
#endif // hifi_OctreeProcessor_h

18
libraries/octree/src/OctreeSceneStats.cpp
View file

@ -141,7 +141,7 @@ OctreeSceneStats::~OctreeSceneStats() {
reset();
}
void OctreeSceneStats::sceneStarted(bool isFullScene, bool isMoving, OctreeElementPointer root,
void OctreeSceneStats::sceneStarted(bool isFullScene, bool isMoving, const OctreeElementPointer& root,
JurisdictionMap* jurisdictionMap) {
reset(); // resets packet and octree stats
_isStarted = true;
@ -246,7 +246,7 @@ void OctreeSceneStats::packetSent(int bytes) {
_bytes += bytes;
}
void OctreeSceneStats::traversed(const OctreeElementPointer element) {
void OctreeSceneStats::traversed(const OctreeElementPointer& element) {
_traversed++;
if (element->isLeaf()) {
_leaves++;
@ -255,7 +255,7 @@ void OctreeSceneStats::traversed(const OctreeElementPointer element) {
}
}
void OctreeSceneStats::skippedDistance(const OctreeElementPointer element) {
void OctreeSceneStats::skippedDistance(const OctreeElementPointer& element) {
_skippedDistance++;
if (element->isLeaf()) {
_leavesSkippedDistance++;
@ -264,7 +264,7 @@ void OctreeSceneStats::skippedDistance(const OctreeElementPointer element) {
}
}
void OctreeSceneStats::skippedOutOfView(const OctreeElementPointer element) {
void OctreeSceneStats::skippedOutOfView(const OctreeElementPointer& element) {
_skippedOutOfView++;
if (element->isLeaf()) {
_leavesSkippedOutOfView++;
@ -273,7 +273,7 @@ void OctreeSceneStats::skippedOutOfView(const OctreeElementPointer element) {
}
}
void OctreeSceneStats::skippedWasInView(const OctreeElementPointer element) {
void OctreeSceneStats::skippedWasInView(const OctreeElementPointer& element) {
_skippedWasInView++;
if (element->isLeaf()) {
_leavesSkippedWasInView++;
@ -282,7 +282,7 @@ void OctreeSceneStats::skippedWasInView(const OctreeElementPointer element) {
}
}
void OctreeSceneStats::skippedNoChange(const OctreeElementPointer element) {
void OctreeSceneStats::skippedNoChange(const OctreeElementPointer& element) {
_skippedNoChange++;
if (element->isLeaf()) {
_leavesSkippedNoChange++;
@ -291,7 +291,7 @@ void OctreeSceneStats::skippedNoChange(const OctreeElementPointer element) {
}
}
void OctreeSceneStats::skippedOccluded(const OctreeElementPointer element) {
void OctreeSceneStats::skippedOccluded(const OctreeElementPointer& element) {
_skippedOccluded++;
if (element->isLeaf()) {
_leavesSkippedOccluded++;
@ -300,7 +300,7 @@ void OctreeSceneStats::skippedOccluded(const OctreeElementPointer element) {
}
}
void OctreeSceneStats::colorSent(const OctreeElementPointer element) {
void OctreeSceneStats::colorSent(const OctreeElementPointer& element) {
_colorSent++;
if (element->isLeaf()) {
_leavesColorSent++;
@ -309,7 +309,7 @@ void OctreeSceneStats::colorSent(const OctreeElementPointer element) {
}
}
void OctreeSceneStats::didntFit(const OctreeElementPointer element) {
void OctreeSceneStats::didntFit(const OctreeElementPointer& element) {
_didntFit++;
if (element->isLeaf()) {
_leavesDidntFit++;

18
libraries/octree/src/OctreeSceneStats.h
View file

@ -39,7 +39,7 @@ public:
OctreeSceneStats& operator= (const OctreeSceneStats& other); // copy assignment
/// Call when beginning the computation of a scene. Initializes internal structures
void sceneStarted(bool fullScene, bool moving, OctreeElementPointer root, JurisdictionMap* jurisdictionMap);
void sceneStarted(bool fullScene, bool moving, const OctreeElementPointer& root, JurisdictionMap* jurisdictionMap);
bool getIsSceneStarted() const { return _isStarted; }
/// Call when the computation of a scene is completed. Finalizes internal structures
@ -57,28 +57,28 @@ public:
void encodeStopped();
/// Track that a element was traversed as part of computation of a scene.
void traversed(const OctreeElementPointer element);
void traversed(const OctreeElementPointer& element);
/// Track that a element was skipped as part of computation of a scene due to being beyond the LOD distance.
void skippedDistance(const OctreeElementPointer element);
void skippedDistance(const OctreeElementPointer& element);
/// Track that a element was skipped as part of computation of a scene due to being out of view.
void skippedOutOfView(const OctreeElementPointer element);
void skippedOutOfView(const OctreeElementPointer& element);
/// Track that a element was skipped as part of computation of a scene due to previously being in view while in delta sending
void skippedWasInView(const OctreeElementPointer element);
void skippedWasInView(const OctreeElementPointer& element);
/// Track that a element was skipped as part of computation of a scene due to not having changed since last full scene sent
void skippedNoChange(const OctreeElementPointer element);
void skippedNoChange(const OctreeElementPointer& element);
/// Track that a element was skipped as part of computation of a scene due to being occluded
void skippedOccluded(const OctreeElementPointer element);
void skippedOccluded(const OctreeElementPointer& element);
/// Track that a element's color was was sent as part of computation of a scene
void colorSent(const OctreeElementPointer element);
void colorSent(const OctreeElementPointer& element);
/// Track that a element was due to be sent, but didn't fit in the packet and was moved to next packet
void didntFit(const OctreeElementPointer element);
void didntFit(const OctreeElementPointer& element);
/// Track that the color bitmask was was sent as part of computation of a scene
void colorBitsWritten();

6
libraries/render-utils/src/DeferredFrameTransform.h
View file

@ -12,10 +12,10 @@
#ifndef hifi_DeferredFrameTransform_h
#define hifi_DeferredFrameTransform_h
#include "gpu/Resource.h"
#include "render/DrawTask.h"
#include <gpu/Resource.h>
class RenderArgs;
#include <render/Forward.h>
#include <render/DrawTask.h>
// DeferredFrameTransform is a helper class gathering in one place the needed camera transform
// and frame resolution needed for all the deferred rendering passes taking advantage of the Deferred buffers

1
libraries/render-utils/src/DeferredFramebuffer.h
View file

@ -15,7 +15,6 @@
#include "gpu/Resource.h"
#include "gpu/Framebuffer.h"
class RenderArgs;
// DeferredFramebuffer is a helper class gathering in one place the GBuffer (Framebuffer) and lighting framebuffer
class DeferredFramebuffer {

1
libraries/render-utils/src/DeferredLightingEffect.h
View file

@ -37,7 +37,6 @@
#include "AmbientOcclusionEffect.h"
class RenderArgs;
struct LightLocations;
using LightLocationsPtr = std::shared_ptr<LightLocations>;

6
libraries/render-utils/src/LightingModel.h
View file

@ -12,10 +12,10 @@
#ifndef hifi_LightingModel_h
#define hifi_LightingModel_h
#include "gpu/Resource.h"
#include "render/DrawTask.h"
#include <gpu/Resource.h>
class RenderArgs;
#include <render/Forward.h>
#include <render/DrawTask.h>
// LightingModel is a helper class gathering in one place the flags to enable the lighting contributions
class LightingModel {

1
libraries/render-utils/src/MeshPartPayload.cpp
View file

@ -557,6 +557,7 @@ void ModelMeshPartPayload::render(RenderArgs* args) {
if (_fadeState == FADE_WAITING_TO_START) {
if (model->isLoaded()) {
// FIXME as far as I can tell this is the ONLY reason render-util depends on entities.
if (EntityItem::getEntitiesShouldFadeFunction()()) {
_fadeStartTime = usecTimestampNow();
_fadeState = FADE_IN_PROGRESS;

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

@ -9,6 +9,8 @@
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
#include "Model.h"
#include <QMetaType>
#include <QRunnable>
#include <QThreadPool>
@ -24,7 +26,6 @@
#include "AbstractViewStateInterface.h"
#include "MeshPartPayload.h"
#include "Model.h"
#include "RenderUtilsLogging.h"
#include <Trace.h>

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

@ -25,6 +25,7 @@
#include <DependencyManager.h>
#include <GeometryUtil.h>
#include <gpu/Batch.h>
#include <render/Forward.h>
#include <render/Scene.h>
#include <Transform.h>
#include <SpatiallyNestable.h>
@ -34,10 +35,10 @@
#include "TextureCache.h"
#include "Rig.h"
class AbstractViewStateInterface;
class QScriptEngine;
#include "RenderArgs.h"
class ViewFrustum;
namespace render {

1
libraries/render-utils/src/RenderDeferredTask.cpp
View file

@ -14,7 +14,6 @@
#include <PerfStat.h>
#include <PathUtils.h>
#include <RenderArgs.h>
#include <ViewFrustum.h>
#include <gpu/Context.h>

1
libraries/render-utils/src/RenderForwardTask.cpp
View file

@ -15,7 +15,6 @@
#include <PerfStat.h>
#include <PathUtils.h>
#include <RenderArgs.h>
#include <ViewFrustum.h>
#include <gpu/Context.h>

1
libraries/render-utils/src/StencilMaskPass.cpp
View file

@ -11,7 +11,6 @@
#include "StencilMaskPass.h"
#include <RenderArgs.h>
#include <ViewFrustum.h>
#include <gpu/Context.h>

1
libraries/render-utils/src/ToneMappingEffect.cpp
View file

@ -14,7 +14,6 @@
#include <gpu/Context.h>
#include <gpu/StandardShaderLib.h>
#include <RenderArgs.h>
#include "StencilMaskPass.h"
#include "FramebufferCache.h"

3
libraries/render-utils/src/ToneMappingEffect.h
View file

@ -17,11 +17,10 @@
#include <gpu/Resource.h>
#include <gpu/Pipeline.h>
#include <render/Forward.h>
#include <render/DrawTask.h>
class RenderArgs;
class ToneMappingEffect {
public:
ToneMappingEffect();

2
libraries/render/CMakeLists.txt
View file

@ -3,6 +3,6 @@ AUTOSCRIBE_SHADER_LIB(gpu model)
setup_hifi_library()
# render needs octree only for getAccuracyAngle(float, int)
link_hifi_libraries(shared ktx gpu model octree)
link_hifi_libraries(shared networking ktx gpu model octree)
target_nsight()

128
libraries/render/src/render/Args.h Normal file
View file

@ -0,0 +1,128 @@
//
// Created by Brad Hefta-Gaub on 10/29/14.
// Copyright 2013-2014 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
#ifndef hifi_render_Args_h
#define hifi_render_Args_h
#include <functional>
#include <memory>
#include <stack>
#include <GLMHelpers.h>
#include <ViewFrustum.h>
#include <gpu/Forward.h>
#include "Forward.h"
class AABox;
namespace render {
class RenderDetails {
public:
enum Type {
ITEM,
SHADOW,
OTHER
};
struct Item {
int _considered = 0;
int _outOfView = 0;
int _tooSmall = 0;
int _rendered = 0;
};
int _materialSwitches = 0;
int _trianglesRendered = 0;
Item _item;
Item _shadow;
Item _other;
Item& edit(Type type) {
switch (type) {
case SHADOW:
return _shadow;
case ITEM:
return _item;
default:
return _other;
}
}
};
class Args {
public:
enum RenderMode { DEFAULT_RENDER_MODE, SHADOW_RENDER_MODE, DIFFUSE_RENDER_MODE, NORMAL_RENDER_MODE, MIRROR_RENDER_MODE };
enum DisplayMode { MONO, STEREO_MONITOR, STEREO_HMD };
enum DebugFlags {
RENDER_DEBUG_NONE = 0,
RENDER_DEBUG_HULLS = 1
};
Args() {}
Args(const gpu::ContextPointer& context,
QSharedPointer<QObject> renderData = QSharedPointer<OctreeRenderer>(nullptr),
float sizeScale = 1.0f,
int boundaryLevelAdjust = 0,
RenderMode renderMode = DEFAULT_RENDER_MODE,
DisplayMode displayMode = MONO,
DebugFlags debugFlags = RENDER_DEBUG_NONE,
gpu::Batch* batch = nullptr) :
_context(context),
_renderData(renderData),
_sizeScale(sizeScale),
_boundaryLevelAdjust(boundaryLevelAdjust),
_renderMode(renderMode),
_displayMode(displayMode),
_debugFlags(debugFlags),
_batch(batch) {
}
bool hasViewFrustum() const { return _viewFrustums.size() > 0; }
void setViewFrustum(const ViewFrustum& viewFrustum) {
while (_viewFrustums.size() > 0) {
_viewFrustums.pop();
}
_viewFrustums.push(viewFrustum);
}
const ViewFrustum& getViewFrustum() const { assert(_viewFrustums.size() > 0); return _viewFrustums.top(); }
void pushViewFrustum(const ViewFrustum& viewFrustum) { _viewFrustums.push(viewFrustum); }
void popViewFrustum() { _viewFrustums.pop(); }
std::shared_ptr<gpu::Context> _context;
std::shared_ptr<gpu::Framebuffer> _blitFramebuffer;
std::shared_ptr<render::ShapePipeline> _pipeline;
QSharedPointer<QObject> _renderData;
std::stack<ViewFrustum> _viewFrustums;
glm::ivec4 _viewport { 0.0f, 0.0f, 1.0f, 1.0f };
glm::vec3 _boomOffset { 0.0f, 0.0f, 1.0f };
float _sizeScale { 1.0f };
int _boundaryLevelAdjust { 0 };
RenderMode _renderMode { DEFAULT_RENDER_MODE };
DisplayMode _displayMode { MONO };
DebugFlags _debugFlags { RENDER_DEBUG_NONE };
gpu::Batch* _batch = nullptr;
uint32_t _globalShapeKey { 0 };
bool _enableTexturing { true };
RenderDetails _details;
render::ScenePointer _scene;
int8_t _cameraMode { -1 };
};
}
using RenderArgs = render::Args;
#endif // hifi_render_Args_h

2
libraries/render/src/render/DrawSceneOctree.cpp
View file

@ -16,11 +16,11 @@
#include <OctreeUtils.h>
#include <PerfStat.h>
#include <RenderArgs.h>
#include <gpu/Context.h>
#include <gpu/StandardShaderLib.h>
#include "Args.h"
#include "drawCellBounds_vert.h"
#include "drawCellBounds_frag.h"

5
libraries/render/src/render/DrawSceneOctree.h
View file

@ -12,9 +12,10 @@
#ifndef hifi_render_DrawSceneOctree_h
#define hifi_render_DrawSceneOctree_h
#include "DrawTask.h"
#include "gpu/Batch.h"
#include <ViewFrustum.h>
#include <gpu/Batch.h>
#include "DrawTask.h"
namespace render {
class DrawSceneOctreeConfig : public Job::Config {

3
libraries/render/src/render/DrawStatus.cpp
View file

@ -16,10 +16,11 @@
#include <PerfStat.h>
#include <ViewFrustum.h>
#include <RenderArgs.h>
#include <gpu/Context.h>
#include "Args.h"
#include "drawItemBounds_vert.h"
#include "drawItemBounds_frag.h"
#include "drawItemStatus_vert.h"

26
libraries/render/src/render/Forward.h Normal file
View file

@ -0,0 +1,26 @@
//
// Created by Bradley Austin Davis on 2017/06/15
// Copyright 2013-2017 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
#ifndef hifi_render_Forward_h
#define hifi_render_Forward_h
#include <memory>
namespace render {
class Scene;
using ScenePointer = std::shared_ptr<Scene>;
class ShapePipeline;
class Args;
}
class OctreeRenderer;
using RenderArgs = render::Args;
#endif // hifi_render_Forward_h

3
libraries/render/src/render/Item.h
View file

@ -22,7 +22,8 @@
#include <vector>
#include <AABox.h>
#include <RenderArgs.h>
#include "Args.h"
#include "model/Material.h"
#include "ShapePipeline.h"

3
libraries/render/src/render/ShapePipeline.h
View file

@ -15,7 +15,8 @@
#include <unordered_set>
#include <gpu/Batch.h>
#include <RenderArgs.h>
#include "Args.h"
namespace render {

6
libraries/script-engine/src/ScriptEngines.cpp
View file

@ -529,7 +529,11 @@ void ScriptEngines::launchScriptEngine(ScriptEngine* scriptEngine) {
initializer(scriptEngine);
}
auto const wantDebug = scriptEngine->isDebuggable() || (qApp->queryKeyboardModifiers() & Qt::ShiftModifier);
// FIXME disabling 'shift key' debugging for now. If you start up the application with
// the shift key held down, it triggers a deadlock because of script interfaces running
// on the main thread
auto const wantDebug = scriptEngine->isDebuggable(); // || (qApp->queryKeyboardModifiers() & Qt::ShiftModifier);
if (HIFI_SCRIPT_DEBUGGABLES && wantDebug) {
scriptEngine->runDebuggable();
} else {

137
libraries/shared/src/RenderArgs.h
View file

@ -1,137 +0,0 @@
//
// RenderArgs.h
// libraries/shared
//
// Created by Brad Hefta-Gaub on 10/29/14.
// Copyright 2013-2014 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
//
#ifndef hifi_RenderArgs_h
#define hifi_RenderArgs_h
#include <functional>
#include <memory>
#include <stack>
#include <GLMHelpers.h>
#include <ViewFrustum.h>
class AABox;
class OctreeRenderer;
namespace render {
class Scene;
using ScenePointer = std::shared_ptr<Scene>;
}
namespace gpu {
class Batch;
class Context;
class Texture;
class Framebuffer;
}
namespace render {
class ShapePipeline;
}
class RenderDetails {
public:
enum Type {
ITEM,
SHADOW,
OTHER
};
struct Item {
int _considered = 0;
int _outOfView = 0;
int _tooSmall = 0;
int _rendered = 0;
};
int _materialSwitches = 0;
int _trianglesRendered = 0;
Item _item;
Item _shadow;
Item _other;
Item& edit(Type type) {
switch (type) {
case SHADOW:
return _shadow;
case ITEM:
return _item;
default:
return _other;
}
}
};
class RenderArgs {
public:
enum RenderMode { DEFAULT_RENDER_MODE, SHADOW_RENDER_MODE, DIFFUSE_RENDER_MODE, NORMAL_RENDER_MODE, MIRROR_RENDER_MODE };
enum DisplayMode { MONO, STEREO_MONITOR, STEREO_HMD };
enum DebugFlags {
RENDER_DEBUG_NONE = 0,
RENDER_DEBUG_HULLS = 1
};
RenderArgs(std::shared_ptr<gpu::Context> context = nullptr,
QSharedPointer<OctreeRenderer> renderer = QSharedPointer<OctreeRenderer>(nullptr),
float sizeScale = 1.0f,
int boundaryLevelAdjust = 0,
RenderMode renderMode = DEFAULT_RENDER_MODE,
DisplayMode displayMode = MONO,
DebugFlags debugFlags = RENDER_DEBUG_NONE,
gpu::Batch* batch = nullptr) :
_context(context),
_renderer(renderer),
_sizeScale(sizeScale),
_boundaryLevelAdjust(boundaryLevelAdjust),
_renderMode(renderMode),
_displayMode(displayMode),
_debugFlags(debugFlags),
_batch(batch) {
}
bool hasViewFrustum() const { return _viewFrustums.size() > 0; }
void setViewFrustum(const ViewFrustum& viewFrustum) {
while (_viewFrustums.size() > 0) {
_viewFrustums.pop();
}
_viewFrustums.push(viewFrustum);
}
const ViewFrustum& getViewFrustum() const { assert(_viewFrustums.size() > 0); return _viewFrustums.top(); }
void pushViewFrustum(const ViewFrustum& viewFrustum) { _viewFrustums.push(viewFrustum); }
void popViewFrustum() { _viewFrustums.pop(); }
std::shared_ptr<gpu::Context> _context = nullptr;
std::shared_ptr<gpu::Framebuffer> _blitFramebuffer = nullptr;
std::shared_ptr<render::ShapePipeline> _pipeline = nullptr;
QSharedPointer<OctreeRenderer> _renderer;
std::stack<ViewFrustum> _viewFrustums;
glm::ivec4 _viewport{ 0.0f, 0.0f, 1.0f, 1.0f };
glm::vec3 _boomOffset{ 0.0f, 0.0f, 1.0f };
float _sizeScale = 1.0f;
int _boundaryLevelAdjust = 0;
RenderMode _renderMode = DEFAULT_RENDER_MODE;
DisplayMode _displayMode = MONO;
DebugFlags _debugFlags = RENDER_DEBUG_NONE;
gpu::Batch* _batch = nullptr;
std::shared_ptr<gpu::Texture> _whiteTexture;
uint32_t _globalShapeKey { 0 };
bool _enableTexturing { true };
RenderDetails _details;
render::ScenePointer _scene;
int8_t _cameraMode { -1 };
};
#endif // hifi_RenderArgs_h

2
plugins/openvr/src/ViveControllerManager.h
View file

@ -23,8 +23,6 @@
#include <gpu/Texture.h>
#include <controllers/InputDevice.h>
#include <plugins/InputPlugin.h>
#include <RenderArgs.h>
#include <render/Scene.h>
#include "OpenVrHelpers.h"
using PuckPosePair = std::pair<uint32_t, controller::Pose>;

3
script-archive/libraries/overlayManager.js
View file

@ -269,9 +269,6 @@
"minorGridWidth", "majorGridEvery"
]);
LocalModelsOverlay = generateOverlayClass(Volume3DOverlay, "localmodels", [
]);
ModelOverlay = generateOverlayClass(Volume3DOverlay, "model", [
"url", "dimensions", "textures"
]);

1
tests/gpu-test/src/TestFbx.cpp
View file

@ -13,7 +13,6 @@
#include <QtCore/QFile>
#include <FBXReader.h>
#include <OctreeRenderer.h>
struct MyVertex {
vec3 position;

1
tests/gpu-test/src/TestWindow.cpp
View file

@ -22,7 +22,6 @@
#include <DeferredLightingEffect.h>
#include <FramebufferCache.h>
#include <TextureCache.h>
#include <OctreeRenderer.h>
#ifdef DEFERRED_LIGHTING
extern void initDeferredPipelines(render::ShapePlumber& plumber);

2
tests/gpu-test/src/main.cpp
View file

@ -45,8 +45,6 @@
#include <TextureCache.h>
#include <PerfStat.h>
#include <PathUtils.h>
#include <OctreeRenderer.h>
#include <RenderArgs.h>
#include <ViewFrustum.h>
#include <gpu/Pipeline.h>

3
tests/render-perf/CMakeLists.txt
View file

@ -10,7 +10,8 @@ setup_hifi_project(Quick Gui OpenGL)
set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "Tests/manual-tests/")
# link in the shared libraries
link_hifi_libraries(shared octree ktx gl gpu gpu-gl render model model-networking networking render-utils fbx entities entities-renderer animation audio avatars script-engine physics image procedural)
link_hifi_libraries(shared networking model fbx ktx image octree gl gpu gpu-gl render model-networking networking render-utils entities entities-renderer animation audio avatars script-engine physics procedural)
package_libraries_for_deployment()

6
tests/render-perf/src/main.cpp
View file

@ -507,7 +507,6 @@ public:
REGISTER_ENTITY_TYPE_WITH_FACTORY(Web, WebEntityItem::factory);
DependencyManager::set<ParentFinder>(_octree->getTree());
getEntities()->setViewFrustum(_viewFrustum);
auto nodeList = DependencyManager::get<LimitedNodeList>();
NodePermissions permissions;
permissions.setAll(true);
@ -735,8 +734,8 @@ private:
class EntityUpdateOperator : public RecurseOctreeOperator {
public:
EntityUpdateOperator(const qint64& now) : now(now) {}
bool preRecursion(OctreeElementPointer element) override { return true; }
bool postRecursion(OctreeElementPointer element) override {
bool preRecursion(const OctreeElementPointer& element) override { return true; }
bool postRecursion(const OctreeElementPointer& element) override {
EntityTreeElementPointer entityTreeElement = std::static_pointer_cast<EntityTreeElement>(element);
entityTreeElement->forEachEntity([&](EntityItemPointer entityItem) {
if (!entityItem->isParentIDValid()) {
@ -865,7 +864,6 @@ private:
}
}
getEntities()->setViewFrustum(_viewFrustum);
EntityUpdateOperator updateOperator(now);
//getEntities()->getTree()->recurseTreeWithOperator(&updateOperator);
{