History

reinserting culling, lod and depth sort to the rendering

Sam Gateau committed 11 years ago

Commit 3f8bdc12 parents 2cbd049 191fedb42 files · +1096 −233Browse files

Unified · Split

42 files
  1. interface/src/Application.cpp +14 −9
  2. interface/src/audio/AudioToolBox.cpp +3 −3
  3. interface/src/avatar/AvatarManager.cpp +3 −3
  4. interface/src/devices/CameraToolBox.cpp +2 −2
  5. interface/src/ui/ApplicationOverlay.cpp +3 −4
  6. interface/src/ui/RearMirrorTools.cpp +3 −4
  7. interface/src/ui/overlays/TextOverlay.cpp +2 −0
  8. interface/src/ui/overlays/TextOverlay.h +1 −1
  9. libraries/entities-renderer/src/EntityTreeRenderer.cpp +25 −24
  10. libraries/entities-renderer/src/EntityTreeRenderer.h +1 −1
  11. libraries/entities-renderer/src/RenderableBoxEntityItem.h +3 −0
  12. libraries/entities-renderer/src/RenderableEntityItem.cpp +3 −3
  13. libraries/entities-renderer/src/RenderableEntityItem.h +40 −6
  14. libraries/entities-renderer/src/RenderableLightEntityItem.h +1 −0
  15. libraries/entities-renderer/src/RenderableLineEntityItem.h +3 −0
  16. libraries/entities-renderer/src/RenderableModelEntityItem.h +1 −0
  17. libraries/entities-renderer/src/RenderableParticleEffectEntityItem.h +3 −0
  18. libraries/entities-renderer/src/RenderableSphereEntityItem.h +4 −0
  19. libraries/entities-renderer/src/RenderableTextEntityItem.cpp +27 −38
  20. libraries/entities-renderer/src/RenderableTextEntityItem.h +3 −2
  21. libraries/entities-renderer/src/RenderableWebEntityItem.h +1 −0
  22. libraries/entities/CMakeLists.txt +1 −0
  23. libraries/entities/src/EntityItem.cpp +7 −0
  24. libraries/entities/src/EntityItem.h +12 −1
  25. libraries/gpu/src/gpu/GLBackendInput.cpp +26 −24
  26. libraries/gpu/src/gpu/Stream.cpp +2 −2
  27. libraries/gpu/src/gpu/Texture.h +10 −10
  28. libraries/render-utils/src/DeferredLightingEffect.cpp +2 −2
  29. libraries/render-utils/src/GeometryCache.cpp +3 −3
  30. libraries/render-utils/src/GeometryCache.h +1 −1
  31. libraries/render-utils/src/RenderUtil.h +0 −2
  32. libraries/render-utils/src/TextRenderer3D.cpp +498 −0
  33. libraries/render-utils/src/TextRenderer3D.h +77 −0
  34. libraries/render-utils/src/TextureCache.cpp +3 −3
  35. libraries/render-utils/src/TextureCache.h +1 −1
  36. libraries/render-utils/src/sdf_text3D.slf +47 −0
  37. libraries/render-utils/src/sdf_text3D.slv +23 −0
  38. libraries/render/src/render/DrawTask.cpp +207 −44
  39. libraries/render/src/render/DrawTask.h +4 −14
  40. libraries/render/src/render/Scene.cpp +5 −5
  41. libraries/render/src/render/Scene.h +21 −20
  42. tests/render-utils/src/main.cpp +0 −1
interface/src/Application.cpp+14−9
@@ -3403,7 +3403,7 @@ void Application::displaySide(RenderArgs* renderArgs, Camera& theCamera, bool se · 3402 unmodified lines
3403 }3403 }
3404 }3404 }
3405 3405
3406 render::Scene::PendingChanges pendingChanges;3406 render::PendingChanges pendingChanges;
3407 3407
3408 // Make sure the WorldBox is in the scene3408 // Make sure the WorldBox is in the scene
3409 if (WorldBoxRenderData::_item == 0) {3409 if (WorldBoxRenderData::_item == 0) {
@@ -3415,18 +3415,23 @@ void Application::displaySide(RenderArgs* renderArgs, Camera& theCamera, bool se · 5 unmodified lines
3415 pendingChanges.resetItem(WorldBoxRenderData::_item, worldBoxRenderPayload);3415 pendingChanges.resetItem(WorldBoxRenderData::_item, worldBoxRenderPayload);
3416 }3416 }
3417 3417
3418 {
3419 PerformanceTimer perfTimer("SceneProcessPendingChanges");
3420 _main3DScene->enqueuePendingChanges(pendingChanges);
3418 3421
3419 _main3DScene->enqueuePendingChanges(pendingChanges);3422 _main3DScene->processPendingChangesQueue();
3420 3423 }
3421 _main3DScene->processPendingChangesQueue();
3422 3424
3423 // FOr now every frame pass the renderCOntext3425 // FOr now every frame pass the renderCOntext
3424 render::RenderContext renderContext;3426 {
3425 renderContext.args = renderArgs;3427 PerformanceTimer perfTimer("EngineRun");
3426 _renderEngine->setRenderContext(renderContext);3428 render::RenderContext renderContext;
3429 renderContext.args = renderArgs;
3430 _renderEngine->setRenderContext(renderContext);
3427 3431
3428 // Before the deferred pass, let's try to use the render engine3432 // Before the deferred pass, let's try to use the render engine
3429 _renderEngine->run();3433 _renderEngine->run();
3434 }
3430 3435
3431 {3436 {
3432 DependencyManager::get<DeferredLightingEffect>()->setAmbientLightMode(getRenderAmbientLight());3437 DependencyManager::get<DeferredLightingEffect>()->setAmbientLightMode(getRenderAmbientLight());
interface/src/audio/AudioToolBox.cpp+3−3
@@ -40,13 +40,13 @@ void AudioToolBox::render(int x, int y, int padding, bool boxed) { · 39 unmodified lines
40 glEnable(GL_TEXTURE_2D);40 glEnable(GL_TEXTURE_2D);
41 41
42 if (!_micTexture) {42 if (!_micTexture) {
43 _micTexture = DependencyManager::get<TextureCache>()->getImageTexture(PathUtils::resourcesPath() + "images/mic.svg");43 _micTexture = TextureCache::getImageTexture(PathUtils::resourcesPath() + "images/mic.svg");
44 }44 }
45 if (!_muteTexture) {45 if (!_muteTexture) {
46 _muteTexture = DependencyManager::get<TextureCache>()->getImageTexture(PathUtils::resourcesPath() + "images/mic-mute.svg");46 _muteTexture = TextureCache::getImageTexture(PathUtils::resourcesPath() + "images/mic-mute.svg");
47 }47 }
48 if (_boxTexture) {48 if (_boxTexture) {
49 _boxTexture = DependencyManager::get<TextureCache>()->getImageTexture(PathUtils::resourcesPath() + "images/audio-box.svg");49 _boxTexture = TextureCache::getImageTexture(PathUtils::resourcesPath() + "images/audio-box.svg");
50 }50 }
51 51
52 auto audioIO = DependencyManager::get<AudioClient>();52 auto audioIO = DependencyManager::get<AudioClient>();
interface/src/avatar/AvatarManager.cpp+3−3
@@ -67,7 +67,7 @@ void AvatarManager::init() { · 66 unmodified lines
67 auto avatarPayloadPointer = Avatar::PayloadPointer(avatarPayload);67 auto avatarPayloadPointer = Avatar::PayloadPointer(avatarPayload);
68 static_cast<Avatar*>(_myAvatar.get())->_renderItemID = scene->allocateID();68 static_cast<Avatar*>(_myAvatar.get())->_renderItemID = scene->allocateID();
69 69
70 render::Scene::PendingChanges pendingChanges;70 render::PendingChanges pendingChanges;
71 pendingChanges.resetItem(static_cast<Avatar*>(_myAvatar.get())->_renderItemID, avatarPayloadPointer);71 pendingChanges.resetItem(static_cast<Avatar*>(_myAvatar.get())->_renderItemID, avatarPayloadPointer);
72 72
73 scene->enqueuePendingChanges(pendingChanges);73 scene->enqueuePendingChanges(pendingChanges);
@@ -152,7 +152,7 @@ AvatarSharedPointer AvatarManager::addAvatar(const QUuid& sessionUUID, const QWe · 78 unmodified lines
152 auto avatarPayloadPointer = Avatar::PayloadPointer(avatarPayload);152 auto avatarPayloadPointer = Avatar::PayloadPointer(avatarPayload);
153 static_cast<Avatar*>(avatar.get())->_renderItemID = scene->allocateID();153 static_cast<Avatar*>(avatar.get())->_renderItemID = scene->allocateID();
154 154
155 render::Scene::PendingChanges pendingChanges;155 render::PendingChanges pendingChanges;
156 pendingChanges.resetItem(static_cast<Avatar*>(avatar.get())->_renderItemID, avatarPayloadPointer);156 pendingChanges.resetItem(static_cast<Avatar*>(avatar.get())->_renderItemID, avatarPayloadPointer);
157 157
158 scene->enqueuePendingChanges(pendingChanges);158 scene->enqueuePendingChanges(pendingChanges);
@@ -186,7 +186,7 @@ void AvatarManager::removeAvatar(const QUuid& sessionUUID) { · 27 unmodified lines
186 }186 }
187 187
188 render::ScenePointer scene = Application::getInstance()->getMain3DScene();188 render::ScenePointer scene = Application::getInstance()->getMain3DScene();
189 render::Scene::PendingChanges pendingChanges;189 render::PendingChanges pendingChanges;
190 pendingChanges.removeItem(avatar->_renderItemID);190 pendingChanges.removeItem(avatar->_renderItemID);
191 scene->enqueuePendingChanges(pendingChanges);191 scene->enqueuePendingChanges(pendingChanges);
192 }192 }
interface/src/devices/CameraToolBox.cpp+2−2
@@ -76,10 +76,10 @@ void CameraToolBox::render(int x, int y, bool boxed) { · 75 unmodified lines
76 glEnable(GL_TEXTURE_2D);76 glEnable(GL_TEXTURE_2D);
77 77
78 if (!_enabledTexture) {78 if (!_enabledTexture) {
79 _enabledTexture = DependencyManager::get<TextureCache>()->getImageTexture(PathUtils::resourcesPath() + "images/face.svg");79 _enabledTexture = TextureCache::getImageTexture(PathUtils::resourcesPath() + "images/face.svg");
80 }80 }
81 if (!_mutedTexture) {81 if (!_mutedTexture) {
82 _mutedTexture = DependencyManager::get<TextureCache>()->getImageTexture(PathUtils::resourcesPath() + "images/face-mute.svg");82 _mutedTexture = TextureCache::getImageTexture(PathUtils::resourcesPath() + "images/face-mute.svg");
83 }83 }
84 84
85 const int MUTE_ICON_SIZE = 24;85 const int MUTE_ICON_SIZE = 24;
interface/src/ui/ApplicationOverlay.cpp+3−4
@@ -423,8 +423,8 @@ void ApplicationOverlay::displayOverlayTextureStereo(Camera& whichCamera, float · 422 unmodified lines
423 });423 });
424 424
425 if (!_crosshairTexture) {425 if (!_crosshairTexture) {
426 _crosshairTexture = DependencyManager::get<TextureCache>()->426 _crosshairTexture = TextureCache::getImageTexture(PathUtils::resourcesPath() +
427 getImageTexture(PathUtils::resourcesPath() + "images/sixense-reticle.png");427 "images/sixense-reticle.png");
428 }428 }
429 429
430 //draw the mouse pointer430 //draw the mouse pointer
@@ -564,8 +564,7 @@ bool ApplicationOverlay::calculateRayUICollisionPoint(const glm::vec3& position, · 133 unmodified lines
564void ApplicationOverlay::renderPointers() {564void ApplicationOverlay::renderPointers() {
565 //lazily load crosshair texture565 //lazily load crosshair texture
566 if (_crosshairTexture == 0) {566 if (_crosshairTexture == 0) {
567 _crosshairTexture = DependencyManager::get<TextureCache>()->567 _crosshairTexture = TextureCache::getImageTexture(PathUtils::resourcesPath() + "images/sixense-reticle.png");
568 getImageTexture(PathUtils::resourcesPath() + "images/sixense-reticle.png");
569 }568 }
570 glEnable(GL_TEXTURE_2D);569 glEnable(GL_TEXTURE_2D);
571 570
interface/src/ui/RearMirrorTools.cpp+3−4
@@ -34,11 +34,10 @@ RearMirrorTools::RearMirrorTools(QRect& bounds) : · 33 unmodified lines
34 _windowed(false),34 _windowed(false),
35 _fullScreen(false)35 _fullScreen(false)
36{36{
37 auto textureCache = DependencyManager::get<TextureCache>();37 _closeTexture = TextureCache::getImageTexture(PathUtils::resourcesPath() + "images/close.svg");
38 _closeTexture = textureCache->getImageTexture(PathUtils::resourcesPath() + "images/close.svg");
39 38
40 _zoomHeadTexture = textureCache->getImageTexture(PathUtils::resourcesPath() + "images/plus.svg");39 _zoomHeadTexture = TextureCache::getImageTexture(PathUtils::resourcesPath() + "images/plus.svg");
41 _zoomBodyTexture = textureCache->getImageTexture(PathUtils::resourcesPath() + "images/minus.svg");40 _zoomBodyTexture = TextureCache::getImageTexture(PathUtils::resourcesPath() + "images/minus.svg");
42 41
43 _shrinkIconRect = QRect(ICON_PADDING, ICON_PADDING, ICON_SIZE, ICON_SIZE);42 _shrinkIconRect = QRect(ICON_PADDING, ICON_PADDING, ICON_SIZE, ICON_SIZE);
44 _closeIconRect = QRect(_bounds.left() + ICON_PADDING, _bounds.top() + ICON_PADDING, ICON_SIZE, ICON_SIZE);43 _closeIconRect = QRect(_bounds.left() + ICON_PADDING, _bounds.top() + ICON_PADDING, ICON_SIZE, ICON_SIZE);
interface/src/ui/overlays/TextOverlay.cpp+2−0
@@ -24,6 +24,7 @@ TextOverlay::TextOverlay() : · 23 unmodified lines
24 _topMargin(DEFAULT_MARGIN),24 _topMargin(DEFAULT_MARGIN),
25 _fontSize(DEFAULT_FONTSIZE)25 _fontSize(DEFAULT_FONTSIZE)
26{26{
27 _textRenderer = TextRenderer::getInstance(SANS_FONT_FAMILY, _fontSize, DEFAULT_FONT_WEIGHT);
27}28}
28 29
29TextOverlay::TextOverlay(const TextOverlay* textOverlay) :30TextOverlay::TextOverlay(const TextOverlay* textOverlay) :
@@ -35,6 +36,7 @@ TextOverlay::TextOverlay(const TextOverlay* textOverlay) : · 5 unmodified lines
35 _topMargin(textOverlay->_topMargin),36 _topMargin(textOverlay->_topMargin),
36 _fontSize(textOverlay->_fontSize)37 _fontSize(textOverlay->_fontSize)
37{38{
39 _textRenderer = TextRenderer::getInstance(SANS_FONT_FAMILY, _fontSize, DEFAULT_FONT_WEIGHT);
38}40}
39 41
40TextOverlay::~TextOverlay() {42TextOverlay::~TextOverlay() {
interface/src/ui/overlays/TextOverlay.h+1−1
@@ -60,7 +60,7 @@ public: · 59 unmodified lines
60 60
61private:61private:
62 62
63 TextRenderer* _textRenderer = TextRenderer::getInstance(SANS_FONT_FAMILY, _fontSize, DEFAULT_FONT_WEIGHT);63 TextRenderer* _textRenderer = nullptr;
64 64
65 QString _text;65 QString _text;
66 xColor _backgroundColor;66 xColor _backgroundColor;
libraries/entities-renderer/src/EntityTreeRenderer.cpp+25−24
@@ -96,9 +96,13 @@ void EntityTreeRenderer::clear() { · 95 unmodified lines
96 OctreeRenderer::clear();96 OctreeRenderer::clear();
97 _entityScripts.clear();97 _entityScripts.clear();
98 98
99 // TODO/FIXME - this needs to be fixed... we need to clear all items out of the scene in this case. 99 auto scene = _viewState->getMain3DScene();
100 qDebug() << "EntityTreeRenderer::clear() need to clear the scene... ";100 render::PendingChanges pendingChanges;
101 101 foreach(auto entity, _entitiesInScene) {
102 entity->removeFromScene(entity, scene, pendingChanges);
103 }
104 scene->enqueuePendingChanges(pendingChanges);
105 _entitiesInScene.clear();
102}106}
103 107
104void EntityTreeRenderer::init() {108void EntityTreeRenderer::init() {
@@ -704,8 +708,8 @@ void EntityTreeRenderer::renderElement(OctreeElement* element, RenderArgs* args) · 599 unmodified lines
704 }708 }
705 }709 }
706 710
707 // hack for models. :(711 // hack for models and other entities that don't yet play well with others. :(
708 if (entityItem->getType() == EntityTypes::Model) {712 if (!entityItem->canRenderInScene()) {
709 // render entityItem713 // render entityItem
710 AABox entityBox = entityItem->getAABox();714 AABox entityBox = entityItem->getAABox();
711 715
@@ -1063,12 +1067,13 @@ void EntityTreeRenderer::deletingEntity(const EntityItemID& entityID) { · 351 unmodified lines
1063 _entityScripts.remove(entityID);1067 _entityScripts.remove(entityID);
1064 1068
1065 // here's where we remove the entity payload from the scene1069 // here's where we remove the entity payload from the scene
1066 1070 auto entity = static_cast<EntityTree*>(_tree)->findEntityByID(entityID);
1067 render::Scene::PendingChanges pendingChanges;1071 if (entity && _entitiesInScene.contains(entity)) {
1068 if (_entityToSceneItems.contains(entityID)) {1072 render::PendingChanges pendingChanges;
1069 render::ItemID renderItem = _entityToSceneItems[entityID];1073 auto scene = _viewState->getMain3DScene();
1070 pendingChanges.removeItem(renderItem);1074 entity->removeFromScene(entity, scene, pendingChanges);
1071 _viewState->getMain3DScene()->enqueuePendingChanges(pendingChanges);1075 scene->enqueuePendingChanges(pendingChanges);
1076 _entitiesInScene.remove(entity);
1072 }1077 }
1073}1078}
1074 1079
@@ -1076,19 +1081,15 @@ void EntityTreeRenderer::addingEntity(const EntityItemID& entityID) { · 1 unmodified line
1076 checkAndCallPreload(entityID);1081 checkAndCallPreload(entityID);
1077 1082
1078 // here's where we add the entity payload to the scene1083 // here's where we add the entity payload to the scene
1079 1084 auto entity = static_cast<EntityTree*>(_tree)->findEntityByID(entityID);
1080 render::Scene::PendingChanges pendingChanges;1085 if (entity && entity->canRenderInScene()) {
1081 render::ItemID renderItem = _viewState->getMain3DScene()->allocateID();1086 render::PendingChanges pendingChanges;
1082 _entityToSceneItems[entityID] = renderItem;1087 auto scene = _viewState->getMain3DScene();
1083 EntityItemPointer entity = static_cast<EntityTree*>(_tree)->findEntityByID(entityID);1088 if (entity->addToScene(entity, scene, pendingChanges)) {
1084 1089 _entitiesInScene.insert(entity);
1085 auto renderData = RenderableEntityItem::Pointer(new RenderableEntityItem(entity));1090 }
1086 auto renderPayload = render::PayloadPointer(new RenderableEntityItem::Payload(renderData));1091 scene->enqueuePendingChanges(pendingChanges);
1087 1092 }
1088 pendingChanges.resetItem(renderItem, renderPayload);
1089
1090 _viewState->getMain3DScene()->enqueuePendingChanges(pendingChanges);
1091 _viewState->getMain3DScene()->processPendingChangesQueue();
1092}1093}
1093 1094
1094void EntityTreeRenderer::entitySciptChanging(const EntityItemID& entityID) {1095void EntityTreeRenderer::entitySciptChanging(const EntityItemID& entityID) {
libraries/entities-renderer/src/EntityTreeRenderer.h+1−1
@@ -187,7 +187,7 @@ private: · 186 unmodified lines
187 float _previousStageHour;187 float _previousStageHour;
188 int _previousStageDay;188 int _previousStageDay;
189 189
190 QHash<EntityItemID, render::ItemID> _entityToSceneItems;190 QSet<EntityItemPointer> _entitiesInScene;
191};191};
192 192
193 193
libraries/entities-renderer/src/RenderableBoxEntityItem.h+3−0
@@ -14,6 +14,7 @@ · 13 unmodified lines
14 14
15#include <BoxEntityItem.h>15#include <BoxEntityItem.h>
16#include "RenderableDebugableEntityItem.h"16#include "RenderableDebugableEntityItem.h"
17#include "RenderableEntityItem.h"
17 18
18class RenderableBoxEntityItem : public BoxEntityItem {19class RenderableBoxEntityItem : public BoxEntityItem {
19public:20public:
@@ -24,6 +25,8 @@ public: · 4 unmodified lines
24 { }25 { }
25 26
26 virtual void render(RenderArgs* args);27 virtual void render(RenderArgs* args);
28
29 SIMPLE_RENDERABLE()
27};30};
28 31
29 32
libraries/entities-renderer/src/RenderableEntityItem.cpp+3−3
@@ -13,7 +13,7 @@ · 12 unmodified lines
13#include "RenderableEntityItem.h"13#include "RenderableEntityItem.h"
14 14
15namespace render {15namespace render {
16 template <> const ItemKey payloadGetKey(const RenderableEntityItem::Pointer& payload) { 16 template <> const ItemKey payloadGetKey(const RenderableEntityItemProxy::Pointer& payload) {
17 if (payload && payload->entity) {17 if (payload && payload->entity) {
18 if (payload->entity->getType() == EntityTypes::Light) {18 if (payload->entity->getType() == EntityTypes::Light) {
19 return ItemKey::Builder::light();19 return ItemKey::Builder::light();
@@ -22,13 +22,13 @@ namespace render { · 2 unmodified lines
22 return ItemKey::Builder::opaqueShape();22 return ItemKey::Builder::opaqueShape();
23 }23 }
24 24
25 template <> const Item::Bound payloadGetBound(const RenderableEntityItem::Pointer& payload) { 25 template <> const Item::Bound payloadGetBound(const RenderableEntityItemProxy::Pointer& payload) {
26 if (payload && payload->entity) {26 if (payload && payload->entity) {
27 return payload->entity->getAABox();27 return payload->entity->getAABox();
28 }28 }
29 return render::Item::Bound();29 return render::Item::Bound();
30 }30 }
31 template <> void payloadRender(const RenderableEntityItem::Pointer& payload, RenderArgs* args) {31 template <> void payloadRender(const RenderableEntityItemProxy::Pointer& payload, RenderArgs* args) {
32 if (args) {32 if (args) {
33 args->_elementsTouched++;33 args->_elementsTouched++;
34 if (payload && payload->entity) {34 if (payload && payload->entity) {
libraries/entities-renderer/src/RenderableEntityItem.h+40−6
@@ -15,19 +15,53 @@ · 14 unmodified lines
15#include <render/Scene.h>15#include <render/Scene.h>
16#include <EntityItem.h>16#include <EntityItem.h>
17 17
18class RenderableEntityItem {18
19class RenderableEntityItemProxy {
19public:20public:
20 RenderableEntityItem(EntityItemPointer entity) : entity(entity) { }21 RenderableEntityItemProxy(EntityItemPointer entity) : entity(entity) { }
21 typedef render::Payload<RenderableEntityItem> Payload;22 typedef render::Payload<RenderableEntityItemProxy> Payload;
22 typedef Payload::DataPointer Pointer;23 typedef Payload::DataPointer Pointer;
23 24
24 EntityItemPointer entity;25 EntityItemPointer entity;
25};26};
26 27
27namespace render {28namespace render {
28 template <> const ItemKey payloadGetKey(const RenderableEntityItem::Pointer& payload); 29 template <> const ItemKey payloadGetKey(const RenderableEntityItemProxy::Pointer& payload);
29 template <> const Item::Bound payloadGetBound(const RenderableEntityItem::Pointer& payload);30 template <> const Item::Bound payloadGetBound(const RenderableEntityItemProxy::Pointer& payload);
30 template <> void payloadRender(const RenderableEntityItem::Pointer& payload, RenderArgs* args);31 template <> void payloadRender(const RenderableEntityItemProxy::Pointer& payload, RenderArgs* args);
31}32}
32 33
34// Mixin class for implementing basic single item rendering
35class SimpleRenderableEntityItem {
36public:
37 bool addToScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene, render::PendingChanges& pendingChanges) {
38 _myItem = scene->allocateID();
39
40 auto renderData = RenderableEntityItemProxy::Pointer(new RenderableEntityItemProxy(self));
41 auto renderPayload = render::PayloadPointer(new RenderableEntityItemProxy::Payload(renderData));
42
43 pendingChanges.resetItem(_myItem, renderPayload);
44
45 return true;
46 }
47
48 void removeFromScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene, render::PendingChanges& pendingChanges) {
49 pendingChanges.removeItem(_myItem);
50 }
51
52private:
53 render::ItemID _myItem;
54};
55
56
57#define SIMPLE_RENDERABLE() \
58public: \
59 virtual bool canRenderInScene() { return true; } \
60 virtual bool addToScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene, render::PendingChanges& pendingChanges) { return _renderHelper.addToScene(self, scene, pendingChanges); } \
61 virtual void removeFromScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene, render::PendingChanges& pendingChanges) { _renderHelper.removeFromScene(self, scene, pendingChanges); } \
62private: \
63 SimpleRenderableEntityItem _renderHelper;
64
65
66
33#endif // hifi_RenderableEntityItem_h67#endif // hifi_RenderableEntityItem_h
libraries/entities-renderer/src/RenderableLightEntityItem.h+1−0
@@ -22,6 +22,7 @@ public: · 21 unmodified lines
22 LightEntityItem(entityItemID, properties)22 LightEntityItem(entityItemID, properties)
23 { }23 { }
24 24
25 virtual bool canRenderInScene() { return false; } // we don't yet play well with others
25 virtual void render(RenderArgs* args);26 virtual void render(RenderArgs* args);
26 virtual bool supportsDetailedRayIntersection() const { return true; }27 virtual bool supportsDetailedRayIntersection() const { return true; }
27 virtual bool findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction,28 virtual bool findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
libraries/entities-renderer/src/RenderableLineEntityItem.h+3−0
@@ -14,6 +14,7 @@ · 13 unmodified lines
14 14
15#include <LineEntityItem.h>15#include <LineEntityItem.h>
16#include "RenderableDebugableEntityItem.h"16#include "RenderableDebugableEntityItem.h"
17#include "RenderableEntityItem.h"
17 18
18class RenderableLineEntityItem : public LineEntityItem {19class RenderableLineEntityItem : public LineEntityItem {
19public:20public:
@@ -23,6 +24,8 @@ public: · 3 unmodified lines
23 LineEntityItem(entityItemID, properties) { }24 LineEntityItem(entityItemID, properties) { }
24 25
25 virtual void render(RenderArgs* args);26 virtual void render(RenderArgs* args);
27
28 SIMPLE_RENDERABLE()
26};29};
27 30
28 31
libraries/entities-renderer/src/RenderableModelEntityItem.h+1−0
@@ -43,6 +43,7 @@ public: · 42 unmodified lines
43 43
44 virtual void somethingChangedNotification() { _needsInitialSimulation = true; }44 virtual void somethingChangedNotification() { _needsInitialSimulation = true; }
45 45
46 virtual bool canRenderInScene() { return false; } // we don't yet play well with others
46 virtual void render(RenderArgs* args);47 virtual void render(RenderArgs* args);
47 virtual bool supportsDetailedRayIntersection() const { return true; }48 virtual bool supportsDetailedRayIntersection() const { return true; }
48 virtual bool findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction,49 virtual bool findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
libraries/entities-renderer/src/RenderableParticleEffectEntityItem.h+3−0
@@ -13,6 +13,7 @@ · 12 unmodified lines
13 13
14#include <ParticleEffectEntityItem.h>14#include <ParticleEffectEntityItem.h>
15#include <TextureCache.h>15#include <TextureCache.h>
16#include "RenderableEntityItem.h"
16 17
17class RenderableParticleEffectEntityItem : public ParticleEffectEntityItem {18class RenderableParticleEffectEntityItem : public ParticleEffectEntityItem {
18public:19public:
@@ -22,6 +23,8 @@ public: · 3 unmodified lines
22 23
23 void updateQuads(RenderArgs* args, bool textured);24 void updateQuads(RenderArgs* args, bool textured);
24 25
26 SIMPLE_RENDERABLE()
27
25protected:28protected:
26 29
27 int _cacheID;30 int _cacheID;
libraries/entities-renderer/src/RenderableSphereEntityItem.h+4−0
@@ -14,6 +14,8 @@ · 13 unmodified lines
14 14
15#include <SphereEntityItem.h>15#include <SphereEntityItem.h>
16 16
17#include "RenderableEntityItem.h"
18
17class RenderableSphereEntityItem : public SphereEntityItem {19class RenderableSphereEntityItem : public SphereEntityItem {
18public:20public:
19 static EntityItemPointer factory(const EntityItemID& entityID, const EntityItemProperties& properties);21 static EntityItemPointer factory(const EntityItemID& entityID, const EntityItemProperties& properties);
@@ -23,6 +25,8 @@ public: · 3 unmodified lines
23 { }25 { }
24 26
25 virtual void render(RenderArgs* args);27 virtual void render(RenderArgs* args);
28
29 SIMPLE_RENDERABLE()
26};30};
27 31
28 32
libraries/entities-renderer/src/RenderableTextEntityItem.cpp+27−38
@@ -20,52 +20,41 @@ · 19 unmodified lines
20#include "RenderableTextEntityItem.h"20#include "RenderableTextEntityItem.h"
21#include "GLMHelpers.h"21#include "GLMHelpers.h"
22 22
23
24EntityItemPointer RenderableTextEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {23EntityItemPointer RenderableTextEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
25 return EntityItemPointer(new RenderableTextEntityItem(entityID, properties));24 return EntityItemPointer(new RenderableTextEntityItem(entityID, properties));
26}25}
27 26
28void RenderableTextEntityItem::render(RenderArgs* args) {27void RenderableTextEntityItem::render(RenderArgs* args) {
29 PerformanceTimer perfTimer("RenderableTextEntityItem::render");28 PerformanceTimer perfTimer("RenderableTextEntityItem::render");
30 assert(getType() == EntityTypes::Text);29 Q_ASSERT(getType() == EntityTypes::Text);
31 glm::vec3 position = getPosition();30
31 static const float SLIGHTLY_BEHIND = -0.005f;
32 glm::vec4 textColor = glm::vec4(toGlm(getTextColorX()), 1.0f);
33 glm::vec4 backgroundColor = glm::vec4(toGlm(getBackgroundColorX()), 1.0f);
32 glm::vec3 dimensions = getDimensions();34 glm::vec3 dimensions = getDimensions();
33 glm::vec3 halfDimensions = dimensions / 2.0f;35
34 glm::quat rotation = getRotation();36 Transform transformToTopLeft = getTransformToCenter();
35 float leftMargin = 0.1f;37 transformToTopLeft.postTranslate(glm::vec3(-0.5f, 0.5f, 0.0f)); // Go to the top left
36 float topMargin = 0.1f;38 transformToTopLeft.setScale(1.0f); // Use a scale of one so that the text is not deformed
37 39
38 //qCDebug(entitytree) << "RenderableTextEntityItem::render() id:" << getEntityItemID() << "text:" << getText();40 // Batch render calls
39 41 Q_ASSERT(args->_batch);
40 glPushMatrix(); 42 gpu::Batch& batch = *args->_batch;
41 {43 batch.setModelTransform(transformToTopLeft);
42 glTranslatef(position.x, position.y, position.z);44
43 glm::vec3 axis = glm::axis(rotation);45 // Render background
44 glRotatef(glm::degrees(glm::angle(rotation)), axis.x, axis.y, axis.z);46 glm::vec3 minCorner = glm::vec3(0.0f, -dimensions.y, SLIGHTLY_BEHIND);
45 47 glm::vec3 maxCorner = glm::vec3(dimensions.x, 0.0f, SLIGHTLY_BEHIND);
46 float alpha = 1.0f; //getBackgroundAlpha();48 DependencyManager::get<DeferredLightingEffect>()->renderQuad(batch, minCorner, maxCorner, backgroundColor);
47 static const float SLIGHTLY_BEHIND = -0.005f;49
48 50 float scale = _lineHeight / _textRenderer->getRowHeight();
49 glm::vec3 topLeft(-halfDimensions.x, -halfDimensions.y, SLIGHTLY_BEHIND);51 transformToTopLeft.setScale(scale); // Scale to have the correct line height
50 glm::vec3 bottomRight(halfDimensions.x, halfDimensions.y, SLIGHTLY_BEHIND);52 batch.setModelTransform(transformToTopLeft);
51 53
52 // TODO: Determine if we want these entities to have the deferred lighting effect? I think we do, so that the color54 float leftMargin = 0.5f * _lineHeight, topMargin = 0.5f * _lineHeight;
53 // used for a sphere, or box have the same look as those used on a text entity.55 glm::vec2 bounds = glm::vec2(dimensions.x - 2.0f * leftMargin, dimensions.y - 2.0f * topMargin);
54 //DependencyManager::get<DeferredLightingEffect>()->bindSimpleProgram();56 _textRenderer->draw(batch, leftMargin / scale, -topMargin / scale, _text, textColor, bounds / scale);
55 DependencyManager::get<GeometryCache>()->renderQuad(topLeft, bottomRight, glm::vec4(toGlm(getBackgroundColorX()), alpha));
56 //DependencyManager::get<DeferredLightingEffect>()->releaseSimpleProgram();
57
58 glTranslatef(-(halfDimensions.x - leftMargin), halfDimensions.y - topMargin, 0.0f);
59 glm::vec4 textColor(toGlm(getTextColorX()), alpha);
60 // this is a ratio determined through experimentation
61 const float scaleFactor = 0.08f * _lineHeight;
62 glScalef(scaleFactor, -scaleFactor, scaleFactor);
63 glm::vec2 bounds(dimensions.x / scaleFactor, dimensions.y / scaleFactor);
64 _textRenderer->draw(0, 0, _text, textColor, bounds);
65 }
66 glPopMatrix();
67}57}
68 58
69 59
70 60
71
libraries/entities-renderer/src/RenderableTextEntityItem.h+3−2
@@ -13,7 +13,7 @@ · 12 unmodified lines
13#define hifi_RenderableTextEntityItem_h13#define hifi_RenderableTextEntityItem_h
14 14
15#include <TextEntityItem.h>15#include <TextEntityItem.h>
16#include <TextRenderer.h>16#include <TextRenderer3D.h>
17 17
18const int FIXED_FONT_POINT_SIZE = 40;18const int FIXED_FONT_POINT_SIZE = 40;
19 19
@@ -27,9 +27,10 @@ public: · 7 unmodified lines
27 ~RenderableTextEntityItem() { delete _textRenderer; }27 ~RenderableTextEntityItem() { delete _textRenderer; }
28 28
29 virtual void render(RenderArgs* args);29 virtual void render(RenderArgs* args);
30 virtual bool canRenderInScene() { return false; } // we don't yet play well with others
30 31
31private:32private:
32 TextRenderer* _textRenderer = TextRenderer::getInstance(SANS_FONT_FAMILY, FIXED_FONT_POINT_SIZE / 2.0f);33 TextRenderer3D* _textRenderer = TextRenderer3D::getInstance(SANS_FONT_FAMILY, FIXED_FONT_POINT_SIZE / 2.0f);
33};34};
34 35
35 36
libraries/entities-renderer/src/RenderableWebEntityItem.h+1−0
@@ -24,6 +24,7 @@ public: · 23 unmodified lines
24 24
25 virtual void render(RenderArgs* args);25 virtual void render(RenderArgs* args);
26 virtual void setSourceUrl(const QString& value);26 virtual void setSourceUrl(const QString& value);
27 virtual bool canRenderInScene() { return false; } // we don't yet play well with others
27 28
28private:29private:
29 OffscreenQmlSurface* _webSurface{ nullptr };30 OffscreenQmlSurface* _webSurface{ nullptr };
libraries/entities/CMakeLists.txt+1−0
@@ -14,3 +14,4 @@ target_include_directories(${TARGET_NAME} SYSTEM PRIVATE ${BULLET_INCLUDE_DIRS}) · 13 unmodified lines
14target_link_libraries(${TARGET_NAME} ${BULLET_LIBRARIES})14target_link_libraries(${TARGET_NAME} ${BULLET_LIBRARIES})
15 15
16link_hifi_libraries(avatars shared octree gpu model fbx networking animation environment)16link_hifi_libraries(avatars shared octree gpu model fbx networking animation environment)
17include_hifi_library_headers(render)
libraries/entities/src/EntityItem.cpp+7−0
@@ -1005,6 +1005,13 @@ void EntityItem::setTranformToCenter(const Transform& transform) { · 1004 unmodified lines
1005 setTransform(copy);1005 setTransform(copy);
1006}1006}
1007 1007
1008void EntityItem::setDimensions(const glm::vec3& value) {
1009 if (value.x == 0.0f || value.y == 0.0f || value.z == 0.0f) {
1010 return;
1011 }
1012 _transform.setScale(value);
1013}
1014
1008/// The maximum bounding cube for the entity, independent of it's rotation.1015/// The maximum bounding cube for the entity, independent of it's rotation.
1009/// This accounts for the registration point (upon which rotation occurs around).1016/// This accounts for the registration point (upon which rotation occurs around).
1010/// 1017///
libraries/entities/src/EntityItem.h+12−1
@@ -12,6 +12,7 @@ · 11 unmodified lines
12#ifndef hifi_EntityItem_h12#ifndef hifi_EntityItem_h
13#define hifi_EntityItem_h13#define hifi_EntityItem_h
14 14
15#include <memory>
15#include <stdint.h>16#include <stdint.h>
16 17
17#include <glm/glm.hpp>18#include <glm/glm.hpp>
@@ -33,6 +34,11 @@ class EntitySimulation; · 15 unmodified lines
33class EntityTreeElement;34class EntityTreeElement;
34class EntityTreeElementExtraEncodeData;35class EntityTreeElementExtraEncodeData;
35 36
37namespace render {
38 class Scene;
39 class PendingChanges;
40}
41
36// these thesholds determine what updates will be ignored (client and server)42// these thesholds determine what updates will be ignored (client and server)
37const float IGNORE_POSITION_DELTA = 0.0001f;43const float IGNORE_POSITION_DELTA = 0.0001f;
38const float IGNORE_DIMENSIONS_DELTA = 0.0005f;44const float IGNORE_DIMENSIONS_DELTA = 0.0005f;
@@ -151,6 +157,11 @@ public: · 112 unmodified lines
151 EntityPropertyFlags& propertyFlags, bool overwriteLocalData) 157 EntityPropertyFlags& propertyFlags, bool overwriteLocalData)
152 { return 0; }158 { return 0; }
153 159
160 virtual bool canRenderInScene() { return false; } // does your entity property render using Render Items and Payloads
161 virtual bool addToScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene,
162 render::PendingChanges& pendingChanges) { return false; } // by default entity items don't add to scene
163 virtual void removeFromScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene,
164 render::PendingChanges& pendingChanges) { } // by default entity items don't add to scene
154 virtual void render(RenderArgs* args) { } // by default entity items don't know how to render165 virtual void render(RenderArgs* args) { } // by default entity items don't know how to render
155 166
156 static int expectedBytes();167 static int expectedBytes();
@@ -195,7 +206,7 @@ public: · 38 unmodified lines
195 206
196 /// Dimensions in meters (0.0 - TREE_SCALE)207 /// Dimensions in meters (0.0 - TREE_SCALE)
197 inline const glm::vec3& getDimensions() const { return _transform.getScale(); }208 inline const glm::vec3& getDimensions() const { return _transform.getScale(); }
198 inline virtual void setDimensions(const glm::vec3& value) { _transform.setScale(glm::abs(value)); }209 virtual void setDimensions(const glm::vec3& value);
199 210
200 211
201 float getGlowLevel() const { return _glowLevel; }212 float getGlowLevel() const { return _glowLevel; }
libraries/gpu/src/gpu/GLBackendInput.cpp+26−24
@@ -66,22 +66,23 @@ void GLBackend::updateInput() { · 65 unmodified lines
66 newActivation.set(attrib._slot);66 newActivation.set(attrib._slot);
67 }67 }
68 }68 }
69 69
70 // Manage Activation what was and what is expected now70 // Manage Activation what was and what is expected now
71 for (unsigned int i = 0; i < newActivation.size(); i++) {71 for (unsigned int i = 0; i < newActivation.size(); i++) {
72 bool newState = newActivation[i];72 bool newState = newActivation[i];
73 if (newState != _input._attributeActivation[i]) {73 if (newState != _input._attributeActivation[i]) {
74#if defined(SUPPORT_LEGACY_OPENGL)74#if defined(SUPPORT_LEGACY_OPENGL)
75 if (i < NUM_CLASSIC_ATTRIBS) {75 const bool useClientState = i < NUM_CLASSIC_ATTRIBS;
76#else
77 const bool useClientState = false;
78#endif
79 if (useClientState) {
76 if (newState) {80 if (newState) {
77 glEnableClientState(attributeSlotToClassicAttribName[i]);81 glEnableClientState(attributeSlotToClassicAttribName[i]);
78 } else {82 } else {
79 glDisableClientState(attributeSlotToClassicAttribName[i]);83 glDisableClientState(attributeSlotToClassicAttribName[i]);
80 }84 }
81 } else {85 } else {
82#else
83 {
84#endif
85 if (newState) {86 if (newState) {
86 glEnableVertexAttribArray(i);87 glEnableVertexAttribArray(i);
87 } else {88 } else {
@@ -89,7 +90,7 @@ void GLBackend::updateInput() { · 1 unmodified line
89 }90 }
90 }91 }
91 (void) CHECK_GL_ERROR();92 (void) CHECK_GL_ERROR();
92 93
93 _input._attributeActivation.flip(i);94 _input._attributeActivation.flip(i);
94 }95 }
95 }96 }
@@ -123,29 +124,30 @@ void GLBackend::updateInput() { · 27 unmodified lines
123 GLenum type = _elementTypeToGLType[attrib._element.getType()];124 GLenum type = _elementTypeToGLType[attrib._element.getType()];
124 GLuint stride = strides[bufferNum];125 GLuint stride = strides[bufferNum];
125 GLuint pointer = attrib._offset + offsets[bufferNum];126 GLuint pointer = attrib._offset + offsets[bufferNum];
126 #if defined(SUPPORT_LEGACY_OPENGL)127#if defined(SUPPORT_LEGACY_OPENGL)
127 if (slot < NUM_CLASSIC_ATTRIBS) {128 const bool useClientState = slot < NUM_CLASSIC_ATTRIBS;
129#else
130 const bool useClientState = false;
131#endif
132 if (useClientState) {
128 switch (slot) {133 switch (slot) {
129 case Stream::POSITION:134 case Stream::POSITION:
130 glVertexPointer(count, type, stride, reinterpret_cast<GLvoid*>(pointer));135 glVertexPointer(count, type, stride, reinterpret_cast<GLvoid*>(pointer));
131 break;136 break;
132 case Stream::NORMAL:137 case Stream::NORMAL:
133 glNormalPointer(type, stride, reinterpret_cast<GLvoid*>(pointer));138 glNormalPointer(type, stride, reinterpret_cast<GLvoid*>(pointer));
134 break;139 break;
135 case Stream::COLOR:140 case Stream::COLOR:
136 glColorPointer(count, type, stride, reinterpret_cast<GLvoid*>(pointer));141 glColorPointer(count, type, stride, reinterpret_cast<GLvoid*>(pointer));
137 break;142 break;
138 case Stream::TEXCOORD:143 case Stream::TEXCOORD:
139 glTexCoordPointer(count, type, stride, reinterpret_cast<GLvoid*>(pointer)); 144 glTexCoordPointer(count, type, stride, reinterpret_cast<GLvoid*>(pointer));
140 break;145 break;
141 };146 };
142 } else {147 } else {
143 #else
144 {
145 #endif
146 GLboolean isNormalized = attrib._element.isNormalized();148 GLboolean isNormalized = attrib._element.isNormalized();
147 glVertexAttribPointer(slot, count, type, isNormalized, stride,149 glVertexAttribPointer(slot, count, type, isNormalized, stride,
148 reinterpret_cast<GLvoid*>(pointer));150 reinterpret_cast<GLvoid*>(pointer));
149 }151 }
150 (void) CHECK_GL_ERROR();152 (void) CHECK_GL_ERROR();
151 }153 }
libraries/gpu/src/gpu/Stream.cpp+2−2
@@ -10,8 +10,8 @@ · 9 unmodified lines
10//10//
11 11
12#include "Stream.h"12#include "Stream.h"
13 13
14#include <algorithm> //min max and more14#include <algorithm> //min max and more
15 15
16using namespace gpu;16using namespace gpu;
17 17
libraries/gpu/src/gpu/Texture.h+10−10
@@ -17,11 +17,11 @@ · 16 unmodified lines
17 17
18namespace gpu {18namespace gpu {
19 19
20// THe spherical harmonics is a nice tool for cubemap, so if required, the irradiance SH can be automatically generated20// THe spherical harmonics is a nice tool for cubemap, so if required, the irradiance SH can be automatically generated
21// with the cube texture21// with the cube texture
22class Texture;22class Texture;
23class SphericalHarmonics {23class SphericalHarmonics {
24public:24public:
25 glm::vec3 L00 ; float spare0;25 glm::vec3 L00 ; float spare0;
26 glm::vec3 L1m1 ; float spare1;26 glm::vec3 L1m1 ; float spare1;
27 glm::vec3 L10 ; float spare2;27 glm::vec3 L10 ; float spare2;
@@ -44,15 +44,15 @@ public: · 16 unmodified lines
44 VINE_STREET_KITCHEN,44 VINE_STREET_KITCHEN,
45 BREEZEWAY,45 BREEZEWAY,
46 CAMPUS_SUNSET,46 CAMPUS_SUNSET,
47 FUNSTON_BEACH_SUNSET,47 FUNSTON_BEACH_SUNSET,
48 48
49 NUM_PRESET,49 NUM_PRESET,
50 };50 };
51 51
52 void assignPreset(int p);52 void assignPreset(int p);
53 53
54 void evalFromTexture(const Texture& texture);54 void evalFromTexture(const Texture& texture);
55};55};
56typedef std::shared_ptr< SphericalHarmonics > SHPointer;56typedef std::shared_ptr< SphericalHarmonics > SHPointer;
57 57
58class Sampler {58class Sampler {
@@ -438,7 +438,7 @@ public: · 379 unmodified lines
438 explicit operator bool() const { return bool(_texture); }438 explicit operator bool() const { return bool(_texture); }
439 bool operator !() const { return (!_texture); }439 bool operator !() const { return (!_texture); }
440};440};
441typedef std::vector<TextureView> TextureViews;441typedef std::vector<TextureView> TextureViews;
442 442
443};443};
444 444
libraries/render-utils/src/DeferredLightingEffect.cpp+2−2
@@ -62,8 +62,8 @@ void DeferredLightingEffect::init(AbstractViewStateInterface* viewState) { · 61 unmodified lines
62 state->setCullMode(gpu::State::CULL_BACK);62 state->setCullMode(gpu::State::CULL_BACK);
63 state->setDepthTest(true, true, gpu::LESS_EQUAL);63 state->setDepthTest(true, true, gpu::LESS_EQUAL);
64 state->setBlendFunction(false,64 state->setBlendFunction(false,
65 gpu::State::SRC_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::INV_SRC_ALPHA,65 gpu::State::SRC_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::INV_SRC_ALPHA,
66 gpu::State::FACTOR_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::ONE);66 gpu::State::FACTOR_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::ONE);
67 _simpleProgram = gpu::PipelinePointer(gpu::Pipeline::create(program, state));67 _simpleProgram = gpu::PipelinePointer(gpu::Pipeline::create(program, state));
68 68
69 _viewState = viewState;69 _viewState = viewState;
libraries/render-utils/src/GeometryCache.cpp+3−3
@@ -815,9 +815,9 @@ void GeometryCache::renderSolidCube(gpu::Batch& batch, float size, const glm::ve · 814 unmodified lines
815 const int VERTEX_STRIDE = sizeof(GLfloat) * FLOATS_PER_VERTEX * 2; // vertices and normals815 const int VERTEX_STRIDE = sizeof(GLfloat) * FLOATS_PER_VERTEX * 2; // vertices and normals
816 const int NORMALS_OFFSET = sizeof(GLfloat) * FLOATS_PER_VERTEX;816 const int NORMALS_OFFSET = sizeof(GLfloat) * FLOATS_PER_VERTEX;
817 817
818 if (!_solidCubeVerticies.contains(size)) {818 if (!_solidCubeVertices.contains(size)) {
819 gpu::BufferPointer verticesBuffer(new gpu::Buffer());819 gpu::BufferPointer verticesBuffer(new gpu::Buffer());
820 _solidCubeVerticies[size] = verticesBuffer;820 _solidCubeVertices[size] = verticesBuffer;
821 821
822 GLfloat* vertexData = new GLfloat[vertexPoints * 2]; // vertices and normals822 GLfloat* vertexData = new GLfloat[vertexPoints * 2]; // vertices and normals
823 GLfloat* vertex = vertexData;823 GLfloat* vertex = vertexData;
@@ -892,7 +892,7 @@ void GeometryCache::renderSolidCube(gpu::Batch& batch, float size, const glm::ve · 68 unmodified lines
892 892
893 colorBuffer->append(sizeof(colors), (gpu::Byte*) colors);893 colorBuffer->append(sizeof(colors), (gpu::Byte*) colors);
894 }894 }
895 gpu::BufferPointer verticesBuffer = _solidCubeVerticies[size];895 gpu::BufferPointer verticesBuffer = _solidCubeVertices[size];
896 gpu::BufferPointer colorBuffer = _solidCubeColors[colorKey];896 gpu::BufferPointer colorBuffer = _solidCubeColors[colorKey];
897 897
898 const int VERTICES_SLOT = 0;898 const int VERTICES_SLOT = 0;
libraries/render-utils/src/GeometryCache.h+1−1
@@ -270,7 +270,7 @@ private: · 269 unmodified lines
270 QHash<Vec2Pair, gpu::BufferPointer> _cubeColors;270 QHash<Vec2Pair, gpu::BufferPointer> _cubeColors;
271 gpu::BufferPointer _wireCubeIndexBuffer;271 gpu::BufferPointer _wireCubeIndexBuffer;
272 272
273 QHash<float, gpu::BufferPointer> _solidCubeVerticies;273 QHash<float, gpu::BufferPointer> _solidCubeVertices;
274 QHash<Vec2Pair, gpu::BufferPointer> _solidCubeColors;274 QHash<Vec2Pair, gpu::BufferPointer> _solidCubeColors;
275 gpu::BufferPointer _solidCubeIndexBuffer;275 gpu::BufferPointer _solidCubeIndexBuffer;
276 276
libraries/render-utils/src/RenderUtil.h+0−2
@@ -12,8 +12,6 @@ · 11 unmodified lines
12#ifndef hifi_RenderUtil_h12#ifndef hifi_RenderUtil_h
13#define hifi_RenderUtil_h13#define hifi_RenderUtil_h
14 14
15#include <MatrixStack.h>
16
17/// Renders a quad from (-1, -1, 0) to (1, 1, 0) with texture coordinates from (sMin, tMin) to (sMax, tMax).15/// Renders a quad from (-1, -1, 0) to (1, 1, 0) with texture coordinates from (sMin, tMin) to (sMax, tMax).
18void renderFullscreenQuad(float sMin = 0.0f, float sMax = 1.0f, float tMin = 0.0f, float tMax = 1.0f);16void renderFullscreenQuad(float sMin = 0.0f, float sMax = 1.0f, float tMin = 0.0f, float tMax = 1.0f);
19 17
libraries/render-utils/src/TextRenderer3D.cpp+498−0
@@ -0,0 +1,498 @@
1//
2// TextRenderer3D.cpp
3// interface/src/ui
4//
5// Created by Andrzej Kapolka on 4/24/13.
6// Copyright 2013 High Fidelity, Inc.
7//
8// Distributed under the Apache License, Version 2.0.
9// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
10//
11
12#include "TextRenderer3D.h"
13
14#include <gpu/GPUConfig.h>
15#include <gpu/GLBackend.h>
16#include <gpu/Shader.h>
17
18#include <QBuffer>
19#include <QImage>
20#include <QStringList>
21#include <QFile>
22
23#include "GLMHelpers.h"
24#include "MatrixStack.h"
25#include "RenderUtilsLogging.h"
26
27#include "sdf_text3D_vert.h"
28#include "sdf_text3D_frag.h"
29
30#include "GeometryCache.h"
31#include "DeferredLightingEffect.h"
32
33// FIXME support the shadow effect, or remove it from the API
34// FIXME figure out how to improve the anti-aliasing on the
35// interior of the outline fonts
36const float DEFAULT_POINT_SIZE = 12;
37
38// Helper functions for reading binary data from an IO device
39template<class T>
40void readStream(QIODevice& in, T& t) {
41 in.read((char*) &t, sizeof(t));
42}
43
44template<typename T, size_t N>
45void readStream(QIODevice& in, T (&t)[N]) {
46 in.read((char*) t, N);
47}
48
49template<class T, size_t N>
50void fillBuffer(QBuffer& buffer, T (&t)[N]) {
51 buffer.setData((const char*) t, N);
52}
53
54// stores the font metrics for a single character
55struct Glyph3D {
56 QChar c;
57 glm::vec2 texOffset;
58 glm::vec2 texSize;
59 glm::vec2 size;
60 glm::vec2 offset;
61 float d; // xadvance - adjusts character positioning
62 size_t indexOffset;
63
64 // We adjust bounds because offset is the bottom left corner of the font but the top left corner of a QRect
65 QRectF bounds() const { return glmToRect(offset, size).translated(0.0f, -size.y); }
66 QRectF textureBounds() const { return glmToRect(texOffset, texSize); }
67
68 void read(QIODevice& in);
69};
70
71void Glyph3D::read(QIODevice& in) {
72 uint16_t charcode;
73 readStream(in, charcode);
74 c = charcode;
75 readStream(in, texOffset);
76 readStream(in, size);
77 readStream(in, offset);
78 readStream(in, d);
79 texSize = size;
80}
81
82struct TextureVertex {
83 glm::vec2 pos;
84 glm::vec2 tex;
85 TextureVertex() {}
86 TextureVertex(const glm::vec2& pos, const glm::vec2& tex) : pos(pos), tex(tex) {}
87};
88
89struct QuadBuilder {
90 TextureVertex vertices[4];
91 QuadBuilder(const glm::vec2& min, const glm::vec2& size,
92 const glm::vec2& texMin, const glm::vec2& texSize) {
93 // min = bottomLeft
94 vertices[0] = TextureVertex(min,
95 texMin + glm::vec2(0.0f, texSize.y));
96 vertices[1] = TextureVertex(min + glm::vec2(size.x, 0.0f),
97 texMin + texSize);
98 vertices[2] = TextureVertex(min + size,
99 texMin + glm::vec2(texSize.x, 0.0f));
100 vertices[3] = TextureVertex(min + glm::vec2(0.0f, size.y),
101 texMin);
102 }
103 QuadBuilder(const Glyph3D& glyph, const glm::vec2& offset) :
104 QuadBuilder(offset + glyph.offset - glm::vec2(0.0f, glyph.size.y), glyph.size,
105 glyph.texOffset, glyph.texSize) {}
106
107};
108
109class Font3D {
110public:
111 Font3D();
112
113 void read(QIODevice& path);
114
115 glm::vec2 computeExtent(const QString& str) const;
116 float getRowHeight() const { return _rowHeight; }
117
118 // Render string to batch
119 void drawString(gpu::Batch& batch, float x, float y, const QString& str,
120 const glm::vec4& color, TextRenderer3D::EffectType effectType,
121 const glm::vec2& bound);
122
123private:
124 QStringList tokenizeForWrapping(const QString& str) const;
125 QStringList splitLines(const QString& str) const;
126 glm::vec2 computeTokenExtent(const QString& str) const;
127
128 const Glyph3D& getGlyph(const QChar& c) const;
129
130 void setupGPU();
131
132 // maps characters to cached glyph info
133 // HACK... the operator[] const for QHash returns a
134 // copy of the value, not a const value reference, so
135 // we declare the hash as mutable in order to avoid such
136 // copies
137 mutable QHash<QChar, Glyph3D> _glyphs;
138
139 // Font characteristics
140 QString _family;
141 float _fontSize = 0.0f;
142 float _rowHeight = 0.0f;
143 float _leading = 0.0f;
144 float _ascent = 0.0f;
145 float _descent = 0.0f;
146 float _spaceWidth = 0.0f;
147
148 bool _initialized = false;
149
150 // gpu structures
151 gpu::PipelinePointer _pipeline;
152 gpu::TexturePointer _texture;
153 gpu::Stream::FormatPointer _format;
154 gpu::BufferPointer _verticesBuffer;
155 gpu::BufferStreamPointer _stream;
156 unsigned int _numVertices = 0;
157
158 int _fontLoc = -1;
159 int _outlineLoc = -1;
160 int _colorLoc = -1;
161
162 // last string render characteristics
163 QString _lastStringRendered;
164 glm::vec2 _lastBounds;
165};
166
167static QHash<QString, Font3D*> LOADED_FONTS;
168
169Font3D* loadFont3D(QIODevice& fontFile) {
170 Font3D* result = new Font3D();
171 result->read(fontFile);
172 return result;
173}
174
175Font3D* loadFont3D(const QString& family) {
176 if (!LOADED_FONTS.contains(family)) {
177
178 const QString SDFF_COURIER_PRIME_FILENAME = ":/CourierPrime.sdff";
179 const QString SDFF_INCONSOLATA_MEDIUM_FILENAME = ":/InconsolataMedium.sdff";
180 const QString SDFF_ROBOTO_FILENAME = ":/Roboto.sdff";
181 const QString SDFF_TIMELESS_FILENAME = ":/Timeless.sdff";
182
183 QString loadFilename;
184
185 if (family == MONO_FONT_FAMILY) {
186 loadFilename = SDFF_COURIER_PRIME_FILENAME;
187 } else if (family == INCONSOLATA_FONT_FAMILY) {
188 loadFilename = SDFF_INCONSOLATA_MEDIUM_FILENAME;
189 } else if (family == SANS_FONT_FAMILY) {
190 loadFilename = SDFF_ROBOTO_FILENAME;
191 } else {
192 if (!LOADED_FONTS.contains(SERIF_FONT_FAMILY)) {
193 loadFilename = SDFF_TIMELESS_FILENAME;
194 } else {
195 LOADED_FONTS[family] = LOADED_FONTS[SERIF_FONT_FAMILY];
196 }
197 }
198
199 if (!loadFilename.isEmpty()) {
200 QFile fontFile(loadFilename);
201 fontFile.open(QIODevice::ReadOnly);
202
203 qCDebug(renderutils) << "Loaded font" << loadFilename << "from Qt Resource System.";
204
205 LOADED_FONTS[family] = loadFont3D(fontFile);
206 }
207 }
208 return LOADED_FONTS[family];
209}
210
211Font3D::Font3D() {
212 static bool fontResourceInitComplete = false;
213 if (!fontResourceInitComplete) {
214 Q_INIT_RESOURCE(fonts);
215 fontResourceInitComplete = true;
216 }
217}
218
219// NERD RAGE: why doesn't QHash have a 'const T & operator[] const' member
220const Glyph3D& Font3D::getGlyph(const QChar& c) const {
221 if (!_glyphs.contains(c)) {
222 return _glyphs[QChar('?')];
223 }
224 return _glyphs[c];
225}
226
227QStringList Font3D::splitLines(const QString& str) const {
228 return str.split('\n');
229}
230
231QStringList Font3D::tokenizeForWrapping(const QString& str) const {
232 QStringList tokens;
233 for(auto line : splitLines(str)) {
234 if (!tokens.empty()) {
235 tokens << QString('\n');
236 }
237 tokens << line.split(' ');
238 }
239 return tokens;
240}
241
242glm::vec2 Font3D::computeTokenExtent(const QString& token) const {
243 glm::vec2 advance(0, _fontSize);
244 foreach(QChar c, token) {
245 Q_ASSERT(c != '\n');
246 advance.x += (c == ' ') ? _spaceWidth : getGlyph(c).d;
247 }
248 return advance;
249}
250
251glm::vec2 Font3D::computeExtent(const QString& str) const {
252 glm::vec2 extent = glm::vec2(0.0f, 0.0f);
253
254 QStringList tokens = splitLines(str);
255 foreach(const QString& token, tokens) {
256 glm::vec2 tokenExtent = computeTokenExtent(token);
257 extent.x = std::max(tokenExtent.x, extent.x);
258 }
259 extent.y = tokens.count() * _rowHeight;
260
261 return extent;
262}
263
264void Font3D::read(QIODevice& in) {
265 uint8_t header[4];
266 readStream(in, header);
267 if (memcmp(header, "SDFF", 4)) {
268 qFatal("Bad SDFF file");
269 }
270
271 uint16_t version;
272 readStream(in, version);
273
274 // read font name
275 _family = "";
276 if (version > 0x0001) {
277 char c;
278 readStream(in, c);
279 while (c) {
280 _family += c;
281 readStream(in, c);
282 }
283 }
284
285 // read font data
286 readStream(in, _leading);
287 readStream(in, _ascent);
288 readStream(in, _descent);
289 readStream(in, _spaceWidth);
290 _fontSize = _ascent + _descent;
291 _rowHeight = _fontSize + _leading;
292
293 // Read character count
294 uint16_t count;
295 readStream(in, count);
296 // read metrics data for each character
297 QVector<Glyph3D> glyphs(count);
298 // std::for_each instead of Qt foreach because we need non-const references
299 std::for_each(glyphs.begin(), glyphs.end(), [&](Glyph3D& g) {
300 g.read(in);
301 });
302
303 // read image data
304 QImage image;
305 if (!image.loadFromData(in.readAll(), "PNG")) {
306 qFatal("Failed to read SDFF image");
307 }
308
309 _glyphs.clear();
310 glm::vec2 imageSize = toGlm(image.size());
311 foreach(Glyph3D g, glyphs) {
312 // Adjust the pixel texture coordinates into UV coordinates,
313 g.texSize /= imageSize;
314 g.texOffset /= imageSize;
315 // store in the character to glyph hash
316 _glyphs[g.c] = g;
317 };
318
319 image = image.convertToFormat(QImage::Format_RGBA8888);
320
321 gpu::Element formatGPU = gpu::Element(gpu::VEC3, gpu::UINT8, gpu::RGB);
322 gpu::Element formatMip = gpu::Element(gpu::VEC3, gpu::UINT8, gpu::RGB);
323 if (image.hasAlphaChannel()) {
324 formatGPU = gpu::Element(gpu::VEC4, gpu::UINT8, gpu::RGBA);
325 formatMip = gpu::Element(gpu::VEC4, gpu::UINT8, gpu::BGRA);
326 }
327 _texture = gpu::TexturePointer(gpu::Texture::create2D(formatGPU, image.width(), image.height(),
328 gpu::Sampler(gpu::Sampler::FILTER_MIN_POINT_MAG_LINEAR)));
329 _texture->assignStoredMip(0, formatMip, image.byteCount(), image.constBits());
330 _texture->autoGenerateMips(-1);
331}
332
333void Font3D::setupGPU() {
334 if (!_initialized) {
335 _initialized = true;
336
337 // Setup render pipeline
338 auto vertexShader = gpu::ShaderPointer(gpu::Shader::createVertex(std::string(sdf_text3D_vert)));
339 auto pixelShader = gpu::ShaderPointer(gpu::Shader::createPixel(std::string(sdf_text3D_frag)));
340 gpu::ShaderPointer program = gpu::ShaderPointer(gpu::Shader::createProgram(vertexShader, pixelShader));
341
342 gpu::Shader::BindingSet slotBindings;
343 gpu::Shader::makeProgram(*program, slotBindings);
344
345 _fontLoc = program->getTextures().findLocation("Font");
346 _outlineLoc = program->getUniforms().findLocation("Outline");
347 _colorLoc = program->getUniforms().findLocation("Color");
348
349 gpu::StatePointer state = gpu::StatePointer(new gpu::State());
350 state->setCullMode(gpu::State::CULL_BACK);
351 state->setDepthTest(true, true, gpu::LESS_EQUAL);
352 state->setBlendFunction(false,
353 gpu::State::SRC_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::INV_SRC_ALPHA,
354 gpu::State::FACTOR_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::ONE);
355 _pipeline = gpu::PipelinePointer(gpu::Pipeline::create(program, state));
356
357 // Sanity checks
358 static const int OFFSET = offsetof(TextureVertex, tex);
359 assert(OFFSET == sizeof(glm::vec2));
360 assert(sizeof(glm::vec2) == 2 * sizeof(float));
361 assert(sizeof(TextureVertex) == 2 * sizeof(glm::vec2));
362 assert(sizeof(QuadBuilder) == 4 * sizeof(TextureVertex));
363
364 // Setup rendering structures
365 _format.reset(new gpu::Stream::Format());
366 _format->setAttribute(gpu::Stream::POSITION, 0, gpu::Element(gpu::VEC2, gpu::FLOAT, gpu::XYZ), 0);
367 _format->setAttribute(gpu::Stream::TEXCOORD, 0, gpu::Element(gpu::VEC2, gpu::FLOAT, gpu::UV), OFFSET);
368 }
369}
370
371void Font3D::drawString(gpu::Batch& batch, float x, float y, const QString& str, const glm::vec4& color,
372 TextRenderer3D::EffectType effectType, const glm::vec2& bounds) {
373 if (str == "") {
374 return;
375 }
376
377 if (str != _lastStringRendered || bounds != _lastBounds) {
378 _verticesBuffer.reset(new gpu::Buffer());
379 _numVertices = 0;
380 _lastStringRendered = str;
381 _lastBounds = bounds;
382
383 // Top left of text
384 glm::vec2 advance = glm::vec2(x, y);
385 foreach(const QString& token, tokenizeForWrapping(str)) {
386 bool isNewLine = (token == QString('\n'));
387 bool forceNewLine = false;
388
389 // Handle wrapping
390 if (!isNewLine && (bounds.x != -1) && (advance.x + computeExtent(token).x > x + bounds.x)) {
391 // We are out of the x bound, force new line
392 forceNewLine = true;
393 }
394 if (isNewLine || forceNewLine) {
395 // Character return, move the advance to a new line
396 advance = glm::vec2(x, advance.y - _rowHeight);
397
398 if (isNewLine) {
399 // No need to draw anything, go directly to next token
400 continue;
401 } else if (computeExtent(token).x > bounds.x) {
402 // token will never fit, stop drawing
403 break;
404 }
405 }
406 if ((bounds.y != -1) && (advance.y - _fontSize < -y - bounds.y)) {
407 // We are out of the y bound, stop drawing
408 break;
409 }
410
411 // Draw the token
412 if (!isNewLine) {
413 for (auto c : token) {
414 auto glyph = _glyphs[c];
415
416 QuadBuilder qd(glyph, advance - glm::vec2(0.0f, _fontSize));
417 _verticesBuffer->append(sizeof(QuadBuilder), (const gpu::Byte*)&qd);
418 _numVertices += 4;
419
420 // Advance by glyph size
421 advance.x += glyph.d;
422 }
423
424 // Add space after all non return tokens
425 advance.x += _spaceWidth;
426 }
427 }
428 }
429
430 setupGPU();
431 batch.setPipeline(_pipeline);
432 batch.setUniformTexture(_fontLoc, _texture);
433 batch._glUniform1f(_outlineLoc, (effectType == TextRenderer3D::OUTLINE_EFFECT) ? 1.0f : 0.0f);
434 batch._glUniform4fv(_colorLoc, 1, (const GLfloat*)&color);
435
436 batch.setInputFormat(_format);
437 batch.setInputBuffer(0, _verticesBuffer, 0, _format->getChannels().at(0)._stride);
438 batch.draw(gpu::QUADS, _numVertices, 0);
439}
440
441TextRenderer3D* TextRenderer3D::getInstance(const char* family, float pointSize,
442 int weight, bool italic, EffectType effect, int effectThickness,
443 const QColor& color) {
444 if (pointSize < 0) {
445 pointSize = DEFAULT_POINT_SIZE;
446 }
447 return new TextRenderer3D(family, pointSize, weight, italic, effect,
448 effectThickness, color);
449}
450
451TextRenderer3D::TextRenderer3D(const char* family, float pointSize, int weight, bool italic,
452 EffectType effect, int effectThickness, const QColor& color) :
453 _effectType(effect),
454 _effectThickness(effectThickness),
455 _pointSize(pointSize),
456 _color(toGlm(color)),
457 _font(loadFont3D(family)) {
458 if (!_font) {
459 qWarning() << "Unable to load font with family " << family;
460 _font = loadFont3D("Courier");
461 }
462 if (1 != _effectThickness) {
463 qWarning() << "Effect thickness not current supported";
464 }
465 if (NO_EFFECT != _effectType && OUTLINE_EFFECT != _effectType) {
466 qWarning() << "Effect thickness not current supported";
467 }
468}
469
470TextRenderer3D::~TextRenderer3D() {
471}
472
473glm::vec2 TextRenderer3D::computeExtent(const QString& str) const {
474 if (_font) {
475 return _font->computeExtent(str);
476 }
477 return glm::vec2(0.0f, 0.0f);
478}
479
480float TextRenderer3D::getRowHeight() const {
481 if (_font) {
482 return _font->getRowHeight();
483 }
484 return 0.0f;
485}
486
487void TextRenderer3D::draw(gpu::Batch& batch, float x, float y, const QString& str, const glm::vec4& color,
488 const glm::vec2& bounds) {
489 // The font does all the OpenGL work
490 if (_font) {
491 glm::vec4 actualColor(color);
492 if (actualColor.r < 0) {
493 actualColor = _color;
494 }
495 _font->drawString(batch, x, y, str, actualColor, _effectType, bounds);
496 }
497}
498
libraries/render-utils/src/TextRenderer3D.h+77−0
@@ -0,0 +1,77 @@
1//
2// TextRenderer3D.h
3// interface/src/ui
4//
5// Created by Andrzej Kapolka on 4/26/13.
6// Copyright 2013 High Fidelity, Inc.
7//
8// Distributed under the Apache License, Version 2.0.
9// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
10//
11
12#ifndef hifi_TextRenderer3D_h
13#define hifi_TextRenderer3D_h
14
15#include <glm/glm.hpp>
16#include <QColor>
17
18// the standard sans serif font family
19#define SANS_FONT_FAMILY "Helvetica"
20
21// the standard sans serif font family
22#define SERIF_FONT_FAMILY "Timeless"
23
24// the standard mono font family
25#define MONO_FONT_FAMILY "Courier"
26
27// the Inconsolata font family
28#ifdef Q_OS_WIN
29#define INCONSOLATA_FONT_FAMILY "Fixedsys"
30#define INCONSOLATA_FONT_WEIGHT QFont::Normal
31#else
32#define INCONSOLATA_FONT_FAMILY "Inconsolata"
33#define INCONSOLATA_FONT_WEIGHT QFont::Bold
34#endif
35
36namespace gpu {
37class Batch;
38}
39class Font3D;
40
41// TextRenderer3D is actually a fairly thin wrapper around a Font class
42// defined in the cpp file.
43class TextRenderer3D {
44public:
45 enum EffectType { NO_EFFECT, SHADOW_EFFECT, OUTLINE_EFFECT };
46
47 static TextRenderer3D* getInstance(const char* family, float pointSize = -1, int weight = -1, bool italic = false,
48 EffectType effect = NO_EFFECT, int effectThickness = 1, const QColor& color = QColor(255, 255, 255));
49
50 ~TextRenderer3D();
51
52 glm::vec2 computeExtent(const QString& str) const;
53 float getRowHeight() const;
54
55 void draw(gpu::Batch& batch, float x, float y, const QString& str, const glm::vec4& color = glm::vec4(-1.0f),
56 const glm::vec2& bounds = glm::vec2(-1.0f));
57
58private:
59 TextRenderer3D(const char* family, float pointSize = -1, int weight = -1, bool italic = false,
60 EffectType effect = NO_EFFECT, int effectThickness = 1, const QColor& color = QColor(255, 255, 255));
61
62 // the type of effect to apply
63 const EffectType _effectType;
64
65 // the thickness of the effect
66 const int _effectThickness;
67
68 const float _pointSize;
69
70 // text color
71 const glm::vec4 _color;
72
73 Font3D* _font;
74};
75
76
77#endif // hifi_TextRenderer3D_h
libraries/render-utils/src/TextureCache.cpp+3−3
@@ -296,7 +296,7 @@ GLuint TextureCache::getShadowDepthTextureID() { · 295 unmodified lines
296}296}
297 297
298/// Returns a texture version of an image file298/// Returns a texture version of an image file
299gpu::TexturePointer TextureCache::getImageTexture(const QString & path) {299gpu::TexturePointer TextureCache::getImageTexture(const QString& path) {
300 QImage image = QImage(path).mirrored(false, true);300 QImage image = QImage(path).mirrored(false, true);
301 gpu::Element formatGPU = gpu::Element(gpu::VEC3, gpu::UINT8, gpu::RGB);301 gpu::Element formatGPU = gpu::Element(gpu::VEC3, gpu::UINT8, gpu::RGB);
302 gpu::Element formatMip = gpu::Element(gpu::VEC3, gpu::UINT8, gpu::RGB);302 gpu::Element formatMip = gpu::Element(gpu::VEC3, gpu::UINT8, gpu::RGB);
@@ -383,9 +383,9 @@ ImageReader::ImageReader(const QWeakPointer<Resource>& texture, TextureType type · 80 unmodified lines
383 _content(content) {383 _content(content) {
384}384}
385 385
386std::once_flag onceListSuppoertedFormatsflag;386std::once_flag onceListSupportedFormatsflag;
387void listSupportedImageFormats() {387void listSupportedImageFormats() {
388 std::call_once(onceListSuppoertedFormatsflag, [](){388 std::call_once(onceListSupportedFormatsflag, [](){
389 auto supportedFormats = QImageReader::supportedImageFormats();389 auto supportedFormats = QImageReader::supportedImageFormats();
390 QString formats;390 QString formats;
391 foreach(const QByteArray& f, supportedFormats) {391 foreach(const QByteArray& f, supportedFormats) {
libraries/render-utils/src/TextureCache.h+1−1
@@ -56,7 +56,7 @@ public: · 55 unmodified lines
56 const gpu::TexturePointer& getBlueTexture();56 const gpu::TexturePointer& getBlueTexture();
57 57
58 /// Returns a texture version of an image file58 /// Returns a texture version of an image file
59 gpu::TexturePointer getImageTexture(const QString & path);59 static gpu::TexturePointer getImageTexture(const QString& path);
60 60
61 /// Loads a texture from the specified URL.61 /// Loads a texture from the specified URL.
62 NetworkTexturePointer getTexture(const QUrl& url, TextureType type = DEFAULT_TEXTURE, bool dilatable = false,62 NetworkTexturePointer getTexture(const QUrl& url, TextureType type = DEFAULT_TEXTURE, bool dilatable = false,
libraries/render-utils/src/sdf_text3D.slf+47−0
@@ -0,0 +1,47 @@
1<@include gpu/Config.slh@>
2<$VERSION_HEADER$>
3// Generated on <$_SCRIBE_DATE$>
4// sdf_text.frag
5// fragment shader
6//
7// Created by Bradley Austin Davis on 2015-02-04
8// Based on fragment shader code from
9// https://github.com/paulhoux/Cinder-Samples/blob/master/TextRendering/include/text/Text.cpp
10// Distributed under the Apache License, Version 2.0.
11// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
12
13uniform sampler2D Font;
14uniform float Outline;
15uniform vec4 Color;
16
17const float gamma = 2.6;
18const float smoothing = 100.0;
19const float interiorCutoff = 0.8;
20const float outlineExpansion = 0.2;
21
22void main() {
23 // retrieve signed distance
24 float sdf = texture2D(Font, gl_TexCoord[0].xy).g;
25 if (Outline == 1.0f) {
26 if (sdf > interiorCutoff) {
27 sdf = 1.0 - sdf;
28 } else {
29 sdf += outlineExpansion;
30 }
31 }
32 // perform adaptive anti-aliasing of the edges
33 // The larger we're rendering, the less anti-aliasing we need
34 float s = smoothing * length(fwidth(gl_TexCoord[0]));
35 float w = clamp( s, 0.0, 0.5);
36 float a = smoothstep(0.5 - w, 0.5 + w, sdf);
37
38 // gamma correction for linear attenuation
39 a = pow(a, 1.0 / gamma);
40
41 if (a < 0.01) {
42 discard;
43 }
44
45 // final color
46 gl_FragColor = vec4(Color.rgb, a);
47}
libraries/render-utils/src/sdf_text3D.slv+23−0
@@ -0,0 +1,23 @@
1<@include gpu/Config.slh@>
2<$VERSION_HEADER$>
3// Generated on <$_SCRIBE_DATE$>
4// sdf_text.vert
5// vertex shader
6//
7// Created by Brad Davis on 10/14/13.
8//
9// Distributed under the Apache License, Version 2.0.
10// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
11//
12<@include gpu/Transform.slh@>
13
14<$declareStandardTransform()$>
15
16void main() {
17 gl_TexCoord[0] = gl_MultiTexCoord0;
18
19 // standard transform
20 TransformCamera cam = getTransformCamera();
21 TransformObject obj = getTransformObject();
22 <$transformModelToClipPos(cam, obj, gl_Vertex, gl_Position)$>
23}
libraries/render/src/render/DrawTask.cpp+207−44
@@ -16,96 +16,259 @@ · 15 unmodified lines
16#include "gpu/Batch.h"16#include "gpu/Batch.h"
17#include "gpu/Context.h"17#include "gpu/Context.h"
18 18
19#include "ViewFrustum.h"
20#include "RenderArgs.h"
21
22#include <algorithm>
23#include <assert.h>
19 24
20using namespace render;25using namespace render;
21 26
22Job::~Job() {27DrawSceneTask::DrawSceneTask() : Task() {
23}
24 28
25template <> void render::jobRun(const FilterItems& filterItems, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) {29 _jobs.push_back(Job(DrawOpaque()));
26 auto& scene = sceneContext->_scene;30 _jobs.push_back(Job(DrawLight()));
31 _jobs.push_back(Job(DrawTransparent()));
32}
27 33
34DrawSceneTask::~DrawSceneTask() {
28}35}
29 36
30template <> void render::jobRun(const RenderItems& renderItems, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) {37void DrawSceneTask::run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) {
31 auto& scene = sceneContext->_scene;38 // sanity checks
32 RenderArgs* args = renderContext->args;39 assert(sceneContext);
33 // render40 if (!sceneContext->_scene) {
34 for (auto id : renderItems._items) {41 return;
35 auto item = scene->getItem(id);
36 item.render(args);
37 }42 }
38}
39 43
40 44
45 // Is it possible that we render without a viewFrustum ?
46 if (!(renderContext->args && renderContext->args->_viewFrustum)) {
47 return;
48 }
49
50 for (auto job : _jobs) {
51 job.run(sceneContext, renderContext);
52 }
53};
41 54
55Job::~Job() {
56}
42 57
43template <> void render::jobRun(const DrawOpaque& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) {58template <> void render::jobRun(const DrawOpaque& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) {
59 assert(renderContext->args);
60 assert(renderContext->args->_viewFrustum);
61
44 // render opaques62 // render opaques
45 auto& scene = sceneContext->_scene;63 auto& scene = sceneContext->_scene;
46 auto& items = scene->getMasterBucket().at(ItemFilter::Builder::opaqueShape());64 auto& items = scene->getMasterBucket().at(ItemFilter::Builder::opaqueShape());
47 65
48 RenderArgs* args = renderContext->args;66 ItemIDs inItems;
49 gpu::Batch theBatch;67 inItems.reserve(items.size());
50 args->_batch = &theBatch;
51 for (auto id : items) {68 for (auto id : items) {
52 auto item = scene->getItem(id);69 inItems.push_back(id);
53 item.render(args);
54 }70 }
55 71
56 args->_context->enqueueBatch((*args->_batch));72 ItemIDs culledItems;
57 args->_batch = nullptr;73 cullItems(sceneContext, renderContext, inItems, culledItems);
74
75 ItemIDs sortedItems;
76 depthSortItems(sceneContext, renderContext, true, culledItems, sortedItems); // Sort Front to back opaque items!
77
78 renderItems(sceneContext, renderContext, sortedItems);
58}79}
59 80
60 81
61template <> void render::jobRun(const DrawTransparent& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) {82template <> void render::jobRun(const DrawTransparent& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) {
83 assert(renderContext->args);
84 assert(renderContext->args->_viewFrustum);
85
62 // render transparents86 // render transparents
63 auto& scene = sceneContext->_scene;87 auto& scene = sceneContext->_scene;
64 auto& items = scene->getMasterBucket().at(ItemFilter::Builder::transparentShape());88 auto& items = scene->getMasterBucket().at(ItemFilter::Builder::transparentShape());
65 89
66 RenderArgs* args = renderContext->args;90 ItemIDs inItems;
67 gpu::Batch theBatch;91 inItems.reserve(items.size());
68 args->_batch = &theBatch;
69 for (auto id : items) {92 for (auto id : items) {
70 auto item = scene->getItem(id);93 inItems.push_back(id);
71 item.render(args);
72 }94 }
73 95
74 args->_context->enqueueBatch((*args->_batch));96 ItemIDs culledItems;
75 args->_batch = nullptr;97 cullItems(sceneContext, renderContext, inItems, culledItems);
98
99 ItemIDs sortedItems;
100 depthSortItems(sceneContext, renderContext, false, culledItems, sortedItems); // Sort Back to front transparent items!
101
102 renderItems(sceneContext, renderContext, sortedItems);
76}103}
77 104
78template <> void render::jobRun(const DrawLight& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) {105template <> void render::jobRun(const DrawLight& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) {
106 assert(renderContext->args);
107 assert(renderContext->args->_viewFrustum);
108
79 // render lights109 // render lights
80 auto& scene = sceneContext->_scene;110 auto& scene = sceneContext->_scene;
81 auto& items = scene->getMasterBucket().at(ItemFilter::Builder::light());111 auto& items = scene->getMasterBucket().at(ItemFilter::Builder::light());
82 112
83 RenderArgs* args = renderContext->args;113
114 ItemIDs inItems;
115 inItems.reserve(items.size());
84 for (auto id : items) {116 for (auto id : items) {
85 auto item = scene->getItem(id);117 inItems.push_back(id);
86 item.render(args);
87 }118 }
119
120 ItemIDs culledItems;
121 cullItems(sceneContext, renderContext, inItems, culledItems);
122 renderItems(sceneContext, renderContext, culledItems);
88}123}
89 124
90DrawSceneTask::DrawSceneTask() : Task() {125/*
126bool LODManager::shouldRenderMesh(float largestDimension, float distanceToCamera) {
127 const float octreeToMeshRatio = 4.0f; // must be this many times closer to a mesh than a voxel to see it.
128 float octreeSizeScale = getOctreeSizeScale();
129 int boundaryLevelAdjust = getBoundaryLevelAdjust();
130 float maxScale = (float)TREE_SCALE;
131 float visibleDistanceAtMaxScale = boundaryDistanceForRenderLevel(boundaryLevelAdjust, octreeSizeScale) / octreeToMeshRatio;
132
133 if (_shouldRenderTableNeedsRebuilding) {
134 _shouldRenderTable.clear();
135
136 float SMALLEST_SCALE_IN_TABLE = 0.001f; // 1mm is plenty small
137 float scale = maxScale;
138 float visibleDistanceAtScale = visibleDistanceAtMaxScale;
139
140 while (scale > SMALLEST_SCALE_IN_TABLE) {
141 scale /= 2.0f;
142 visibleDistanceAtScale /= 2.0f;
143 _shouldRenderTable[scale] = visibleDistanceAtScale;
144 }
145 _shouldRenderTableNeedsRebuilding = false;
146 }
147
148 float closestScale = maxScale;
149 float visibleDistanceAtClosestScale = visibleDistanceAtMaxScale;
150 QMap<float, float>::const_iterator lowerBound = _shouldRenderTable.lowerBound(largestDimension);
151 if (lowerBound != _shouldRenderTable.constEnd()) {
152 closestScale = lowerBound.key();
153 visibleDistanceAtClosestScale = lowerBound.value();
154 }
155
156 if (closestScale < largestDimension) {
157 visibleDistanceAtClosestScale *= 2.0f;
158 }
159
160 return (distanceToCamera <= visibleDistanceAtClosestScale);
161}*/
91 162
92 _jobs.push_back(Job(DrawOpaque()));163void render::cullItems(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext, const ItemIDs& inItems, ItemIDs& outItems) {
93 _jobs.push_back(Job(DrawLight()));164 assert(renderContext->args);
94 _jobs.push_back(Job(DrawTransparent()));165 assert(renderContext->args->_viewFrustum);
95}166
167 auto& scene = sceneContext->_scene;
168 RenderArgs* args = renderContext->args;
169
170 // Culling / LOD
171 for (auto id : inItems) {
172 auto item = scene->getItem(id);
173 auto bound = item.getBound();
174
175 if (bound.isNull()) {
176 outItems.push_back(id); // One more Item to render
177 args->_itemsRendered++;
178 continue;
179 }
180
181 // TODO: some entity types (like lights) might want to be rendered even
182 // when they are outside of the view frustum...
183
184 float distance = args->_viewFrustum->distanceToCamera(bound.calcCenter());
185
186 bool outOfView = args->_viewFrustum->boxInFrustum(bound) == ViewFrustum::OUTSIDE;
187 if (!outOfView) {
188 bool bigEnoughToRender = true; //_viewState->shouldRenderMesh(bound.getLargestDimension(), distance);
189
190 if (bigEnoughToRender) {
191 outItems.push_back(id); // One more Item to render
192 args->_itemsRendered++;
193 } else {
194 args->_itemsTooSmall++;
195 }
196 } else {
197 args->_itemsOutOfView++;
198 }
199 }
96 200
97DrawSceneTask::~DrawSceneTask() {
98}201}
99 202
100void DrawSceneTask::run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) {203
101 // sanity checks204void render::depthSortItems(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext, bool frontToBack, const ItemIDs& inItems, ItemIDs& outItems) {
102 assert(sceneContext);205 assert(renderContext->args);
103 if (!sceneContext->_scene) {206 assert(renderContext->args->_viewFrustum);
104 return;207
208 auto& scene = sceneContext->_scene;
209 RenderArgs* args = renderContext->args;
210
211 // Allocate and simply copy
212 outItems.reserve(inItems.size());
213
214
215 // Make a local dataset of the center distance and closest point distance
216 struct ItemBound {
217 float _centerDepth = 0.0f;
218 float _nearDepth = 0.0f;
219 float _farDepth = 0.0f;
220 ItemID _id = 0;
221
222 ItemBound() {}
223 ItemBound(float centerDepth, float nearDepth, float farDepth, ItemID id) : _centerDepth(centerDepth), _nearDepth(nearDepth), _farDepth(farDepth), _id(id) {}
224 };
225 std::vector<ItemBound> itemBounds;
226 itemBounds.reserve(outItems.size());
227
228 for (auto id : inItems) {
229 auto item = scene->getItem(id);
230 auto bound = item.getBound();
231 float distance = args->_viewFrustum->distanceToCamera(bound.calcCenter());
232
233 itemBounds.emplace_back(ItemBound(distance, distance, distance, id));
105 }234 }
106 235
107 for (auto job : _jobs) {236 // sort against Z
108 job.run(sceneContext, renderContext);237 if (frontToBack) {
238 struct FrontToBackSort {
239 bool operator() (ItemBound& left, ItemBound& right) {
240 return (left._centerDepth < right._centerDepth);
241 }
242 } frontToBackSort;
243 std::sort (itemBounds.begin(), itemBounds.end(), frontToBackSort);
244 } else {
245 struct BackToFrontSort {
246 bool operator() (ItemBound& left, ItemBound& right) {
247 return (left._centerDepth > right._centerDepth);
248 }
249 } backToFrontSort;
250 std::sort (itemBounds.begin(), itemBounds.end(), backToFrontSort);
109 }251 }
110};
111 252
253 // FInally once sorted result to a list of itemID
254 for (auto& itemBound : itemBounds) {
255 outItems.emplace_back(itemBound._id);
256 }
257}
258
259void render::renderItems(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext, const ItemIDs& inItems) {
260 auto& scene = sceneContext->_scene;
261 RenderArgs* args = renderContext->args;
262 gpu::Batch theBatch;
263 args->_batch = &theBatch;
264
265 // render
266 for (auto id : inItems) {
267 auto item = scene->getItem(id);
268 item.render(args);
269 }
270
271
272 args->_context->enqueueBatch((*args->_batch));
273 args->_batch = nullptr;
274}
libraries/render/src/render/DrawTask.h+4−14
@@ -57,11 +57,13 @@ protected: · 56 unmodified lines
57 57
58typedef std::vector<Job> Jobs;58typedef std::vector<Job> Jobs;
59 59
60void cullItems(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext, const ItemIDs& inItems, ItemIDs& outITems);
61void depthSortItems(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext, bool frontToBack, const ItemIDs& inItems, ItemIDs& outITems);
62void renderItems(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext, const ItemIDs& inItems);
60 63
61 64
62class DrawOpaque {65class DrawOpaque {
63public:66public:
64 Jobs _jobs;
65};67};
66template <> void jobRun(const DrawOpaque& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext);68template <> void jobRun(const DrawOpaque& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext);
67 69
@@ -77,19 +79,6 @@ public: · 9 unmodified lines
77template <> void jobRun(const DrawLight& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext);79template <> void jobRun(const DrawLight& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext);
78 80
79 81
80class FilterItems {
81public:
82 ItemIDs _items;
83};
84template <> void jobRun(const FilterItems& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext);
85
86class RenderItems {
87public:
88 ItemIDs _items;
89};
90template <> void jobRun(const RenderItems& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext);
91
92
93class DrawSceneTask : public Task {82class DrawSceneTask : public Task {
94public:83public:
95 84
@@ -99,6 +88,7 @@ public: · 3 unmodified lines
99 Jobs _jobs;88 Jobs _jobs;
100 89
101 virtual void run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext);90 virtual void run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext);
91
102};92};
103 93
104}94}
libraries/render/src/render/Scene.cpp+5−5
@@ -70,21 +70,21 @@ void Item::move() { · 69 unmodified lines
70 70
71}71}
72 72
73void Scene::PendingChanges::resetItem(ItemID id, const PayloadPointer& payload) {73void PendingChanges::resetItem(ItemID id, const PayloadPointer& payload) {
74 _resetItems.push_back(id);74 _resetItems.push_back(id);
75 _resetPayloads.push_back(payload);75 _resetPayloads.push_back(payload);
76}76}
77 77
78void Scene::PendingChanges::removeItem(ItemID id) {78void PendingChanges::removeItem(ItemID id) {
79 _removedItems.push_back(id);79 _removedItems.push_back(id);
80}80}
81 81
82void Scene::PendingChanges::moveItem(ItemID id) {82void PendingChanges::moveItem(ItemID id) {
83 _movedItems.push_back(id);83 _movedItems.push_back(id);
84}84}
85 85
86 86
87void Scene::PendingChanges::merge(PendingChanges& changes) {87void PendingChanges::merge(PendingChanges& changes) {
88 _resetItems.insert(_resetItems.end(), changes._resetItems.begin(), changes._resetItems.end());88 _resetItems.insert(_resetItems.end(), changes._resetItems.begin(), changes._resetItems.end());
89 _resetPayloads.insert(_resetPayloads.end(), changes._resetPayloads.begin(), changes._resetPayloads.end());89 _resetPayloads.insert(_resetPayloads.end(), changes._resetPayloads.begin(), changes._resetPayloads.end());
90 _removedItems.insert(_removedItems.end(), changes._removedItems.begin(), changes._removedItems.end());90 _removedItems.insert(_removedItems.end(), changes._removedItems.begin(), changes._removedItems.end());
@@ -108,7 +108,7 @@ void Scene::enqueuePendingChanges(const PendingChanges& pendingChanges) { · 17 unmodified lines
108 _changeQueueMutex.unlock();108 _changeQueueMutex.unlock();
109}109}
110 110
111void consolidateChangeQueue(Scene::PendingChangesQueue& queue, Scene::PendingChanges& singleBatch) {111void consolidateChangeQueue(PendingChangesQueue& queue, PendingChanges& singleBatch) {
112 while (!queue.empty()) {112 while (!queue.empty()) {
113 auto pendingChanges = queue.front();113 auto pendingChanges = queue.front();
114 singleBatch.merge(pendingChanges);114 singleBatch.merge(pendingChanges);
libraries/render/src/render/Scene.h+21−20
@@ -305,6 +305,27 @@ public: · 304 unmodified lines
305class Engine;305class Engine;
306class Observer;306class Observer;
307 307
308class PendingChanges {
309public:
310 PendingChanges() {}
311 ~PendingChanges() {}
312
313 void resetItem(ItemID id, const PayloadPointer& payload);
314 void removeItem(ItemID id);
315 void moveItem(ItemID id);
316
317 void merge(PendingChanges& changes);
318
319 Payloads _resetPayloads;
320 ItemIDs _resetItems;
321 ItemIDs _removedItems;
322 ItemIDs _movedItems;
323
324protected:
325};
326typedef std::queue<PendingChanges> PendingChangesQueue;
327
328
308// Scene is a container for Items329// Scene is a container for Items
309// Items are introduced, modified or erased in the scene through PendingChanges330// Items are introduced, modified or erased in the scene through PendingChanges
310// Once per Frame, the PendingChanges are all flushed331// Once per Frame, the PendingChanges are all flushed
@@ -342,26 +363,6 @@ public: · 31 unmodified lines
342 typedef std::shared_ptr< Observer > ObserverPointer;363 typedef std::shared_ptr< Observer > ObserverPointer;
343 typedef std::vector< ObserverPointer > Observers;364 typedef std::vector< ObserverPointer > Observers;
344 365
345 class PendingChanges {
346 public:
347 PendingChanges() {}
348 ~PendingChanges() {}
349
350 void resetItem(ItemID id, const PayloadPointer& payload);
351 void removeItem(ItemID id);
352 void moveItem(ItemID id);
353
354 void merge(PendingChanges& changes);
355
356 Payloads _resetPayloads;
357 ItemIDs _resetItems;
358 ItemIDs _removedItems;
359 ItemIDs _movedItems;
360
361 protected:
362 };
363 typedef std::queue<PendingChanges> PendingChangesQueue;
364
365 Scene();366 Scene();
366 ~Scene() {}367 ~Scene() {}
367 368
tests/render-utils/src/main.cpp+0−1
@@ -9,7 +9,6 @@ · 8 unmodified lines
9//9//
10 10
11#include "TextRenderer.h"11#include "TextRenderer.h"
12#include "MatrixStack.h"
13 12
14#include <QWindow>13#include <QWindow>
15#include <QFile>14#include <QFile>

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t