Mirrors/overte
3
0
Fork 0
mirror of https://github.com/overte-org/overte.git synced 2025-04-10 18:36:11 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

scriptablematerial -> scriptablemateriallayer

Browse source
This commit is contained in:
SamGondelman 2018-03-01 16:56:51 -08:00
parent e3b65a9201
commit a66125fbb7
5 changed files with 68 additions and 41 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

17
libraries/graphics-scripting/src/graphics-scripting/Forward.h
View file

@ -39,7 +39,7 @@ namespace scriptable {
class ScriptableMaterial {
public:
ScriptableMaterial() {}
ScriptableMaterial(const graphics::MaterialLayer& materialLayer);
ScriptableMaterial(const graphics::MaterialPointer& material);
ScriptableMaterial(const ScriptableMaterial& material) { *this = material; }
ScriptableMaterial& operator=(const ScriptableMaterial& material);
@ -64,9 +64,18 @@ namespace scriptable {
QString occlusionMap;
QString lightmapMap;
QString scatteringMap;
};
class ScriptableMaterialLayer {
public:
ScriptableMaterialLayer() {}
ScriptableMaterialLayer(const graphics::MaterialLayer& materialLayer) : material(materialLayer.material), priority(materialLayer.priority) {}
ScriptableMaterialLayer(const ScriptableMaterialLayer& materialLayer) { *this = materialLayer; }
ScriptableMaterialLayer& operator=(const ScriptableMaterialLayer& materialLayer);
ScriptableMaterial material;
quint16 priority;
};
typedef QHash<QString, QVector<scriptable::ScriptableMaterial>> MultiMaterialMap;
typedef QHash<QString, QVector<scriptable::ScriptableMaterialLayer>> MultiMaterialMap;
class ScriptableMeshBase : public QObject {
Q_OBJECT
@ -92,7 +101,7 @@ namespace scriptable {
WeakModelProviderPointer provider;
QUuid objectID; // spatially nestable ID
QVector<scriptable::ScriptableMeshBase> meshes;
MultiMaterialMap materials;
MultiMaterialMap materialLayers;
QVector<QString> materialNames;
ScriptableModelBase(QObject* parent = nullptr) : QObject(parent) {}
@ -102,7 +111,7 @@ namespace scriptable {
void append(const ScriptableMeshBase& mesh);
void append(scriptable::WeakMeshPointer mesh);
void appendMaterial(const graphics::MaterialLayer& material, int shapeID, std::string materialName);
void appendMaterial(const graphics::MaterialLayer& materialLayer, int shapeID, std::string materialName);
void appendMaterials(const std::unordered_map<std::string, graphics::MultiMaterial>& materialsToAppend);
void appendMaterialNames(const std::vector<std::string>& names);
// TODO: in future containers for these could go here

26
libraries/graphics-scripting/src/graphics-scripting/GraphicsScriptingInterface.cpp
View file

@ -298,7 +298,8 @@ namespace {
qRegisterMetaType<scriptable::ScriptableModelPointer>(),
qRegisterMetaType<scriptable::ScriptableMeshPartPointer>(),
qRegisterMetaType<scriptable::ScriptableMaterial>(),
qRegisterMetaType<QVector<scriptable::ScriptableMaterial>>(),
qRegisterMetaType<scriptable::ScriptableMaterialLayer>(),
qRegisterMetaType<QVector<scriptable::ScriptableMaterialLayer>>(),
qRegisterMetaType<scriptable::MultiMaterialMap>(),
qRegisterMetaType<graphics::Mesh::Topology>(),
};
@ -338,11 +339,11 @@ namespace scriptable {
);
}
QScriptValue qVectorScriptableMaterialToScriptValue(QScriptEngine* engine, const QVector<scriptable::ScriptableMaterial>& vector) {
QScriptValue qVectorScriptableMaterialLayerToScriptValue(QScriptEngine* engine, const QVector<scriptable::ScriptableMaterialLayer>& vector) {
return qScriptValueFromSequence(engine, vector);
}
void qVectorScriptableMaterialFromScriptValue(const QScriptValue& array, QVector<scriptable::ScriptableMaterial>& result) {
void qVectorScriptableMaterialLayerFromScriptValue(const QScriptValue& array, QVector<scriptable::ScriptableMaterialLayer>& result) {
qScriptValueToSequence(array, result);
}
@ -369,7 +370,6 @@ namespace scriptable {
obj.setProperty("occlusionMap", material.occlusionMap);
obj.setProperty("lightmapMap", material.lightmapMap);
obj.setProperty("scatteringMap", material.scatteringMap);
obj.setProperty("priority", material.priority);
return obj;
}
@ -377,10 +377,21 @@ namespace scriptable {
// No need to convert from QScriptValue to ScriptableMaterial
}
QScriptValue scriptableMaterialLayerToScriptValue(QScriptEngine* engine, const scriptable::ScriptableMaterialLayer &materialLayer) {
QScriptValue obj = engine->newObject();
obj.setProperty("material", scriptableMaterialToScriptValue(engine, materialLayer.material));
obj.setProperty("priority", materialLayer.priority);
return obj;
}
void scriptableMaterialLayerFromScriptValue(const QScriptValue &object, scriptable::ScriptableMaterialLayer& materialLayer) {
// No need to convert from QScriptValue to ScriptableMaterialLayer
}
QScriptValue multiMaterialMapToScriptValue(QScriptEngine* engine, const scriptable::MultiMaterialMap& map) {
QScriptValue obj = engine->newObject();
for (auto key : map.keys()) {
obj.setProperty(key, qVectorScriptableMaterialToScriptValue(engine, map[key]));
obj.setProperty(key, qVectorScriptableMaterialLayerToScriptValue(engine, map[key]));
}
return obj;
}
@ -405,7 +416,7 @@ namespace scriptable {
void GraphicsScriptingInterface::registerMetaTypes(QScriptEngine* engine) {
qScriptRegisterSequenceMetaType<QVector<glm::uint32>>(engine);
qScriptRegisterSequenceMetaType<QVector<scriptable::ScriptableMaterial>>(engine);
qScriptRegisterSequenceMetaType<QVector<scriptable::ScriptableMaterialLayer>>(engine);
scriptable::registerQPointerMetaType<scriptable::ScriptableModel>(engine);
scriptable::registerQPointerMetaType<scriptable::ScriptableMesh>(engine);
@ -417,7 +428,8 @@ void GraphicsScriptingInterface::registerMetaTypes(QScriptEngine* engine) {
scriptable::registerDebugEnum<gpu::Dimension>(engine, gpu::DIMENSIONS);
qScriptRegisterMetaType(engine, scriptable::scriptableMaterialToScriptValue, scriptable::scriptableMaterialFromScriptValue);
qScriptRegisterMetaType(engine, scriptable::qVectorScriptableMaterialToScriptValue, scriptable::qVectorScriptableMaterialFromScriptValue);
qScriptRegisterMetaType(engine, scriptable::scriptableMaterialLayerToScriptValue, scriptable::scriptableMaterialLayerFromScriptValue);
qScriptRegisterMetaType(engine, scriptable::qVectorScriptableMaterialLayerToScriptValue, scriptable::qVectorScriptableMaterialLayerFromScriptValue);
qScriptRegisterMetaType(engine, scriptable::multiMaterialMapToScriptValue, scriptable::multiMaterialMapFromScriptValue);
Q_UNUSED(metaTypeIds);

57
libraries/graphics-scripting/src/graphics-scripting/ScriptableModel.cpp
View file

@ -42,29 +42,27 @@ scriptable::ScriptableMaterial& scriptable::ScriptableMaterial::operator=(const
occlusionMap = material.occlusionMap;
lightmapMap = material.lightmapMap;
scatteringMap = material.scatteringMap;
priority = material.priority;
return *this;
}
scriptable::ScriptableMaterial::ScriptableMaterial(const graphics::MaterialLayer& materialLayer) :
name(materialLayer.material->getName().c_str()),
model(materialLayer.material->getModel().c_str()),
opacity(materialLayer.material->getOpacity()),
roughness(materialLayer.material->getRoughness()),
metallic(materialLayer.material->getMetallic()),
scattering(materialLayer.material->getScattering()),
unlit(materialLayer.material->isUnlit()),
emissive(materialLayer.material->getEmissive()),
albedo(materialLayer.material->getAlbedo()),
priority(materialLayer.priority)
scriptable::ScriptableMaterial::ScriptableMaterial(const graphics::MaterialPointer& material) :
name(material->getName().c_str()),
model(material->getModel().c_str()),
opacity(material->getOpacity()),
roughness(material->getRoughness()),
metallic(material->getMetallic()),
scattering(material->getScattering()),
unlit(material->isUnlit()),
emissive(material->getEmissive()),
albedo(material->getAlbedo())
{
auto map = materialLayer.material->getTextureMap(graphics::Material::MapChannel::EMISSIVE_MAP);
auto map = material->getTextureMap(graphics::Material::MapChannel::EMISSIVE_MAP);
if (map && map->getTextureSource()) {
emissiveMap = map->getTextureSource()->getUrl().toString();
}
map = materialLayer.material->getTextureMap(graphics::Material::MapChannel::ALBEDO_MAP);
map = material->getTextureMap(graphics::Material::MapChannel::ALBEDO_MAP);
if (map && map->getTextureSource()) {
albedoMap = map->getTextureSource()->getUrl().toString();
if (map->useAlphaChannel()) {
@ -72,7 +70,7 @@ scriptable::ScriptableMaterial::ScriptableMaterial(const graphics::MaterialLayer
}
}
map = materialLayer.material->getTextureMap(graphics::Material::MapChannel::METALLIC_MAP);
map = material->getTextureMap(graphics::Material::MapChannel::METALLIC_MAP);
if (map && map->getTextureSource()) {
if (map->getTextureSource()->getType() == image::TextureUsage::Type::METALLIC_TEXTURE) {
metallicMap = map->getTextureSource()->getUrl().toString();
@ -81,7 +79,7 @@ scriptable::ScriptableMaterial::ScriptableMaterial(const graphics::MaterialLayer
}
}
map = materialLayer.material->getTextureMap(graphics::Material::MapChannel::ROUGHNESS_MAP);
map = material->getTextureMap(graphics::Material::MapChannel::ROUGHNESS_MAP);
if (map && map->getTextureSource()) {
if (map->getTextureSource()->getType() == image::TextureUsage::Type::ROUGHNESS_TEXTURE) {
roughnessMap = map->getTextureSource()->getUrl().toString();
@ -90,7 +88,7 @@ scriptable::ScriptableMaterial::ScriptableMaterial(const graphics::MaterialLayer
}
}
map = materialLayer.material->getTextureMap(graphics::Material::MapChannel::NORMAL_MAP);
map = material->getTextureMap(graphics::Material::MapChannel::NORMAL_MAP);
if (map && map->getTextureSource()) {
if (map->getTextureSource()->getType() == image::TextureUsage::Type::NORMAL_TEXTURE) {
normalMap = map->getTextureSource()->getUrl().toString();
@ -99,29 +97,36 @@ scriptable::ScriptableMaterial::ScriptableMaterial(const graphics::MaterialLayer
}
}
map = materialLayer.material->getTextureMap(graphics::Material::MapChannel::OCCLUSION_MAP);
map = material->getTextureMap(graphics::Material::MapChannel::OCCLUSION_MAP);
if (map && map->getTextureSource()) {
occlusionMap = map->getTextureSource()->getUrl().toString();
}
map = materialLayer.material->getTextureMap(graphics::Material::MapChannel::LIGHTMAP_MAP);
map = material->getTextureMap(graphics::Material::MapChannel::LIGHTMAP_MAP);
if (map && map->getTextureSource()) {
lightmapMap = map->getTextureSource()->getUrl().toString();
}
map = materialLayer.material->getTextureMap(graphics::Material::MapChannel::SCATTERING_MAP);
map = material->getTextureMap(graphics::Material::MapChannel::SCATTERING_MAP);
if (map && map->getTextureSource()) {
scatteringMap = map->getTextureSource()->getUrl().toString();
}
}
scriptable::ScriptableMaterialLayer& scriptable::ScriptableMaterialLayer::operator=(const scriptable::ScriptableMaterialLayer& materialLayer) {
material = materialLayer.material;
priority = materialLayer.priority;
return *this;
}
scriptable::ScriptableModelBase& scriptable::ScriptableModelBase::operator=(const scriptable::ScriptableModelBase& other) {
provider = other.provider;
objectID = other.objectID;
for (const auto& mesh : other.meshes) {
append(mesh);
}
materials = other.materials;
materialLayers = other.materialLayers;
materialNames = other.materialNames;
return *this;
}
@ -135,7 +140,7 @@ scriptable::ScriptableModelBase::~ScriptableModelBase() {
m.strongMesh.reset();
}
meshes.clear();
materials.clear();
materialLayers.clear();
materialNames.clear();
}
@ -150,16 +155,16 @@ void scriptable::ScriptableModelBase::append(const ScriptableMeshBase& mesh) {
meshes << mesh;
}
void scriptable::ScriptableModelBase::appendMaterial(const graphics::MaterialLayer& material, int shapeID, std::string materialName) {
materials[QString::number(shapeID)].push_back(ScriptableMaterial(material));
materials["mat::" + QString::fromStdString(materialName)].push_back(ScriptableMaterial(material));
void scriptable::ScriptableModelBase::appendMaterial(const graphics::MaterialLayer& materialLayer, int shapeID, std::string materialName) {
materialLayers[QString::number(shapeID)].push_back(ScriptableMaterialLayer(materialLayer));
materialLayers["mat::" + QString::fromStdString(materialName)].push_back(ScriptableMaterialLayer(materialLayer));
}
void scriptable::ScriptableModelBase::appendMaterials(const std::unordered_map<std::string, graphics::MultiMaterial>& materialsToAppend) {
auto materialsToAppendCopy = materialsToAppend;
for (auto& multiMaterial : materialsToAppendCopy) {
while (!multiMaterial.second.empty()) {
materials[QString(multiMaterial.first.c_str())].push_back(ScriptableMaterial(multiMaterial.second.top()));
materialLayers[QString(multiMaterial.first.c_str())].push_back(ScriptableMaterialLayer(multiMaterial.second.top()));
multiMaterial.second.pop();
}
}

5
libraries/graphics-scripting/src/graphics-scripting/ScriptableModel.h
View file

@ -28,7 +28,7 @@ namespace scriptable {
Q_PROPERTY(QUuid objectID MEMBER objectID CONSTANT)
Q_PROPERTY(glm::uint32 numMeshes READ getNumMeshes)
Q_PROPERTY(ScriptableMeshes meshes READ getMeshes)
Q_PROPERTY(scriptable::MultiMaterialMap materials READ getMaterials)
Q_PROPERTY(scriptable::MultiMaterialMap materialLayers READ getMaterialLayers)
Q_PROPERTY(QVector<QString> materialNames READ getMaterialNames)
public:
@ -43,7 +43,7 @@ namespace scriptable {
ScriptableMeshes getMeshes();
const ScriptableMeshes getConstMeshes() const;
scriptable::MultiMaterialMap getMaterials() { return materials; }
scriptable::MultiMaterialMap getMaterialLayers() { return materialLayers; }
QVector<QString> getMaterialNames() { return materialNames; }
public slots:
@ -60,4 +60,5 @@ namespace scriptable {
Q_DECLARE_METATYPE(scriptable::ScriptableModelPointer)
Q_DECLARE_METATYPE(QVector<scriptable::ScriptableModelPointer>)
Q_DECLARE_METATYPE(scriptable::ScriptableMaterial)
Q_DECLARE_METATYPE(scriptable::ScriptableMaterialLayer)
Q_DECLARE_METATYPE(scriptable::MultiMaterialMap)

4
libraries/graphics/src/graphics/Material.h
View file

@ -356,9 +356,9 @@ public:
void setTextureTransforms(const Transform& transform);
const std::string& getName() { return _name; }
const std::string& getName() const { return _name; }
const std::string& getModel() { return _model; }
const std::string& getModel() const { return _model; }
void setModel(const std::string& model) { _model = model; }
protected: