Mirrors/overte-lubosz
3
0
Fork 0
mirror of https://github.com/lubosz/overte.git synced 2025-04-13 21:06:32 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

add support for renderInfo properties to model entities

Browse source
This commit is contained in:
Brad Hefta-Gaub 2016-08-31 14:59:02 -07:00
parent 74fac8c7c9
commit e1845e2c3f
8 changed files with 139 additions and 3 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -548,6 +548,15 @@ EntityItemProperties RenderableModelEntityItem::getProperties(EntityPropertyFlag
if (_originalTexturesRead) {
properties.setTextureNames(_originalTextures);
}
if (_model) {
properties.setRenderInfoVertexCount(_model->getRenderInfoVertexCount());
properties.setRenderInfoTextureCount(_model->getRenderInfoTextureCount());
properties.setRenderInfoTextureSize(_model->getRenderInfoTextureSize());
properties.setRenderInfoDrawCalls(_model->getRenderInfoDrawCalls());
properties.setRenderInfoHasTransparent(_model->getRenderInfoHasTransparent());
}
return properties;
}

18
libraries/entities/src/EntityItemProperties.cpp
View file

@ -580,6 +580,24 @@ QScriptValue EntityItemProperties::copyToScriptValue(QScriptEngine* engine, bool
COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_CLIENT_ONLY, clientOnly);
COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_OWNING_AVATAR_ID, owningAvatarID);
// Rendering info
if (!skipDefaults) {
QScriptValue renderInfo = engine->newObject();
// currently only supported by models
if (_type == EntityTypes::Model) {
renderInfo.setProperty("verticesCount", (int)getRenderInfoVertexCount()); // FIXME - theoretically the number of vertex could be > max int
renderInfo.setProperty("texturesSize", (int)getRenderInfoTextureSize()); // FIXME - theoretically the size of textures could be > max int
renderInfo.setProperty("hasTransparent", getRenderInfoHasTransparent());
renderInfo.setProperty("drawCalls", getRenderInfoDrawCalls());
}
if (_type == EntityTypes::Model || _type == EntityTypes::PolyLine || _type == EntityTypes::ParticleEffect) {
renderInfo.setProperty("texturesCount", QScriptValue(_textureNames.count()));
}
COPY_PROPERTY_TO_QSCRIPTVALUE_GETTER_NO_SKIP(renderInfo, renderInfo); // Gettable but not settable
}
properties.setProperty("clientOnly", convertScriptValue(engine, getClientOnly()));
properties.setProperty("owningAvatarID", convertScriptValue(engine, getOwningAvatarID()));

19
libraries/entities/src/EntityItemProperties.h
View file

@ -285,6 +285,19 @@ public:
void setJointRotationsDirty() { _jointRotationsSetChanged = true; _jointRotationsChanged = true; }
void setJointTranslationsDirty() { _jointTranslationsSetChanged = true; _jointTranslationsChanged = true; }
// render info related items
size_t getRenderInfoVertexCount() const { return _renderInfoVertexCount; }
void setRenderInfoVertexCount(size_t value) { _renderInfoVertexCount = value; }
int getRenderInfoTextureCount() const { return _renderInfoTextureCount; }
void setRenderInfoTextureCount(int value) { _renderInfoTextureCount = value; }
size_t getRenderInfoTextureSize() const { return _renderInfoTextureSize; }
void setRenderInfoTextureSize(size_t value) { _renderInfoTextureSize = value; }
int getRenderInfoDrawCalls() const { return _renderInfoDrawCalls; }
void setRenderInfoDrawCalls(int value) { _renderInfoDrawCalls = value; }
bool getRenderInfoHasTransparent() const { return _renderInfoHasTransparent; }
void setRenderInfoHasTransparent(bool value) { _renderInfoHasTransparent = value; }
protected:
QString getCollisionMaskAsString() const;
void setCollisionMaskFromString(const QString& maskString);
@ -308,6 +321,12 @@ private:
glm::vec3 _naturalDimensions;
glm::vec3 _naturalPosition;
size_t _renderInfoVertexCount { 0 };
int _renderInfoTextureCount { 0 };
size_t _renderInfoTextureSize { 0 };
int _renderInfoDrawCalls { 0 };
bool _renderInfoHasTransparent { false };
EntityPropertyFlags _desiredProperties; // if set will narrow scopes of copy/to/from to just these properties
};

1
libraries/model/src/model/TextureMap.h
View file

@ -59,6 +59,7 @@ public:
TextureMap() {}
void setTextureSource(gpu::TextureSourcePointer& textureSource);
gpu::TextureSourcePointer getTextureSource() const { return _textureSource; }
bool isDefined() const;
gpu::TextureView getTextureView() const;

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

