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

Merge pull request #9976 from mittens/21215

Browse source 
Worklist #21215 - Removing Duplicate Status Icons for Submeshes
This commit is contained in:
Brad Hefta-Gaub 2017-03-24 08:52:12 -07:00 committed by GitHub
commit 1972b140b9
3 changed files with 49 additions and 49 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
interface/src/avatar/CauterizedModel.cpp
View file

@ -56,9 +56,9 @@ void CauterizedModel::createVisibleRenderItemSet() {
} }
// We should not have any existing renderItems if we enter this section of code // We should not have any existing renderItems if we enter this section of code
Q_ASSERT(_modelMeshRenderItemsSet.isEmpty()); Q_ASSERT(_modelMeshRenderItems.isEmpty());
_modelMeshRenderItemsSet.clear(); _modelMeshRenderItems.clear();
Transform transform; Transform transform;
transform.setTranslation(_translation); transform.setTranslation(_translation);
@ -81,7 +81,7 @@ void CauterizedModel::createVisibleRenderItemSet() {
int numParts = (int)mesh->getNumParts(); int numParts = (int)mesh->getNumParts();
for (int partIndex = 0; partIndex < numParts; partIndex++) { for (int partIndex = 0; partIndex < numParts; partIndex++) {
auto ptr = std::make_shared<CauterizedMeshPartPayload>(this, i, partIndex, shapeID, transform, offset); auto ptr = std::make_shared<CauterizedMeshPartPayload>(this, i, partIndex, shapeID, transform, offset);
_modelMeshRenderItemsSet << std::static_pointer_cast<ModelMeshPartPayload>(ptr); _modelMeshRenderItems << std::static_pointer_cast<ModelMeshPartPayload>(ptr);
shapeID++; shapeID++;
} }
} }

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

