All material objects.

src/brayns/core/objects/MaterialObjects.cpp

@@ -21,8 +21,6 @@
 
 #include "MaterialObjects.h"
 
-#include "common/Objects.h"
-
 namespace
 {
 using namespace brayns;
@@ -79,60 +77,157 @@ MaterialField<T> storeAndGet(ObjectManager &objects, std::vector<Stored<UserText
     return std::visit([&](const auto &value) { return storeAndGet(objects, textures, value); }, params);
 }
 
-AoMaterialSettings storeTexturesAndGetSettings(ObjectManager &objects, std::vector<Stored<UserTexture>> &textures, const AoMaterialParams &params)
+AoMaterialSettings parseSettings(ObjectManager &objects, std::vector<Stored<UserTexture>> &textures, const AoMaterialParams &params)
 {
     return {
         .diffuse = storeAndGet(objects, textures, params.diffuse),
         .opacity = storeAndGet(objects, textures, params.opacity),
     };
 }
+
+ScivisMaterialSettings parseSettings(ObjectManager &objects, std::vector<Stored<UserTexture>> &textures, const ScivisMaterialParams &params)
+{
+    return {
+        .diffuse = storeAndGet(objects, textures, params.diffuse),
+        .opacity = storeAndGet(objects, textures, params.opacity),
+        .specular = storeAndGet(objects, textures, params.specular),
+        .shininess = storeAndGet(objects, textures, params.shininess),
+        .transparencyFilter = params.transparencyFilter,
+    };
 }
 
-namespace brayns
+PrincipledMaterialSettings parseSettings(ObjectManager &objects, std::vector<Stored<UserTexture>> &textures, const PrincipledMaterialParams &params)
 {
-CreateObjectResult createAoMaterial(ObjectManager &objects, Device &device, CreateAoMaterialParams params)
+    return {
+        .baseColor = storeAndGet(objects, textures, params.baseColor),
+        .edgeColor = storeAndGet(objects, textures, params.edgeColor),
+        .metallic = storeAndGet(objects, textures, params.metallic),
+        .diffuse = storeAndGet(objects, textures, params.diffuse),
+        .specular = storeAndGet(objects, textures, params.specular),
+        .ior = storeAndGet(objects, textures, params.ior),
+        .transmission = storeAndGet(objects, textures, params.transmission),
+        .transmissionColor = storeAndGet(objects, textures, params.transmissionColor),
+        .transmissionDepth = storeAndGet(objects, textures, params.transmissionDepth),
+        .roughness = storeAndGet(objects, textures, params.roughness),
+        .anisotropy = storeAndGet(objects, textures, params.anisotropy),
+        .rotation = storeAndGet(objects, textures, params.rotation),
+        .normal = storeAndGet(objects, textures, params.normal),
+        .baseNormal = storeAndGet(objects, textures, params.baseNormal),
+        .thin = params.thin,
+        .thickness = storeAndGet(objects, textures, params.thickness),
+        .backlight = storeAndGet(objects, textures, params.backlight),
+        .coat = storeAndGet(objects, textures, params.coat),
+        .coatIor = storeAndGet(objects, textures, params.coatIor),
+        .coatColor = storeAndGet(objects, textures, params.coatColor),
+        .coatThickness = storeAndGet(objects, textures, params.coatThickness),
+        .coatRoughness = storeAndGet(objects, textures, params.coatRoughness),
+        .coatNormal = storeAndGet(objects, textures, params.coatNormal),
+        .sheen = storeAndGet(objects, textures, params.sheen),
+        .sheenColor = storeAndGet(objects, textures, params.sheenColor),
+        .sheenTint = storeAndGet(objects, textures, params.sheenTint),
+        .sheenRoughness = storeAndGet(objects, textures, params.sheenRoughness),
+        .opacity = storeAndGet(objects, textures, params.opacity),
+        .emissiveColor = storeAndGet(objects, textures, params.emissiveColor),
+    };
+}
+
+template<typename T>
+CreateObjectResult createMaterialAs(ObjectManager &objects, Device &device, const auto &params, auto create, std::string name)
 {
-    auto &[base, derived] = params;
+    const auto &[base, derived] = params;
 
     auto textures = std::vector<Stored<UserTexture>>();
 
-    auto settings = storeTexturesAndGetSettings(objects, textures, derived);
+    auto settings = parseSettings(objects, textures, derived);
 
-    auto material = createAoMaterial(device, settings);
+    auto material = create(device, settings);
 
-    auto ptr = toShared(UserAoMaterial{std::move(derived), std::move(material), std::move(textures)});
+    auto ptr = toShared(T{derived, std::move(material), std::move(textures)});
 
     auto object = UserMaterial{
         .value = ptr,
         .get = [=] { return ptr->value; },
     };
 
-    auto stored = objects.add(std::move(object), {"AoMaterial"}, std::move(base));
+    auto stored = objects.add(std::move(object), {std::move(name)}, std::move(base));
 
     return getResult(stored);
 }
 
-GetAoMaterialResult getAoMaterial(ObjectManager &objects, const GetObjectParams &params)
+template<typename T>
+auto getMaterialAs(ObjectManager &objects, const GetObjectParams &params)
 {
     auto stored = objects.getAsStored<UserMaterial>(params.id);
-    auto &material = *castAsShared<UserAoMaterial>(stored.get().value, stored);
+    auto &material = *castAsShared<T>(stored.get().value, stored);
     return getResult(material.settings);
 }
 
-void updateAoMaterial(ObjectManager &objects, Device &device, const UpdateAoMaterialParams &params)
+template<typename T>
+void updateMaterialAs(ObjectManager &objects, Device &device, const auto &params)
 {
     auto stored = objects.getAsStored<UserMaterial>(params.id);
-    auto &material = *castAsShared<UserAoMaterial>(stored.get().value, stored);
+    auto &material = *castAsShared<T>(stored.get().value, stored);
 
     auto updated = getUpdatedParams(params, material.settings);
 
     auto textures = std::vector<Stored<UserTexture>>();
 
-    auto settings = storeTexturesAndGetSettings(objects, textures, updated);
+    auto settings = parseSettings(objects, textures, updated);
 
     material.value.update(settings);
     device.throwIfError();
 
     material.settings = std::move(updated);
 }
 }