@ -71,8 +71,37 @@ void MeshPartPayload::updateTransform(const Transform& transform, const Transfor
void MeshPartPayload::updateMaterial(model::MaterialPointer drawMaterial) {
_drawMaterial = drawMaterial;
calculateMaterialSize();
}
bool MeshPartPayload::calculateMaterialSize() {
bool allTextures = true; // assume we got this...
_materialTextureSize = 0;
auto textureMaps = _drawMaterial->getTextureMaps();
for (auto const &textureMapItem : textureMaps) {
auto textureMap = textureMapItem.second;
if (textureMap) {
auto textureSoure = textureMap->getTextureSource();
if (textureSoure) {
auto texture = textureSoure->getGPUTexture();
if (texture) {
//auto storedSize = texture->getStoredSize();
auto size = texture->getSize();
_materialTextureSize += size;
} else {
allTextures = false;
}
} else {
allTextures = false;
}
} else {
allTextures = false;
}
}
return allTextures;
}
ItemKey MeshPartPayload::getKey() const {
ItemKey::Builder builder;
builder.withTypeShape();
@ -347,8 +376,8 @@ void ModelMeshPartPayload::initCache() {
auto networkMaterial = _model->getGeometry()->getShapeMaterial(_shapeID);
if (networkMaterial) {
_drawMaterial = networkMaterial;
};
calculateMaterialSize();
}
}
void ModelMeshPartPayload::notifyLocationChanged() {

7
libraries/render-utils/src/MeshPartPayload.h
View file

@ -64,6 +64,13 @@ public:
mutable model::Box _worldBound;
bool _hasColorAttrib = false;
size_t getVerticesCount() const { return _drawMesh ? _drawMesh->getNumVertices() : 0; }
size_t getMaterialTextureSize() { return _materialTextureSize; }
bool calculateMaterialSize();
protected:
size_t _materialTextureSize { 0 };
};
namespace render {

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

@ -161,6 +161,23 @@ void Model::setOffset(const glm::vec3& offset) {
_snappedToRegistrationPoint = false;
}
size_t Model::getRenderInfoTextureSize() {
if (!_hasCalculatedTextureSize && isLoaded() && getGeometry()->areTexturesLoaded()) {
size_t textureSize = 0;
bool allTexturesLoaded = true;
foreach(auto renderItem, _modelMeshRenderItemsSet) {
auto meshPart = renderItem.get();
bool allTexturesForThisMesh = meshPart->calculateMaterialSize();
allTexturesLoaded = allTexturesLoaded & allTexturesForThisMesh;
textureSize += meshPart->getMaterialTextureSize();
}
_renderInfoTextureSize = textureSize;
_hasCalculatedTextureSize = allTexturesLoaded; // only do this once
}
return _renderInfoTextureSize;
}
void Model::updateRenderItems() {
if (!_addedToScene) {
return;
@ -615,16 +632,26 @@ bool Model::addToScene(std::shared_ptr<render::Scene> scene,
}
} else {
if (_modelMeshRenderItems.empty()) {
foreach (auto renderItem, _modelMeshRenderItemsSet) {
bool hasTransparent = false;
size_t verticesCount = 0;
foreach(auto renderItem, _modelMeshRenderItemsSet) {
auto item = scene->allocateID();
auto renderPayload = std::make_shared<ModelMeshPartPayload::Payload>(renderItem);
if (statusGetters.size()) {
renderPayload->addStatusGetters(statusGetters);
}
pendingChanges.resetItem(item, renderPayload);
hasTransparent = hasTransparent || renderItem.get()->getShapeKey().isTranslucent();
verticesCount += renderItem.get()->getVerticesCount();
_modelMeshRenderItems.insert(item, renderPayload);
}
somethingAdded = !_modelMeshRenderItems.empty();
_renderInfoVertexCount = verticesCount;
_renderInfoDrawCalls = _modelMeshRenderItems.count();
_renderInfoHasTransparent = hasTransparent;
}
}
@ -650,6 +677,11 @@ void Model::removeFromScene(std::shared_ptr<render::Scene> scene, render::Pendin
_collisionRenderItems.clear();
_collisionRenderItemsSet.clear();
_addedToScene = false;
_renderInfoVertexCount = 0;
_renderInfoDrawCalls = 0;
_renderInfoTextureSize = 0;
_renderInfoHasTransparent = false;
}
void Model::renderDebugMeshBoxes(gpu::Batch& batch) {
@ -1332,13 +1364,21 @@ bool Model::initWhenReady(render::ScenePointer scene) {
}
addedPendingChanges = !_collisionRenderItems.empty();
} else {
bool hasTransparent = false;
size_t verticesCount = 0;
foreach (auto renderItem, _modelMeshRenderItemsSet) {
auto item = scene->allocateID();
auto renderPayload = std::make_shared<ModelMeshPartPayload::Payload>(renderItem);
hasTransparent = hasTransparent || renderItem.get()->getShapeKey().isTranslucent();
verticesCount += renderItem.get()->getVerticesCount();
_modelMeshRenderItems.insert(item, renderPayload);
pendingChanges.resetItem(item, renderPayload);
}
addedPendingChanges = !_modelMeshRenderItems.empty();
_renderInfoVertexCount = verticesCount;
_renderInfoDrawCalls = _modelMeshRenderItems.count();
_renderInfoHasTransparent = hasTransparent;
}
_addedToScene = addedPendingChanges;
if (addedPendingChanges) {

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

@ -232,6 +232,12 @@ public:
void setLoadingPriority(float priority) { _loadingPriority = priority; }
size_t getRenderInfoVertexCount() const { return _renderInfoVertexCount; }
int getRenderInfoTextureCount() const { return _renderInfoTextureCount; }
size_t getRenderInfoTextureSize();
int getRenderInfoDrawCalls() const { return _renderInfoDrawCalls; }
bool getRenderInfoHasTransparent() const { return _renderInfoHasTransparent; }
public slots:
void loadURLFinished(bool success);
@ -400,6 +406,13 @@ protected:
bool _renderItemsNeedUpdate { false };
size_t _renderInfoVertexCount { 0 };
int _renderInfoTextureCount { 0 };
size_t _renderInfoTextureSize { 0 };
bool _hasCalculatedTextureSize { false };
int _renderInfoDrawCalls { 0 };
int _renderInfoHasTransparent { false };
private:
float _loadingPriority { 0.0f };