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

Cleaning the code

Browse source
This commit is contained in:
samcake 2018-05-29 17:46:25 -07:00
parent 82503a9e64
commit 873cabe284
9 changed files with 58 additions and 109 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -2061,8 +2061,8 @@ void MyAvatar::preDisplaySide(const RenderArgs* renderArgs) {
_attachmentData[i].jointName.compare("RightEye", Qt::CaseInsensitive) == 0 ||
_attachmentData[i].jointName.compare("HeadTop_End", Qt::CaseInsensitive) == 0 ||
_attachmentData[i].jointName.compare("Face", Qt::CaseInsensitive) == 0) {
uint8_t modelRenderTagBits = shouldDrawHead ? render::ItemKey::TAG_BITS_0 : render::ItemKey::TAG_BITS_NONE;
modelRenderTagBits |= render::ItemKey::TAG_BITS_1;
uint8_t modelRenderTagBits = shouldDrawHead ? Model::MainView : Model::NoView;
modelRenderTagBits |= Model::SecondaryView;
_attachmentModels[i]->setViewMask(modelRenderTagBits);
_attachmentModels[i]->setGroupCulled(false);

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

@ -103,12 +103,9 @@ void ModelOverlay::update(float deltatime) {
if (_visibleDirty) {
_visibleDirty = false;
// don't show overlays in mirrors or spectator-cam unless _isVisibleInSecondaryCamera is true
_model->setViewMask((_isVisibleInSecondaryCamera ? render::ItemKey::TAG_BITS_1 : render::ItemKey::TAG_BITS_NONE), scene);
uint8_t modelRenderTagBits = Model::MainView | (_isVisibleInSecondaryCamera ? Model::SecondaryView : Model::NoView);
_model->setViewMask(modelRenderTagBits, scene);
_model->setVisibleInScene(getVisible(), scene);
/*,
render::ItemKey::TAG_BITS_0 |
(_isVisibleInSecondaryCamera ? render::ItemKey::TAG_BITS_1 : render::ItemKey::TAG_BITS_NONE),
false);*/
}
if (_drawInFrontDirty) {
_drawInFrontDirty = false;

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

@ -132,7 +132,6 @@ private:
namespace render {
template <> const ItemKey payloadGetKey(const Overlay::Pointer& overlay);
template <> const Item::Bound payloadGetBound(const Overlay::Pointer& overlay);
template <> int payloadGetLayer(const Overlay::Pointer& overlay);
template <> void payloadRender(const Overlay::Pointer& overlay, RenderArgs* args);
template <> const ShapeKey shapeGetShapeKey(const Overlay::Pointer& overlay);
template <> uint32_t metaFetchMetaSubItems(const Overlay::Pointer& overlay, ItemIDs& subItems);

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

@ -64,20 +64,6 @@ namespace render {
template <> const Item::Bound payloadGetBound(const Overlay::Pointer& overlay) {
return overlay->getBounds();
}
template <> int payloadGetLayer(const Overlay::Pointer& overlay) {
if (overlay->is3D()) {
auto overlay3D = std::dynamic_pointer_cast<Base3DOverlay>(overlay);
if (overlay3D->getDrawInFront()) {
return Item::LAYER_3D_FRONT;
} else if (overlay3D->getDrawHUDLayer()) {
return Item::LAYER_3D_HUD;
} else {
return Item::LAYER_3D;
}
} else {
return Item::LAYER_2D;
}
}
template <> void payloadRender(const Overlay::Pointer& overlay, RenderArgs* args) {
if (args) {
overlay->render(args);
@ -87,7 +73,6 @@ namespace render {
return overlay->getShapeKey();
}
template <> uint32_t metaFetchMetaSubItems(const Overlay::Pointer& overlay, ItemIDs& subItems) {
return overlay->fetchMetaSubItems(subItems);
}

4
libraries/avatars-renderer/src/avatars-renderer/Avatar.cpp
View file

@ -597,7 +597,7 @@ void Avatar::addToScene(AvatarSharedPointer self, const render::ScenePointer& sc
for (auto& attachmentModel : _attachmentModels) {
attachmentModel->addToScene(scene, transaction);
attachmentModel->setViewMask(Model::AllViews);
attachmentModel->setGroupCulled(true);
attachmentModel->setGroupCulled(false);
attachmentModel->setCanCastShadow(true);
attachmentModel->setVisibleInScene(_isMeshEnableVisible, scene);
}
@ -827,7 +827,7 @@ void Avatar::fixupModelsInScene(const render::ScenePointer& scene) {
attachmentModel->addToScene(scene, transaction);
attachmentModel->setViewMask(Model::AllViews);
attachmentModel->setGroupCulled(true);
attachmentModel->setGroupCulled(false);
attachmentModel->setCanCastShadow(true);
attachmentModel->setVisibleInScene(_isMeshEnableVisible, scene);
}

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

@ -103,12 +103,10 @@ Model::Model(QObject* parent, SpatiallyNestable* spatiallyNestableOverride) :
_snapModelToRegistrationPoint(false),
_snappedToRegistrationPoint(false),
_url(HTTP_INVALID_COM),
// _isVisible(true),
// _canCastShadow(false),
_blendNumber(0),
_appliedBlendNumber(0),
_isWireframe(false),
_renderItemsKey(render::ItemKey::Builder().withVisible().withTagBits(AllViews).build())
_renderItemKeyGlobalFlags(render::ItemKey::Builder().withVisible().withTagBits(AllViews).build())
{
// we may have been created in the network thread, but we live in the main thread
if (_viewState) {
@ -269,12 +267,7 @@ void Model::updateRenderItems() {
modelTransform.setScale(glm::vec3(1.0f));
bool isWireframe = self->isWireframe();
bool isVisible = self->isVisible();
bool canCastShadow = self->canCastShadow();
uint8_t viewTagBits = self->getViewMask();
bool isLayeredInFront = self->isLayeredInFront();
bool isLayeredInHUD = self->isLayeredInHUD();
bool isGroupCulled = self->isGroupCulled();
auto renderItemKeyGlobalFlags = self->getRenderItemKeyGlobalFlags();
render::Transaction transaction;
for (int i = 0; i < (int) self->_modelMeshRenderItemIDs.size(); i++) {
@ -288,9 +281,7 @@ void Model::updateRenderItems() {
bool useDualQuaternionSkinning = self->getUseDualQuaternionSkinning();
transaction.updateItem<ModelMeshPartPayload>(itemID, [modelTransform, meshState, useDualQuaternionSkinning,
invalidatePayloadShapeKey, isWireframe, isVisible,
canCastShadow, viewTagBits, isLayeredInFront,
isLayeredInHUD, isGroupCulled](ModelMeshPartPayload& data) {
invalidatePayloadShapeKey, isWireframe, renderItemKeyGlobalFlags](ModelMeshPartPayload& data) {
if (useDualQuaternionSkinning) {
data.updateClusterBuffer(meshState.clusterDualQuaternions);
} else {
@ -314,8 +305,7 @@ void Model::updateRenderItems() {
}
data.updateTransformForSkinnedMesh(renderTransform, modelTransform);
data.updateKey(isVisible, isLayeredInFront || isLayeredInHUD, canCastShadow, viewTagBits, isGroupCulled);
// data.setLayer(isLayeredInFront, isLayeredInHUD);
data.updateKey(renderItemKeyGlobalFlags);
data.setShapeKey(invalidatePayloadShapeKey, isWireframe, useDualQuaternionSkinning);
});
}
@ -323,8 +313,9 @@ void Model::updateRenderItems() {
Transform collisionMeshOffset;
collisionMeshOffset.setIdentity();
foreach(auto itemID, self->_collisionRenderItemsMap.keys()) {
transaction.updateItem<MeshPartPayload>(itemID, [modelTransform, collisionMeshOffset](MeshPartPayload& data) {
transaction.updateItem<MeshPartPayload>(itemID, [renderItemKeyGlobalFlags, modelTransform, collisionMeshOffset](MeshPartPayload& data) {
// update the model transform for this render item.
data.updateKey(renderItemKeyGlobalFlags);
data.updateTransform(modelTransform, collisionMeshOffset);
});
}
@ -773,40 +764,13 @@ void Model::calculateTriangleSets(const FBXGeometry& geometry) {
}
}
}
/*
void Model::setVisibleInScene(bool isVisible, const render::ScenePointer& scene, uint8_t viewTagBits, bool isGroupCulled) {
if (_isVisible != isVisible || _viewTagBits != viewTagBits || _isGroupCulled != isGroupCulled) {
_isVisible = isVisible;
_viewTagBits = viewTagBits;
_isGroupCulled = isGroupCulled;
bool isLayeredInFront = _isLayeredInFront;
bool isLayeredInHUD = _isLayeredInHUD;
bool canCastShadow = _canCastShadow;
render::Transaction transaction;
foreach (auto item, _modelMeshRenderItemsMap.keys()) {
transaction.updateItem<ModelMeshPartPayload>(item, [isVisible, viewTagBits, isLayeredInFront, canCastShadow,
isLayeredInHUD, isGroupCulled](ModelMeshPartPayload& data) {
data.updateKey(isVisible, isLayeredInFront || isLayeredInHUD, canCastShadow, viewTagBits, isGroupCulled);
});
}
foreach(auto item, _collisionRenderItemsMap.keys()) {
transaction.updateItem<ModelMeshPartPayload>(item, [isVisible, viewTagBits, isLayeredInFront, canCastShadow,
isLayeredInHUD, isGroupCulled](ModelMeshPartPayload& data) {
data.updateKey(isVisible, isLayeredInFront || isLayeredInHUD, canCastShadow, viewTagBits, isGroupCulled);
});
}
scene->enqueueTransaction(transaction);
}
}
*/
void Model::updateRenderItemsKey(const render::ScenePointer& scene) {
if (!scene) {
_needsFixupInScene = true;
return;
}
auto renderItemsKey = _renderItemsKey;
auto renderItemsKey = _renderItemKeyGlobalFlags;
render::Transaction transaction;
foreach(auto item, _modelMeshRenderItemsMap.keys()) {
transaction.updateItem<ModelMeshPartPayload>(item, [renderItemsKey](ModelMeshPartPayload& data) {
@ -823,72 +787,76 @@ void Model::updateRenderItemsKey(const render::ScenePointer& scene) {
void Model::setVisibleInScene(bool isVisible, const render::ScenePointer& scene) {
if (Model::isVisible() != isVisible) {
auto keyBuilder = render::ItemKey::Builder(_renderItemsKey);
_renderItemsKey = (isVisible ? keyBuilder.withVisible() : keyBuilder.withInvisible());
auto keyBuilder = render::ItemKey::Builder(_renderItemKeyGlobalFlags);
_renderItemKeyGlobalFlags = (isVisible ? keyBuilder.withVisible() : keyBuilder.withInvisible());
updateRenderItemsKey(scene);
}
}
bool Model::isVisible() const {
return _renderItemsKey.isVisible();
return _renderItemKeyGlobalFlags.isVisible();
}
void Model::setCanCastShadow(bool canCastShadow, const render::ScenePointer& scene) {
if (Model::canCastShadow() != canCastShadow) {
auto keyBuilder = render::ItemKey::Builder(_renderItemsKey);
_renderItemsKey = (canCastShadow ? keyBuilder.withShadowCaster() : keyBuilder.withoutShadowCaster());
auto keyBuilder = render::ItemKey::Builder(_renderItemKeyGlobalFlags);
_renderItemKeyGlobalFlags = (canCastShadow ? keyBuilder.withShadowCaster() : keyBuilder.withoutShadowCaster());
updateRenderItemsKey(scene);
}
}
bool Model::canCastShadow() const {
return _renderItemsKey.isShadowCaster();
return _renderItemKeyGlobalFlags.isShadowCaster();
}
void Model::setLayeredInFront(bool isLayeredInFront, const render::ScenePointer& scene) {
if (Model::isLayeredInFront() != isLayeredInFront) {
auto keyBuilder = render::ItemKey::Builder(_renderItemsKey);
_renderItemsKey = (isLayeredInFront ? keyBuilder.withLayer(render::Item::LAYER_3D_FRONT) : keyBuilder.withoutLayer());
auto keyBuilder = render::ItemKey::Builder(_renderItemKeyGlobalFlags);
_renderItemKeyGlobalFlags = (isLayeredInFront ? keyBuilder.withLayer(render::Item::LAYER_3D_FRONT) : keyBuilder.withoutLayer());
updateRenderItemsKey(scene);
}
}
bool Model::isLayeredInFront() const {
return _renderItemsKey.isLayer(render::Item::LAYER_3D_FRONT);
return _renderItemKeyGlobalFlags.isLayer(render::Item::LAYER_3D_FRONT);
}
void Model::setLayeredInHUD(bool isLayeredInHUD, const render::ScenePointer& scene) {
if (Model::isLayeredInHUD() != isLayeredInHUD) {
auto keyBuilder = render::ItemKey::Builder(_renderItemsKey);
_renderItemsKey = (isLayeredInHUD ? keyBuilder.withLayer(render::Item::LAYER_3D_HUD) : keyBuilder.withoutLayer());
auto keyBuilder = render::ItemKey::Builder(_renderItemKeyGlobalFlags);
_renderItemKeyGlobalFlags = (isLayeredInHUD ? keyBuilder.withLayer(render::Item::LAYER_3D_HUD) : keyBuilder.withoutLayer());
updateRenderItemsKey(scene);
}
}
bool Model::isLayeredInHUD() const {
return _renderItemsKey.isLayer(render::Item::LAYER_3D_HUD);
return _renderItemKeyGlobalFlags.isLayer(render::Item::LAYER_3D_HUD);
}
void Model::setViewMask(uint8_t mask, const render::ScenePointer& scene) {
if (Model::getViewMask() != mask) {
auto keyBuilder = render::ItemKey::Builder(_renderItemsKey);
_renderItemsKey = keyBuilder.withTagBits(mask);
auto keyBuilder = render::ItemKey::Builder(_renderItemKeyGlobalFlags);
_renderItemKeyGlobalFlags = keyBuilder.withTagBits(mask);
updateRenderItemsKey(scene);
}
}
Model::ViewMask Model::getViewMask() const {
return (Model::ViewMask) _renderItemsKey.getTagBits();
return (Model::ViewMask) _renderItemKeyGlobalFlags.getTagBits();
}
void Model::setGroupCulled(bool isGroupCulled, const render::ScenePointer& scene) {
if (Model::isGroupCulled() != isGroupCulled) {
auto keyBuilder = render::ItemKey::Builder(_renderItemsKey);
_renderItemsKey = (isGroupCulled ? keyBuilder.withSubMetaCulled() : keyBuilder.withoutSubMetaCulled());
auto keyBuilder = render::ItemKey::Builder(_renderItemKeyGlobalFlags);
_renderItemKeyGlobalFlags = (isGroupCulled ? keyBuilder.withSubMetaCulled() : keyBuilder.withoutSubMetaCulled());
updateRenderItemsKey(scene);
}
}
bool Model::isGroupCulled() const {
return _renderItemsKey.isSubMetaCulled();
return _renderItemKeyGlobalFlags.isSubMetaCulled();
}
const render::ItemKey Model::getRenderItemKeyGlobalFlags() const {
return _renderItemKeyGlobalFlags;
}
bool Model::addToScene(const render::ScenePointer& scene,
@ -1690,7 +1658,7 @@ void Model::addMaterial(graphics::MaterialLayer material, const std::string& par
for (auto shapeID : shapeIDs) {
if (shapeID < _modelMeshRenderItemIDs.size()) {
auto itemID = _modelMeshRenderItemIDs[shapeID];
auto renderItemsKey = _renderItemsKey;
auto renderItemsKey = _renderItemKeyGlobalFlags;
bool wireframe = isWireframe();
auto meshIndex = _modelMeshRenderItemShapes[shapeID].meshIndex;
bool invalidatePayloadShapeKey = shouldInvalidatePayloadShapeKey(meshIndex);
@ -1714,7 +1682,7 @@ void Model::removeMaterial(graphics::MaterialPointer material, const std::string
if (shapeID < _modelMeshRenderItemIDs.size()) {
auto itemID = _modelMeshRenderItemIDs[shapeID];
bool visible = isVisible();
auto renderItemsKey = _renderItemsKey;
auto renderItemsKey = _renderItemKeyGlobalFlags;
bool wireframe = isWireframe();
auto meshIndex = _modelMeshRenderItemShapes[shapeID].meshIndex;
bool invalidatePayloadShapeKey = shouldInvalidatePayloadShapeKey(meshIndex);

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

@ -91,6 +91,7 @@ public:
bool isVisible() const;
enum ViewMask : uint8_t {
NoView = 0x00, // Not drawn at all
MainView = 0x01, //render::ItemKey::TAG_BITS_0,
SecondaryView = 0x02, //render::ItemKey::TAG_BITS_1,
AllViews = 0xFF, //render::ItemKey::TAG_BITS_ALL,
@ -110,6 +111,9 @@ public:
bool isLayeredInFront() const;
bool isLayeredInHUD() const;
// Access the current RenderItemKey Global Flags used by the model and applied to the render items representing the parts of the model.
const render::ItemKey getRenderItemKeyGlobalFlags() const;
bool needsFixupInScene() const;
bool needsReload() const { return _needsReload; }
@ -414,10 +418,6 @@ protected:
QVector<float> _blendshapeCoefficients;
QUrl _url;
// bool _isVisible;
// uint8_t _viewTagBits{ render::ItemKey::TAG_BITS_ALL };
// bool _canCastShadow;
gpu::Buffers _blendedVertexBuffers;
@ -481,12 +481,17 @@ protected:
int _renderInfoDrawCalls { 0 };
int _renderInfoHasTransparent { false };
render::ItemKey _renderItemsKey;
/* bool _isLayeredInFront { false };
bool _isLayeredInHUD { false };
// This Render ItemKey Global Flags capture the Model wide global set of flags that should be communicated to all the render items representing the Model.
// The flags concerned are:
// - isVisible: if true the Model is visible globally in the scene, regardless of the other flags in the item keys (tags or layer or shadow caster).
// - TagBits: the view mask defined through the TagBits telling in which view the Model is rendered if visible.
// - Layer: In which Layer this Model lives.
// - CastShadow: if true and visible and rendered in the view, the Model cast shadows if in a Light volume casting shadows.
// - CullGroup: if true, the render items representing the parts of the Model are culled by a single Meta render item that knows about them, they are not culled individually.
// For this to work, a Meta RI must exists and knows about the RIs of this Model.
//
render::ItemKey _renderItemKeyGlobalFlags;
bool _isGroupCulled{ false };
*/
bool shouldInvalidatePayloadShapeKey(int meshIndex);
private:

1
libraries/render/src/render/Item.cpp
View file

@ -49,7 +49,6 @@ const uint8_t ItemKey::TAG_BITS_7 { 0x80 };
const uint32_t ItemKey::KEY_TAG_BITS_MASK = ((uint32_t) ItemKey::TAG_BITS_ALL) << FIRST_TAG_BIT;
// Layer bits are derived from the Layer enum, the number of bits needed to represent integer 0 to NUM_LAYERS
//const uint8_t ItemKey::NUM_LAYER_BITS { 3 };
const uint8_t ItemKey::LAYER_BITS_ALL { 0x07 };
const uint32_t ItemKey::KEY_LAYER_BITS_MASK = ((uint32_t)ItemKey::LAYER_BITS_ALL) << FIRST_LAYER_BIT;

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

@ -67,11 +67,10 @@ public:
const static uint8_t TAG_BITS_7;
// Items are organized in layers, an item belongs to one of the 8 Layers available.
// By default an item is in the 'LAYER_NONE' meaning that it is NOT layered.
// Which is equivalent to say that LAYER_NONE, is the default Layer.
// By default an item is in the 'LAYER_DEFAULT' meaning that it is NOT layered.
// THere is NO ordering relationship between layers.
enum Layer : uint8_t {
LAYER_NONE = 0, // layer 0 is a 'NOT' layer, items are not considered layered, this is the default value
LAYER_DEFAULT = 0, // layer 0 aka Default is a 'NOT' layer, items are not considered layered, this is the default value
LAYER_1,
LAYER_2,
LAYER_3,
@ -164,7 +163,7 @@ public:
Builder& withTagBits(uint8_t tagBits) { _flags = evalTagBitsWithKeyBits(tagBits, _flags.to_ulong()); return (*this); }
Builder& withLayer(uint8_t layer) { _flags = evalLayerBitsWithKeyBits(layer, _flags.to_ulong()); return (*this); }
Builder& withoutLayer() { return withLayer(LAYER_NONE); }
Builder& withoutLayer() { return withLayer(LAYER_DEFAULT); }
// Convenient standard keys that we will keep on using all over the place
static Builder opaqueShape() { return Builder().withTypeShape(); }
@ -206,7 +205,7 @@ public:
uint8_t getLayer() const { return ((_flags.to_ulong() & KEY_LAYER_BITS_MASK) >> FIRST_LAYER_BIT); }
bool isLayer(uint8_t layer) const { return getLayer() == layer; }
bool isLayered() const { return getLayer() != LAYER_NONE; }
bool isLayered() const { return getLayer() != LAYER_DEFAULT; }
bool isSpatial() const { return !isLayered(); }
// Probably not public, flags used by the scene
@ -277,7 +276,7 @@ public:
// Set ALL the tags in one call using the Tag bits and the Tag bits touched
Builder& withTagBits(uint8_t tagBits, uint8_t tagMask) { _value = ItemKey::evalTagBitsWithKeyBits(tagBits, _value.to_ulong()); _mask = ItemKey::evalTagBitsWithKeyBits(tagMask, _mask.to_ulong()); return (*this); }
Builder& withoutLayered() { _value = ItemKey::evalLayerBitsWithKeyBits(ItemKey::LAYER_NONE, _value.to_ulong()); _mask |= ItemKey::KEY_LAYER_BITS_MASK; return (*this); }
Builder& withoutLayered() { _value = ItemKey::evalLayerBitsWithKeyBits(ItemKey::LAYER_DEFAULT, _value.to_ulong()); _mask |= ItemKey::KEY_LAYER_BITS_MASK; return (*this); }
Builder& withLayer(uint8_t layer) { _value = ItemKey::evalLayerBitsWithKeyBits(layer, _value.to_ulong()); _mask |= ItemKey::KEY_LAYER_BITS_MASK; return (*this); }
Builder& withNothing() { _value.reset(); _mask.reset(); return (*this); }
@ -458,12 +457,11 @@ public:
// Get the bound of the item expressed in world space (or eye space depending on the key.isWorldSpace())
const Bound getBound() const { return _payload->getBound(); }
// Get the layer where the item belongs.
// int getLayer() const { return _payload->getLayer(); }
// Get the layer where the item belongs, simply reflecting the key.
int getLayer() const { return _key.getLayer(); }
static const uint8_t LAYER_2D{ ItemKey::LAYER_1 };
static const uint8_t LAYER_3D{ ItemKey::LAYER_NONE };
static const uint8_t LAYER_3D{ ItemKey::LAYER_DEFAULT };
static const uint8_t LAYER_3D_FRONT{ ItemKey::LAYER_2 };
static const uint8_t LAYER_3D_HUD{ ItemKey::LAYER_3 };
@ -515,7 +513,6 @@ inline QDebug operator<<(QDebug debug, const Item& item) {
// Item shared interface supported by the payload
template <class T> const ItemKey payloadGetKey(const std::shared_ptr<T>& payloadData) { return ItemKey(); }
template <class T> const Item::Bound payloadGetBound(const std::shared_ptr<T>& payloadData) { return Item::Bound(); }
template <class T> int payloadGetLayer(const std::shared_ptr<T>& payloadData) { return 0; }
template <class T> void payloadRender(const std::shared_ptr<T>& payloadData, RenderArgs* args) { }
// Shape type interface
@ -542,7 +539,6 @@ public:
// Payload general interface
virtual const ItemKey getKey() const override { return payloadGetKey<T>(_data); }
virtual const Item::Bound getBound() const override { return payloadGetBound<T>(_data); }
// virtual int getLayer() const override { return payloadGetLayer<T>(_data); }
virtual void render(RenderArgs* args) override { payloadRender<T>(_data, args); }