+
+namespace brayns
+{
+CreateObjectResult createAoMaterial(ObjectManager &objects, Device &device, const CreateAoMaterialParams &params)
+{
+    auto create = [](auto &device, const auto &settings) { return createAoMaterial(device, settings); };
+    return createMaterialAs<UserAoMaterial>(objects, device, params, create, "AoMaterial");
+}
+
+GetAoMaterialResult getAoMaterial(ObjectManager &objects, const GetObjectParams &params)
+{
+    return getMaterialAs<UserAoMaterial>(objects, params);
+}
+
+void updateAoMaterial(ObjectManager &objects, Device &device, const UpdateAoMaterialParams &params)
+{
+    updateMaterialAs<UserAoMaterial>(objects, device, params);
+}
+
+CreateObjectResult createScivisMaterial(ObjectManager &objects, Device &device, const CreateScivisMaterialParams &params)
+{
+    auto create = [](auto &device, const auto &settings) { return createScivisMaterial(device, settings); };
+    return createMaterialAs<UserScivisMaterial>(objects, device, params, create, "ScivisMaterial");
+}
+
+GetScivisMaterialResult getScivisMaterial(ObjectManager &objects, const GetObjectParams &params)
+{
+    return getMaterialAs<UserScivisMaterial>(objects, params);
+}
+
+void updateScivisMaterial(ObjectManager &objects, Device &device, const UpdateScivisMaterialParams &params)
+{
+    updateMaterialAs<UserScivisMaterial>(objects, device, params);
+}
+
+CreateObjectResult createPrincipledMaterial(ObjectManager &objects, Device &device, const CreatePrincipledMaterialParams &params)
+{
+    auto create = [](auto &device, const auto &settings) { return createPrincipledMaterial(device, settings); };
+    return createMaterialAs<UserPrincipledMaterial>(objects, device, params, create, "PrincipledMaterial");
+}
+
+GetPrincipledMaterialResult getPrincipledMaterial(ObjectManager &objects, const GetObjectParams &params)
+{
+    return getMaterialAs<UserPrincipledMaterial>(objects, params);
+}
+
+void updatePrincipledMaterial(ObjectManager &objects, Device &device, const UpdatePrincipledMaterialParams &params)
+{
+    updateMaterialAs<UserPrincipledMaterial>(objects, device, params);
+}
+}

src/brayns/core/objects/MaterialObjects.h

@@ -132,7 +132,150 @@ using GetAoMaterialResult = GetResultOf<AoMaterialParams>;
 using UpdateAoMaterialParams = UpdateParamsOf<AoMaterialParams>;
 using UserAoMaterial = UserMaterialOf<AoMaterialParams, AoMaterial>;
 
-CreateObjectResult createAoMaterial(ObjectManager &objects, Device &device, CreateAoMaterialParams params);
+CreateObjectResult createAoMaterial(ObjectManager &objects, Device &device, const CreateAoMaterialParams &params);
 GetAoMaterialResult getAoMaterial(ObjectManager &objects, const GetObjectParams &params);
 void updateAoMaterial(ObjectManager &objects, Device &device, const UpdateAoMaterialParams &params);