@ -176,11 +176,11 @@ void Model::setOffset(const glm::vec3& offset) {
} }
void Model::calculateTextureInfo() { void Model::calculateTextureInfo() {
if (!_hasCalculatedTextureInfo && isLoaded() && getGeometry()->areTexturesLoaded() && !_modelMeshRenderItems.isEmpty()) { if (!_hasCalculatedTextureInfo && isLoaded() && getGeometry()->areTexturesLoaded() && !_modelMeshRenderItemsMap.isEmpty()) {
size_t textureSize = 0; size_t textureSize = 0;
int textureCount = 0; int textureCount = 0;
bool allTexturesLoaded = true; bool allTexturesLoaded = true;
foreach(auto renderItem, _modelMeshRenderItemsSet) { foreach(auto renderItem, _modelMeshRenderItems) {
auto meshPart = renderItem.get(); auto meshPart = renderItem.get();
textureSize += meshPart->getMaterialTextureSize(); textureSize += meshPart->getMaterialTextureSize();
textureCount += meshPart->getMaterialTextureCount(); textureCount += meshPart->getMaterialTextureCount();
@ -236,7 +236,7 @@ void Model::updateRenderItems() {
uint32_t deleteGeometryCounter = self->_deleteGeometryCounter; uint32_t deleteGeometryCounter = self->_deleteGeometryCounter;
render::PendingChanges pendingChanges; render::PendingChanges pendingChanges;
foreach (auto itemID, self->_modelMeshRenderItems.keys()) { foreach (auto itemID, self->_modelMeshRenderItemsMap.keys()) {
pendingChanges.updateItem<ModelMeshPartPayload>(itemID, [deleteGeometryCounter](ModelMeshPartPayload& data) { pendingChanges.updateItem<ModelMeshPartPayload>(itemID, [deleteGeometryCounter](ModelMeshPartPayload& data) {
if (data._model && data._model->isLoaded()) { if (data._model && data._model->isLoaded()) {
// Ensure the model geometry was not reset between frames // Ensure the model geometry was not reset between frames
@ -259,7 +259,7 @@ void Model::updateRenderItems() {
Transform collisionMeshOffset; Transform collisionMeshOffset;
collisionMeshOffset.setIdentity(); collisionMeshOffset.setIdentity();
Transform modelTransform = self->getTransform(); Transform modelTransform = self->getTransform();
foreach (auto itemID, self->_collisionRenderItems.keys()) { foreach(auto itemID, self->_collisionRenderItemsMap.keys()) {
pendingChanges.updateItem<MeshPartPayload>(itemID, [modelTransform, collisionMeshOffset](MeshPartPayload& data) { pendingChanges.updateItem<MeshPartPayload>(itemID, [modelTransform, collisionMeshOffset](MeshPartPayload& data) {
// update the model transform for this render item. // update the model transform for this render item.
data.updateTransform(modelTransform, collisionMeshOffset); data.updateTransform(modelTransform, collisionMeshOffset);
@ -539,11 +539,11 @@ void Model::setVisibleInScene(bool newValue, std::shared_ptr<render::Scene> scen
_isVisible = newValue; _isVisible = newValue;
render::PendingChanges pendingChanges; render::PendingChanges pendingChanges;
foreach (auto item, _modelMeshRenderItems.keys()) { foreach (auto item, _modelMeshRenderItemsMap.keys()) {
pendingChanges.resetItem(item, _modelMeshRenderItems[item]); pendingChanges.resetItem(item, _modelMeshRenderItemsMap[item]);
} }
foreach (auto item, _collisionRenderItems.keys()) { foreach(auto item, _collisionRenderItemsMap.keys()) {
pendingChanges.resetItem(item, _collisionRenderItems[item]); pendingChanges.resetItem(item, _collisionRenderItemsMap[item]);
} }
scene->enqueuePendingChanges(pendingChanges); scene->enqueuePendingChanges(pendingChanges);
} }
@ -555,11 +555,11 @@ void Model::setLayeredInFront(bool layered, std::shared_ptr<render::Scene> scene
_isLayeredInFront = layered; _isLayeredInFront = layered;
render::PendingChanges pendingChanges; render::PendingChanges pendingChanges;
foreach(auto item, _modelMeshRenderItems.keys()) { foreach(auto item, _modelMeshRenderItemsMap.keys()) {
pendingChanges.resetItem(item, _modelMeshRenderItems[item]); pendingChanges.resetItem(item, _modelMeshRenderItemsMap[item]);
} }
foreach(auto item, _collisionRenderItems.keys()) { foreach(auto item, _collisionRenderItemsMap.keys()) {
pendingChanges.resetItem(item, _collisionRenderItems[item]); pendingChanges.resetItem(item, _collisionRenderItemsMap[item]);
} }
scene->enqueuePendingChanges(pendingChanges); scene->enqueuePendingChanges(pendingChanges);
} }
@ -576,39 +576,39 @@ bool Model::addToScene(std::shared_ptr<render::Scene> scene,
bool somethingAdded = false; bool somethingAdded = false;
if (_collisionGeometry) { if (_collisionGeometry) {
if (_collisionRenderItems.empty()) { if (_collisionRenderItems.empty()) {
foreach (auto renderItem, _collisionRenderItemsSet) { foreach (auto renderItem, _collisionRenderItems) {
auto item = scene->allocateID(); auto item = scene->allocateID();
auto renderPayload = std::make_shared<MeshPartPayload::Payload>(renderItem); auto renderPayload = std::make_shared<MeshPartPayload::Payload>(renderItem);
if (statusGetters.size()) { if (_collisionRenderItems.empty() && statusGetters.size()) {
renderPayload->addStatusGetters(statusGetters); renderPayload->addStatusGetters(statusGetters);
} }
pendingChanges.resetItem(item, renderPayload); pendingChanges.resetItem(item, renderPayload);
_collisionRenderItems.insert(item, renderPayload); _collisionRenderItemsMap.insert(item, renderPayload);
} }
somethingAdded = !_collisionRenderItems.empty(); somethingAdded = !_collisionRenderItems.empty();
} }
} else { } else {
if (_modelMeshRenderItems.empty()) { if (_modelMeshRenderItemsMap.empty()) {
bool hasTransparent = false; bool hasTransparent = false;
size_t verticesCount = 0; size_t verticesCount = 0;
foreach(auto renderItem, _modelMeshRenderItemsSet) { foreach(auto renderItem, _modelMeshRenderItems) {
auto item = scene->allocateID(); auto item = scene->allocateID();
auto renderPayload = std::make_shared<ModelMeshPartPayload::Payload>(renderItem); auto renderPayload = std::make_shared<ModelMeshPartPayload::Payload>(renderItem);
if (statusGetters.size()) { if (_modelMeshRenderItemsMap.empty() && statusGetters.size()) {
renderPayload->addStatusGetters(statusGetters); renderPayload->addStatusGetters(statusGetters);
} }
pendingChanges.resetItem(item, renderPayload); pendingChanges.resetItem(item, renderPayload);
hasTransparent = hasTransparent || renderItem.get()->getShapeKey().isTranslucent(); hasTransparent = hasTransparent || renderItem.get()->getShapeKey().isTranslucent();
verticesCount += renderItem.get()->getVerticesCount(); verticesCount += renderItem.get()->getVerticesCount();
_modelMeshRenderItems.insert(item, renderPayload); _modelMeshRenderItemsMap.insert(item, renderPayload);
_modelMeshRenderItemIDs.emplace_back(item); _modelMeshRenderItemIDs.emplace_back(item);
} }
somethingAdded = !_modelMeshRenderItems.empty(); somethingAdded = !_modelMeshRenderItemsMap.empty();
_renderInfoVertexCount = verticesCount; _renderInfoVertexCount = verticesCount;
_renderInfoDrawCalls = _modelMeshRenderItems.count(); _renderInfoDrawCalls = _modelMeshRenderItemsMap.count();
_renderInfoHasTransparent = hasTransparent; _renderInfoHasTransparent = hasTransparent;
} }
} }
@ -623,18 +623,18 @@ bool Model::addToScene(std::shared_ptr<render::Scene> scene,
} }
void Model::removeFromScene(std::shared_ptr<render::Scene> scene, render::PendingChanges& pendingChanges) { void Model::removeFromScene(std::shared_ptr<render::Scene> scene, render::PendingChanges& pendingChanges) {
foreach (auto item, _modelMeshRenderItems.keys()) { foreach (auto item, _modelMeshRenderItemsMap.keys()) {
pendingChanges.removeItem(item); pendingChanges.removeItem(item);
} }
_modelMeshRenderItemIDs.clear(); _modelMeshRenderItemIDs.clear();
_modelMeshRenderItemsMap.clear();
_modelMeshRenderItems.clear(); _modelMeshRenderItems.clear();
_modelMeshRenderItemsSet.clear();
foreach (auto item, _collisionRenderItems.keys()) { foreach(auto item, _collisionRenderItemsMap.keys()) {
pendingChanges.removeItem(item); pendingChanges.removeItem(item);
} }
_collisionRenderItems.clear(); _collisionRenderItems.clear();
_collisionRenderItemsSet.clear(); _collisionRenderItems.clear();
_addedToScene = false; _addedToScene = false;
_renderInfoVertexCount = 0; _renderInfoVertexCount = 0;
@ -1052,8 +1052,8 @@ void Model::updateRig(float deltaTime, glm::mat4 parentTransform) {
} }
void Model::computeMeshPartLocalBounds() { void Model::computeMeshPartLocalBounds() {
for (auto& part : _modelMeshRenderItemsSet) { for (auto& part : _modelMeshRenderItems) {
assert(part->_meshIndex < _modelMeshRenderItemsSet.size()); assert(part->_meshIndex < _modelMeshRenderItems.size());
const Model::MeshState& state = _meshStates.at(part->_meshIndex); const Model::MeshState& state = _meshStates.at(part->_meshIndex);
part->computeAdjustedLocalBound(state.clusterMatrices); part->computeAdjustedLocalBound(state.clusterMatrices);
} }
@ -1167,7 +1167,7 @@ AABox Model::getRenderableMeshBound() const {
} else { } else {
// Build a bound using the last known bound from all the renderItems. // Build a bound using the last known bound from all the renderItems.
AABox totalBound; AABox totalBound;
for (auto& renderItem : _modelMeshRenderItemsSet) { for (auto& renderItem : _modelMeshRenderItems) {
totalBound += renderItem->getBound(); totalBound += renderItem->getBound();
} }
return totalBound; return totalBound;
@ -1180,11 +1180,11 @@ const render::ItemIDs& Model::fetchRenderItemIDs() const {
void Model::createRenderItemSet() { void Model::createRenderItemSet() {
if (_collisionGeometry) { if (_collisionGeometry) {
if (_collisionRenderItemsSet.empty()) { if (_collisionRenderItems.empty()) {
createCollisionRenderItemSet(); createCollisionRenderItemSet();
} }
} else { } else {
if (_modelMeshRenderItemsSet.empty()) { if (_modelMeshRenderItems.empty()) {
createVisibleRenderItemSet(); createVisibleRenderItemSet();
} }
} }
@ -1201,9 +1201,9 @@ void Model::createVisibleRenderItemSet() {
} }
// We should not have any existing renderItems if we enter this section of code // We should not have any existing renderItems if we enter this section of code
Q_ASSERT(_modelMeshRenderItemsSet.isEmpty()); Q_ASSERT(_modelMeshRenderItems.isEmpty());
_modelMeshRenderItemsSet.clear(); _modelMeshRenderItems.clear();
Transform transform; Transform transform;
transform.setTranslation(_translation); transform.setTranslation(_translation);
@ -1225,7 +1225,7 @@ void Model::createVisibleRenderItemSet() {
// Create the render payloads // Create the render payloads
int numParts = (int)mesh->getNumParts(); int numParts = (int)mesh->getNumParts();
for (int partIndex = 0; partIndex < numParts; partIndex++) { for (int partIndex = 0; partIndex < numParts; partIndex++) {
_modelMeshRenderItemsSet << std::make_shared<ModelMeshPartPayload>(this, i, partIndex, shapeID, transform, offset); _modelMeshRenderItems << std::make_shared<ModelMeshPartPayload>(this, i, partIndex, shapeID, transform, offset);
shapeID++; shapeID++;
} }
} }
@ -1241,7 +1241,7 @@ void Model::createCollisionRenderItemSet() {
const auto& meshes = _collisionGeometry->getMeshes(); const auto& meshes = _collisionGeometry->getMeshes();
// We should not have any existing renderItems if we enter this section of code // We should not have any existing renderItems if we enter this section of code
Q_ASSERT(_collisionRenderItemsSet.isEmpty()); Q_ASSERT(_collisionRenderItems.isEmpty());
Transform identity; Transform identity;
identity.setIdentity(); identity.setIdentity();
@ -1262,7 +1262,7 @@ void Model::createCollisionRenderItemSet() {
model::MaterialPointer& material = _collisionMaterials[partIndex % NUM_COLLISION_HULL_COLORS]; model::MaterialPointer& material = _collisionMaterials[partIndex % NUM_COLLISION_HULL_COLORS];
auto payload = std::make_shared<MeshPartPayload>(mesh, partIndex, material); auto payload = std::make_shared<MeshPartPayload>(mesh, partIndex, material);
payload->updateTransform(identity, offset); payload->updateTransform(identity, offset);
_collisionRenderItemsSet << payload; _collisionRenderItems << payload;
} }
} }
} }
@ -1283,28 +1283,28 @@ bool Model::initWhenReady(render::ScenePointer scene) {
bool addedPendingChanges = false; bool addedPendingChanges = false;
if (_collisionGeometry) { if (_collisionGeometry) {
foreach (auto renderItem, _collisionRenderItemsSet) { foreach (auto renderItem, _collisionRenderItems) {
auto item = scene->allocateID(); auto item = scene->allocateID();
auto renderPayload = std::make_shared<MeshPartPayload::Payload>(renderItem); auto renderPayload = std::make_shared<MeshPartPayload::Payload>(renderItem);
_collisionRenderItems.insert(item, renderPayload); _collisionRenderItemsMap.insert(item, renderPayload);
pendingChanges.resetItem(item, renderPayload); pendingChanges.resetItem(item, renderPayload);
} }
addedPendingChanges = !_collisionRenderItems.empty(); addedPendingChanges = !_collisionRenderItems.empty();
} else { } else {
bool hasTransparent = false; bool hasTransparent = false;
size_t verticesCount = 0; size_t verticesCount = 0;
foreach (auto renderItem, _modelMeshRenderItemsSet) { foreach (auto renderItem, _modelMeshRenderItems) {
auto item = scene->allocateID(); auto item = scene->allocateID();
auto renderPayload = std::make_shared<ModelMeshPartPayload::Payload>(renderItem); auto renderPayload = std::make_shared<ModelMeshPartPayload::Payload>(renderItem);
hasTransparent = hasTransparent || renderItem.get()->getShapeKey().isTranslucent(); hasTransparent = hasTransparent || renderItem.get()->getShapeKey().isTranslucent();
verticesCount += renderItem.get()->getVerticesCount(); verticesCount += renderItem.get()->getVerticesCount();
_modelMeshRenderItems.insert(item, renderPayload); _modelMeshRenderItemsMap.insert(item, renderPayload);
pendingChanges.resetItem(item, renderPayload); pendingChanges.resetItem(item, renderPayload);
} }
addedPendingChanges = !_modelMeshRenderItems.empty(); addedPendingChanges = !_modelMeshRenderItemsMap.empty();
_renderInfoVertexCount = verticesCount; _renderInfoVertexCount = verticesCount;
_renderInfoDrawCalls = _modelMeshRenderItems.count(); _renderInfoDrawCalls = _modelMeshRenderItemsMap.count();
_renderInfoHasTransparent = hasTransparent; _renderInfoHasTransparent = hasTransparent;
} }
_addedToScene = addedPendingChanges; _addedToScene = addedPendingChanges;

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

@ -248,7 +248,7 @@ public:
const MeshState& getMeshState(int index) { return _meshStates.at(index); } const MeshState& getMeshState(int index) { return _meshStates.at(index); }
uint32_t getGeometryCounter() const { return _deleteGeometryCounter; } uint32_t getGeometryCounter() const { return _deleteGeometryCounter; }
const QMap<render::ItemID, render::PayloadPointer>& getRenderItems() const { return _modelMeshRenderItems; } const QMap<render::ItemID, render::PayloadPointer>& getRenderItems() const { return _modelMeshRenderItemsMap; }
void renderDebugMeshBoxes(gpu::Batch& batch); void renderDebugMeshBoxes(gpu::Batch& batch);
@ -373,11 +373,11 @@ protected:
static AbstractViewStateInterface* _viewState; static AbstractViewStateInterface* _viewState;
QSet<std::shared_ptr<MeshPartPayload>> _collisionRenderItemsSet; QVector<std::shared_ptr<MeshPartPayload>> _collisionRenderItems;
QMap<render::ItemID, render::PayloadPointer> _collisionRenderItems; QMap<render::ItemID, render::PayloadPointer> _collisionRenderItemsMap;
QSet<std::shared_ptr<ModelMeshPartPayload>> _modelMeshRenderItemsSet; QVector<std::shared_ptr<ModelMeshPartPayload>> _modelMeshRenderItems;
QMap<render::ItemID, render::PayloadPointer> _modelMeshRenderItems; QMap<render::ItemID, render::PayloadPointer> _modelMeshRenderItemsMap;
render::ItemIDs _modelMeshRenderItemIDs; render::ItemIDs _modelMeshRenderItemIDs;