592406a328
Refactored code to support local and external material sources This is the first PR in a series to support external modules. External modules allow materials to be stored in external data sources such as databases or web services. No new functionality is introduced in this PR, rather it is a refactoring of code that will allow for changes to be introduced in future PRs. Minor performance improvements have also been made in the model and material managers. The Python API has been enhanced for many data types to allow for modification within Python.
1107 lines
48 KiB
C++
1107 lines
48 KiB
C++
/***************************************************************************
|
|
* Copyright (c) 2023 David Carter <dcarter@david.carter.ca> *
|
|
* *
|
|
* This file is part of FreeCAD. *
|
|
* *
|
|
* FreeCAD is free software: you can redistribute it and/or modify it *
|
|
* under the terms of the GNU Lesser General Public License as *
|
|
* published by the Free Software Foundation, either version 2.1 of the *
|
|
* License, or (at your option) any later version. *
|
|
* *
|
|
* FreeCAD is distributed in the hope that it will be useful, but *
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of *
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
|
|
* Lesser General Public License for more details. *
|
|
* *
|
|
* You should have received a copy of the GNU Lesser General Public *
|
|
* License along with FreeCAD. If not, see *
|
|
* <https://www.gnu.org/licenses/>. *
|
|
* *
|
|
**************************************************************************/
|
|
|
|
#include "PreCompiled.h"
|
|
#ifndef _PreComp_
|
|
#include <QDirIterator>
|
|
#include <QFileInfo>
|
|
#include <QString>
|
|
#include <QFile>
|
|
#include <QIODevice>
|
|
#include <QTextStream>
|
|
#include <QUuid>
|
|
#include <memory>
|
|
#include <fstream>
|
|
#endif
|
|
|
|
|
|
#include <App/Application.h>
|
|
#include <Base/Interpreter.h>
|
|
|
|
|
|
#include "Exceptions.h"
|
|
#include "MaterialConfigLoader.h"
|
|
#include "MaterialLoader.h"
|
|
#include "Model.h"
|
|
#include "ModelUuids.h"
|
|
|
|
|
|
using namespace Materials;
|
|
|
|
bool MaterialConfigLoader::isConfigStyle(const QString& path)
|
|
{
|
|
QSettings fcmat(path, QSettings::IniFormat);
|
|
|
|
// No [sections] means not .ini
|
|
if (fcmat.childGroups().empty()) {
|
|
return false;
|
|
}
|
|
|
|
// Sometimes arrays can create a false positive
|
|
QFile infile(path);
|
|
if (infile.open(QIODevice::ReadOnly)) {
|
|
QTextStream in(&infile);
|
|
|
|
if (!in.atEnd()) {
|
|
auto line = in.readLine();
|
|
if (line.trimmed().startsWith(QLatin1Char('-'))
|
|
|| line.trimmed().startsWith(QLatin1Char('#'))) {
|
|
// Definitely a YAML file
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
infile.close();
|
|
|
|
// No false positive
|
|
return true;
|
|
}
|
|
|
|
bool MaterialConfigLoader::readFile(const QString& path, QMap<QString, QString>& map)
|
|
{
|
|
// This function is necessary as the built in routines don't always return the full value string
|
|
QFile infile(path);
|
|
if (infile.open(QIODevice::ReadOnly)) {
|
|
QTextStream in(&infile);
|
|
#if QT_VERSION < QT_VERSION_CHECK(6,0,0)
|
|
in.setCodec("UTF-8");
|
|
#endif
|
|
QString line;
|
|
QString prefix;
|
|
while (!in.atEnd()) {
|
|
line = in.readLine();
|
|
if (line.trimmed().startsWith(QLatin1Char(';'))) {
|
|
continue;
|
|
}
|
|
|
|
if (line.startsWith(QLatin1Char('['))) {
|
|
// read prefix
|
|
auto end = line.indexOf(QLatin1Char(']'));
|
|
if (end > 1) {
|
|
prefix = line.mid(1, end - 1) + QStringLiteral("/");
|
|
|
|
// Render WB uses both Render and Rendering
|
|
if (prefix == QStringLiteral("Rendering/")) {
|
|
prefix = QStringLiteral("Render/");
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
auto separator = line.indexOf(QLatin1Char('='));
|
|
if (separator > 2) {
|
|
auto left = line.mid(0, separator - 1);
|
|
auto right = line.mid(separator + 2);
|
|
map[prefix + left] = right;
|
|
}
|
|
}
|
|
}
|
|
infile.close();
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void MaterialConfigLoader::splitTexture(const QString& value, QString* texture, QString* remain)
|
|
{
|
|
// Split Texture(...);(...) into its two pieces
|
|
if (value.contains(QLatin1Char(';'))) {
|
|
auto separator = value.indexOf(QLatin1Char(';'));
|
|
auto left = value.mid(0, separator);
|
|
auto right = value.mid(separator + 1);
|
|
if (isTexture(left)) {
|
|
*texture = left;
|
|
*remain = right;
|
|
}
|
|
else {
|
|
*texture = right;
|
|
*remain = left;
|
|
}
|
|
}
|
|
else {
|
|
if (isTexture(value)) {
|
|
*texture = value;
|
|
}
|
|
else {
|
|
*remain = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
void MaterialConfigLoader::splitTextureObject(const QString& value,
|
|
QString* texture,
|
|
QString* remain,
|
|
QString* object)
|
|
{
|
|
splitTexture(value, texture, remain);
|
|
if (*remain == QStringLiteral("Object")) {
|
|
*remain = QString(); // Empty string
|
|
*object = QStringLiteral("true");
|
|
}
|
|
}
|
|
|
|
QString MaterialConfigLoader::getAuthorAndLicense(const QString& path)
|
|
{
|
|
std::ifstream infile(path.toStdString());
|
|
QString noAuthor;
|
|
|
|
// Skip the first line
|
|
std::string line;
|
|
if (!std::getline(infile, line)) {
|
|
return noAuthor;
|
|
}
|
|
|
|
// The second line has it in a comment
|
|
if (!std::getline(infile, line)) {
|
|
return noAuthor;
|
|
}
|
|
std::size_t found = line.find(';');
|
|
if (found != std::string::npos) {
|
|
return QString::fromStdString(trim_copy(line.substr(found + 1)));
|
|
}
|
|
|
|
return noAuthor;
|
|
}
|
|
|
|
void MaterialConfigLoader::addVectorRendering(const QMap<QString, QString>& fcmat,
|
|
const std::shared_ptr<Material>& finalModel)
|
|
{
|
|
QString sectionFillPattern = value(fcmat, "VectorRendering/SectionFillPattern", "");
|
|
QString sectionLinewidth = value(fcmat, "VectorRendering/SectionLinewidth", "");
|
|
QString sectionColor = value(fcmat, "VectorRendering/SectionColor", "");
|
|
QString viewColor = value(fcmat, "VectorRendering/ViewColor", "");
|
|
QString viewFillPattern = value(fcmat, "VectorRendering/ViewFillPattern", "");
|
|
QString viewLinewidth = value(fcmat, "VectorRendering/ViewLinewidth", "");
|
|
|
|
// Defined by the Render WB
|
|
QString aSection = value(fcmat, "Architectural/SectionColor", "");
|
|
|
|
if (!aSection.isEmpty()) {
|
|
sectionColor = aSection;
|
|
}
|
|
|
|
if (sectionFillPattern.length() + sectionLinewidth.length() + sectionColor.length()
|
|
+ viewColor.length() + viewFillPattern.length() + viewLinewidth.length()
|
|
> 0) {
|
|
finalModel->addAppearance(ModelUUIDs::ModelUUID_Rendering_Vector);
|
|
|
|
// Now add the data
|
|
setAppearanceValue(finalModel, "SectionFillPattern", sectionFillPattern);
|
|
setAppearanceValue(finalModel, "SectionLinewidth", sectionLinewidth);
|
|
setAppearanceValue(finalModel, "SectionColor", sectionColor);
|
|
setAppearanceValue(finalModel, "ViewColor", viewColor);
|
|
setAppearanceValue(finalModel, "ViewFillPattern", viewFillPattern);
|
|
setAppearanceValue(finalModel, "ViewLinewidth", viewLinewidth);
|
|
}
|
|
}
|
|
|
|
void MaterialConfigLoader::addRendering(const QMap<QString, QString>& fcmat,
|
|
const std::shared_ptr<Material>& finalModel)
|
|
{
|
|
QString ambientColor = value(fcmat, "Rendering/AmbientColor", "");
|
|
QString diffuseColor = value(fcmat, "Rendering/DiffuseColor", "");
|
|
QString emissiveColor = value(fcmat, "Rendering/EmissiveColor", "");
|
|
QString shininess = value(fcmat, "Rendering/Shininess", "");
|
|
QString specularColor = value(fcmat, "Rendering/SpecularColor", "");
|
|
QString transparency = value(fcmat, "Rendering/Transparency", "");
|
|
QString texturePath = value(fcmat, "Rendering/TexturePath", "");
|
|
QString textureScaling = value(fcmat, "Rendering/TextureScaling", "");
|
|
QString fragmentShader = value(fcmat, "Rendering/FragmentShader", "");
|
|
QString vertexShader = value(fcmat, "Rendering/VertexShader", "");
|
|
|
|
// Defined by the Render WB
|
|
QString aDiffuse = value(fcmat, "Architectural/DiffuseColor", "");
|
|
QString aTransparency = value(fcmat, "Architectural/Transparency", "");
|
|
|
|
if (!aDiffuse.isEmpty()) {
|
|
diffuseColor = aDiffuse;
|
|
}
|
|
if (!aTransparency.isEmpty()) {
|
|
transparency = aTransparency;
|
|
}
|
|
|
|
// Check which model we need
|
|
bool useTexture = false;
|
|
bool useAdvanced = false;
|
|
bool useBasic = false;
|
|
if (texturePath.length() + textureScaling.length() > 0) {
|
|
useTexture = true;
|
|
}
|
|
if (fragmentShader.length() + vertexShader.length() > 0) {
|
|
useAdvanced = true;
|
|
}
|
|
if (ambientColor.length() + diffuseColor.length() + emissiveColor.length() + shininess.length()
|
|
+ specularColor.length() + transparency.length()
|
|
> 0) {
|
|
useBasic = true;
|
|
}
|
|
|
|
if (useAdvanced) {
|
|
finalModel->addAppearance(ModelUUIDs::ModelUUID_Rendering_Advanced);
|
|
}
|
|
else if (useTexture) {
|
|
finalModel->addAppearance(ModelUUIDs::ModelUUID_Rendering_Texture);
|
|
}
|
|
else if (useBasic) {
|
|
finalModel->addAppearance(ModelUUIDs::ModelUUID_Rendering_Basic);
|
|
}
|
|
|
|
// Now add the data
|
|
setAppearanceValue(finalModel, "AmbientColor", ambientColor);
|
|
setAppearanceValue(finalModel, "DiffuseColor", diffuseColor);
|
|
setAppearanceValue(finalModel, "EmissiveColor", emissiveColor);
|
|
setAppearanceValue(finalModel, "Shininess", shininess);
|
|
setAppearanceValue(finalModel, "SpecularColor", specularColor);
|
|
setAppearanceValue(finalModel, "Transparency", transparency);
|
|
setAppearanceValue(finalModel, "TexturePath", texturePath);
|
|
setAppearanceValue(finalModel, "TextureScaling", textureScaling);
|
|
setAppearanceValue(finalModel, "FragmentShader", fragmentShader);
|
|
setAppearanceValue(finalModel, "VertexShader", vertexShader);
|
|
}
|
|
|
|
QString MaterialConfigLoader::multiLineKey(QMap<QString, QString>& fcmat, const QString& prefix)
|
|
{
|
|
// fcmat.beginGroup(QStringLiteral("Render"));
|
|
QString multiLineString;
|
|
auto keys = fcmat.keys();
|
|
for (const auto& key : keys) {
|
|
if (key.startsWith(prefix) || key.startsWith(QStringLiteral("Render/") + prefix)) {
|
|
QString string = value(fcmat, key.toStdString(), "");
|
|
if (multiLineString.isEmpty()) {
|
|
multiLineString += string;
|
|
}
|
|
else {
|
|
multiLineString += QStringLiteral("\n") + string;
|
|
}
|
|
}
|
|
}
|
|
// fcmat.endGroup();
|
|
|
|
return multiLineString;
|
|
}
|
|
|
|
void MaterialConfigLoader::addRenderAppleseed(QMap<QString, QString>& fcmat,
|
|
const std::shared_ptr<Material>& finalModel)
|
|
{
|
|
QString prefix = QStringLiteral("Render.Appleseed");
|
|
QString string = multiLineKey(fcmat, prefix);
|
|
|
|
if (!string.isEmpty()) {
|
|
finalModel->addAppearance(ModelUUIDs::ModelUUID_Render_Appleseed);
|
|
|
|
// Now add the data
|
|
setAppearanceValue(finalModel, "Render.Appleseed", string);
|
|
}
|
|
}
|
|
|
|
void MaterialConfigLoader::addRenderCarpaint(QMap<QString, QString>& fcmat,
|
|
const std::shared_ptr<Material>& finalModel)
|
|
{
|
|
QString renderBaseColorValue = value(fcmat, "Render/Render.Carpaint.BaseColor", "");
|
|
QString renderBump = value(fcmat, "Render/Render.Carpaint.Bump", "");
|
|
QString renderDisplacement = value(fcmat, "Render/Render.Carpaint.Displacement", "");
|
|
QString renderNormal = value(fcmat, "Render/Render.Carpaint.Normal", "");
|
|
|
|
// Split out the textures
|
|
QString renderBaseColor;
|
|
QString renderBaseColorTexture;
|
|
QString renderBaseColorObject;
|
|
splitTextureObject(renderBaseColorValue,
|
|
&renderBaseColorTexture,
|
|
&renderBaseColor,
|
|
&renderBaseColorObject);
|
|
|
|
if (!renderBaseColorValue.isEmpty() || !renderBump.isEmpty() || !renderDisplacement.isEmpty()
|
|
|| !renderNormal.isEmpty()) {
|
|
finalModel->addAppearance(ModelUUIDs::ModelUUID_Render_Carpaint);
|
|
|
|
// Now add the data
|
|
setAppearanceValue(finalModel, "Render.Carpaint.BaseColor", renderBaseColor);
|
|
setAppearanceValue(finalModel, "Render.Carpaint.BaseColor.Texture", renderBaseColorTexture);
|
|
setAppearanceValue(finalModel, "Render.Carpaint.BaseColor.Object", renderBaseColorObject);
|
|
setAppearanceValue(finalModel, "Render.Carpaint.Bump", renderBump);
|
|
setAppearanceValue(finalModel, "Render.Carpaint.Displacement", renderDisplacement);
|
|
setAppearanceValue(finalModel, "Render.Carpaint.Normal", renderNormal);
|
|
}
|
|
}
|
|
|
|
void MaterialConfigLoader::addRenderCycles(QMap<QString, QString>& fcmat,
|
|
const std::shared_ptr<Material>& finalModel)
|
|
{
|
|
QString prefix = QStringLiteral("Render.Cycles");
|
|
QString string = multiLineKey(fcmat, prefix);
|
|
if (!string.isEmpty()) {
|
|
finalModel->addAppearance(ModelUUIDs::ModelUUID_Render_Cycles);
|
|
|
|
// Now add the data
|
|
setAppearanceValue(finalModel, "Render.Cycles", string);
|
|
}
|
|
}
|
|
|
|
void MaterialConfigLoader::addRenderDiffuse(QMap<QString, QString>& fcmat,
|
|
const std::shared_ptr<Material>& finalModel)
|
|
{
|
|
QString renderBump = value(fcmat, "Render/Render.Diffuse.Bump", "");
|
|
QString renderColorValue = value(fcmat, "Render/Render.Diffuse.Color", "");
|
|
QString renderDisplacement = value(fcmat, "Render/Render.Diffuse.Displacement", "");
|
|
QString renderNormal = value(fcmat, "Render/Render.Diffuse.Normal", "");
|
|
|
|
// Split out the textures
|
|
QString renderColor;
|
|
QString renderColorTexture;
|
|
QString renderColorObject;
|
|
splitTextureObject(renderColorValue, &renderColorTexture, &renderColor, &renderColorObject);
|
|
|
|
if (!renderBump.isEmpty() || !renderColorValue.isEmpty() || !renderDisplacement.isEmpty()
|
|
|| !renderNormal.isEmpty()) {
|
|
finalModel->addAppearance(ModelUUIDs::ModelUUID_Render_Diffuse);
|
|
|
|
// Now add the data
|
|
setAppearanceValue(finalModel, "Render.Diffuse.Bump", renderBump);
|
|
setAppearanceValue(finalModel, "Render.Diffuse.Color", renderColor);
|
|
setAppearanceValue(finalModel, "Render.Diffuse.Color.Texture", renderColorTexture);
|
|
setAppearanceValue(finalModel, "Render.Diffuse.Color.Object", renderColorObject);
|
|
setAppearanceValue(finalModel, "Render.Diffuse.Displacement", renderDisplacement);
|
|
setAppearanceValue(finalModel, "Render.Diffuse.Normal", renderNormal);
|
|
}
|
|
}
|
|
|
|
void MaterialConfigLoader::addRenderDisney(QMap<QString, QString>& fcmat,
|
|
const std::shared_ptr<Material>& finalModel)
|
|
{
|
|
QString renderAnisotropicValue = value(fcmat, "Render/Render.Disney.Anisotropic", "");
|
|
QString renderBaseColorValue = value(fcmat, "Render/Render.Disney.BaseColor", "");
|
|
QString renderBump = value(fcmat, "Render/Render.Disney.Bump", "");
|
|
QString renderClearCoatValue = value(fcmat, "Render/Render.Disney.ClearCoat", "");
|
|
QString renderClearCoatGlossValue = value(fcmat, "Render/Render.Disney.ClearCoatGloss", "");
|
|
QString renderDisplacement = value(fcmat, "Render/Render.Disney.Displacement", "");
|
|
QString renderMetallicValue = value(fcmat, "Render/Render.Disney.Metallic", "");
|
|
QString renderNormal = value(fcmat, "Render/Render.Disney.Normal", "");
|
|
QString renderRoughnessValue = value(fcmat, "Render/Render.Disney.Roughness", "");
|
|
QString renderSheenValue = value(fcmat, "Render/Render.Disney.Sheen", "");
|
|
QString renderSheenTintValue = value(fcmat, "Render/Render.Disney.SheenTint", "");
|
|
QString renderSpecularValue = value(fcmat, "Render/Render.Disney.Specular", "");
|
|
QString renderSpecularTintValue = value(fcmat, "Render/Render.Disney.SpecularTint", "");
|
|
QString renderSubsurfaceValue = value(fcmat, "Render/Render.Disney.Subsurface", "");
|
|
|
|
// Split out the textures
|
|
QString renderAnisotropic;
|
|
QString renderAnisotropicTexture;
|
|
splitTexture(renderAnisotropicValue, &renderAnisotropicTexture, &renderAnisotropic);
|
|
QString renderBaseColor;
|
|
QString renderBaseColorTexture;
|
|
QString renderBaseColorObject;
|
|
splitTextureObject(renderBaseColorValue,
|
|
&renderBaseColorTexture,
|
|
&renderBaseColor,
|
|
&renderBaseColorObject);
|
|
QString renderClearCoat;
|
|
QString renderClearCoatTexture;
|
|
QString renderClearCoatObject;
|
|
splitTextureObject(renderClearCoatValue,
|
|
&renderClearCoatTexture,
|
|
&renderClearCoat,
|
|
&renderClearCoatObject);
|
|
QString renderClearCoatGloss;
|
|
QString renderClearCoatGlossTexture;
|
|
QString renderClearCoatGlossObject;
|
|
splitTextureObject(renderClearCoatGlossValue,
|
|
&renderClearCoatGlossTexture,
|
|
&renderClearCoatGloss,
|
|
&renderClearCoatGlossObject);
|
|
QString renderMetallic;
|
|
QString renderMetallicTexture;
|
|
splitTexture(renderMetallicValue, &renderMetallicTexture, &renderMetallic);
|
|
QString renderRoughness;
|
|
QString renderRoughnessTexture;
|
|
splitTexture(renderRoughnessValue, &renderRoughnessTexture, &renderRoughness);
|
|
QString renderSheen;
|
|
QString renderSheenTexture;
|
|
splitTexture(renderSheenValue, &renderSheenTexture, &renderSheen);
|
|
QString renderSheenTint;
|
|
QString renderSheenTintTexture;
|
|
splitTexture(renderSheenTintValue, &renderSheenTintTexture, &renderSheenTint);
|
|
QString renderSpecular;
|
|
QString renderSpecularTexture;
|
|
QString renderSpecularObject;
|
|
splitTextureObject(renderSpecularValue,
|
|
&renderSpecularTexture,
|
|
&renderSpecular,
|
|
&renderSpecularObject);
|
|
QString renderSpecularTint;
|
|
QString renderSpecularTintTexture;
|
|
QString renderSpecularTintObject;
|
|
splitTextureObject(renderSpecularTintValue,
|
|
&renderSpecularTintTexture,
|
|
&renderSpecularTint,
|
|
&renderSpecularTintObject);
|
|
QString renderSubsurface;
|
|
QString renderSubsurfaceTexture;
|
|
splitTexture(renderSubsurfaceValue, &renderSubsurfaceTexture, &renderSubsurface);
|
|
|
|
if (!renderAnisotropicValue.isEmpty() || !renderBaseColorValue.isEmpty()
|
|
|| !renderBump.isEmpty() || !renderClearCoatValue.isEmpty()
|
|
|| !renderClearCoatGlossValue.isEmpty() || !renderDisplacement.isEmpty()
|
|
|| !renderMetallicValue.isEmpty() || !renderNormal.isEmpty()
|
|
|| !renderRoughnessValue.isEmpty() || !renderSheenValue.isEmpty()
|
|
|| !renderSheenTintValue.isEmpty() || !renderSpecularValue.isEmpty()
|
|
|| !renderSpecularTintValue.isEmpty() || !renderSubsurfaceValue.isEmpty()) {
|
|
finalModel->addAppearance(ModelUUIDs::ModelUUID_Render_Disney);
|
|
|
|
// Now add the data
|
|
setAppearanceValue(finalModel, "Render.Disney.Anisotropic", renderAnisotropic);
|
|
setAppearanceValue(finalModel,
|
|
"Render.Disney.Anisotropic.Texture",
|
|
renderAnisotropicTexture);
|
|
setAppearanceValue(finalModel, "Render.Disney.BaseColor", renderBaseColor);
|
|
setAppearanceValue(finalModel, "Render.Disney.BaseColor.Texture", renderBaseColorTexture);
|
|
setAppearanceValue(finalModel, "Render.Disney.Bump", renderBump);
|
|
setAppearanceValue(finalModel, "Render.Disney.ClearCoat", renderClearCoat);
|
|
setAppearanceValue(finalModel, "Render.Disney.ClearCoat.Texture", renderClearCoatTexture);
|
|
setAppearanceValue(finalModel, "Render.Disney.ClearCoatGloss", renderClearCoatGloss);
|
|
setAppearanceValue(finalModel,
|
|
"Render.Disney.ClearCoatGloss.Texture",
|
|
renderClearCoatGlossTexture);
|
|
setAppearanceValue(finalModel, "Render.Disney.Displacement", renderDisplacement);
|
|
setAppearanceValue(finalModel, "Render.Disney.Metallic", renderMetallic);
|
|
setAppearanceValue(finalModel, "Render.Disney.Metallic.Texture", renderMetallicTexture);
|
|
setAppearanceValue(finalModel, "Render.Disney.Normal", renderNormal);
|
|
setAppearanceValue(finalModel, "Render.Disney.Roughness", renderRoughness);
|
|
setAppearanceValue(finalModel, "Render.Disney.Roughness.Texture", renderRoughnessTexture);
|
|
setAppearanceValue(finalModel, "Render.Disney.Sheen", renderSheen);
|
|
setAppearanceValue(finalModel, "Render.Disney.Sheen.Texture", renderSheenTexture);
|
|
setAppearanceValue(finalModel, "Render.Disney.SheenTint", renderSheenTint);
|
|
setAppearanceValue(finalModel, "Render.Disney.SheenTint.Texture", renderSheenTintTexture);
|
|
setAppearanceValue(finalModel, "Render.Disney.Specular", renderSpecular);
|
|
setAppearanceValue(finalModel, "Render.Disney.Specular.Texture", renderSpecularTexture);
|
|
setAppearanceValue(finalModel, "Render.Disney.SpecularTint", renderSpecularTint);
|
|
setAppearanceValue(finalModel,
|
|
"Render.Disney.SpecularTint.Texture",
|
|
renderSpecularTintTexture);
|
|
setAppearanceValue(finalModel, "Render.Disney.Subsurface", renderSubsurface);
|
|
setAppearanceValue(finalModel, "Render.Disney.Subsurface.Texture", renderSubsurfaceTexture);
|
|
}
|
|
}
|
|
|
|
void MaterialConfigLoader::addRenderEmission(QMap<QString, QString>& fcmat,
|
|
const std::shared_ptr<Material>& finalModel)
|
|
{
|
|
QString renderBump = value(fcmat, "Render/Render.Emission.Bump", "");
|
|
QString renderColorValue = value(fcmat, "Render/Render.Emission.Color", "");
|
|
QString renderNormal = value(fcmat, "Render/Render.Emission.Normal", "");
|
|
QString renderPowerValue = value(fcmat, "Render/Render.Emission.Power", "");
|
|
|
|
// Split out the textures
|
|
QString renderColor;
|
|
QString renderColorTexture;
|
|
QString renderColorObject;
|
|
splitTextureObject(renderColorValue, &renderColorTexture, &renderColor, &renderColorObject);
|
|
QString renderPower;
|
|
QString renderPowerTexture;
|
|
splitTexture(renderPowerValue, &renderPowerTexture, &renderPower);
|
|
|
|
if (!renderColorValue.isEmpty() || !renderBump.isEmpty() || !renderPowerValue.isEmpty()
|
|
|| !renderNormal.isEmpty()) {
|
|
finalModel->addAppearance(ModelUUIDs::ModelUUID_Render_Emission);
|
|
|
|
// Now add the data
|
|
setAppearanceValue(finalModel, "Render.Emission.Bump", renderBump);
|
|
setAppearanceValue(finalModel, "Render.Emission.Color", renderColor);
|
|
setAppearanceValue(finalModel, "Render.Emission.Color.Texture", renderColorTexture);
|
|
setAppearanceValue(finalModel, "Render.Emission.Color.Object", renderColorObject);
|
|
setAppearanceValue(finalModel, "Render.Emission.Normal", renderNormal);
|
|
setAppearanceValue(finalModel, "Render.Emission.Power", renderPower);
|
|
setAppearanceValue(finalModel, "Render.Emission.Power.Texture", renderPowerTexture);
|
|
}
|
|
}
|
|
|
|
void MaterialConfigLoader::addRenderGlass(QMap<QString, QString>& fcmat,
|
|
const std::shared_ptr<Material>& finalModel)
|
|
{
|
|
QString renderBump = value(fcmat, "Render/Render.Glass.Bump", "");
|
|
QString renderColorValue = value(fcmat, "Render/Render.Glass.Color", "");
|
|
QString renderIORValue = value(fcmat, "Render/Render.Glass.IOR", "");
|
|
QString renderDisplacement = value(fcmat, "Render/Render.Glass.Displacement", "");
|
|
QString renderNormal = value(fcmat, "Render/Render.Glass.Normal", "");
|
|
|
|
// Split out the textures
|
|
QString renderColor;
|
|
QString renderColorTexture;
|
|
QString renderColorObject;
|
|
splitTextureObject(renderColorValue, &renderColorTexture, &renderColor, &renderColorObject);
|
|
QString renderIOR;
|
|
QString renderIORTexture;
|
|
splitTexture(renderIORValue, &renderIORTexture, &renderIOR);
|
|
|
|
if (!renderBump.isEmpty() || !renderColorValue.isEmpty() || !renderIORValue.isEmpty()
|
|
|| !renderDisplacement.isEmpty() || !renderNormal.isEmpty()) {
|
|
finalModel->addAppearance(ModelUUIDs::ModelUUID_Render_Glass);
|
|
|
|
setAppearanceValue(finalModel, "Render.Glass.Bump", renderBump);
|
|
setAppearanceValue(finalModel, "Render.Glass.Color", renderColor);
|
|
setAppearanceValue(finalModel, "Render.Glass.Color.Texture", renderColorTexture);
|
|
setAppearanceValue(finalModel, "Render.Glass.Color.Object", renderColorObject);
|
|
setAppearanceValue(finalModel, "Render.Glass.IOR", renderIOR);
|
|
setAppearanceValue(finalModel, "Render.Glass.IOR.Texture", renderIORTexture);
|
|
setAppearanceValue(finalModel, "Render.Glass.Displacement", renderDisplacement);
|
|
setAppearanceValue(finalModel, "Render.Glass.Normal", renderNormal);
|
|
}
|
|
}
|
|
|
|
void MaterialConfigLoader::addRenderLuxcore(QMap<QString, QString>& fcmat,
|
|
const std::shared_ptr<Material>& finalModel)
|
|
{
|
|
QString prefix = QStringLiteral("Render.Luxcore");
|
|
QString string = multiLineKey(fcmat, prefix);
|
|
|
|
if (!string.isEmpty()) {
|
|
finalModel->addAppearance(ModelUUIDs::ModelUUID_Render_Luxcore);
|
|
|
|
// Now add the data
|
|
setAppearanceValue(finalModel, "Render.Luxcore", string);
|
|
}
|
|
}
|
|
|
|
void MaterialConfigLoader::addRenderLuxrender(QMap<QString, QString>& fcmat,
|
|
const std::shared_ptr<Material>& finalModel)
|
|
{
|
|
QString prefix = QStringLiteral("Render.Luxrender");
|
|
QString string = multiLineKey(fcmat, prefix);
|
|
|
|
if (!string.isEmpty()) {
|
|
finalModel->addAppearance(ModelUUIDs::ModelUUID_Render_Luxrender);
|
|
|
|
// Now add the data
|
|
setAppearanceValue(finalModel, "Render.Luxrender", string);
|
|
}
|
|
}
|
|
|
|
void MaterialConfigLoader::addRenderMixed(QMap<QString, QString>& fcmat,
|
|
const std::shared_ptr<Material>& finalModel)
|
|
{
|
|
QString renderBump = value(fcmat, "Render/Render.Mixed.Bump", "");
|
|
QString renderDiffuseColorValue = value(fcmat, "Render/Render.Mixed.Diffuse.Color", "");
|
|
QString renderDisplacement = value(fcmat, "Render/Render.Mixed.Displacement", "");
|
|
QString renderGlassColorValue = value(fcmat, "Render/Render.Mixed.Glass.Color", "");
|
|
QString renderGlassIORValue = value(fcmat, "Render/Render.Mixed.Glass.IOR", "");
|
|
QString renderNormal = value(fcmat, "Render/Render.Mixed.Normal", "");
|
|
QString renderTransparencyValue = value(fcmat, "Render/Render.Mixed.Transparency", "");
|
|
|
|
// Split out the textures
|
|
QString renderDiffuseColor;
|
|
QString renderDiffuseColorTexture;
|
|
QString renderDiffuseColorObject;
|
|
splitTextureObject(renderDiffuseColorValue,
|
|
&renderDiffuseColorTexture,
|
|
&renderDiffuseColor,
|
|
&renderDiffuseColorObject);
|
|
QString renderGlassColor;
|
|
QString renderGlassColorTexture;
|
|
QString renderGlassColorObject;
|
|
splitTextureObject(renderGlassColorValue,
|
|
&renderGlassColorTexture,
|
|
&renderGlassColor,
|
|
&renderGlassColorObject);
|
|
QString renderGlassIOR;
|
|
QString renderGlassIORTexture;
|
|
splitTexture(renderGlassIORValue, &renderGlassIORTexture, &renderGlassIOR);
|
|
QString renderTransparency;
|
|
QString renderTransparencyTexture;
|
|
splitTexture(renderTransparencyValue, &renderTransparencyTexture, &renderTransparency);
|
|
|
|
if (!renderBump.isEmpty() || !renderDiffuseColorValue.isEmpty() || !renderDisplacement.isEmpty()
|
|
|| !renderGlassColorValue.isEmpty() || !renderGlassIORValue.isEmpty()
|
|
|| !renderNormal.isEmpty() || !renderTransparencyValue.isEmpty()) {
|
|
finalModel->addAppearance(ModelUUIDs::ModelUUID_Render_Mixed);
|
|
|
|
// Now add the data
|
|
setAppearanceValue(finalModel, "Render.Mixed.Bump", renderBump);
|
|
setAppearanceValue(finalModel, "Render.Mixed.Diffuse.Color", renderDiffuseColor);
|
|
setAppearanceValue(finalModel,
|
|
"Render.Mixed.Diffuse.Color.Texture",
|
|
renderDiffuseColorTexture);
|
|
setAppearanceValue(finalModel,
|
|
"Render.Mixed.Diffuse.Color.Object",
|
|
renderDiffuseColorObject);
|
|
setAppearanceValue(finalModel, "Render.Mixed.Displacement", renderDisplacement);
|
|
setAppearanceValue(finalModel, "Render.Mixed.Glass.Color", renderGlassColor);
|
|
setAppearanceValue(finalModel, "Render.Mixed.Glass.Color.Texture", renderGlassColorTexture);
|
|
setAppearanceValue(finalModel, "Render.Mixed.Glass.Color.Object", renderGlassColorObject);
|
|
setAppearanceValue(finalModel, "Render.Mixed.Glass.IOR", renderGlassIOR);
|
|
setAppearanceValue(finalModel, "Render.Mixed.Glass.IOR.Texture", renderGlassIORTexture);
|
|
setAppearanceValue(finalModel, "Render.Mixed.Normal", renderNormal);
|
|
setAppearanceValue(finalModel, "Render.Mixed.Transparency", renderTransparency);
|
|
setAppearanceValue(finalModel,
|
|
"Render.Mixed.Transparency.Texture",
|
|
renderTransparencyTexture);
|
|
}
|
|
}
|
|
|
|
void MaterialConfigLoader::addRenderOspray(QMap<QString, QString>& fcmat,
|
|
const std::shared_ptr<Material>& finalModel)
|
|
{
|
|
QString prefix = QStringLiteral("Render.Ospray");
|
|
QString string = multiLineKey(fcmat, prefix);
|
|
|
|
if (!string.isEmpty()) {
|
|
finalModel->addAppearance(ModelUUIDs::ModelUUID_Render_Ospray);
|
|
|
|
// Now add the data
|
|
setAppearanceValue(finalModel, "Render.Ospray", string);
|
|
}
|
|
}
|
|
|
|
void MaterialConfigLoader::addRenderPbrt(QMap<QString, QString>& fcmat,
|
|
const std::shared_ptr<Material>& finalModel)
|
|
{
|
|
QString prefix = QStringLiteral("Render.Pbrt");
|
|
QString string = multiLineKey(fcmat, prefix);
|
|
|
|
if (!string.isEmpty()) {
|
|
finalModel->addAppearance(ModelUUIDs::ModelUUID_Render_Pbrt);
|
|
|
|
// Now add the data
|
|
setAppearanceValue(finalModel, "Render.Pbrt", string);
|
|
}
|
|
}
|
|
|
|
void MaterialConfigLoader::addRenderPovray(QMap<QString, QString>& fcmat,
|
|
const std::shared_ptr<Material>& finalModel)
|
|
{
|
|
QString prefix = QStringLiteral("Render.Povray");
|
|
QString string = multiLineKey(fcmat, prefix);
|
|
|
|
if (!string.isEmpty()) {
|
|
finalModel->addAppearance(ModelUUIDs::ModelUUID_Render_Povray);
|
|
|
|
// Now add the data
|
|
setAppearanceValue(finalModel, "Render.Povray", string);
|
|
}
|
|
}
|
|
|
|
void MaterialConfigLoader::addRenderSubstancePBR(QMap<QString, QString>& fcmat,
|
|
const std::shared_ptr<Material>& finalModel)
|
|
{
|
|
QString renderBaseColorValue = value(fcmat, "Render/Render.Substance_PBR.BaseColor", "");
|
|
QString renderBump = value(fcmat, "Render/Render.Substance_PBR.Bump", "");
|
|
QString renderMetallicValue = value(fcmat, "Render/Render.Substance_PBR.Metallic", "");
|
|
QString renderNormal = value(fcmat, "Render/Render.Substance_PBR.Normal", "");
|
|
QString renderRoughnessValue = value(fcmat, "Render/Render.Substance_PBR.Roughness", "");
|
|
QString renderSpecularValue = value(fcmat, "Render/Render.Substance_PBR.Specular", "");
|
|
|
|
// Split out the textures
|
|
QString renderBaseColor;
|
|
QString renderBaseColorTexture;
|
|
QString renderBaseColorObject;
|
|
splitTextureObject(renderBaseColorValue,
|
|
&renderBaseColorTexture,
|
|
&renderBaseColor,
|
|
&renderBaseColorObject);
|
|
QString renderMetallic;
|
|
QString renderMetallicTexture;
|
|
splitTexture(renderMetallicValue, &renderMetallicTexture, &renderMetallic);
|
|
QString renderRoughness;
|
|
QString renderRoughnessTexture;
|
|
splitTexture(renderRoughnessValue, &renderRoughnessTexture, &renderRoughness);
|
|
QString renderSpecular;
|
|
QString renderSpecularTexture;
|
|
splitTexture(renderSpecularValue, &renderSpecularTexture, &renderSpecular);
|
|
|
|
if (!renderBaseColorValue.isEmpty() || !renderBump.isEmpty() || !renderMetallicValue.isEmpty()
|
|
|| !renderNormal.isEmpty() || !renderRoughnessValue.isEmpty()
|
|
|| !renderSpecularValue.isEmpty()) {
|
|
finalModel->addAppearance(ModelUUIDs::ModelUUID_Render_SubstancePBR);
|
|
|
|
// Now add the data
|
|
setAppearanceValue(finalModel, "Render.Substance_PBR.BaseColor", renderBaseColor);
|
|
setAppearanceValue(finalModel,
|
|
"Render.Substance_PBR.BaseColor.Texture",
|
|
renderBaseColorTexture);
|
|
setAppearanceValue(finalModel,
|
|
"Render.Substance_PBR.BaseColor.Object",
|
|
renderBaseColorObject);
|
|
setAppearanceValue(finalModel, "Render.Substance_PBR.Bump", renderBump);
|
|
setAppearanceValue(finalModel, "Render.Substance_PBR.Metallic", renderMetallic);
|
|
setAppearanceValue(finalModel,
|
|
"Render.Substance_PBR.Metallic.Texture",
|
|
renderMetallicTexture);
|
|
setAppearanceValue(finalModel, "Render.Substance_PBR.Normal", renderNormal);
|
|
setAppearanceValue(finalModel, "Render.Substance_PBR.Roughness", renderRoughness);
|
|
setAppearanceValue(finalModel,
|
|
"Render.Substance_PBR.Roughness.Texture",
|
|
renderRoughnessTexture);
|
|
setAppearanceValue(finalModel, "Render.Substance_PBR.Specular", renderSpecular);
|
|
setAppearanceValue(finalModel,
|
|
"Render.Substance_PBR.Specular.Texture",
|
|
renderSpecularTexture);
|
|
}
|
|
}
|
|
|
|
void MaterialConfigLoader::addRenderTexture(QMap<QString, QString>& fcmat,
|
|
const std::shared_ptr<Material>& finalModel)
|
|
{
|
|
QString renderName;
|
|
auto renderImage = std::make_shared<QList<QVariant>>();
|
|
QString renderScale;
|
|
QString renderRotation;
|
|
QString renderTranslationU;
|
|
QString renderTranslationV;
|
|
|
|
auto keys = fcmat.keys();
|
|
for (const auto& key : keys) {
|
|
if (key.startsWith(QStringLiteral("Render/Render.Textures."))) {
|
|
QStringList list1 = key.split(QLatin1Char('.'));
|
|
if (renderName.isEmpty()) {
|
|
renderName = list1[2];
|
|
}
|
|
if (list1[3] == QStringLiteral("Images")) {
|
|
renderImage->push_back(value(fcmat, key.toStdString(), ""));
|
|
}
|
|
else if (list1[3] == QStringLiteral("Scale")) {
|
|
renderScale = value(fcmat, key.toStdString(), "");
|
|
}
|
|
else if (list1[3] == QStringLiteral("Rotation")) {
|
|
renderRotation = value(fcmat, key.toStdString(), "");
|
|
}
|
|
else if (list1[3] == QStringLiteral("TranslationU")) {
|
|
renderTranslationU = value(fcmat, key.toStdString(), "");
|
|
}
|
|
else if (list1[3] == QStringLiteral(" TranslationV")) {
|
|
renderTranslationV = value(fcmat, key.toStdString(), "");
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!renderName.isEmpty()) {
|
|
finalModel->addAppearance(ModelUUIDs::ModelUUID_Render_Texture);
|
|
|
|
// Now add the data
|
|
setAppearanceValue(finalModel, "Render.Textures.Name", renderName);
|
|
setAppearanceValue(finalModel, "Render.Textures.Images", renderImage);
|
|
setAppearanceValue(finalModel, "Render.Textures.Scale", renderScale);
|
|
setAppearanceValue(finalModel, "Render.Textures.Rotation", renderRotation);
|
|
setAppearanceValue(finalModel, "Render.Textures.TranslationU", renderTranslationU);
|
|
setAppearanceValue(finalModel, "Render.Textures.TranslationV", renderTranslationV);
|
|
}
|
|
}
|
|
|
|
void MaterialConfigLoader::addRenderWB(QMap<QString, QString>& fcmat,
|
|
const std::shared_ptr<Material>& finalModel)
|
|
{
|
|
QString useObjectColor = value(fcmat, "General/UseObjectColor", "");
|
|
QString renderType = value(fcmat, "Render/Render.Type", "");
|
|
|
|
if (!renderType.isEmpty()) {
|
|
finalModel->addAppearance(ModelUUIDs::ModelUUID_RenderWB);
|
|
|
|
// Now add the data
|
|
setAppearanceValue(finalModel, "UseObjectColor", useObjectColor);
|
|
setAppearanceValue(finalModel, "Render.Type", renderType);
|
|
}
|
|
|
|
addRenderAppleseed(fcmat, finalModel);
|
|
addRenderCarpaint(fcmat, finalModel);
|
|
addRenderCycles(fcmat, finalModel);
|
|
addRenderDiffuse(fcmat, finalModel);
|
|
addRenderDisney(fcmat, finalModel);
|
|
addRenderEmission(fcmat, finalModel);
|
|
addRenderGlass(fcmat, finalModel);
|
|
addRenderLuxcore(fcmat, finalModel);
|
|
addRenderLuxrender(fcmat, finalModel);
|
|
addRenderMixed(fcmat, finalModel);
|
|
addRenderOspray(fcmat, finalModel);
|
|
addRenderPbrt(fcmat, finalModel);
|
|
addRenderPovray(fcmat, finalModel);
|
|
addRenderSubstancePBR(fcmat, finalModel);
|
|
addRenderTexture(fcmat, finalModel);
|
|
}
|
|
|
|
void MaterialConfigLoader::addCosts(const QMap<QString, QString>& fcmat,
|
|
const std::shared_ptr<Material>& finalModel)
|
|
{
|
|
QString productURL = value(fcmat, "Cost/ProductURL", "");
|
|
QString specificPrice = value(fcmat, "Cost/SpecificPrice", "");
|
|
QString vendor = value(fcmat, "Cost/Vendor", "");
|
|
|
|
if (productURL.length() + specificPrice.length() + vendor.length() > 0) {
|
|
finalModel->addPhysical(ModelUUIDs::ModelUUID_Costs_Default);
|
|
|
|
// Now add the data
|
|
setPhysicalValue(finalModel, "ProductURL", productURL);
|
|
setPhysicalValue(finalModel, "SpecificPrice", specificPrice);
|
|
setPhysicalValue(finalModel, "Vendor", vendor);
|
|
}
|
|
}
|
|
|
|
void MaterialConfigLoader::addArchitectural(const QMap<QString, QString>& fcmat,
|
|
const std::shared_ptr<Material>& finalModel)
|
|
{
|
|
QString color = value(fcmat, "Architectural/Color", "");
|
|
QString environmentalEfficiencyClass =
|
|
value(fcmat, "Architectural/EnvironmentalEfficiencyClass", "");
|
|
QString executionInstructions = value(fcmat, "Architectural/ExecutionInstructions", "");
|
|
QString finish = value(fcmat, "Architectural/Finish", "");
|
|
QString fireResistanceClass = value(fcmat, "Architectural/FireResistanceClass", "");
|
|
QString model = value(fcmat, "Architectural/Model", "");
|
|
QString soundTransmissionClass = value(fcmat, "Architectural/SoundTransmissionClass", "");
|
|
QString unitsPerQuantity = value(fcmat, "Architectural/UnitsPerQuantity", "");
|
|
|
|
if (environmentalEfficiencyClass.length() + executionInstructions.length()
|
|
+ fireResistanceClass.length() + model.length() + soundTransmissionClass.length()
|
|
+ unitsPerQuantity.length()
|
|
> 0) {
|
|
finalModel->addPhysical(ModelUUIDs::ModelUUID_Architectural_Default);
|
|
}
|
|
if (color.length() + finish.length() > 0) {
|
|
finalModel->addAppearance(ModelUUIDs::ModelUUID_Rendering_Architectural);
|
|
}
|
|
|
|
// Now add the data
|
|
setPhysicalValue(finalModel, "EnvironmentalEfficiencyClass", environmentalEfficiencyClass);
|
|
setPhysicalValue(finalModel, "ExecutionInstructions", executionInstructions);
|
|
setPhysicalValue(finalModel, "FireResistanceClass", fireResistanceClass);
|
|
setPhysicalValue(finalModel, "Model", model);
|
|
setPhysicalValue(finalModel, "SoundTransmissionClass", soundTransmissionClass);
|
|
setPhysicalValue(finalModel, "UnitsPerQuantity", unitsPerQuantity);
|
|
|
|
setAppearanceValue(finalModel, "Color", color);
|
|
setAppearanceValue(finalModel, "Finish", finish);
|
|
}
|
|
|
|
void MaterialConfigLoader::addElectromagnetic(const QMap<QString, QString>& fcmat,
|
|
const std::shared_ptr<Material>& finalModel)
|
|
{
|
|
QString relativePermittivity = value(fcmat, "Electromagnetic/RelativePermittivity", "");
|
|
QString electricalConductivity = value(fcmat, "Electromagnetic/ElectricalConductivity", "");
|
|
QString relativePermeability = value(fcmat, "Electromagnetic/RelativePermeability", "");
|
|
|
|
if (relativePermittivity.length() + electricalConductivity.length()
|
|
+ relativePermeability.length()
|
|
> 0) {
|
|
finalModel->addPhysical(ModelUUIDs::ModelUUID_Electromagnetic_Default);
|
|
|
|
// Now add the data
|
|
setPhysicalValue(finalModel, "RelativePermittivity", relativePermittivity);
|
|
setPhysicalValue(finalModel, "ElectricalConductivity", electricalConductivity);
|
|
setPhysicalValue(finalModel, "RelativePermeability", relativePermeability);
|
|
}
|
|
}
|
|
|
|
void MaterialConfigLoader::addThermal(const QMap<QString, QString>& fcmat,
|
|
const std::shared_ptr<Material>& finalModel)
|
|
{
|
|
QString specificHeat = value(fcmat, "Thermal/SpecificHeat", "");
|
|
QString thermalConductivity = value(fcmat, "Thermal/ThermalConductivity", "");
|
|
QString thermalExpansionCoefficient = value(fcmat, "Thermal/ThermalExpansionCoefficient", "");
|
|
|
|
if (specificHeat.length() + thermalConductivity.length() + thermalExpansionCoefficient.length()
|
|
> 0) {
|
|
finalModel->addPhysical(ModelUUIDs::ModelUUID_Thermal_Default);
|
|
|
|
// Now add the data
|
|
setPhysicalValue(finalModel, "SpecificHeat", specificHeat);
|
|
setPhysicalValue(finalModel, "ThermalConductivity", thermalConductivity);
|
|
setPhysicalValue(finalModel, "ThermalExpansionCoefficient", thermalExpansionCoefficient);
|
|
}
|
|
}
|
|
|
|
void MaterialConfigLoader::addFluid(const QMap<QString, QString>& fcmat,
|
|
const std::shared_ptr<Material>& finalModel)
|
|
{
|
|
QString density = value(fcmat, "Fluidic/Density", "");
|
|
QString dynamicViscosity = value(fcmat, "Fluidic/DynamicViscosity", "");
|
|
QString kinematicViscosity = value(fcmat, "Fluidic/KinematicViscosity", "");
|
|
QString prandtlNumber = value(fcmat, "Fluidic/PrandtlNumber", "");
|
|
|
|
// Check which model we need
|
|
bool useDensity = false;
|
|
bool useFluid = false;
|
|
if (density.length() > 0) {
|
|
useDensity = true;
|
|
}
|
|
if (dynamicViscosity.length() + kinematicViscosity.length() + prandtlNumber.length() > 0) {
|
|
useFluid = true;
|
|
}
|
|
|
|
if (useFluid) {
|
|
finalModel->addPhysical(ModelUUIDs::ModelUUID_Fluid_Default);
|
|
}
|
|
else if (useDensity) {
|
|
finalModel->addPhysical(ModelUUIDs::ModelUUID_Mechanical_Density);
|
|
}
|
|
|
|
// Now add the data
|
|
setPhysicalValue(finalModel, "Density", density);
|
|
setPhysicalValue(finalModel, "DynamicViscosity", dynamicViscosity);
|
|
setPhysicalValue(finalModel, "KinematicViscosity", kinematicViscosity);
|
|
setPhysicalValue(finalModel, "PrandtlNumber", prandtlNumber);
|
|
}
|
|
|
|
void MaterialConfigLoader::addMechanical(const QMap<QString, QString>& fcmat,
|
|
const std::shared_ptr<Material>& finalModel)
|
|
{
|
|
QString density = value(fcmat, "Mechanical/Density", "");
|
|
QString bulkModulus = value(fcmat, "Mechanical/BulkModulus", "");
|
|
QString poissonRatio = value(fcmat, "Mechanical/PoissonRatio", "");
|
|
QString shearModulus = value(fcmat, "Mechanical/ShearModulus", "");
|
|
QString youngsModulus = value(fcmat, "Mechanical/YoungsModulus", "");
|
|
QString angleOfFriction = value(fcmat, "Mechanical/AngleOfFriction", "");
|
|
QString compressiveStrength = value(fcmat, "Mechanical/CompressiveStrength", "");
|
|
QString fractureToughness = value(fcmat, "Mechanical/FractureToughness", "");
|
|
QString ultimateStrain = value(fcmat, "Mechanical/UltimateStrain", "");
|
|
QString ultimateTensileStrength = value(fcmat, "Mechanical/UltimateTensileStrength", "");
|
|
QString yieldStrength = value(fcmat, "Mechanical/YieldStrength", "");
|
|
QString stiffness = value(fcmat, "Mechanical/Stiffness", "");
|
|
|
|
// Check which model we need
|
|
bool useDensity = false;
|
|
bool useIso = false;
|
|
bool useLinearElastic = false;
|
|
if (density.length() > 0) {
|
|
useDensity = true;
|
|
}
|
|
if (bulkModulus.length() + poissonRatio.length() + shearModulus.length()
|
|
+ youngsModulus.length()
|
|
> 0) {
|
|
useIso = true;
|
|
}
|
|
if (angleOfFriction.length() + compressiveStrength.length() + fractureToughness.length()
|
|
+ ultimateStrain.length() + ultimateTensileStrength.length() + yieldStrength.length()
|
|
+ stiffness.length()
|
|
> 0) {
|
|
useLinearElastic = true;
|
|
}
|
|
|
|
if (useLinearElastic) {
|
|
finalModel->addPhysical(ModelUUIDs::ModelUUID_Mechanical_LinearElastic);
|
|
}
|
|
else {
|
|
if (useIso) {
|
|
finalModel->addPhysical(ModelUUIDs::ModelUUID_Mechanical_IsotropicLinearElastic);
|
|
}
|
|
if (useDensity) {
|
|
finalModel->addPhysical(ModelUUIDs::ModelUUID_Mechanical_Density);
|
|
}
|
|
}
|
|
|
|
// Now add the data
|
|
setPhysicalValue(finalModel, "Density", density);
|
|
setPhysicalValue(finalModel, "BulkModulus", bulkModulus);
|
|
setPhysicalValue(finalModel, "PoissonRatio", poissonRatio);
|
|
setPhysicalValue(finalModel, "ShearModulus", shearModulus);
|
|
setPhysicalValue(finalModel, "YoungsModulus", youngsModulus);
|
|
setPhysicalValue(finalModel, "AngleOfFriction", angleOfFriction);
|
|
setPhysicalValue(finalModel, "CompressiveStrength", compressiveStrength);
|
|
setPhysicalValue(finalModel, "FractureToughness", fractureToughness);
|
|
setPhysicalValue(finalModel, "UltimateStrain", ultimateStrain);
|
|
setPhysicalValue(finalModel, "UltimateTensileStrength", ultimateTensileStrength);
|
|
setPhysicalValue(finalModel, "YieldStrength", yieldStrength);
|
|
setPhysicalValue(finalModel, "Stiffness", stiffness);
|
|
}
|
|
|
|
void MaterialConfigLoader::addLegacy(const QMap<QString, QString>& fcmat,
|
|
const std::shared_ptr<Material>& finalModel)
|
|
{
|
|
for (auto const& legacy : fcmat.keys()) {
|
|
auto name = legacy;
|
|
int last = name.lastIndexOf(QStringLiteral("/"));
|
|
if (last > 0) {
|
|
name = name.mid(last + 1);
|
|
}
|
|
|
|
if (!finalModel->hasNonLegacyProperty(name)) {
|
|
setLegacyValue(finalModel, name.toStdString(), fcmat[legacy]);
|
|
}
|
|
}
|
|
}
|
|
|
|
std::shared_ptr<Material>
|
|
MaterialConfigLoader::getMaterialFromPath(const std::shared_ptr<MaterialLibraryLocal>& library,
|
|
const QString& path)
|
|
{
|
|
QString author = getAuthorAndLicense(path); // Place them both in the author field
|
|
|
|
QMap<QString, QString> fcmat;
|
|
if (!readFile(path, fcmat)) {
|
|
Base::Console().Log("Error reading '%s'\n", path.toStdString().c_str());
|
|
throw MaterialReadError();
|
|
}
|
|
|
|
// General section
|
|
// QString name = value(fcmat, "Name", ""); - always get the name from the filename
|
|
QFileInfo filepath(path);
|
|
QString name =
|
|
filepath.fileName().remove(QStringLiteral(".FCMat"), Qt::CaseInsensitive);
|
|
QString uuid = QUuid::createUuid().toString(QUuid::WithoutBraces);
|
|
|
|
QString description = value(fcmat, "Description", "");
|
|
QString sourceReference = value(fcmat, "ReferenceSource", "");
|
|
QString sourceURL = value(fcmat, "SourceURL", "");
|
|
|
|
auto baseLibrary =
|
|
reinterpret_cast<const std::shared_ptr<Materials::MaterialLibrary>&>(library);
|
|
std::shared_ptr<Material> finalModel =
|
|
std::make_shared<Material>(baseLibrary, path, uuid, name);
|
|
finalModel->setOldFormat(true);
|
|
|
|
finalModel->setAuthor(author);
|
|
finalModel->setDescription(description);
|
|
finalModel->setReference(sourceReference);
|
|
finalModel->setURL(sourceURL);
|
|
|
|
QString father = value(fcmat, "Father", "");
|
|
if (!father.isEmpty()) {
|
|
finalModel->addPhysical(ModelUUIDs::ModelUUID_Legacy_Father);
|
|
|
|
// Now add the data
|
|
setPhysicalValue(finalModel, "Father", father);
|
|
}
|
|
|
|
QString kindOfMaterial = value(fcmat, "KindOfMaterial", "");
|
|
QString materialNumber = value(fcmat, "MaterialNumber", "");
|
|
QString norm = value(fcmat, "Norm", "");
|
|
QString standardCode = value(fcmat, "StandardCode", "");
|
|
if (kindOfMaterial.length() + materialNumber.length() + norm.length() + standardCode.length()
|
|
> 0) {
|
|
finalModel->addPhysical(ModelUUIDs::ModelUUID_Legacy_MaterialStandard);
|
|
|
|
// Now add the data
|
|
setPhysicalValue(finalModel, "KindOfMaterial", kindOfMaterial);
|
|
setPhysicalValue(finalModel, "MaterialNumber", materialNumber);
|
|
setPhysicalValue(finalModel, "StandardCode", norm); // Norm is the same as StandardCode
|
|
setPhysicalValue(finalModel, "StandardCode", standardCode);
|
|
}
|
|
|
|
// Add the remaining sections
|
|
addMechanical(fcmat, finalModel);
|
|
addFluid(fcmat, finalModel);
|
|
addThermal(fcmat, finalModel);
|
|
addElectromagnetic(fcmat, finalModel);
|
|
addArchitectural(fcmat, finalModel);
|
|
addCosts(fcmat, finalModel);
|
|
addRendering(fcmat, finalModel);
|
|
addVectorRendering(fcmat, finalModel);
|
|
addRenderWB(fcmat, finalModel);
|
|
addLegacy(fcmat, finalModel);
|
|
|
|
return finalModel;
|
|
}
|