+
+struct ScivisMaterialParams
+{
+    MaterialParams<Color3> diffuse;
+    MaterialParams<float> opacity;
+    MaterialParams<Color3> specular;
+    MaterialParams<float> shininess;
+    Color3 transparencyFilter;
+};
+
+template<>
+struct JsonObjectReflector<ScivisMaterialParams>
+{
+    static auto reflect()
+    {
+        auto builder = JsonBuilder<ScivisMaterialParams>();
+        builder.field("diffuse", [](auto &object) { return &object.diffuse; }).description("Diffuse color").defaultValue(Color3{0.8F, 0.8F, 0.8F});
+        builder.field("opacity", [](auto &object) { return &object.opacity; }).description("Opacity").defaultValue(1.0F);
+        builder.field("specular", [](auto &object) { return &object.specular; }).description("Specular color").defaultValue(Color3{0.0F, 0.0F, 0.0F});
+        builder.field("shininess", [](auto &object) { return &object.shininess; }).description("Phong exponent").defaultValue(10);
+        builder.field("transparencyFilter", [](auto &object) { return &object.transparencyFilter; })
+            .description("Transparency filter")
+            .defaultValue(Color3{0.0F, 0.0F, 0.0F});
+        return builder.build();
+    }
+};
+
+using CreateScivisMaterialParams = CreateParamsOf<ScivisMaterialParams>;
+using GetScivisMaterialResult = GetResultOf<ScivisMaterialParams>;
+using UpdateScivisMaterialParams = UpdateParamsOf<ScivisMaterialParams>;
+using UserScivisMaterial = UserMaterialOf<ScivisMaterialParams, ScivisMaterial>;
+
+CreateObjectResult createScivisMaterial(ObjectManager &objects, Device &device, const CreateScivisMaterialParams &params);
+GetScivisMaterialResult getScivisMaterial(ObjectManager &objects, const GetObjectParams &params);
+void updateScivisMaterial(ObjectManager &objects, Device &device, const UpdateScivisMaterialParams &params);
+
+struct PrincipledMaterialParams
+{
+    MaterialParams<Color3> baseColor;
+    MaterialParams<Color3> edgeColor;
+    MaterialParams<float> metallic;
+    MaterialParams<float> diffuse;
+    MaterialParams<float> specular;
+    MaterialParams<float> ior;
+    MaterialParams<float> transmission;
+    MaterialParams<Color3> transmissionColor;
+    MaterialParams<float> transmissionDepth;
+    MaterialParams<float> roughness;
+    MaterialParams<float> anisotropy;
+    MaterialParams<float> rotation;
+    MaterialParams<float> normal;
+    MaterialParams<float> baseNormal;
+    bool thin;
+    MaterialParams<float> thickness;
+    MaterialParams<float> backlight;
+    MaterialParams<float> coat;
+    MaterialParams<float> coatIor;
+    MaterialParams<Color3> coatColor;
+    MaterialParams<float> coatThickness;
+    MaterialParams<float> coatRoughness;
+    MaterialParams<float> coatNormal;
+    MaterialParams<float> sheen;
+    MaterialParams<Color3> sheenColor;
+    MaterialParams<float> sheenTint;
+    MaterialParams<float> sheenRoughness;
+    MaterialParams<float> opacity;
+    MaterialParams<Color3> emissiveColor;
+};
+
+template<>
+struct JsonObjectReflector<PrincipledMaterialParams>
+{
+    static auto reflect()
+    {
+        auto builder = JsonBuilder<PrincipledMaterialParams>();
+        builder.field("baseColor", [](auto &object) { return &object.baseColor; })
+            .description("Base color, linear RGB")
+            .defaultValue(Color3{0.8F, 0.8F, 0.8F});
+        builder.field("edgeColor", [](auto &object) { return &object.edgeColor; })
+            .description("Edge color, linear RGB, metallic only")
+            .defaultValue(Color3{1.0F, 1.0F, 1.0F});
+        builder.field("metallic", [](auto &object) { return &object.metallic; })
+            .description("Mix between dielectric and metallic (1 = full metal)")
+            .defaultValue(0.0F);
+        builder.field("diffuse", [](auto &object) { return &object.diffuse; }).description("Diffuse reflection weight").defaultValue(1.0F);
+        builder.field("specular", [](auto &object) { return &object.specular; }).description("Specular reflection weight").defaultValue(1.0F);
+        builder.field("ior", [](auto &object) { return &object.ior; }).description("Index of refraction").defaultValue(1.0F);
+        builder.field("transmission", [](auto &object) { return &object.transmission; })
+            .description("Specular transmission weight")
+            .defaultValue(0.0F);
+        builder.field("transmissionColor", [](auto &object) { return &object.transmissionColor; })
+            .description("Attenuated color due to transmission")
+            .defaultValue(Color3{1.0F, 1.0F, 1.0F});
+        builder.field("transmissionDepth", [](auto &object) { return &object.transmissionDepth; })
+            .description("Distance at which color attenuation is transmissionColor")
+            .defaultValue(1.0F);
+        builder.field("roughness", [](auto &object) { return &object.roughness; })
+            .description("Diffuse and specular roughness (0 = smooth)")
+            .defaultValue(0.0F);
+        builder.field("anisotropy", [](auto &object) { return &object.anisotropy; }).description("Specular anisotropy").defaultValue(0.0F);
+        builder.field("rotation", [](auto &object) { return &object.rotation; })
+            .description("Rotation of anisotropy direction (1 = full circle)")
+            .defaultValue(0.0F);
+        builder.field("normal", [](auto &object) { return &object.normal; }).description("Normal map").defaultValue(1.0F);
+        builder.field("baseNormal", [](auto &object) { return &object.baseNormal; }).description("Overrides default normal").defaultValue(1.0F);
+        builder.field("thin", [](auto &object) { return &object.thin; })
+            .description("")
+            .description("Wether the material is thin or solid")
+            .defaultValue(false);
+        builder.field("thickness", [](auto &object) { return &object.thickness; }).description("Thickness of thin material").defaultValue(1.0F);
+        builder.field("backlight", [](auto &object) { return &object.backlight; })
+            .description("Diffuse transmission of thin material, 0 = reflection, 1 = 50/50, 2 = transmission")
+            .defaultValue(0.0F);
+        builder.field("coat", [](auto &object) { return &object.coat; }).description("Coat layer weight").defaultValue(0.0F);
+        builder.field("coatIor", [](auto &object) { return &object.coatIor; }).description("Coat layer IOR").defaultValue(1.5F);
+        builder.field("coatColor", [](auto &object) { return &object.coatColor; })
+            .description("Coat layer color")
+            .defaultValue(Color3{1.0F, 1.0F, 1.0F});
+        builder.field("coatThickness", [](auto &object) { return &object.coatThickness; }).description("Coat layer thickness").defaultValue(1.0F);
+        builder.field("coatRoughness", [](auto &object) { return &object.coatRoughness; }).description("Coat layer roughness").defaultValue(0.0F);
+        builder.field("coatNormal", [](auto &object) { return &object.coatNormal; }).description("Coat layer normal map").defaultValue(1.0F);
+        builder.field("sheen", [](auto &object) { return &object.sheen; }).description("Sheen layer weight").defaultValue(0.0F);
+        builder.field("sheenColor", [](auto &object) { return &object.sheenColor; })
+            .description("Sheen layer color")
+            .defaultValue(Color3{1.0F, 1.0F, 1.0F});
+        builder.field("sheenTint", [](auto &object) { return &object.sheenTint; }).description("Sheen layer color").defaultValue(0.0F);
+        builder.field("sheenRoughness", [](auto &object) { return &object.sheenRoughness; }).description("Sheen layer roughness").defaultValue(0.2F);
+        builder.field("opacity", [](auto &object) { return &object.opacity; }).description("Cut-out opacity").defaultValue(1.0F);
+        builder.field("emissiveColor", [](auto &object) { return &object.emissiveColor; })
+            .description("Color and intensity of light emission")
+            .defaultValue(Color3{0.0F, 0.0F, 0.0F});
+        return builder.build();
+    }
+};
+
+using CreatePrincipledMaterialParams = CreateParamsOf<PrincipledMaterialParams>;
+using GetPrincipledMaterialResult = GetResultOf<PrincipledMaterialParams>;
+using UpdatePrincipledMaterialParams = UpdateParamsOf<PrincipledMaterialParams>;
+using UserPrincipledMaterial = UserMaterialOf<PrincipledMaterialParams, PrincipledMaterial>;
+
+CreateObjectResult createPrincipledMaterial(ObjectManager &objects, Device &device, const CreatePrincipledMaterialParams &params);
+GetPrincipledMaterialResult getPrincipledMaterial(ObjectManager &objects, const GetObjectParams &params);
+void updatePrincipledMaterial(ObjectManager &objects, Device &device, const UpdatePrincipledMaterialParams &params);
 }