From 7de4c2eff757afbf9274cccd093a9f4e8fb938bf Mon Sep 17 00:00:00 2001 From: Sam Gateau Date: Tue, 9 Jun 2015 12:17:10 -0700 Subject: [PATCH] first take on the materialKey --- libraries/fbx/src/FBXReader.cpp | 4 +- libraries/fbx/src/OBJReader.cpp | 12 +- libraries/gpu/src/gpu/Texture.h | 2 + libraries/model/src/model/Material.cpp | 46 ++-- libraries/model/src/model/Material.h | 220 +++++++++++++++--- libraries/model/src/model/TextureStorage.h | 2 +- libraries/render-utils/src/Model.cpp | 3 + .../render-utils/src/RenderDeferredTask.cpp | 80 ++++++- .../render-utils/src/RenderDeferredTask.h | 8 + libraries/render/src/render/DrawTask.cpp | 15 ++ libraries/render/src/render/DrawTask.h | 18 ++ libraries/render/src/render/Scene.h | 20 +- 12 files changed, 347 insertions(+), 83 deletions(-) diff --git a/libraries/fbx/src/FBXReader.cpp b/libraries/fbx/src/FBXReader.cpp index 464deb1059..f282f7e35d 100644 --- a/libraries/fbx/src/FBXReader.cpp +++ b/libraries/fbx/src/FBXReader.cpp @@ -1902,8 +1902,8 @@ FBXGeometry extractFBXGeometry(const FBXNode& node, const QVariantHash& mapping, } else { material._material->setDiffuse(material.diffuse); } - material._material->setSpecular(material.specular); - material._material->setShininess(material.shininess); + material._material->setMetallic(glm::length(material.specular)); + material._material->setGloss(material.shininess); if (material.opacity <= 0.0f) { material._material->setOpacity(1.0f); diff --git a/libraries/fbx/src/OBJReader.cpp b/libraries/fbx/src/OBJReader.cpp index 4a8a2fc53d..080fb98690 100644 --- a/libraries/fbx/src/OBJReader.cpp +++ b/libraries/fbx/src/OBJReader.cpp @@ -134,8 +134,8 @@ void setMeshPartDefaults(FBXMeshPart& meshPart, QString materialID) { meshPart._material = model::MaterialPointer(new model::Material()); meshPart._material->setDiffuse(glm::vec3(1.0, 1.0, 1.0)); meshPart._material->setOpacity(1.0); - meshPart._material->setSpecular(glm::vec3(1.0, 1.0, 1.0)); - meshPart._material->setShininess(96.0); + meshPart._material->setMetallic(0.0); + meshPart._material->setGloss(96.0); meshPart._material->setEmissive(glm::vec3(0.0, 0.0, 0.0)); } @@ -481,8 +481,8 @@ FBXGeometry OBJReader::readOBJ(QIODevice* device, const QVariantHash& mapping, Q meshPart.specularTexture.filename = material->specularTextureFilename; // ... and some things are set in the underlying material. meshPart._material->setDiffuse(material->diffuseColor); - meshPart._material->setSpecular(material->specularColor); - meshPart._material->setShininess(material->shininess); + meshPart._material->setMetallic(glm::length(material->specularColor)); + meshPart._material->setGloss(material->shininess); meshPart._material->setOpacity(material->opacity); } // qCDebug(modelformat) << "OBJ Reader part:" << meshPartCount << "name:" << leadFace.groupName << "material:" << groupMaterialName << "diffuse:" << meshPart._material->getDiffuse() << "faces:" << faceGroup.count() << "triangle indices will start with:" << mesh.vertices.count(); @@ -567,10 +567,10 @@ void fbxDebugDump(const FBXGeometry& fbxgeo) { qCDebug(modelformat) << " quadIndices.count() =" << meshPart.quadIndices.count(); qCDebug(modelformat) << " triangleIndices.count() =" << meshPart.triangleIndices.count(); qCDebug(modelformat) << " diffuseColor =" << meshPart.diffuseColor << "mat =" << meshPart._material->getDiffuse(); - qCDebug(modelformat) << " specularColor =" << meshPart.specularColor << "mat =" << meshPart._material->getSpecular(); + qCDebug(modelformat) << " specularColor =" << meshPart.specularColor << "mat =" << meshPart._material->getMetallic(); qCDebug(modelformat) << " emissiveColor =" << meshPart.emissiveColor << "mat =" << meshPart._material->getEmissive(); qCDebug(modelformat) << " emissiveParams =" << meshPart.emissiveParams; - qCDebug(modelformat) << " shininess =" << meshPart.shininess << "mat =" << meshPart._material->getShininess(); + qCDebug(modelformat) << " gloss =" << meshPart.shininess << "mat =" << meshPart._material->getGloss(); qCDebug(modelformat) << " opacity =" << meshPart.opacity << "mat =" << meshPart._material->getOpacity(); qCDebug(modelformat) << " materialID =" << meshPart.materialID; qCDebug(modelformat) << " diffuse texture =" << meshPart.diffuseTexture.filename; diff --git a/libraries/gpu/src/gpu/Texture.h b/libraries/gpu/src/gpu/Texture.h index 9036f0f6db..d5c3635816 100755 --- a/libraries/gpu/src/gpu/Texture.h +++ b/libraries/gpu/src/gpu/Texture.h @@ -437,6 +437,8 @@ public: explicit operator bool() const { return bool(_texture); } bool operator !() const { return (!_texture); } + + bool isValid() const { return bool(_texture); } }; typedef std::vector TextureViews; diff --git a/libraries/model/src/model/Material.cpp b/libraries/model/src/model/Material.cpp index 55572a5122..a3448889b0 100755 --- a/libraries/model/src/model/Material.cpp +++ b/libraries/model/src/model/Material.cpp @@ -14,7 +14,7 @@ using namespace model; using namespace gpu; Material::Material() : - _flags(0), + _key(0), _schemaBuffer(), _textureMap() { @@ -26,13 +26,13 @@ Material::Material() : } Material::Material(const Material& material) : - _flags(material._flags), + _key(material._key), _schemaBuffer(material._schemaBuffer), _textureMap(material._textureMap) { } Material& Material::operator= (const Material& material) { - _flags = (material._flags); + _key = (material._key); _schemaBuffer = (material._schemaBuffer); _textureMap = (material._textureMap); @@ -43,52 +43,32 @@ Material::~Material() { } void Material::setDiffuse(const Color& diffuse) { - if (glm::any(glm::greaterThan(diffuse, Color(0.0f)))) { - _flags.set(DIFFUSE_BIT); - } else { - _flags.reset(DIFFUSE_BIT); - } + _key.setDiffuse(glm::any(glm::greaterThan(diffuse, Color(0.0f)))); _schemaBuffer.edit()._diffuse = diffuse; } -void Material::setSpecular(const Color& specular) { - if (glm::any(glm::greaterThan(specular, Color(0.0f)))) { - _flags.set(SPECULAR_BIT); - } else { - _flags.reset(SPECULAR_BIT); - } - _schemaBuffer.edit()._specular = specular; +void Material::setMetallic(float metallic) { + _key.setMetallic(metallic > 0.0f); + _schemaBuffer.edit()._metallic = glm::vec3(metallic); } void Material::setEmissive(const Color& emissive) { - if (glm::any(glm::greaterThan(emissive, Color(0.0f)))) { - _flags.set(EMISSIVE_BIT); - } else { - _flags.reset(EMISSIVE_BIT); - } + _key.setEmissive(glm::any(glm::greaterThan(emissive, Color(0.0f)))); _schemaBuffer.edit()._emissive = emissive; } -void Material::setShininess(float shininess) { - if (shininess > 0.0f) { - _flags.set(SHININESS_BIT); - } else { - _flags.reset(SHININESS_BIT); - } - _schemaBuffer.edit()._shininess = shininess; +void Material::setGloss(float gloss) { + _key.setGloss((gloss > 0.0f)); + _schemaBuffer.edit()._gloss = gloss; } void Material::setOpacity(float opacity) { - if (opacity >= 1.0f) { - _flags.reset(TRANSPARENT_BIT); - } else { - _flags.set(TRANSPARENT_BIT); - } + _key.setTransparent((opacity < 1.0f)); _schemaBuffer.edit()._opacity = opacity; } void Material::setTextureView(MapChannel channel, const gpu::TextureView& view) { - _flags.set(DIFFUSE_MAP_BIT + channel); + _key.setMapChannel(channel, (view.isValid())); _textureMap[channel] = view; } diff --git a/libraries/model/src/model/Material.h b/libraries/model/src/model/Material.h index ea0ab808e9..392fd918a1 100755 --- a/libraries/model/src/model/Material.h +++ b/libraries/model/src/model/Material.h @@ -23,6 +23,177 @@ namespace model { +// Material Key is a coarse trait description of a material used to classify the materials +class MaterialKey { +public: + enum FlagBit { + EMISSIVE_VAL_BIT = 0, + DIFFUSE_VAL_BIT, + METALLIC_VAL_BIT, + GLOSS_VAL_BIT, + TRANSPARENT_VAL_BIT, + + EMISSIVE_MAP_BIT, + DIFFUSE_MAP_BIT, + METALLIC_MAP_BIT, + GLOSS_MAP_BIT, + TRANSPARENT_MAP_BIT, + NORMAL_MAP_BIT, + + NUM_FLAGS, + }; + typedef std::bitset Flags; + + enum MapChannel { + EMISSIVE_MAP = 0, + DIFFUSE_MAP, + METALLIC_MAP, + GLOSS_MAP, + TRANSPARENT_MAP, + NORMAL_MAP, + + NUM_MAP_CHANNELS, + }; + + // The signature is the Flags + Flags _flags; + + MaterialKey() : _flags(0) {} + MaterialKey(const Flags& flags) : _flags(flags) {} + + class Builder { + Flags _flags{ 0 }; + public: + Builder() {} + + MaterialKey build() const { return MaterialKey(_flags); } + + Builder& withEmissive() { _flags.set(EMISSIVE_VAL_BIT); return (*this); } + Builder& withDiffuse() { _flags.set(DIFFUSE_VAL_BIT); return (*this); } + Builder& withMetallic() { _flags.set(METALLIC_VAL_BIT); return (*this); } + Builder& withGloss() { _flags.set(GLOSS_VAL_BIT); return (*this); } + Builder& withTransparent() { _flags.set(TRANSPARENT_VAL_BIT); return (*this); } + + Builder& withEmissiveMap() { _flags.set(EMISSIVE_MAP_BIT); return (*this); } + Builder& withDiffuseMap() { _flags.set(DIFFUSE_MAP_BIT); return (*this); } + Builder& withMetallicMap() { _flags.set(METALLIC_MAP_BIT); return (*this); } + Builder& withGlossMap() { _flags.set(GLOSS_MAP_BIT); return (*this); } + Builder& withTransparentMap() { _flags.set(TRANSPARENT_MAP_BIT); return (*this); } + + Builder& withNormalMap() { _flags.set(NORMAL_MAP_BIT); return (*this); } + + // Convenient standard keys that we will keep on using all over the place + static MaterialKey opaqueDiffuse() { return Builder().withDiffuse().build(); } + }; + + void setEmissive(bool value) { _flags.set(EMISSIVE_VAL_BIT, value); } + bool isEmissive() const { return _flags[EMISSIVE_VAL_BIT]; } + + void setEmissiveMap(bool value) { _flags.set(EMISSIVE_MAP_BIT, value); } + bool isEmissiveMap() const { return _flags[EMISSIVE_MAP_BIT]; } + + void setDiffuse(bool value) { _flags.set(DIFFUSE_VAL_BIT, value); } + bool isDiffuse() const { return _flags[DIFFUSE_VAL_BIT]; } + + void setDiffuseMap(bool value) { _flags.set(DIFFUSE_MAP_BIT, value); } + bool isDiffuseMap() const { return _flags[DIFFUSE_MAP_BIT]; } + + void setMetallic(bool value) { _flags.set(METALLIC_VAL_BIT, value); } + bool isMetallic() const { return _flags[METALLIC_VAL_BIT]; } + + void setMetallicMap(bool value) { _flags.set(METALLIC_MAP_BIT, value); } + bool isMetallicMap() const { return _flags[METALLIC_MAP_BIT]; } + + void setGloss(bool value) { _flags.set(GLOSS_VAL_BIT, value); } + bool isGloss() const { return _flags[GLOSS_VAL_BIT]; } + + void setGlossMap(bool value) { _flags.set(GLOSS_MAP_BIT, value); } + bool isGlossMap() const { return _flags[GLOSS_MAP_BIT]; } + + void setTransparent(bool value) { _flags.set(TRANSPARENT_VAL_BIT, value); } + bool isTransparent() const { return _flags[TRANSPARENT_VAL_BIT]; } + bool isOpaque() const { return !_flags[TRANSPARENT_VAL_BIT]; } + + void setTransparentMap(bool value) { _flags.set(TRANSPARENT_MAP_BIT, value); } + bool isTransparentMap() const { return _flags[TRANSPARENT_MAP_BIT]; } + + void setNormalMap(bool value) { _flags.set(NORMAL_MAP_BIT, value); } + bool isNormalMap() const { return _flags[NORMAL_MAP_BIT]; } + + void setMapChannel(MapChannel channel, bool value) { _flags.set(EMISSIVE_MAP_BIT + channel, value); } + bool isMapChannel(MapChannel channel) const { return _flags[EMISSIVE_MAP_BIT + channel]; } + +}; + + +class MaterialFilter { +public: + MaterialKey::Flags _value{ 0 }; + MaterialKey::Flags _mask{ 0 }; + + + MaterialFilter(const MaterialKey::Flags& value = MaterialKey::Flags(0), const MaterialKey::Flags& mask = MaterialKey::Flags(0)) : _value(value), _mask(mask) {} + + class Builder { + MaterialKey::Flags _value{ 0 }; + MaterialKey::Flags _mask{ 0 }; + public: + Builder() {} + + MaterialFilter build() const { return MaterialFilter(_value, _mask); } + + Builder& withoutEmissive() { _value.reset(MaterialKey::EMISSIVE_VAL_BIT); _mask.set(MaterialKey::EMISSIVE_VAL_BIT); return (*this); } + Builder& withEmissive() { _value.set(MaterialKey::EMISSIVE_VAL_BIT); _mask.set(MaterialKey::EMISSIVE_VAL_BIT); return (*this); } + + Builder& withoutEmissiveMap() { _value.reset(MaterialKey::EMISSIVE_MAP_BIT); _mask.set(MaterialKey::EMISSIVE_MAP_BIT); return (*this); } + Builder& withEmissiveMap() { _value.set(MaterialKey::EMISSIVE_MAP_BIT); _mask.set(MaterialKey::EMISSIVE_MAP_BIT); return (*this); } + + Builder& withoutDiffuse() { _value.reset(MaterialKey::DIFFUSE_VAL_BIT); _mask.set(MaterialKey::DIFFUSE_VAL_BIT); return (*this); } + Builder& withDiffuse() { _value.set(MaterialKey::DIFFUSE_VAL_BIT); _mask.set(MaterialKey::DIFFUSE_VAL_BIT); return (*this); } + + Builder& withoutDiffuseMap() { _value.reset(MaterialKey::DIFFUSE_MAP_BIT); _mask.set(MaterialKey::DIFFUSE_MAP_BIT); return (*this); } + Builder& withDiffuseMap() { _value.set(MaterialKey::DIFFUSE_MAP_BIT); _mask.set(MaterialKey::DIFFUSE_MAP_BIT); return (*this); } + + Builder& withoutMetallic() { _value.reset(MaterialKey::METALLIC_VAL_BIT); _mask.set(MaterialKey::METALLIC_VAL_BIT); return (*this); } + Builder& withMetallic() { _value.set(MaterialKey::METALLIC_VAL_BIT); _mask.set(MaterialKey::METALLIC_VAL_BIT); return (*this); } + + Builder& withoutMetallicMap() { _value.reset(MaterialKey::METALLIC_MAP_BIT); _mask.set(MaterialKey::METALLIC_MAP_BIT); return (*this); } + Builder& withMetallicMap() { _value.set(MaterialKey::METALLIC_MAP_BIT); _mask.set(MaterialKey::METALLIC_MAP_BIT); return (*this); } + + Builder& withoutGloss() { _value.reset(MaterialKey::GLOSS_VAL_BIT); _mask.set(MaterialKey::GLOSS_VAL_BIT); return (*this); } + Builder& withGloss() { _value.set(MaterialKey::GLOSS_VAL_BIT); _mask.set(MaterialKey::GLOSS_VAL_BIT); return (*this); } + + Builder& withoutGlossMap() { _value.reset(MaterialKey::GLOSS_MAP_BIT); _mask.set(MaterialKey::GLOSS_MAP_BIT); return (*this); } + Builder& withGlossMap() { _value.set(MaterialKey::GLOSS_MAP_BIT); _mask.set(MaterialKey::GLOSS_MAP_BIT); return (*this); } + + Builder& withoutTransparent() { _value.reset(MaterialKey::TRANSPARENT_VAL_BIT); _mask.set(MaterialKey::TRANSPARENT_VAL_BIT); return (*this); } + Builder& withTransparent() { _value.set(MaterialKey::TRANSPARENT_VAL_BIT); _mask.set(MaterialKey::TRANSPARENT_VAL_BIT); return (*this); } + + Builder& withoutTransparentMap() { _value.reset(MaterialKey::TRANSPARENT_MAP_BIT); _mask.set(MaterialKey::TRANSPARENT_MAP_BIT); return (*this); } + Builder& withTransparentMap() { _value.set(MaterialKey::TRANSPARENT_MAP_BIT); _mask.set(MaterialKey::TRANSPARENT_MAP_BIT); return (*this); } + + Builder& withoutNormalMap() { _value.reset(MaterialKey::NORMAL_MAP_BIT); _mask.set(MaterialKey::NORMAL_MAP_BIT); return (*this); } + Builder& withNormalMap() { _value.set(MaterialKey::NORMAL_MAP_BIT); _mask.set(MaterialKey::NORMAL_MAP_BIT); return (*this); } + + // Convenient standard keys that we will keep on using all over the place + static MaterialFilter opaqueDiffuse() { return Builder().withDiffuse().withoutTransparent().build(); } + }; + + // Item Filter operator testing if a key pass the filter + bool test(const MaterialKey& key) const { return (key._flags & _mask) == (_value & _mask); } + + class Less { + public: + bool operator() (const MaterialFilter& left, const MaterialFilter& right) const { + if (left._value.to_ulong() == right._value.to_ulong()) { + return left._mask.to_ulong() < right._mask.to_ulong(); + } else { + return left._value.to_ulong() < right._value.to_ulong(); + } + } + }; +}; + class Material { public: typedef gpu::BufferView UniformBufferView; @@ -30,52 +201,27 @@ public: typedef glm::vec3 Color; - enum MapChannel { - DIFFUSE_MAP = 0, - SPECULAR_MAP, - SHININESS_MAP, - EMISSIVE_MAP, - OPACITY_MAP, - NORMAL_MAP, - - NUM_MAPS, - }; + typedef MaterialKey::MapChannel MapChannel; typedef std::map TextureMap; - typedef std::bitset MapFlags; - - enum FlagBit { - DIFFUSE_BIT = 0, - SPECULAR_BIT, - SHININESS_BIT, - EMISSIVE_BIT, - TRANSPARENT_BIT, - - DIFFUSE_MAP_BIT, - SPECULAR_MAP_BIT, - SHININESS_MAP_BIT, - EMISSIVE_MAP_BIT, - OPACITY_MAP_BIT, - NORMAL_MAP_BIT, - - NUM_FLAGS, - }; - typedef std::bitset Flags; + typedef std::bitset MapFlags; Material(); Material(const Material& material); Material& operator= (const Material& material); virtual ~Material(); + const MaterialKey& getKey() const { return _key; } + const Color& getEmissive() const { return _schemaBuffer.get()._emissive; } const Color& getDiffuse() const { return _schemaBuffer.get()._diffuse; } - const Color& getSpecular() const { return _schemaBuffer.get()._specular; } - float getShininess() const { return _schemaBuffer.get()._shininess; } + float getMetallic() const { return _schemaBuffer.get()._metallic.x; } + float getGloss() const { return _schemaBuffer.get()._gloss; } float getOpacity() const { return _schemaBuffer.get()._opacity; } - void setDiffuse(const Color& diffuse); - void setSpecular(const Color& specular); void setEmissive(const Color& emissive); - void setShininess(float shininess); + void setDiffuse(const Color& diffuse); + void setMetallic(float metallic); + void setGloss(float gloss); void setOpacity(float opacity); // Schema to access the attribute values of the material @@ -84,8 +230,8 @@ public: Color _diffuse{0.5f}; float _opacity{1.f}; - Color _specular{0.03f}; - float _shininess{0.1f}; + Color _metallic{0.03f}; + float _gloss{0.1f}; Color _emissive{0.0f}; float _spare0{0.0f}; glm::vec4 _spareVec4{0.0f}; // for alignment beauty, Material size == Mat4x4 @@ -100,7 +246,7 @@ public: protected: - Flags _flags; + MaterialKey _key; UniformBufferView _schemaBuffer; TextureMap _textureMap; diff --git a/libraries/model/src/model/TextureStorage.h b/libraries/model/src/model/TextureStorage.h index ebc027298b..a6752d21b2 100755 --- a/libraries/model/src/model/TextureStorage.h +++ b/libraries/model/src/model/TextureStorage.h @@ -24,7 +24,7 @@ typedef glm::vec3 Color; class TextureUsage { public: gpu::Texture::Type _type{ gpu::Texture::TEX_2D }; - Material::MapFlags _materialUsage{ Material::DIFFUSE_MAP }; + Material::MapFlags _materialUsage{ MaterialKey::DIFFUSE_MAP }; int _environmentUsage = 0; }; diff --git a/libraries/render-utils/src/Model.cpp b/libraries/render-utils/src/Model.cpp index aadc4bffbe..2be340f405 100644 --- a/libraries/render-utils/src/Model.cpp +++ b/libraries/render-utils/src/Model.cpp @@ -891,6 +891,9 @@ namespace render { return payload->model->renderPart(args, payload->meshIndex, payload->partIndex, false); } } + /* template <> const model::MaterialKey& shapeGetMaterialKey(const OpaqueMeshPart::Pointer& payload) { + return payload->model->getPartMaterial(payload->meshIndex, payload->partIndex); + }*/ } void Model::setVisibleInScene(bool newValue, std::shared_ptr scene) { diff --git a/libraries/render-utils/src/RenderDeferredTask.cpp b/libraries/render-utils/src/RenderDeferredTask.cpp index f9e78c69bb..2568275d4e 100755 --- a/libraries/render-utils/src/RenderDeferredTask.cpp +++ b/libraries/render-utils/src/RenderDeferredTask.cpp @@ -44,7 +44,7 @@ template <> void render::jobRun(const ResolveDeferred& job, const SceneContextPo RenderDeferredTask::RenderDeferredTask() : Task() { _jobs.push_back(Job(PrepareDeferred())); _jobs.push_back(Job(DrawBackground())); - _jobs.push_back(Job(DrawOpaque())); + _jobs.push_back(Job(DrawOpaqueDeferred())); _jobs.push_back(Job(DrawLight())); _jobs.push_back(Job(ResetGLState())); _jobs.push_back(Job(RenderDeferred())); @@ -78,6 +78,84 @@ void RenderDeferredTask::run(const SceneContextPointer& sceneContext, const Rend +template <> void render::jobRun(const DrawOpaqueDeferred& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) { + PerformanceTimer perfTimer("DrawOpaqueDeferred"); + assert(renderContext->args); + assert(renderContext->args->_viewFrustum); + + // render opaques + auto& scene = sceneContext->_scene; + auto& items = scene->getMasterBucket().at(ItemFilter::Builder::opaqueShape()); + auto& renderDetails = renderContext->args->_details; + + ItemIDsBounds inItems; + inItems.reserve(items.size()); + for (auto id : items) { + inItems.emplace_back(ItemIDAndBounds(id)); + } + ItemIDsBounds& renderedItems = inItems; + + renderContext->_numFeedOpaqueItems = renderedItems.size(); + + ItemIDsBounds culledItems; + culledItems.reserve(inItems.size()); + if (renderContext->_cullOpaque) { + renderDetails.pointTo(RenderDetails::OPAQUE_ITEM); + cullItems(sceneContext, renderContext, renderedItems, culledItems); + renderDetails.pointTo(RenderDetails::OTHER_ITEM); + renderedItems = culledItems; + } + + renderContext->_numDrawnOpaqueItems = renderedItems.size(); + + + ItemIDsBounds sortedItems; + sortedItems.reserve(culledItems.size()); + if (renderContext->_sortOpaque) { + depthSortItems(sceneContext, renderContext, true, renderedItems, sortedItems); // Sort Front to back opaque items! + renderedItems = sortedItems; + } + + // ItemIDsBounds sortedItems; + ItemMaterialBucketMap stateSortedItems; + stateSortedItems.allocateStandardMaterialBuckets(); + if (true) { + for (auto& itemIDAndBound : renderedItems) { + stateSortedItems.insert(itemIDAndBound.id, scene->getItem(itemIDAndBound.id).getMaterialKey()); + } + } + + + if (renderContext->_renderOpaque) { + RenderArgs* args = renderContext->args; + gpu::Batch batch; + args->_batch = &batch; + + glm::mat4 projMat; + Transform viewMat; + args->_viewFrustum->evalProjectionMatrix(projMat); + args->_viewFrustum->evalViewTransform(viewMat); + batch.setProjectionTransform(projMat); + batch.setViewTransform(viewMat); + + renderContext->args->_renderMode = RenderArgs::NORMAL_RENDER_MODE; + { + GLenum buffers[3]; + int bufferCount = 0; + buffers[bufferCount++] = GL_COLOR_ATTACHMENT0; + buffers[bufferCount++] = GL_COLOR_ATTACHMENT1; + buffers[bufferCount++] = GL_COLOR_ATTACHMENT2; + batch._glDrawBuffers(bufferCount, buffers); + } + + renderItems(sceneContext, renderContext, renderedItems, renderContext->_maxDrawnOpaqueItems); + + args->_context->render((*args->_batch)); + args->_batch = nullptr; + } +} + + template <> void render::jobRun(const DrawTransparentDeferred& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) { PerformanceTimer perfTimer("DrawTransparentDeferred"); assert(renderContext->args); diff --git a/libraries/render-utils/src/RenderDeferredTask.h b/libraries/render-utils/src/RenderDeferredTask.h index 17971dbfac..e2cac53c0d 100755 --- a/libraries/render-utils/src/RenderDeferredTask.h +++ b/libraries/render-utils/src/RenderDeferredTask.h @@ -35,6 +35,14 @@ namespace render { template <> void jobRun(const ResolveDeferred& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext); } + +class DrawOpaqueDeferred { +public: +}; +namespace render { +template <> void jobRun(const DrawOpaqueDeferred& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext); +} + class DrawTransparentDeferred { public: }; diff --git a/libraries/render/src/render/DrawTask.cpp b/libraries/render/src/render/DrawTask.cpp index e58b92aafa..dd4f8f8aab 100755 --- a/libraries/render/src/render/DrawTask.cpp +++ b/libraries/render/src/render/DrawTask.cpp @@ -445,3 +445,18 @@ template <> void render::jobRun(const DrawBackground& job, const SceneContextPoi // Force the context sync args->_context->syncCache(); } + + + +void ItemMaterialBucketMap::insert(const ItemID& id, const model::MaterialKey& key) { + // Insert the itemID in every bucket where it filters true + for (auto& bucket : (*this)) { + if (bucket.first.test(key)) { + bucket.second.push_back(id); + } + } +} + +void ItemMaterialBucketMap::allocateStandardMaterialBuckets() { + (*this)[model::MaterialFilter::Builder::opaqueDiffuse()]; +} diff --git a/libraries/render/src/render/DrawTask.h b/libraries/render/src/render/DrawTask.h index 687287cd56..1f260583f2 100755 --- a/libraries/render/src/render/DrawTask.h +++ b/libraries/render/src/render/DrawTask.h @@ -62,6 +62,10 @@ void depthSortItems(const SceneContextPointer& sceneContext, const RenderContext void renderItems(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext, const ItemIDsBounds& inItems, int maxDrawnItems = -1); + +void materialSortItems(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext, const ItemIDsBounds& inItems, ItemIDsBounds& outItems); + + class DrawOpaque { public: }; @@ -101,6 +105,20 @@ public: }; + +// A map of ItemIDs allowing to create bucket lists of SHAPE type items which are filtered by their +// Material +class ItemMaterialBucketMap : public std::map { +public: + + ItemMaterialBucketMap() {} + + void insert(const ItemID& id, const model::MaterialKey& key); + + // standard builders allocating the main buckets + void allocateStandardMaterialBuckets(); +}; + } #endif // hifi_render_Task_h diff --git a/libraries/render/src/render/Scene.h b/libraries/render/src/render/Scene.h index 054fbeb602..6f116d7d47 100644 --- a/libraries/render/src/render/Scene.h +++ b/libraries/render/src/render/Scene.h @@ -24,6 +24,8 @@ #include #include +#include "model/Material.h" + namespace render { class Context; @@ -216,6 +218,8 @@ public: virtual void update(const UpdateFunctorPointer& functor) = 0; + virtual const model::MaterialKey& getMaterialKey() const = 0; + ~PayloadInterface() {} protected: }; @@ -240,6 +244,9 @@ public: void render(RenderArgs* args) { _payload->render(args); } void update(const UpdateFunctorPointer& updateFunctor) { _payload->update(updateFunctor); } + // Shape Type Interface + const model::MaterialKey& getMaterialKey() const { return _payload->getMaterialKey(); } + protected: PayloadPointer _payload; ItemKey _key; @@ -275,16 +282,23 @@ template const ItemKey payloadGetKey(const std::shared_ptr& payload template const Item::Bound payloadGetBound(const std::shared_ptr& payloadData) { return Item::Bound(); } template void payloadRender(const std::shared_ptr& payloadData, RenderArgs* args) { } +// Shape type interface +template const model::MaterialKey& shapeGetMaterialKey(const std::shared_ptr& payloadData) { return model::MaterialKey(); } + template class Payload : public Item::PayloadInterface { public: typedef std::shared_ptr DataPointer; typedef UpdateFunctor Updater; + virtual void update(const UpdateFunctorPointer& functor) { static_cast(functor.get())->_func((*_data)); } + + // Payload general interface virtual const ItemKey getKey() const { return payloadGetKey(_data); } virtual const Item::Bound getBound() const { return payloadGetBound(_data); } - virtual void render(RenderArgs* args) { payloadRender(_data, args); } - - virtual void update(const UpdateFunctorPointer& functor) { static_cast(functor.get())->_func((*_data)); } + virtual void render(RenderArgs* args) { payloadRender(_data, args); } + + // Shape Type interface + virtual const model::MaterialKey& getMaterialKey() const { return shapeGetMaterialKey(_data); } Payload(const DataPointer& data) : _data(data) {} protected: