Merge pull request #805 from HifiExperiments/mtoon

MToon materials

libraries/entities-renderer/src/RenderableEntityItem.cpp

@@ -4,6 +4,7 @@
 //
 //  Created by Brad Hefta-Gaub on 12/6/13.
 //  Copyright 2013 High Fidelity, Inc.
+//  Copyright 2024 Overte e.V.
 //
 //  Distributed under the Apache License, Version 2.0.
 //  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
@@ -196,6 +197,8 @@ ItemKey EntityRenderer::getKey() {
         builder.withInvisible();
     }
 
+    updateItemKeyBuilderFromMaterials(builder);
+
     return builder;
 }
 
@@ -221,6 +224,20 @@ bool EntityRenderer::passesZoneOcclusionTest(const std::unordered_set<QUuid>& co
     return true;
 }
 
+HighlightStyle EntityRenderer::getOutlineStyle(const ViewFrustum& viewFrustum, const size_t height) const {
+    std::lock_guard<std::mutex> lock(_materialsLock);
+    auto materials = _materials.find("0");
+    if (materials != _materials.end()) {
+        glm::vec3 position;
+        withReadLock([&] {
+            position = _renderTransform.getTranslation();
+        });
+        return HighlightStyle::calculateOutlineStyle(materials->second.getOutlineWidthMode(), materials->second.getOutlineWidth(),
+                                                     materials->second.getOutline(), position, viewFrustum, height);
+    }
+    return HighlightStyle();
+}
+
 void EntityRenderer::render(RenderArgs* args) {
     if (!isValidRenderItem()) {
         return;
@@ -510,7 +527,7 @@ EntityRenderer::Pipeline EntityRenderer::getPipelineType(const graphics::MultiMa
     }
 
     graphics::MaterialKey drawMaterialKey = materials.getMaterialKey();
-    if (drawMaterialKey.isEmissive() || drawMaterialKey.isMetallic() || drawMaterialKey.isScattering()) {
+    if (materials.isMToon() || drawMaterialKey.isEmissive() || drawMaterialKey.isMetallic() || drawMaterialKey.isScattering()) {
         return Pipeline::MATERIAL;
     }
 
@@ -630,6 +647,26 @@ Item::Bound EntityRenderer::getMaterialBound(RenderArgs* args) {
     return EntityRenderer::getBound(args);
 }
 
+void EntityRenderer::updateItemKeyBuilderFromMaterials(ItemKey::Builder& builder) {
+    MaterialMap::iterator materials;
+    {
+        std::lock_guard<std::mutex> lock(_materialsLock);
+        materials = _materials.find("0");
+
+        if (materials != _materials.end()) {
+            if (materials->second.shouldUpdate()) {
+                RenderPipelines::updateMultiMaterial(materials->second);
+            }
+        } else {
+            return;
+        }
+    }
+
+    if (materials->second.hasOutline()) {
+        builder.withOutline();
+    }
+}
+
 void EntityRenderer::updateShapeKeyBuilderFromMaterials(ShapeKey::Builder& builder) {
     MaterialMap::iterator materials;
     {
@@ -656,7 +693,7 @@ void EntityRenderer::updateShapeKeyBuilderFromMaterials(ShapeKey::Builder& build
     builder.withCullFaceMode(materials->second.getCullFaceMode());
 
     graphics::MaterialKey drawMaterialKey = materials->second.getMaterialKey();
-    if (drawMaterialKey.isUnlit()) {
+    if (!materials->second.isMToon() && drawMaterialKey.isUnlit()) {
         builder.withUnlit();
     }
 
@@ -666,8 +703,12 @@ void EntityRenderer::updateShapeKeyBuilderFromMaterials(ShapeKey::Builder& build
         if (drawMaterialKey.isNormalMap()) {
             builder.withTangents();
         }
-        if (drawMaterialKey.isLightMap()) {
-            builder.withLightMap();
+        if (!materials->second.isMToon()) {
+            if (drawMaterialKey.isLightMap()) {
+                builder.withLightMap();
+            }
+        } else {
+            builder.withMToon();
         }
     } else if (pipelineType == Pipeline::PROCEDURAL) {
         builder.withOwnPipeline();

libraries/entities-renderer/src/RenderableEntityItem.h

@@ -4,6 +4,7 @@
 //
 //  Created by Brad Hefta-Gaub on 12/6/13.
 //  Copyright 2013 High Fidelity, Inc.
+//  Copyright 2024 Overte e.V.
 //
 //  Distributed under the Apache License, Version 2.0.
 //  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
@@ -13,6 +14,8 @@
 #define hifi_RenderableEntityItem_h
 
 #include <render/Scene.h>
+#include <render/HighlightStyle.h>
+
 #include <EntityItem.h>
 #include <Sound.h>
 #include "AbstractViewStateInterface.h"
@@ -74,6 +77,7 @@ class EntityRenderer : public QObject, public std::enable_shared_from_this<Entit
     virtual uint32_t metaFetchMetaSubItems(ItemIDs& subItems) const override;
     virtual Item::Bound getBound(RenderArgs* args) override;
     bool passesZoneOcclusionTest(const std::unordered_set<QUuid>& containingZones) const override;
+    virtual HighlightStyle getOutlineStyle(const ViewFrustum& viewFrustum, const size_t height) const override;
 
 protected:
     virtual bool needsRenderUpdateFromEntity() const final { return needsRenderUpdateFromEntity(_entity); }
@@ -131,6 +135,7 @@ class EntityRenderer : public QObject, public std::enable_shared_from_this<Entit
     void updateMaterials(bool baseMaterialChanged = false);
     bool materialsTransparent() const;
     Item::Bound getMaterialBound(RenderArgs* args);
+    void updateItemKeyBuilderFromMaterials(ItemKey::Builder& builder);
     void updateShapeKeyBuilderFromMaterials(ShapeKey::Builder& builder);
 
     Item::Bound _bound;

libraries/entities-renderer/src/RenderableImageEntityItem.cpp

@@ -130,8 +130,7 @@ void ImageEntityRenderer::doRender(RenderArgs* args) {
         materials = _materials["0"];
     }
 
-    auto& schema = materials.getSchemaBuffer().get<graphics::MultiMaterial::Schema>();
-    glm::vec4 color = glm::vec4(ColorUtils::tosRGBVec3(schema._albedo), schema._opacity);
+    glm::vec4 color = materials.getColor();
     color = EntityRenderer::calculatePulseColor(color, _pulseProperties, _created);
 
     if (!_texture || !_texture->isLoaded() || color.a == 0.0f) {

libraries/entities-renderer/src/RenderableMaterialEntityItem.cpp

@@ -1,6 +1,7 @@
 //
 //  Created by Sam Gondelman on 1/18/2018
 //  Copyright 2018 High Fidelity, Inc.
+//  Copyright 2024 Overte e.V.
 //
 //  Distributed under the Apache License, Version 2.0.
 //  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
@@ -219,7 +220,7 @@ void MaterialEntityRenderer::doRenderUpdateAsynchronousTyped(const TypedEntityPo
 ItemKey MaterialEntityRenderer::getKey() {
     auto builder = ItemKey::Builder().withTypeShape().withTagBits(getTagMask()).withLayer(getHifiRenderLayer());
 
-    if (!_visible) {
+    if (!_visible || !_parentID.isNull()) {
         builder.withInvisible();
     }
 
@@ -229,6 +230,10 @@ ItemKey MaterialEntityRenderer::getKey() {
         if (matKey.isTranslucent()) {
             builder.withTransparent();
         }
+
+        if (drawMaterial->getOutlineWidthMode() != NetworkMToonMaterial::OutlineWidthMode::OUTLINE_NONE && drawMaterial->getOutlineWidth() > 0.0f) {
+            builder.withOutline();
+        }
     }
 
     return builder.build();
@@ -258,11 +263,16 @@ ShapeKey MaterialEntityRenderer::getShapeKey() {
         if (drawMaterialKey.isNormalMap()) {
             builder.withTangents();
         }
-        if (drawMaterialKey.isLightMap()) {
-            builder.withLightMap();
-        }
-        if (drawMaterialKey.isUnlit()) {
-            builder.withUnlit();
+
+        if (drawMaterial && drawMaterial->isMToon()) {
+            builder.withMToon();
+        } else {
+            if (drawMaterialKey.isLightMap()) {
+                builder.withLightMap();
+            }
+            if (drawMaterialKey.isUnlit()) {
+                builder.withUnlit();
+            }
         }
     }
 
@@ -273,6 +283,18 @@ ShapeKey MaterialEntityRenderer::getShapeKey() {
     return builder.build();
 }
 
+HighlightStyle MaterialEntityRenderer::getOutlineStyle(const ViewFrustum& viewFrustum, const size_t height) const {
+    if (const auto drawMaterial = getMaterial()) {
+        glm::vec3 position;
+        withReadLock([&] {
+            position = _renderTransform.getTranslation();
+        });
+        return HighlightStyle::calculateOutlineStyle(drawMaterial->getOutlineWidthMode(), drawMaterial->getOutlineWidth(),
+                                                     drawMaterial->getOutline(), position, viewFrustum, height);
+    }
+    return HighlightStyle();
+}
+
 void MaterialEntityRenderer::doRender(RenderArgs* args) {
     PerformanceTimer perfTimer("RenderableMaterialEntityItem::render");
     Q_ASSERT(args->_batch);

libraries/entities-renderer/src/RenderableMaterialEntityItem.h

@@ -1,6 +1,7 @@
 //
 //  Created by Sam Gondelman on 1/18/2018
 //  Copyright 2018 High Fidelity, Inc.
+//  Copyright 2024 Overte e.V.
 //
 //  Distributed under the Apache License, Version 2.0.
 //  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
@@ -32,6 +33,7 @@ class MaterialEntityRenderer : public TypedEntityRenderer<MaterialEntityItem> {
     virtual void doRenderUpdateSynchronousTyped(const ScenePointer& scene, Transaction& transaction, const TypedEntityPointer& entity) override;
     virtual void doRenderUpdateAsynchronousTyped(const TypedEntityPointer& entity) override;
     virtual void doRender(RenderArgs* args) override;
+    virtual HighlightStyle getOutlineStyle(const ViewFrustum& viewFrustum, const size_t height) const override;
 
     ItemKey getKey() override;
     ShapeKey getShapeKey() override;

libraries/entities-renderer/src/RenderableShapeEntityItem.cpp

@@ -99,8 +99,7 @@ void ShapeEntityRenderer::doRender(RenderArgs* args) {
         materials = _materials["0"];
     }
 
-    auto& schema = materials.getSchemaBuffer().get<graphics::MultiMaterial::Schema>();
-    glm::vec4 outColor = glm::vec4(ColorUtils::tosRGBVec3(schema._albedo), schema._opacity);
+    glm::vec4 outColor = materials.getColor();
     outColor = EntityRenderer::calculatePulseColor(outColor, _pulseProperties, _created);
 
     if (outColor.a == 0.0f) {
@@ -178,7 +177,7 @@ scriptable::ScriptableModelBase ShapeEntityRenderer::getScriptableModel()  {
         result.appendMaterials(_materials);
         auto materials = _materials.find("0");
         if (materials != _materials.end()) {
-            vertexColor = ColorUtils::tosRGBVec3(materials->second.getSchemaBuffer().get<graphics::MultiMaterial::Schema>()._albedo);
+            vertexColor = materials->second.getColor();
         }
     }
     if (auto mesh = geometryCache->meshFromShape(geometryShape, vertexColor)) {

libraries/entities-renderer/src/RenderableTextEntityItem.cpp

@@ -147,8 +147,7 @@ void TextEntityRenderer::doRender(RenderArgs* args) {
         materials = _materials["0"];
     }
 
-    auto& schema = materials.getSchemaBuffer().get<graphics::MultiMaterial::Schema>();
-    glm::vec4 backgroundColor = glm::vec4(ColorUtils::tosRGBVec3(schema._albedo), schema._opacity);
+    glm::vec4 backgroundColor = materials.getColor();
     backgroundColor = EntityRenderer::calculatePulseColor(backgroundColor, _pulseProperties, _created);
 
     if (backgroundColor.a <= 0.0f) {

libraries/graphics-scripting/src/graphics-scripting/Forward.h

@@ -52,43 +52,63 @@ namespace scriptable {
         ScriptableMaterial(const ScriptableMaterial& material) { *this = material; }
         ScriptableMaterial& operator=(const ScriptableMaterial& material);
 
-        QString name;
-        QString model;
-        float opacity;
-        float roughness;
-        float metallic;
-        float scattering;
-        bool unlit;
-        glm::vec3 emissive;
-        glm::vec3 albedo;
-        QString emissiveMap;
-        QString albedoMap;
-        QString opacityMap;
-        QString opacityMapMode;
-        float opacityCutoff;
-        QString metallicMap;
-        QString specularMap;
-        QString roughnessMap;
-        QString glossMap;
-        QString normalMap;
-        QString bumpMap;
-        QString occlusionMap;
-        QString lightMap;
-        QString scatteringMap;
+        QString name { "" };
+        QString model { "" };
+        float opacity { 0.0f };
+        float roughness { 0.0f };
+        float metallic { 0.0f };
+        float scattering { 0.0f };
+        bool unlit { false };
+        glm::vec3 emissive { 0.0f };
+        glm::vec3 albedo { 0.0f };
+        QString emissiveMap { "" };
+        QString albedoMap { "" };
+        QString opacityMap { "" };
+        QString opacityMapMode { "" };
+        float opacityCutoff { 0.0f };
+        QString metallicMap { "" };
+        QString specularMap { "" };
+        QString roughnessMap { "" };
+        QString glossMap { "" };
+        QString normalMap { "" };
+        QString bumpMap { "" };
+        QString occlusionMap { "" };
+        QString lightMap { "" };
+        QString scatteringMap { "" };
         std::array<glm::mat4, graphics::Material::NUM_TEXCOORD_TRANSFORMS> texCoordTransforms;
-        QString cullFaceMode;
-        bool defaultFallthrough;
+        QString cullFaceMode { "" };
+        bool defaultFallthrough { false };
         std::unordered_map<uint, bool> propertyFallthroughs; // not actually exposed to script
 
-        QString procedural;
+        QString procedural { "" };
+
+        glm::vec3 shade { 0.0f };
+        QString shadeMap { "" };
+        float shadingShift { 0.0f };
+        QString shadingShiftMap { "" };
+        float shadingToony { 0.0f };
+        glm::vec3 matcap { 0.0f };
+        QString matcapMap { "" };
+        glm::vec3 parametricRim { 0.0f };
+        float parametricRimFresnelPower { 0.0f };
+        float parametricRimLift { 0.0f };
+        QString rimMap { "" };
+        float rimLightingMix { 0.0f };
+        QString outlineWidthMode { "" };
+        float outlineWidth { 0.0f };
+        glm::vec3 outline { 0.0f };
+        QString uvAnimationMaskMap { "" };
+        float uvAnimationScrollXSpeed { 0.0f };
+        float uvAnimationScrollYSpeed { 0.0f };
+        float uvAnimationRotationSpeed { 0.0f };
 
         graphics::MaterialKey key { 0 };
     };
 
     /*@jsdoc
      * A material layer.
      * @typedef {object} Graphics.MaterialLayer
-     * @property {Graphics.Material} material - The layer's material.
+     * @property {Entities.Material} material - The layer's material.
      * @property {number} priority - The priority of the layer. If multiple materials are applied to a mesh part, only the 
      *     layer with the highest priority is applied, with materials of the same priority randomly assigned.
      */