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

remove fresnel, add unlit, fix overlays, cleanup

Browse source
This commit is contained in:
SamGondelman 2018-02-14 12:56:34 -08:00
parent 4500ed17e7
commit 324eefc914
37 changed files with 417 additions and 379 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
interface/resources/qml/hifi/tablet/NewMaterialDialog.qml
View file

@ -114,7 +114,7 @@ Rectangle {
}
ComboBox {
id: materialMode
id: materialMappingMode
property var materialArray: ["UV space material",
"3D projected material"]
@ -142,7 +142,7 @@ Rectangle {
method: "newMaterialDialogAdd",
params: {
textInput: materialURL.text,
//comboBox: materialMode.currentIndex
//comboBox: materialMappingMode.currentIndex
}
});
}

16
interface/src/Application.cpp
View file

@ -1593,37 +1593,37 @@ Application::Application(int& argc, char** argv, QElapsedTimer& startupTimer, bo
}
});
EntityTree::setAddMaterialToAvatarOperator([](const QUuid& avatarID, graphics::MaterialPointer material, const QString& parentMaterialID) {
EntityTree::setAddMaterialToAvatarOperator([](const QUuid& avatarID, graphics::MaterialPointer material, const QString& parentMaterialName) {
auto avatarManager = DependencyManager::get<AvatarManager>();
auto avatar = avatarManager->getAvatarBySessionID(avatarID);
if (avatar) {
avatar->addMaterial(material, parentMaterialID);
avatar->addMaterial(material, parentMaterialName);
return true;
}
return false;
});
EntityTree::setRemoveMaterialFromAvatarOperator([](const QUuid& avatarID, graphics::MaterialPointer material, const QString& parentMaterialID) {
EntityTree::setRemoveMaterialFromAvatarOperator([](const QUuid& avatarID, graphics::MaterialPointer material, const QString& parentMaterialName) {
auto avatarManager = DependencyManager::get<AvatarManager>();
auto avatar = avatarManager->getAvatarBySessionID(avatarID);
if (avatar) {
avatar->removeMaterial(material, parentMaterialID);
avatar->removeMaterial(material, parentMaterialName);
return true;
}
return false;
});
EntityTree::setAddMaterialToOverlayOperator([&](const QUuid& overlayID, graphics::MaterialPointer material, const QString& parentMaterialID) {
EntityTree::setAddMaterialToOverlayOperator([&](const QUuid& overlayID, graphics::MaterialPointer material, const QString& parentMaterialName) {
auto overlay = _overlays.getOverlay(overlayID);
if (overlay) {
overlay->addMaterial(material, parentMaterialID);
overlay->addMaterial(material, parentMaterialName);
return true;
}
return false;
});
EntityTree::setRemoveMaterialFromOverlayOperator([&](const QUuid& overlayID, graphics::MaterialPointer material, const QString& parentMaterialID) {
EntityTree::setRemoveMaterialFromOverlayOperator([&](const QUuid& overlayID, graphics::MaterialPointer material, const QString& parentMaterialName) {
auto overlay = _overlays.getOverlay(overlayID);
if (overlay) {
overlay->removeMaterial(material, parentMaterialID);
overlay->removeMaterial(material, parentMaterialName);
return true;
}
return false;

14
interface/src/ui/overlays/ModelOverlay.cpp
View file

@ -83,6 +83,7 @@ void ModelOverlay::update(float deltatime) {
auto modelOverlay = static_cast<ModelOverlay*>(&data);
modelOverlay->setSubRenderItemIDs(newRenderItemIDs);
});
processMaterials();
}
if (_visibleDirty) {
_visibleDirty = false;
@ -108,6 +109,7 @@ void ModelOverlay::update(float deltatime) {
bool ModelOverlay::addToScene(Overlay::Pointer overlay, const render::ScenePointer& scene, render::Transaction& transaction) {
Volume3DOverlay::addToScene(overlay, scene, transaction);
_model->addToScene(scene, transaction);
processMaterials();
return true;
}
@ -633,17 +635,17 @@ uint32_t ModelOverlay::fetchMetaSubItems(render::ItemIDs& subItems) const {
return 0;
}
void ModelOverlay::addMaterial(graphics::MaterialPointer material, const QString& parentMaterialID) {
Overlay::addMaterial(material, parentMaterialID);
void ModelOverlay::addMaterial(graphics::MaterialPointer material, const QString& parentMaterialName) {
Overlay::addMaterial(material, parentMaterialName);
if (_model && _model->fetchRenderItemIDs().size() > 0) {
_model->addMaterial(material, parentMaterialID);
_model->addMaterial(material, parentMaterialName);
}
}
void ModelOverlay::removeMaterial(graphics::MaterialPointer material, const QString& parentMaterialID) {
Overlay::removeMaterial(material, parentMaterialID);
void ModelOverlay::removeMaterial(graphics::MaterialPointer material, const QString& parentMaterialName) {
Overlay::removeMaterial(material, parentMaterialName);
if (_model && _model->fetchRenderItemIDs().size() > 0) {
_model->removeMaterial(material, parentMaterialID);
_model->removeMaterial(material, parentMaterialName);
}
}

4
interface/src/ui/overlays/ModelOverlay.h
View file

@ -59,8 +59,8 @@ public:
void setDrawInFront(bool drawInFront) override;
void setDrawHUDLayer(bool drawHUDLayer) override;
void addMaterial(graphics::MaterialPointer material, const QString& parentMaterialID) override;
void removeMaterial(graphics::MaterialPointer material, const QString& parentMaterialID) override;
void addMaterial(graphics::MaterialPointer material, const QString& parentMaterialName) override;
void removeMaterial(graphics::MaterialPointer material, const QString& parentMaterialName) override;
protected:
Transform evalRenderTransform() override;

8
interface/src/ui/overlays/Overlay.cpp
View file

@ -236,12 +236,12 @@ QVector<OverlayID> qVectorOverlayIDFromScriptValue(const QScriptValue& array) {
return newVector;
}
void Overlay::addMaterial(graphics::MaterialPointer material, const QString& parentMaterialID) {
void Overlay::addMaterial(graphics::MaterialPointer material, const QString& parentMaterialName) {
std::lock_guard<std::mutex> lock(_materialsLock);
_materials[parentMaterialID].push(material);
_materials[parentMaterialName].push(material);
}
void Overlay::removeMaterial(graphics::MaterialPointer material, const QString& parentMaterialID) {
void Overlay::removeMaterial(graphics::MaterialPointer material, const QString& parentMaterialName) {
std::lock_guard<std::mutex> lock(_materialsLock);
_materials[parentMaterialID].remove(material);
_materials[parentMaterialName].remove(material);
}

4
interface/src/ui/overlays/Overlay.h
View file

@ -91,8 +91,8 @@ public:
unsigned int getStackOrder() const { return _stackOrder; }
void setStackOrder(unsigned int stackOrder) { _stackOrder = stackOrder; }
virtual void addMaterial(graphics::MaterialPointer material, const QString& parentMaterialID);
virtual void removeMaterial(graphics::MaterialPointer material, const QString& parentMaterialID);
virtual void addMaterial(graphics::MaterialPointer material, const QString& parentMaterialName);
virtual void removeMaterial(graphics::MaterialPointer material, const QString& parentMaterialName);
protected:
float updatePulse();

12
libraries/avatars-renderer/src/avatars-renderer/Avatar.cpp
View file

@ -1763,19 +1763,19 @@ float Avatar::getUnscaledEyeHeightFromSkeleton() const {
}
}
void Avatar::addMaterial(graphics::MaterialPointer material, const QString& parentMaterialID) {
void Avatar::addMaterial(graphics::MaterialPointer material, const QString& parentMaterialName) {
std::lock_guard<std::mutex> lock(_materialsLock);
_materials[parentMaterialID].push(material);
_materials[parentMaterialName].push(material);
if (_skeletonModel && _skeletonModel->fetchRenderItemIDs().size() > 0) {
_skeletonModel->addMaterial(material, parentMaterialID);
_skeletonModel->addMaterial(material, parentMaterialName);
}
}
void Avatar::removeMaterial(graphics::MaterialPointer material, const QString& parentMaterialID) {
void Avatar::removeMaterial(graphics::MaterialPointer material, const QString& parentMaterialName) {
std::lock_guard<std::mutex> lock(_materialsLock);
_materials[parentMaterialID].remove(material);
_materials[parentMaterialName].remove(material);
if (_skeletonModel && _skeletonModel->fetchRenderItemIDs().size() > 0) {
_skeletonModel->removeMaterial(material, parentMaterialID);
_skeletonModel->removeMaterial(material, parentMaterialName);
}
}

4
libraries/avatars-renderer/src/avatars-renderer/Avatar.h
View file

@ -272,8 +272,8 @@ public:
virtual void setAvatarEntityDataChanged(bool value) override;
void addMaterial(graphics::MaterialPointer material, const QString& parentMaterialID) override;
void removeMaterial(graphics::MaterialPointer material, const QString& parentMaterialID) override;
void addMaterial(graphics::MaterialPointer material, const QString& parentMaterialName) override;
void removeMaterial(graphics::MaterialPointer material, const QString& parentMaterialName) override;
public slots:

4
libraries/avatars/src/AvatarData.h
View file

@ -696,8 +696,8 @@ public:
bool getIsReplicated() const { return _isReplicated; }
virtual void addMaterial(graphics::MaterialPointer material, const QString& parentMaterialID) {}
virtual void removeMaterial(graphics::MaterialPointer material, const QString& parentMaterialID) {}
virtual void addMaterial(graphics::MaterialPointer material, const QString& parentMaterialName) {}
virtual void removeMaterial(graphics::MaterialPointer material, const QString& parentMaterialName) {}
signals:
void displayNameChanged();

8
libraries/entities-renderer/src/RenderableEntityItem.cpp
View file

@ -404,12 +404,12 @@ void EntityRenderer::onRemoveFromScene(const EntityItemPointer& entity) {
QObject::disconnect(this, &EntityRenderer::requestRenderUpdate, this, nullptr);
}
void EntityRenderer::addMaterial(graphics::MaterialPointer material, const QString& parentMaterialID) {
void EntityRenderer::addMaterial(graphics::MaterialPointer material, const QString& parentMaterialName) {
std::lock_guard<std::mutex> lock(_materialsLock);
_materials[parentMaterialID].push(material);
_materials[parentMaterialName].push(material);
}
void EntityRenderer::removeMaterial(graphics::MaterialPointer material, const QString& parentMaterialID) {
void EntityRenderer::removeMaterial(graphics::MaterialPointer material, const QString& parentMaterialName) {
std::lock_guard<std::mutex> lock(_materialsLock);
_materials[parentMaterialID].remove(material);
_materials[parentMaterialName].remove(material);
}

4
libraries/entities-renderer/src/RenderableEntityItem.h
View file

@ -102,8 +102,8 @@ protected:
}
public slots:
virtual void addMaterial(graphics::MaterialPointer material, const QString& parentMaterialID);
virtual void removeMaterial(graphics::MaterialPointer material, const QString& parentMaterialID);
virtual void addMaterial(graphics::MaterialPointer material, const QString& parentMaterialName);
virtual void removeMaterial(graphics::MaterialPointer material, const QString& parentMaterialName);
signals:
void requestRenderUpdate();

14
libraries/entities-renderer/src/RenderableMaterialEntityItem.cpp
View file

@ -18,7 +18,7 @@ bool MaterialEntityRenderer::needsRenderUpdateFromTypedEntity(const TypedEntityP
if (entity->getParentID() != _parentID || entity->getClientOnly() != _clientOnly || entity->getOwningAvatarID() != _owningAvatarID) {
return true;
}
if (entity->getMaterialPos() != _materialPos || entity->getMaterialScale() != _materialScale || entity->getMaterialRot() != _materialRot) {
if (entity->getMaterialMappingPos() != _materialMappingPos || entity->getMaterialMappingScale() != _materialMappingScale || entity->getMaterialMappingRot() != _materialMappingRot) {
return true;
}
return false;
@ -30,9 +30,9 @@ void MaterialEntityRenderer::doRenderUpdateSynchronousTyped(const ScenePointer&
_parentID = entity->getParentID();
_clientOnly = entity->getClientOnly();
_owningAvatarID = entity->getOwningAvatarID();
_materialPos = entity->getMaterialPos();
_materialScale = entity->getMaterialScale();
_materialRot = entity->getMaterialRot();
_materialMappingPos = entity->getMaterialMappingPos();
_materialMappingScale = entity->getMaterialMappingScale();
_materialMappingRot = entity->getMaterialMappingRot();
_renderTransform = getModelTransform();
const float MATERIAL_ENTITY_SCALE = 0.5f;
_renderTransform.postScale(MATERIAL_ENTITY_SCALE);
@ -238,9 +238,9 @@ void MaterialEntityRenderer::doRender(RenderArgs* args) {
parentID = _clientOnly ? _owningAvatarID : _parentID;
renderTransform = _renderTransform;
drawMaterial = _drawMaterial;
textureTransform.setTranslation(glm::vec3(_materialPos, 0));
textureTransform.setRotation(glm::vec3(0, 0, glm::radians(_materialRot)));
textureTransform.setScale(glm::vec3(_materialScale, 1));
textureTransform.setTranslation(glm::vec3(_materialMappingPos, 0));
textureTransform.setRotation(glm::vec3(0, 0, glm::radians(_materialMappingRot)));
textureTransform.setScale(glm::vec3(_materialMappingScale, 1));
});
if (!parentID.isNull() || !drawMaterial) {
return;

6
libraries/entities-renderer/src/RenderableMaterialEntityItem.h
View file

@ -34,9 +34,9 @@ private:
QUuid _parentID;
bool _clientOnly;
QUuid _owningAvatarID;
glm::vec2 _materialPos;
glm::vec2 _materialScale;
float _materialRot;
glm::vec2 _materialMappingPos;
glm::vec2 _materialMappingScale;
float _materialMappingRot;
Transform _renderTransform;
std::shared_ptr<NetworkMaterial> _drawMaterial;

12
libraries/entities-renderer/src/RenderableModelEntityItem.cpp
View file

@ -1467,17 +1467,17 @@ void ModelEntityRenderer::mapJoints(const TypedEntityPointer& entity, const QStr
}
}
void ModelEntityRenderer::addMaterial(graphics::MaterialPointer material, const QString& parentMaterialID) {
Parent::addMaterial(material, parentMaterialID);
void ModelEntityRenderer::addMaterial(graphics::MaterialPointer material, const QString& parentMaterialName) {
Parent::addMaterial(material, parentMaterialName);
if (_model && _model->fetchRenderItemIDs().size() > 0) {
_model->addMaterial(material, parentMaterialID);
_model->addMaterial(material, parentMaterialName);
}
}
void ModelEntityRenderer::removeMaterial(graphics::MaterialPointer material, const QString& parentMaterialID) {
Parent::removeMaterial(material, parentMaterialID);
void ModelEntityRenderer::removeMaterial(graphics::MaterialPointer material, const QString& parentMaterialName) {
Parent::removeMaterial(material, parentMaterialName);
if (_model && _model->fetchRenderItemIDs().size() > 0) {
_model->removeMaterial(material, parentMaterialID);
_model->removeMaterial(material, parentMaterialName);
}
}

4
libraries/entities-renderer/src/RenderableModelEntityItem.h
View file

@ -144,8 +144,8 @@ public:
ModelEntityRenderer(const EntityItemPointer& entity);
public slots:
void addMaterial(graphics::MaterialPointer material, const QString& parentMaterialID) override;
void removeMaterial(graphics::MaterialPointer material, const QString& parentMaterialID) override;
void addMaterial(graphics::MaterialPointer material, const QString& parentMaterialName) override;
void removeMaterial(graphics::MaterialPointer material, const QString& parentMaterialName) override;
protected:
virtual void removeFromScene(const ScenePointer& scene, Transaction& transaction) override;

12
libraries/entities/src/EntityItem.cpp
View file

@ -2940,16 +2940,16 @@ void EntityItem::preDelete() {
}
}
void EntityItem::addMaterial(graphics::MaterialPointer material, const QString& parentMaterialID) {
void EntityItem::addMaterial(graphics::MaterialPointer material, const QString& parentMaterialName) {
std::lock_guard<std::mutex> lock(_materialsLock);
_materials[parentMaterialID].push(material);
emit addMaterialToRenderItem(material, parentMaterialID);
_materials[parentMaterialName].push(material);
emit addMaterialToRenderItem(material, parentMaterialName);
}
void EntityItem::removeMaterial(graphics::MaterialPointer material, const QString& parentMaterialID) {
void EntityItem::removeMaterial(graphics::MaterialPointer material, const QString& parentMaterialName) {
std::lock_guard<std::mutex> lock(_materialsLock);
_materials[parentMaterialID].remove(material);
emit removeMaterialFromRenderItem(material, parentMaterialID);
_materials[parentMaterialName].remove(material);
emit removeMaterialFromRenderItem(material, parentMaterialName);
}
std::unordered_map<QString, graphics::MultiMaterial> EntityItem::getMaterials() {

8
libraries/entities/src/EntityItem.h
View file

@ -482,14 +482,14 @@ public:
virtual void preDelete();
virtual void postParentFixup() {}
void addMaterial(graphics::MaterialPointer material, const QString& parentMaterialID);
void removeMaterial(graphics::MaterialPointer material, const QString& parentMaterialID);
void addMaterial(graphics::MaterialPointer material, const QString& parentMaterialName);
void removeMaterial(graphics::MaterialPointer material, const QString& parentMaterialName);
std::unordered_map<QString, graphics::MultiMaterial> getMaterials();
signals:
void requestRenderUpdate();
void addMaterialToRenderItem(graphics::MaterialPointer material, const QString& parentMaterialID);
void removeMaterialFromRenderItem(graphics::MaterialPointer material, const QString& parentMaterialID);
void addMaterialToRenderItem(graphics::MaterialPointer material, const QString& parentMaterialName);
void removeMaterialFromRenderItem(graphics::MaterialPointer material, const QString& parentMaterialName);
protected:
QHash<ChangeHandlerId, ChangeHandlerCallback> _changeHandlers;

120
libraries/entities/src/EntityItemProperties.cpp
View file

@ -115,15 +115,15 @@ void buildStringToShapeTypeLookup() {
addShapeType(SHAPE_TYPE_STATIC_MESH);
}
QHash<QString, MaterialMode> stringToMaterialModeLookup;
QHash<QString, MaterialMappingMode> stringToMaterialMappingModeLookup;
void addMaterialMode(MaterialMode mode) {
stringToMaterialModeLookup[MaterialModeHelpers::getNameForMaterialMode(mode)] = mode;
void addMaterialMappingMode(MaterialMappingMode mode) {
stringToMaterialMappingModeLookup[MaterialMappingModeHelpers::getNameForMaterialMappingMode(mode)] = mode;
}
void buildStringToMaterialModeLookup() {
addMaterialMode(UV);
addMaterialMode(PROJECTED);
void buildStringToMaterialMappingModeLookup() {
addMaterialMappingMode(UV);
addMaterialMappingMode(PROJECTED);
}
QString getCollisionGroupAsString(uint8_t group) {
@ -270,18 +270,18 @@ void EntityItemProperties::setSkyboxModeFromString(const QString& skyboxMode) {
}
}
QString EntityItemProperties::getMaterialModeAsString() const {
return MaterialModeHelpers::getNameForMaterialMode(_materialMode);
QString EntityItemProperties::getMaterialMappingModeAsString() const {
return MaterialMappingModeHelpers::getNameForMaterialMappingMode(_materialMappingMode);
}
void EntityItemProperties::setMaterialModeFromString(const QString& materialMode) {
if (stringToMaterialModeLookup.empty()) {
buildStringToMaterialModeLookup();
void EntityItemProperties::setMaterialMappingModeFromString(const QString& materialMappingMode) {
if (stringToMaterialMappingModeLookup.empty()) {
buildStringToMaterialMappingModeLookup();
}
auto materialModeItr = stringToMaterialModeLookup.find(materialMode.toLower());
if (materialModeItr != stringToMaterialModeLookup.end()) {
_materialMode = materialModeItr.value();
_materialModeChanged = true;
auto materialMappingModeItr = stringToMaterialMappingModeLookup.find(materialMappingMode.toLower());
if (materialMappingModeItr != stringToMaterialMappingModeLookup.end()) {
_materialMappingMode = materialMappingModeItr.value();
_materialMappingModeChanged = true;
}
}
@ -356,12 +356,12 @@ EntityPropertyFlags EntityItemProperties::getChangedProperties() const {
CHECK_PROPERTY_CHANGE(PROP_RADIUS_START, radiusStart);
CHECK_PROPERTY_CHANGE(PROP_RADIUS_FINISH, radiusFinish);
CHECK_PROPERTY_CHANGE(PROP_MATERIAL_URL, materialURL);
CHECK_PROPERTY_CHANGE(PROP_MATERIAL_TYPE, materialMode);
CHECK_PROPERTY_CHANGE(PROP_MATERIAL_MAPPING_MODE, materialMappingMode);
CHECK_PROPERTY_CHANGE(PROP_MATERIAL_PRIORITY, priority);
CHECK_PROPERTY_CHANGE(PROP_PARENT_MATERIAL_ID, parentMaterialID);
CHECK_PROPERTY_CHANGE(PROP_MATERIAL_POS, materialPos);
CHECK_PROPERTY_CHANGE(PROP_MATERIAL_SCALE, materialScale);
CHECK_PROPERTY_CHANGE(PROP_MATERIAL_ROT, materialRot);
CHECK_PROPERTY_CHANGE(PROP_PARENT_MATERIAL_NAME, parentMaterialName);
CHECK_PROPERTY_CHANGE(PROP_MATERIAL_MAPPING_POS, materialMappingPos);
CHECK_PROPERTY_CHANGE(PROP_MATERIAL_MAPPING_SCALE, materialMappingScale);
CHECK_PROPERTY_CHANGE(PROP_MATERIAL_MAPPING_ROT, materialMappingRot);
// Certifiable Properties
CHECK_PROPERTY_CHANGE(PROP_ITEM_NAME, itemName);
@ -661,12 +661,12 @@ QScriptValue EntityItemProperties::copyToScriptValue(QScriptEngine* engine, bool
// Materials
if (_type == EntityTypes::Material) {
COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_MATERIAL_URL, materialURL);
COPY_PROPERTY_TO_QSCRIPTVALUE_GETTER(PROP_MATERIAL_TYPE, materialMode, getMaterialModeAsString());
COPY_PROPERTY_TO_QSCRIPTVALUE_GETTER(PROP_MATERIAL_MAPPING_MODE, materialMappingMode, getMaterialMappingModeAsString());
COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_MATERIAL_PRIORITY, priority);
COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_PARENT_MATERIAL_ID, parentMaterialID);
COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_MATERIAL_POS, materialPos);
COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_MATERIAL_SCALE, materialScale);
COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_MATERIAL_ROT, materialRot);
COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_PARENT_MATERIAL_NAME, parentMaterialName);
COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_MATERIAL_MAPPING_POS, materialMappingPos);
COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_MATERIAL_MAPPING_SCALE, materialMappingScale);
COPY_PROPERTY_TO_QSCRIPTVALUE(PROP_MATERIAL_MAPPING_ROT, materialMappingRot);
}
if (!skipDefaults && !strictSemantics) {
@ -803,12 +803,12 @@ void EntityItemProperties::copyFromScriptValue(const QScriptValue& object, bool
COPY_PROPERTY_FROM_QSCRIPTVALUE(radiusFinish, float, setRadiusFinish);
COPY_PROPERTY_FROM_QSCRIPTVALUE(relayParentJoints, bool, setRelayParentJoints);
COPY_PROPERTY_FROM_QSCRIPTVALUE(materialURL, QString, setMaterialURL);
COPY_PROPERTY_FROM_QSCRIPTVALUE_ENUM(materialMode, MaterialMode);
COPY_PROPERTY_FROM_QSCRIPTVALUE_ENUM(materialMappingMode, MaterialMappingMode);
COPY_PROPERTY_FROM_QSCRIPTVALUE(priority, quint16, setPriority);
COPY_PROPERTY_FROM_QSCRIPTVALUE(parentMaterialID, QString, setParentMaterialID);
COPY_PROPERTY_FROM_QSCRIPTVALUE(materialPos, glmVec2, setMaterialPos);
COPY_PROPERTY_FROM_QSCRIPTVALUE(materialScale, glmVec2, setMaterialScale);
COPY_PROPERTY_FROM_QSCRIPTVALUE(materialRot, float, setMaterialRot);
COPY_PROPERTY_FROM_QSCRIPTVALUE(parentMaterialName, QString, setParentMaterialName);
COPY_PROPERTY_FROM_QSCRIPTVALUE(materialMappingPos, glmVec2, setMaterialMappingPos);
COPY_PROPERTY_FROM_QSCRIPTVALUE(materialMappingScale, glmVec2, setMaterialMappingScale);
COPY_PROPERTY_FROM_QSCRIPTVALUE(materialMappingRot, float, setMaterialMappingRot);
// Certifiable Properties
COPY_PROPERTY_FROM_QSCRIPTVALUE(itemName, QString, setItemName);
@ -1164,12 +1164,12 @@ void EntityItemProperties::entityPropertyFlagsFromScriptValue(const QScriptValue
ADD_PROPERTY_TO_MAP(PROP_RADIUS_FINISH, RadiusFinish, radiusFinish, float);
ADD_PROPERTY_TO_MAP(PROP_MATERIAL_URL, MaterialURL, materialURL, QString);
ADD_PROPERTY_TO_MAP(PROP_MATERIAL_TYPE, MaterialMode, materialMode, MaterialMode);
ADD_PROPERTY_TO_MAP(PROP_MATERIAL_MAPPING_MODE, MaterialMappingMode, materialMappingMode, MaterialMappingMode);
ADD_PROPERTY_TO_MAP(PROP_MATERIAL_PRIORITY, Priority, priority, quint16);
ADD_PROPERTY_TO_MAP(PROP_PARENT_MATERIAL_ID, ParentMaterialID, parentMaterialID, QString);
ADD_PROPERTY_TO_MAP(PROP_MATERIAL_POS, MaterialPos, materialPos, glmVec2);
ADD_PROPERTY_TO_MAP(PROP_MATERIAL_SCALE, MaterialScale, materialScale, glmVec2);
ADD_PROPERTY_TO_MAP(PROP_MATERIAL_ROT, MaterialRot, materialRot, float);
ADD_PROPERTY_TO_MAP(PROP_PARENT_MATERIAL_NAME, ParentMaterialName, parentMaterialName, QString);
ADD_PROPERTY_TO_MAP(PROP_MATERIAL_MAPPING_POS, MaterialMappingPos, materialMappingPos, glmVec2);
ADD_PROPERTY_TO_MAP(PROP_MATERIAL_MAPPING_SCALE, MaterialMappingScale, materialMappingScale, glmVec2);
ADD_PROPERTY_TO_MAP(PROP_MATERIAL_MAPPING_ROT, MaterialMappingRot, materialMappingRot, float);
// Certifiable Properties
ADD_PROPERTY_TO_MAP(PROP_ITEM_NAME, ItemName, itemName, QString);
@ -1557,12 +1557,12 @@ OctreeElement::AppendState EntityItemProperties::encodeEntityEditPacket(PacketTy
// Materials
if (properties.getType() == EntityTypes::Material) {
APPEND_ENTITY_PROPERTY(PROP_MATERIAL_URL, properties.getMaterialURL());
APPEND_ENTITY_PROPERTY(PROP_MATERIAL_TYPE, (uint32_t)properties.getMaterialMode());
APPEND_ENTITY_PROPERTY(PROP_MATERIAL_MAPPING_MODE, (uint32_t)properties.getMaterialMappingMode());
APPEND_ENTITY_PROPERTY(PROP_MATERIAL_PRIORITY, properties.getPriority());
APPEND_ENTITY_PROPERTY(PROP_PARENT_MATERIAL_ID, properties.getParentMaterialID());
APPEND_ENTITY_PROPERTY(PROP_MATERIAL_POS, properties.getMaterialPos());
APPEND_ENTITY_PROPERTY(PROP_MATERIAL_SCALE, properties.getMaterialScale());
APPEND_ENTITY_PROPERTY(PROP_MATERIAL_ROT, properties.getMaterialRot());
APPEND_ENTITY_PROPERTY(PROP_PARENT_MATERIAL_NAME, properties.getParentMaterialName());
APPEND_ENTITY_PROPERTY(PROP_MATERIAL_MAPPING_POS, properties.getMaterialMappingPos());
APPEND_ENTITY_PROPERTY(PROP_MATERIAL_MAPPING_SCALE, properties.getMaterialMappingScale());
APPEND_ENTITY_PROPERTY(PROP_MATERIAL_MAPPING_ROT, properties.getMaterialMappingRot());
}
APPEND_ENTITY_PROPERTY(PROP_NAME, properties.getName());
@ -1924,12 +1924,12 @@ bool EntityItemProperties::decodeEntityEditPacket(const unsigned char* data, int
// Materials
if (properties.getType() == EntityTypes::Material) {
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_MATERIAL_URL, QString, setMaterialURL);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_MATERIAL_TYPE, MaterialMode, setMaterialMode);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_MATERIAL_MAPPING_MODE, MaterialMappingMode, setMaterialMappingMode);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_MATERIAL_PRIORITY, quint16, setPriority);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_PARENT_MATERIAL_ID, QString, setParentMaterialID);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_MATERIAL_POS, glmVec2, setMaterialPos);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_MATERIAL_SCALE, glmVec2, setMaterialScale);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_MATERIAL_ROT, float, setMaterialRot);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_PARENT_MATERIAL_NAME, QString, setParentMaterialName);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_MATERIAL_MAPPING_POS, glmVec2, setMaterialMappingPos);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_MATERIAL_MAPPING_SCALE, glmVec2, setMaterialMappingScale);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_MATERIAL_MAPPING_ROT, float, setMaterialMappingRot);
}
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_NAME, QString, setName);
@ -2106,12 +2106,12 @@ void EntityItemProperties::markAllChanged() {
//_alphaFinishChanged = true;
_materialURLChanged = true;
_materialModeChanged = true;
_materialMappingModeChanged = true;
_priorityChanged = true;
_parentMaterialIDChanged = true;
_materialPosChanged = true;
_materialScaleChanged = true;
_materialRotChanged = true;
_parentMaterialNameChanged = true;
_materialMappingPosChanged = true;
_materialMappingScaleChanged = true;
_materialMappingRotChanged = true;
// Certifiable Properties
_itemNameChanged = true;
@ -2439,23 +2439,23 @@ QList<QString> EntityItemProperties::listChangedProperties() {
if (materialURLChanged()) {
out += "materialURL";
}
if (materialModeChanged()) {
out += "materialMode";
if (materialMappingModeChanged()) {
out += "materialMappingMode";
}
if (priorityChanged()) {
out += "priority";
}
if (parentMaterialIDChanged()) {
out += "parentMaterialID";
if (parentMaterialNameChanged()) {
out += "parentMaterialName";
}
if (materialPosChanged()) {
out += "materialPos";
if (materialMappingPosChanged()) {
out += "materialMappingPos";
}
if (materialScaleChanged()) {
out += "materialScale";
if (materialMappingScaleChanged()) {
out += "materialMappingScale";
}
if (materialRotChanged()) {
out += "materialRot";
if (materialMappingRotChanged()) {
out += "materialMappingRot";
}
// Certifiable Properties

12
libraries/entities/src/EntityItemProperties.h
View file

@ -44,7 +44,7 @@
#include "TextEntityItem.h"
#include "ZoneEntityItem.h"
#include "MaterialMode.h"
#include "MaterialMappingMode.h"
const quint64 UNKNOWN_CREATED_TIME = 0;
@ -223,12 +223,12 @@ public:
DEFINE_PROPERTY_REF(PROP_SHAPE, Shape, shape, QString, "Sphere");
DEFINE_PROPERTY_REF(PROP_MATERIAL_URL, MaterialURL, materialURL, QString, "");
DEFINE_PROPERTY_REF_ENUM(PROP_MATERIAL_TYPE, MaterialMode, materialMode, MaterialMode, UV);
DEFINE_PROPERTY_REF_ENUM(PROP_MATERIAL_MAPPING_MODE, MaterialMappingMode, materialMappingMode, MaterialMappingMode, UV);
DEFINE_PROPERTY_REF(PROP_MATERIAL_PRIORITY, Priority, priority, quint16, 0);
DEFINE_PROPERTY_REF(PROP_PARENT_MATERIAL_ID, ParentMaterialID, parentMaterialID, QString, "0");
DEFINE_PROPERTY_REF(PROP_MATERIAL_POS, MaterialPos, materialPos, glmVec2, glm::vec2(0, 0));
DEFINE_PROPERTY_REF(PROP_MATERIAL_SCALE, MaterialScale, materialScale, glmVec2, glm::vec2(1, 1));
DEFINE_PROPERTY_REF(PROP_MATERIAL_ROT, MaterialRot, materialRot, float, 0);
DEFINE_PROPERTY_REF(PROP_PARENT_MATERIAL_NAME, ParentMaterialName, parentMaterialName, QString, "0");
DEFINE_PROPERTY_REF(PROP_MATERIAL_MAPPING_POS, MaterialMappingPos, materialMappingPos, glmVec2, glm::vec2(0, 0));
DEFINE_PROPERTY_REF(PROP_MATERIAL_MAPPING_SCALE, MaterialMappingScale, materialMappingScale, glmVec2, glm::vec2(1, 1));
DEFINE_PROPERTY_REF(PROP_MATERIAL_MAPPING_ROT, MaterialMappingRot, materialMappingRot, float, 0);
// Certifiable Properties - related to Proof of Purchase certificates
DEFINE_PROPERTY_REF(PROP_ITEM_NAME, ItemName, itemName, QString, ENTITY_ITEM_DEFAULT_ITEM_NAME);

10
libraries/entities/src/EntityPropertyFlags.h
View file

@ -228,12 +228,12 @@ enum EntityPropertyList {
PROP_LOCAL_DIMENSIONS, // only used to convert values to and from scripts
PROP_MATERIAL_URL,
PROP_MATERIAL_TYPE,
PROP_MATERIAL_MAPPING_MODE,
PROP_MATERIAL_PRIORITY,
PROP_PARENT_MATERIAL_ID,
PROP_MATERIAL_POS,
PROP_MATERIAL_SCALE,
PROP_MATERIAL_ROT,
PROP_PARENT_MATERIAL_NAME,
PROP_MATERIAL_MAPPING_POS,
PROP_MATERIAL_MAPPING_SCALE,
PROP_MATERIAL_MAPPING_ROT,
////////////////////////////////////////////////////////////////////////////////////////////////////
// ATTENTION: add new properties to end of list just ABOVE this line

31
libraries/entities/src/EntityTree.cpp
View file

@ -1740,18 +1740,15 @@ void EntityTree::fixupNeedsParentFixups() {
});
entity->locationChanged(true);
entity->postParentFixup();
} else if (_avatarIDs.contains(entity->getParentID())) {
if (getIsServer()) {
// this is a child of an avatar, which the entity server will never have
// a SpatiallyNestable object for. Add it to a list for cleanup when the avatar leaves.
if (!_childrenOfAvatars.contains(entity->getParentID())) {
_childrenOfAvatars[entity->getParentID()] = QSet<EntityItemID>();
}
_childrenOfAvatars[entity->getParentID()] += entity->getEntityItemID();
} else if (getIsServer() || _avatarIDs.contains(entity->getParentID())) {
// this is a child of an avatar, which the entity server will never have
// a SpatiallyNestable object for. Add it to a list for cleanup when the avatar leaves.
if (!_childrenOfAvatars.contains(entity->getParentID())) {
_childrenOfAvatars[entity->getParentID()] = QSet<EntityItemID>();
}
_childrenOfAvatars[entity->getParentID()] += entity->getEntityItemID();
doMove = true;
iter.remove(); // and pull it out of the list
entity->postParentFixup();
}
if (queryAACubeSuccess && doMove) {
@ -2394,30 +2391,30 @@ std::function<bool(const QUuid&, graphics::MaterialPointer, const QString&)> Ent
std::function<bool(const QUuid&, graphics::MaterialPointer, const QString&)> EntityTree::_addMaterialToOverlayOperator = nullptr;
std::function<bool(const QUuid&, graphics::MaterialPointer, const QString&)> EntityTree::_removeMaterialFromOverlayOperator = nullptr;
bool EntityTree::addMaterialToAvatar(const QUuid& avatarID, graphics::MaterialPointer material, const QString& parentMaterialID) {
bool EntityTree::addMaterialToAvatar(const QUuid& avatarID, graphics::MaterialPointer material, const QString& parentMaterialName) {
if (_addMaterialToAvatarOperator) {
return _addMaterialToAvatarOperator(avatarID, material, parentMaterialID);
return _addMaterialToAvatarOperator(avatarID, material, parentMaterialName);
}
return false;
}
bool EntityTree::removeMaterialFromAvatar(const QUuid& avatarID, graphics::MaterialPointer material, const QString& parentMaterialID) {
bool EntityTree::removeMaterialFromAvatar(const QUuid& avatarID, graphics::MaterialPointer material, const QString& parentMaterialName) {
if (_removeMaterialFromAvatarOperator) {
return _removeMaterialFromAvatarOperator(avatarID, material, parentMaterialID);
return _removeMaterialFromAvatarOperator(avatarID, material, parentMaterialName);
}
return false;
}
bool EntityTree::addMaterialToOverlay(const QUuid& overlayID, graphics::MaterialPointer material, const QString& parentMaterialID) {
bool EntityTree::addMaterialToOverlay(const QUuid& overlayID, graphics::MaterialPointer material, const QString& parentMaterialName) {
if (_addMaterialToOverlayOperator) {
return _addMaterialToOverlayOperator(overlayID, material, parentMaterialID);
return _addMaterialToOverlayOperator(overlayID, material, parentMaterialName);
}
return false;
}
bool EntityTree::removeMaterialFromOverlay(const QUuid& overlayID, graphics::MaterialPointer material, const QString& parentMaterialID) {
bool EntityTree::removeMaterialFromOverlay(const QUuid& overlayID, graphics::MaterialPointer material, const QString& parentMaterialName) {
if (_removeMaterialFromOverlayOperator) {
return _removeMaterialFromOverlayOperator(overlayID, material, parentMaterialID);
return _removeMaterialFromOverlayOperator(overlayID, material, parentMaterialName);
}
return false;
}

8
libraries/entities/src/EntityTree.h
View file

@ -282,13 +282,13 @@ public:
static void setAddMaterialToAvatarOperator(std::function<bool(const QUuid&, graphics::MaterialPointer, const QString&)> addMaterialToAvatarOperator) { _addMaterialToAvatarOperator = addMaterialToAvatarOperator; }
static void setRemoveMaterialFromAvatarOperator(std::function<bool(const QUuid&, graphics::MaterialPointer, const QString&)> removeMaterialFromAvatarOperator) { _removeMaterialFromAvatarOperator = removeMaterialFromAvatarOperator; }
static bool addMaterialToAvatar(const QUuid& avatarID, graphics::MaterialPointer material, const QString& parentMaterialID);
static bool removeMaterialFromAvatar(const QUuid& avatarID, graphics::MaterialPointer material, const QString& parentMaterialID);
static bool addMaterialToAvatar(const QUuid& avatarID, graphics::MaterialPointer material, const QString& parentMaterialName);
static bool removeMaterialFromAvatar(const QUuid& avatarID, graphics::MaterialPointer material, const QString& parentMaterialName);
static void setAddMaterialToOverlayOperator(std::function<bool(const QUuid&, graphics::MaterialPointer, const QString&)> addMaterialToOverlayOperator) { _addMaterialToOverlayOperator = addMaterialToOverlayOperator; }
static void setRemoveMaterialFromOverlayOperator(std::function<bool(const QUuid&, graphics::MaterialPointer, const QString&)> removeMaterialFromOverlayOperator) { _removeMaterialFromOverlayOperator = removeMaterialFromOverlayOperator; }
static bool addMaterialToOverlay(const QUuid& overlayID, graphics::MaterialPointer material, const QString& parentMaterialID);
static bool removeMaterialFromOverlay(const QUuid& overlayID, graphics::MaterialPointer material, const QString& parentMaterialID);
static bool addMaterialToOverlay(const QUuid& overlayID, graphics::MaterialPointer material, const QString& parentMaterialName);
static bool removeMaterialFromOverlay(const QUuid& overlayID, graphics::MaterialPointer material, const QString& parentMaterialName);
signals:
void deletingEntity(const EntityItemID& entityID);

145
libraries/entities/src/MaterialEntityItem.cpp
View file

@ -30,12 +30,12 @@ MaterialEntityItem::MaterialEntityItem(const EntityItemID& entityItemID) : Entit
EntityItemProperties MaterialEntityItem::getProperties(EntityPropertyFlags desiredProperties) const {
EntityItemProperties properties = EntityItem::getProperties(desiredProperties); // get the properties from our base class
COPY_ENTITY_PROPERTY_TO_PROPERTIES(materialURL, getMaterialURL);
COPY_ENTITY_PROPERTY_TO_PROPERTIES(materialMode, getMaterialMode);
COPY_ENTITY_PROPERTY_TO_PROPERTIES(materialMappingMode, getMaterialMappingMode);
COPY_ENTITY_PROPERTY_TO_PROPERTIES(priority, getPriority);
COPY_ENTITY_PROPERTY_TO_PROPERTIES(parentMaterialID, getParentMaterialID);
COPY_ENTITY_PROPERTY_TO_PROPERTIES(materialPos, getMaterialPos);
COPY_ENTITY_PROPERTY_TO_PROPERTIES(materialScale, getMaterialScale);
COPY_ENTITY_PROPERTY_TO_PROPERTIES(materialRot, getMaterialRot);
COPY_ENTITY_PROPERTY_TO_PROPERTIES(parentMaterialName, getParentMaterialName);
COPY_ENTITY_PROPERTY_TO_PROPERTIES(materialMappingPos, getMaterialMappingPos);
COPY_ENTITY_PROPERTY_TO_PROPERTIES(materialMappingScale, getMaterialMappingScale);
COPY_ENTITY_PROPERTY_TO_PROPERTIES(materialMappingRot, getMaterialMappingRot);
return properties;
}
@ -43,12 +43,12 @@ bool MaterialEntityItem::setProperties(const EntityItemProperties& properties) {
bool somethingChanged = EntityItem::setProperties(properties); // set the properties in our base class
SET_ENTITY_PROPERTY_FROM_PROPERTIES(materialURL, setMaterialURL);
SET_ENTITY_PROPERTY_FROM_PROPERTIES(materialMode, setMaterialMode);
SET_ENTITY_PROPERTY_FROM_PROPERTIES(materialMappingMode, setMaterialMappingMode);
SET_ENTITY_PROPERTY_FROM_PROPERTIES(priority, setPriority);
SET_ENTITY_PROPERTY_FROM_PROPERTIES(parentMaterialID, setParentMaterialID);
SET_ENTITY_PROPERTY_FROM_PROPERTIES(materialPos, setMaterialPos);
SET_ENTITY_PROPERTY_FROM_PROPERTIES(materialScale, setMaterialScale);
SET_ENTITY_PROPERTY_FROM_PROPERTIES(materialRot, setMaterialRot);
SET_ENTITY_PROPERTY_FROM_PROPERTIES(parentMaterialName, setParentMaterialName);
SET_ENTITY_PROPERTY_FROM_PROPERTIES(materialMappingPos, setMaterialMappingPos);
SET_ENTITY_PROPERTY_FROM_PROPERTIES(materialMappingScale, setMaterialMappingScale);
SET_ENTITY_PROPERTY_FROM_PROPERTIES(materialMappingRot, setMaterialMappingRot);
if (somethingChanged) {
bool wantDebug = false;
@ -72,12 +72,12 @@ int MaterialEntityItem::readEntitySubclassDataFromBuffer(const unsigned char* da
const unsigned char* dataAt = data;
READ_ENTITY_PROPERTY(PROP_MATERIAL_URL, QString, setMaterialURL);
READ_ENTITY_PROPERTY(PROP_MATERIAL_TYPE, MaterialMode, setMaterialMode);
READ_ENTITY_PROPERTY(PROP_MATERIAL_MAPPING_MODE, MaterialMappingMode, setMaterialMappingMode);
READ_ENTITY_PROPERTY(PROP_MATERIAL_PRIORITY, quint16, setPriority);
READ_ENTITY_PROPERTY(PROP_PARENT_MATERIAL_ID, QString, setParentMaterialID);
READ_ENTITY_PROPERTY(PROP_MATERIAL_POS, glm::vec2, setMaterialPos);
READ_ENTITY_PROPERTY(PROP_MATERIAL_SCALE, glm::vec2, setMaterialScale);
READ_ENTITY_PROPERTY(PROP_MATERIAL_ROT, float, setMaterialRot);
READ_ENTITY_PROPERTY(PROP_PARENT_MATERIAL_NAME, QString, setParentMaterialName);
READ_ENTITY_PROPERTY(PROP_MATERIAL_MAPPING_POS, glm::vec2, setMaterialMappingPos);
READ_ENTITY_PROPERTY(PROP_MATERIAL_MAPPING_SCALE, glm::vec2, setMaterialMappingScale);
READ_ENTITY_PROPERTY(PROP_MATERIAL_MAPPING_ROT, float, setMaterialMappingRot);
return bytesRead;
}
@ -87,12 +87,12 @@ int MaterialEntityItem::readEntitySubclassDataFromBuffer(const unsigned char* da
EntityPropertyFlags MaterialEntityItem::getEntityProperties(EncodeBitstreamParams& params) const {
EntityPropertyFlags requestedProperties = EntityItem::getEntityProperties(params);
requestedProperties += PROP_MATERIAL_URL;
requestedProperties += PROP_MATERIAL_TYPE;
requestedProperties += PROP_MATERIAL_MAPPING_MODE;
requestedProperties += PROP_MATERIAL_PRIORITY;
requestedProperties += PROP_PARENT_MATERIAL_ID;
requestedProperties += PROP_MATERIAL_POS;
requestedProperties += PROP_MATERIAL_SCALE;
requestedProperties += PROP_MATERIAL_ROT;
requestedProperties += PROP_PARENT_MATERIAL_NAME;
requestedProperties += PROP_MATERIAL_MAPPING_POS;
requestedProperties += PROP_MATERIAL_MAPPING_SCALE;
requestedProperties += PROP_MATERIAL_MAPPING_ROT;
return requestedProperties;
}
@ -106,26 +106,26 @@ void MaterialEntityItem::appendSubclassData(OctreePacketData* packetData, Encode
bool successPropertyFits = true;
APPEND_ENTITY_PROPERTY(PROP_MATERIAL_URL, getMaterialURL());
APPEND_ENTITY_PROPERTY(PROP_MATERIAL_TYPE, (uint32_t)getMaterialMode());
APPEND_ENTITY_PROPERTY(PROP_MATERIAL_MAPPING_MODE, (uint32_t)getMaterialMappingMode());
APPEND_ENTITY_PROPERTY(PROP_MATERIAL_PRIORITY, getPriority());
APPEND_ENTITY_PROPERTY(PROP_PARENT_MATERIAL_ID, getParentMaterialID());
APPEND_ENTITY_PROPERTY(PROP_MATERIAL_POS, getMaterialPos());
APPEND_ENTITY_PROPERTY(PROP_MATERIAL_SCALE, getMaterialScale());
APPEND_ENTITY_PROPERTY(PROP_MATERIAL_ROT, getMaterialRot());
APPEND_ENTITY_PROPERTY(PROP_PARENT_MATERIAL_NAME, getParentMaterialName());
APPEND_ENTITY_PROPERTY(PROP_MATERIAL_MAPPING_POS, getMaterialMappingPos());
APPEND_ENTITY_PROPERTY(PROP_MATERIAL_MAPPING_SCALE, getMaterialMappingScale());
APPEND_ENTITY_PROPERTY(PROP_MATERIAL_MAPPING_ROT, getMaterialMappingRot());
}
void MaterialEntityItem::debugDump() const {
quint64 now = usecTimestampNow();
qCDebug(entities) << " MATERIAL EntityItem id:" << getEntityItemID() << "---------------------------------------------";
qCDebug(entities) << " name:" << _name;
qCDebug(entities) << " material json:" << _materialURL;
qCDebug(entities) << " material url:" << _materialURL;
qCDebug(entities) << " current material name:" << _currentMaterialName;
qCDebug(entities) << " material type:" << _materialMode;
qCDebug(entities) << " material mapping mode:" << _materialMappingMode;
qCDebug(entities) << " priority:" << _priority;
qCDebug(entities) << " parent material ID:" << _parentMaterialID;
qCDebug(entities) << " material pos:" << _materialPos;
qCDebug(entities) << " material scale:" << _materialRot;
qCDebug(entities) << " material rot:" << _materialScale;
qCDebug(entities) << " parent material name:" << _parentMaterialName;
qCDebug(entities) << " material mapping pos:" << _materialMappingPos;
qCDebug(entities) << " material mapping scale:" << _materialMappingRot;
qCDebug(entities) << " material mapping rot:" << _materialMappingScale;
qCDebug(entities) << " position:" << debugTreeVector(getWorldPosition());
qCDebug(entities) << " dimensions:" << debugTreeVector(getScaledDimensions());
qCDebug(entities) << " getLastEdited:" << debugTime(getLastEdited(), now);
@ -137,8 +137,8 @@ void MaterialEntityItem::setUnscaledDimensions(const glm::vec3& value) {
}
std::shared_ptr<NetworkMaterial> MaterialEntityItem::getMaterial() const {
auto material = _materials.find(_currentMaterialName);
if (material != _materials.end()) {
auto material = _parsedMaterials.networkMaterials.find(_currentMaterialName);
if (material != _parsedMaterials.networkMaterials.end()) {
return material.value();
} else {
return nullptr;
@ -151,28 +151,14 @@ void MaterialEntityItem::setMaterialURL(const QString& materialURLString, bool u
removeMaterial();
_materialURL = materialURLString;
// TODO: if URL ends with ?string, try to set _currentMaterialName = string
if (materialURLString.contains("?")) {
auto split = materialURLString.split("?");
_currentMaterialName = split.last();
}
if (usingUserData) {
QJsonDocument materialJSON = QJsonDocument::fromJson(getUserData().toUtf8());
_materials.clear();
_materialNames.clear();
if (!materialJSON.isNull()) {
if (materialJSON.isArray()) {
QJsonArray materials = materialJSON.array();
for (auto material : materials) {
if (!material.isNull() && material.isObject()) {
auto networkMaterial = NetworkMaterialResource::parseJSONMaterial(material.toObject());
_materials[networkMaterial.first] = networkMaterial.second;
_materialNames.push_back(networkMaterial.first);
}
}
} else if (materialJSON.isObject()) {
auto networkMaterial = NetworkMaterialResource::parseJSONMaterial(materialJSON.object());
_materials[networkMaterial.first] = networkMaterial.second;
_materialNames.push_back(networkMaterial.first);
}
}
_parsedMaterials = NetworkMaterialResource::parseJSONMaterials(QJsonDocument::fromJson(getUserData().toUtf8()));
// Since our material changed, the current name might not be valid anymore, so we need to update
setCurrentMaterialName(_currentMaterialName);
applyMaterial();
@ -180,8 +166,7 @@ void MaterialEntityItem::setMaterialURL(const QString& materialURLString, bool u
_networkMaterial = MaterialCache::instance().getMaterial(materialURLString);
auto onMaterialRequestFinished = [&](bool success) {
if (success) {
_materials[_networkMaterial->name] = _networkMaterial->networkMaterial;
_materialNames.push_back(_networkMaterial->name);
_parsedMaterials = _networkMaterial->parsedMaterials;
setCurrentMaterialName(_currentMaterialName);
applyMaterial();
@ -199,11 +184,11 @@ void MaterialEntityItem::setMaterialURL(const QString& materialURLString, bool u
}
void MaterialEntityItem::setCurrentMaterialName(const QString& currentMaterialName) {
auto material = _materials.find(currentMaterialName);
if (material != _materials.end()) {
auto material = _parsedMaterials.networkMaterials.find(currentMaterialName);
if (material != _parsedMaterials.networkMaterials.end()) {
_currentMaterialName = currentMaterialName;
} else if (_materialNames.size() > 0) {
_currentMaterialName = _materialNames[0];
} else if (_parsedMaterials.names.size() > 0) {
_currentMaterialName = _parsedMaterials.names[0];
}
}
@ -217,26 +202,26 @@ void MaterialEntityItem::setUserData(const QString& userData) {
}
}
void MaterialEntityItem::setMaterialPos(const glm::vec2& materialPos) {
if (_materialPos != materialPos) {
void MaterialEntityItem::setMaterialMappingPos(const glm::vec2& materialMappingPos) {
if (_materialMappingPos != materialMappingPos) {
removeMaterial();
_materialPos = materialPos;
_materialMappingPos = materialMappingPos;
applyMaterial();
}
}
void MaterialEntityItem::setMaterialScale(const glm::vec2& materialScale) {
if (_materialScale != materialScale) {
void MaterialEntityItem::setMaterialMappingScale(const glm::vec2& materialMappingScale) {
if (_materialMappingScale != materialMappingScale) {
removeMaterial();
_materialScale = materialScale;
_materialMappingScale = materialMappingScale;
applyMaterial();
}
}
void MaterialEntityItem::setMaterialRot(const float& materialRot) {
if (_materialRot != materialRot) {
void MaterialEntityItem::setMaterialMappingRot(const float& materialMappingRot) {
if (_materialMappingRot != materialMappingRot) {
removeMaterial();
_materialRot = materialRot;
_materialMappingRot = materialMappingRot;
applyMaterial();
}
}
@ -249,10 +234,10 @@ void MaterialEntityItem::setPriority(quint16 priority) {
}
}
void MaterialEntityItem::setParentMaterialID(const QString& parentMaterialID) {
if (_parentMaterialID != parentMaterialID) {
void MaterialEntityItem::setParentMaterialName(const QString& parentMaterialName) {
if (_parentMaterialName != parentMaterialName) {
removeMaterial();
_parentMaterialID = parentMaterialID;
_parentMaterialName = parentMaterialName;
applyMaterial();
}
}
@ -293,16 +278,16 @@ void MaterialEntityItem::removeMaterial() {
if (tree) {
EntityItemPointer entity = tree->findEntityByEntityItemID(parentID);
if (entity) {
entity->removeMaterial(material, getParentMaterialID());
entity->removeMaterial(material, getParentMaterialName());
return;
}
}
if (EntityTree::removeMaterialFromAvatar(parentID, material, getParentMaterialID())) {
if (EntityTree::removeMaterialFromAvatar(parentID, material, getParentMaterialName())) {
return;
}
if (EntityTree::removeMaterialFromOverlay(parentID, material, getParentMaterialID())) {
if (EntityTree::removeMaterialFromOverlay(parentID, material, getParentMaterialName())) {
return;
}
@ -317,9 +302,9 @@ void MaterialEntityItem::applyMaterial() {
return;
}
Transform textureTransform;
textureTransform.setTranslation(glm::vec3(_materialPos, 0));
textureTransform.setRotation(glm::vec3(0, 0, glm::radians(_materialRot)));
textureTransform.setScale(glm::vec3(_materialScale, 1));
textureTransform.setTranslation(glm::vec3(_materialMappingPos, 0));
textureTransform.setRotation(glm::vec3(0, 0, glm::radians(_materialMappingRot)));
textureTransform.setScale(glm::vec3(_materialMappingScale, 1));
material->setTextureTransforms(textureTransform);
material->setPriority(getPriority());
@ -328,16 +313,16 @@ void MaterialEntityItem::applyMaterial() {
if (tree) {
EntityItemPointer entity = tree->findEntityByEntityItemID(parentID);
if (entity) {
entity->addMaterial(material, getParentMaterialID());
entity->addMaterial(material, getParentMaterialName());
return;
}
}
if (EntityTree::addMaterialToAvatar(parentID, material, getParentMaterialID())) {
if (EntityTree::addMaterialToAvatar(parentID, material, getParentMaterialName())) {
return;
}
if (EntityTree::addMaterialToOverlay(parentID, material, getParentMaterialID())) {
if (EntityTree::addMaterialToOverlay(parentID, material, getParentMaterialName())) {
return;
}

58
libraries/entities/src/MaterialEntityItem.h
View file

@ -11,7 +11,7 @@
#include "EntityItem.h"
#include "MaterialMode.h"
#include "MaterialMappingMode.h"
#include <model-networking/ModelCache.h>
#include <model-networking/MaterialCache.h>
@ -58,21 +58,21 @@ public:
QString getCurrentMaterialName() const { return _currentMaterialName; }
void setCurrentMaterialName(const QString& currentMaterialName);
MaterialMode getMaterialMode() const { return _materialMode; }
void setMaterialMode(MaterialMode mode) { _materialMode = mode; }
MaterialMappingMode getMaterialMappingMode() const { return _materialMappingMode; }
void setMaterialMappingMode(MaterialMappingMode mode) { _materialMappingMode = mode; }
quint16 getPriority() const { return _priority; }
void setPriority(quint16 priority);
QString getParentMaterialID() const { return _parentMaterialID; }
void setParentMaterialID(const QString& parentMaterialID);
QString getParentMaterialName() const { return _parentMaterialName; }
void setParentMaterialName(const QString& parentMaterialName);
glm::vec2 getMaterialPos() const { return _materialPos; }
void setMaterialPos(const glm::vec2& materialPos);
glm::vec2 getMaterialScale() const { return _materialScale; }
void setMaterialScale(const glm::vec2& materialScale);
float getMaterialRot() const { return _materialRot; }
void setMaterialRot(const float& materialRot);
glm::vec2 getMaterialMappingPos() const { return _materialMappingPos; }
void setMaterialMappingPos(const glm::vec2& materialMappingPos);
glm::vec2 getMaterialMappingScale() const { return _materialMappingScale; }
void setMaterialMappingScale(const glm::vec2& materialMappingScale);
float getMaterialMappingRot() const { return _materialMappingRot; }
void setMaterialMappingRot(const float& materialMappingRot);
std::shared_ptr<NetworkMaterial> getMaterial() const;
@ -91,33 +91,37 @@ public:
private:
// URL for this material. Currently, only JSON format is supported. Set to "userData" to use the user data to live edit a material.
// The following fields are supported in the JSON:
// strings:
// name (NOT YET USED)
// floats:
// opacity, roughness, metallic, scattering
// colors (arrays of 3 floats 0-1. Optional fourth value in array can be a boolean isSRGB):
// emissive, albedo, fresnel
// urls to textures:
// emissiveMap, albedoMap, metallicMap, roughnessMap, normalMap, occlusionMap, lightmapMap, scatteringMap
// materialVersion: a uint for the version of this network material (currently, only 1 is supported)
// materials, which is either an object or an array of objects, each with the following properties:
// strings:
// name (NOT YET USED), model (NOT YET USED, should use "hifi_pbr")
// floats:
// opacity, roughness, metallic, scattering
// bool:
// unlit
// colors (arrays of 3 floats 0-1. Optional fourth value in array can be a boolean isSRGB):
// emissive, albedo
// urls to textures:
// emissiveMap, albedoMap (set opacityMap = albedoMap for transparency), metallicMap or specularMap, roughnessMap or glossMap,
// normalMap or bumpMap, occlusionMap, lightmapMap (broken, FIXME), scatteringMap (only works if normal mapped)
QString _materialURL;
// Type of material. "uv" or "projected". NOT YET IMPLEMENTED, only UV is used
MaterialMode _materialMode { UV };
MaterialMappingMode _materialMappingMode { UV };
// Priority for this material when applying it to its parent. Only the highest priority material will be used. Materials with the same priority are (essentially) randomly sorted.
// Base materials that come with models always have priority 0.
quint16 _priority { 0 };
// An identifier for choosing a submesh or submeshes within a parent. If in the format "mat::<string>", all submeshes with material name "<string>" will be replaced. Otherwise,
// parentMaterialID will be parsed as an unsigned int (strings not starting with "mat::" will parse to 0), representing the mesh index to modify.
QString _parentMaterialID { "0" };
// parentMaterialName will be parsed as an unsigned int (strings not starting with "mat::" will parse to 0), representing the mesh index to modify.
QString _parentMaterialName { "0" };
// Offset position in UV-space of top left of material, (0, 0) to (1, 1)
glm::vec2 _materialPos { 0, 0 };
glm::vec2 _materialMappingPos { 0, 0 };
// How much to scale this material within its parent's UV-space
glm::vec2 _materialScale { 1, 1 };
glm::vec2 _materialMappingScale { 1, 1 };
// How much to rotate this material within its parent's UV-space (degrees)
float _materialRot { 0 };
float _materialMappingRot { 0 };
NetworkMaterialResourcePointer _networkMaterial;
QHash<QString, std::shared_ptr<NetworkMaterial>> _materials;
std::vector<QString> _materialNames;
NetworkMaterialResource::ParsedMaterials _parsedMaterials;
QString _currentMaterialName;
bool _retryApply { false };

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

@ -361,6 +361,8 @@ public:
const QString& getName() { return _name; }
void setModel(const QString& model) { _model = model; }
protected:
QString _name { "" };
@ -379,6 +381,8 @@ private:
quint16 _priority { 0 };
QString _model { "hifi_pbr" };
};
typedef std::shared_ptr< Material > MaterialPointer;

61
libraries/model-networking/src/model-networking/MaterialCache.cpp
View file

@ -15,13 +15,10 @@ NetworkMaterialResource::NetworkMaterialResource(const QUrl& url) :
Resource(url) {}
void NetworkMaterialResource::downloadFinished(const QByteArray& data) {
if (_url.toString().endsWith(".json")) {
QJsonDocument materialJSON = QJsonDocument::fromJson(data);
if (!materialJSON.isNull() && materialJSON.isObject()) {
auto parsedMaterial = parseJSONMaterial(materialJSON.object());
name = parsedMaterial.first;
networkMaterial = parsedMaterial.second;
}
parsedMaterials.reset();
if (_url.toString().contains(".json")) {
parsedMaterials = parseJSONMaterials(QJsonDocument::fromJson(data));
}
// TODO: parse other material types
@ -46,6 +43,39 @@ bool NetworkMaterialResource::parseJSONColor(const QJsonValue& array, glm::vec3&
return false;
}
NetworkMaterialResource::ParsedMaterials NetworkMaterialResource::parseJSONMaterials(const QJsonDocument& materialJSON) {
ParsedMaterials toReturn;
if (!materialJSON.isNull() && materialJSON.isObject()) {
QJsonObject materialJSONObject = materialJSON.object();
for (auto& key : materialJSONObject.keys()) {
if (key == "materialVersion") {
auto value = materialJSONObject.value(key);
if (value.isDouble()) {
toReturn.version = (uint)value.toInt();
}
} else if (key == "materials") {
auto materialsValue = materialJSONObject.value(key);
if (materialsValue.isArray()) {
QJsonArray materials = materialsValue.toArray();
for (auto material : materials) {
if (!material.isNull() && material.isObject()) {
auto parsedMaterial = parseJSONMaterial(material.toObject());
toReturn.networkMaterials[parsedMaterial.first] = parsedMaterial.second;
toReturn.names.push_back(parsedMaterial.first);
}
}
} else if (materialsValue.isObject()) {
auto parsedMaterial = parseJSONMaterial(materialsValue.toObject());
toReturn.networkMaterials[parsedMaterial.first] = parsedMaterial.second;
toReturn.names.push_back(parsedMaterial.first);
}
}
}
}
return toReturn;;
}
std::pair<QString, std::shared_ptr<NetworkMaterial>> NetworkMaterialResource::parseJSONMaterial(const QJsonObject& materialJSON) {
QString name = "";
std::shared_ptr<NetworkMaterial> material = std::make_shared<NetworkMaterial>();
@ -55,6 +85,11 @@ std::pair<QString, std::shared_ptr<NetworkMaterial>> NetworkMaterialResource::pa
if (nameJSON.isString()) {
name = nameJSON.toString();
}
} else if (key == "model") {
auto modelJSON = materialJSON.value(key);
if (modelJSON.isString()) {
material->setModel(modelJSON.toString());
}
} else if (key == "emissive") {
glm::vec3 color;
bool isSRGB;
@ -67,6 +102,11 @@ std::pair<QString, std::shared_ptr<NetworkMaterial>> NetworkMaterialResource::pa
if (value.isDouble()) {
material->setOpacity(value.toDouble());
}
} else if (key == "unlit") {
auto value = materialJSON.value(key);
if (value.isBool()) {
material->setUnlit(value.toBool());
}
} else if (key == "albedo") {
glm::vec3 color;
bool isSRGB;
@ -79,13 +119,6 @@ std::pair<QString, std::shared_ptr<NetworkMaterial>> NetworkMaterialResource::pa
if (value.isDouble()) {
material->setRoughness(value.toDouble());
}
} else if (key == "fresnel") {
glm::vec3 color;
bool isSRGB;
bool valid = parseJSONColor(materialJSON.value(key), color, isSRGB);
if (valid) {
material->setFresnel(color, isSRGB);
}
} else if (key == "metallic") {
auto value = materialJSON.value(key);
if (value.isDouble()) {

17
libraries/model-networking/src/model-networking/MaterialCache.h
View file

@ -22,9 +22,22 @@ public:
virtual void downloadFinished(const QByteArray& data) override;
QString name { "" };
std::shared_ptr<NetworkMaterial> networkMaterial { nullptr };
typedef struct ParsedMaterials {
uint version { 1 };
std::vector<QString> names;
QHash<QString, std::shared_ptr<NetworkMaterial>> networkMaterials;
void reset() {
version = 1;
names.clear();
networkMaterials.clear();
}
} ParsedMaterials;
ParsedMaterials parsedMaterials;
static ParsedMaterials parseJSONMaterials(const QJsonDocument& materialJSON);
static std::pair<QString, std::shared_ptr<NetworkMaterial>> parseJSONMaterial(const QJsonObject& materialJSON);
private:

4
libraries/octree/src/OctreePacketData.h
View file

@ -33,7 +33,7 @@
#include <NLPacket.h>
#include <udt/PacketHeaders.h>
#include "MaterialMode.h"
#include "MaterialMappingMode.h"
#include "OctreeConstants.h"
#include "OctreeElement.h"
@ -263,7 +263,7 @@ public:
static int unpackDataFromBytes(const unsigned char* dataBytes, rgbColor& result) { memcpy(&result, dataBytes, sizeof(result)); return sizeof(result); }
static int unpackDataFromBytes(const unsigned char* dataBytes, glm::quat& result) { int bytes = unpackOrientationQuatFromBytes(dataBytes, result); return bytes; }
static int unpackDataFromBytes(const unsigned char* dataBytes, ShapeType& result) { memcpy(&result, dataBytes, sizeof(result)); return sizeof(result); }
static int unpackDataFromBytes(const unsigned char* dataBytes, MaterialMode& result) { memcpy(&result, dataBytes, sizeof(result)); return sizeof(result); }
static int unpackDataFromBytes(const unsigned char* dataBytes, MaterialMappingMode& result) { memcpy(&result, dataBytes, sizeof(result)); return sizeof(result); }
static int unpackDataFromBytes(const unsigned char* dataBytes, QString& result);
static int unpackDataFromBytes(const unsigned char* dataBytes, QUuid& result);
static int unpackDataFromBytes(const unsigned char* dataBytes, xColor& result);

24
libraries/render-utils/src/Model.cpp
View file

@ -1527,29 +1527,29 @@ bool Model::isRenderable() const {
return !_meshStates.empty() || (isLoaded() && _renderGeometry->getMeshes().empty());
}
std::vector<unsigned int> Model::getMeshIDsFromMaterialID(QString parentMaterialID) {
// try to find all meshes with materials that match parentMaterialID as a string
// if none, return parentMaterialID as a uint
std::vector<unsigned int> Model::getMeshIDsFromMaterialID(QString parentMaterialName) {
// try to find all meshes with materials that match parentMaterialName as a string
// if none, return parentMaterialName as a uint
std::vector<unsigned int> toReturn;
const QString MATERIAL_NAME_PREFIX = "mat::";
if (parentMaterialID.startsWith(MATERIAL_NAME_PREFIX)) {
parentMaterialID.replace(0, MATERIAL_NAME_PREFIX.size(), QString(""));
for (int i = 0; i < _modelMeshMaterialNames.size(); i++) {
if (_modelMeshMaterialNames[i] == parentMaterialID) {
if (parentMaterialName.startsWith(MATERIAL_NAME_PREFIX)) {
parentMaterialName.replace(0, MATERIAL_NAME_PREFIX.size(), QString(""));
for (unsigned int i = 0; i < (unsigned int)_modelMeshMaterialNames.size(); i++) {
if (_modelMeshMaterialNames[i] == parentMaterialName) {
toReturn.push_back(i);
}
}
}
if (toReturn.empty()) {
toReturn.push_back(parentMaterialID.toUInt());
toReturn.push_back(parentMaterialName.toUInt());
}
return toReturn;
}
void Model::addMaterial(graphics::MaterialPointer material, const QString& parentMaterialID) {
std::vector<unsigned int> shapeIDs = getMeshIDsFromMaterialID(parentMaterialID);
void Model::addMaterial(graphics::MaterialPointer material, const QString& parentMaterialName) {
std::vector<unsigned int> shapeIDs = getMeshIDsFromMaterialID(parentMaterialName);
render::Transaction transaction;
for (auto shapeID : shapeIDs) {
if (shapeID < _modelMeshRenderItemIDs.size()) {
@ -1573,8 +1573,8 @@ void Model::addMaterial(graphics::MaterialPointer material, const QString& paren
AbstractViewStateInterface::instance()->getMain3DScene()->enqueueTransaction(transaction);
}
void Model::removeMaterial(graphics::MaterialPointer material, const QString& parentMaterialID) {
std::vector<unsigned int> shapeIDs = getMeshIDsFromMaterialID(parentMaterialID);
void Model::removeMaterial(graphics::MaterialPointer material, const QString& parentMaterialName) {
std::vector<unsigned int> shapeIDs = getMeshIDsFromMaterialID(parentMaterialName);
render::Transaction transaction;
for (auto shapeID : shapeIDs) {
if (shapeID < _modelMeshRenderItemIDs.size()) {

6
libraries/render-utils/src/Model.h
View file

@ -318,8 +318,8 @@ public:
void scaleToFit();
void addMaterial(graphics::MaterialPointer material, const QString& parentMaterialID);
void removeMaterial(graphics::MaterialPointer material, const QString& parentMaterialID);
void addMaterial(graphics::MaterialPointer material, const QString& parentMaterialName);
void removeMaterial(graphics::MaterialPointer material, const QString& parentMaterialName);
public slots:
void loadURLFinished(bool success);
@ -473,7 +473,7 @@ private:
void calculateTextureInfo();
std::vector<unsigned int> getMeshIDsFromMaterialID(QString parentMaterialID);
std::vector<unsigned int> getMeshIDsFromMaterialID(QString parentMaterialName);
};
Q_DECLARE_METATYPE(ModelPointer)

24
libraries/shared/src/MaterialMappingMode.cpp Normal file
View file

@ -0,0 +1,24 @@
//
// Created by Sam Gondelman on 1/17/2018
// Copyright 2018 High Fidelity, Inc.
//
// Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
#include "MaterialMappingMode.h"
const char* materialMappingModeNames[] = {
"uv",
"projected"
};
static const size_t MATERIAL_MODE_NAMES = (sizeof(materialMappingModeNames) / sizeof((materialMappingModeNames)[0]));
QString MaterialMappingModeHelpers::getNameForMaterialMappingMode(MaterialMappingMode mode) {
if (((int)mode <= 0) || ((int)mode >= (int)MATERIAL_MODE_NAMES)) {
mode = (MaterialMappingMode)0;
}
return materialMappingModeNames[(int)mode];
}

12
libraries/shared/src/MaterialMode.h → libraries/shared/src/MaterialMappingMode.h
View file

@ -6,20 +6,20 @@
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
#ifndef hifi_MaterialMode_h
#define hifi_MaterialMode_h
#ifndef hifi_MaterialMappingMode_h
#define hifi_MaterialMappingMode_h
#include "QString"
enum MaterialMode {
enum MaterialMappingMode {
UV = 0,
PROJECTED
};
class MaterialModeHelpers {
class MaterialMappingModeHelpers {
public:
static QString getNameForMaterialMode(MaterialMode mode);
static QString getNameForMaterialMappingMode(MaterialMappingMode mode);
};
#endif // hifi_MaterialMode_h
#endif // hifi_MaterialMappingMode_h

24
libraries/shared/src/MaterialMode.cpp
View file

@ -1,24 +0,0 @@
//
// Created by Sam Gondelman on 1/17/2018
// Copyright 2018 High Fidelity, Inc.
//
// Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
#include "MaterialMode.h"
const char* materialModeNames[] = {
"uv",
"projected"
};
static const size_t MATERIAL_MODE_NAMES = (sizeof(materialModeNames) / sizeof((materialModeNames)[0]));
QString MaterialModeHelpers::getNameForMaterialMode(MaterialMode mode) {
if (((int)mode <= 0) || ((int)mode >= (int)MATERIAL_MODE_NAMES)) {
mode = (MaterialMode)0;
}
return materialModeNames[(int)mode];
}

2
scripts/developer/tests/toolbarTest.js
View file

@ -92,7 +92,7 @@ var toolBar = (function() {
newMaterialButton = toolBar.addButton({
objectName: "newMaterialButton",
imageURL: toolIconUrl + "model-01.svg",
imageURL: toolIconUrl + "material-01.svg",
alpha: 0.9,
visible: false
});

6
scripts/system/edit.js
View file

@ -400,10 +400,10 @@ var toolBar = (function () {
function handleNewMaterialDialogResult(result) {
if (result) {
var materialURL = result.textInput;
//var materialMode;
//var materialMappingMode;
//switch (result.comboBox) {
// case MATERIAL_MODE_PROJECTED:
// materialMode = "projected";
// materialMappingMode = "projected";
// break;
// default:
// shapeType = "uv";
@ -414,7 +414,7 @@ var toolBar = (function () {
createNewEntity({
type: "Material",
materialURL: materialURL,
//materialMode: materialMode,
//materialMappingMode: materialMappingMode,
priority: DEFAULT_LAYERED_MATERIAL_PRIORITY
});
}

12
scripts/system/html/entityProperties.html
View file

@ -805,7 +805,7 @@
<!-- TODO: support 3D projected materials
<div class="material-group material-section property dropdown">
<label>Material mode </label>
<select name="SelectMaterialMode" id="property-material-mode">
<select name="SelectMaterialMode" id="property-material-mapping-mode">
<option value="uv">UV space material</option>
<option value="projected">3D projected material</option>
</select>
@ -815,20 +815,20 @@
<div class="material-group material-section property xy fstuple">
<label>Material Position </label>
<div class="tuple">
<div><input type="number" class="x" id="property-material-pos-x" min="0" max="1" step="0.1"><label for="property-material-pos-x">X:</label></div>
<div><input type="number" class="y" id="property-material-pos-y" min="0" max="1" step="0.1"><label for="property-material-pos-y">Y:</label></div>
<div><input type="number" class="x" id="property-material-mapping-pos-x" min="0" max="1" step="0.1"><label for="property-material-mapping-pos-x">X:</label></div>
<div><input type="number" class="y" id="property-material-mapping-pos-y" min="0" max="1" step="0.1"><label for="property-material-mapping-pos-y">Y:</label></div>
</div>
<div class="material-group material-section property wh fstuple">
<label>Material Scale </label>
<div class="tuple">
<div><input type="number" class="x" id="property-material-scale-x" min="0" step="0.1"><label for="property-material-scale-x">Width:</label></div>
<div><input type="number" class="y" id="property-material-scale-y" min="0" step="0.1"><label for="property-material-scale-y">Height:</label></div>
<div><input type="number" class="x" id="property-material-mapping-scale-x" min="0" step="0.1"><label for="property-material-mapping-scale-x">Width:</label></div>
<div><input type="number" class="y" id="property-material-mapping-scale-y" min="0" step="0.1"><label for="property-material-mapping-scale-y">Height:</label></div>
</div>
<div class="material-group material-section property number">
<label>Material Rotation <span class="unit">deg</span></label>
<input type="number" id="property-material-rot" step="0.1">
<input type="number" id="property-material-mapping-rot" step="0.1">
</div>
</fieldset>

78
scripts/system/html/js/entityProperties.js
View file

@ -518,7 +518,7 @@ function clearSelection() {
}
}
function showParentMaterialIDBox(number, elNumber, elString) {
function showParentMaterialNameBox(number, elNumber, elString) {
if (number) {
$('#property-parent-material-id-number-container').show();
$('#property-parent-material-id-string-container').hide();
@ -653,16 +653,16 @@ function loaded() {
var elModelOriginalTextures = document.getElementById("property-model-original-textures");
var elMaterialURL = document.getElementById("property-material-url");
//var elMaterialMode = document.getElementById("property-material-mode");
//var elMaterialMappingMode = document.getElementById("property-material-mapping-mode");
var elPriority = document.getElementById("property-priority");
var elParentMaterialIDString = document.getElementById("property-parent-material-id-string");
var elParentMaterialIDNumber = document.getElementById("property-parent-material-id-number");
var elParentMaterialIDCheckbox = document.getElementById("property-parent-material-id-checkbox");
var elMaterialPosX = document.getElementById("property-material-pos-x");
var elMaterialPosY = document.getElementById("property-material-pos-y");
var elMaterialScaleX = document.getElementById("property-material-scale-x");
var elMaterialScaleY = document.getElementById("property-material-scale-y");
var elMaterialRot = document.getElementById("property-material-rot");
var elParentMaterialNameString = document.getElementById("property-parent-material-id-string");
var elParentMaterialNameNumber = document.getElementById("property-parent-material-id-number");
var elParentMaterialNameCheckbox = document.getElementById("property-parent-material-id-checkbox");
var elMaterialMappingPosX = document.getElementById("property-material-mapping-pos-x");
var elMaterialMappingPosY = document.getElementById("property-material-mapping-pos-y");
var elMaterialMappingScaleX = document.getElementById("property-material-mapping-scale-x");
var elMaterialMappingScaleY = document.getElementById("property-material-mapping-scale-y");
var elMaterialMappingRot = document.getElementById("property-material-mapping-rot");
var elImageURL = document.getElementById("property-image-url");
@ -1164,23 +1164,23 @@ function loaded() {
elZTextureURL.value = properties.zTextureURL;
} else if (properties.type === "Material") {
elMaterialURL.value = properties.materialURL;
//elMaterialMode.value = properties.materialMode;
//setDropdownText(elMaterialMode);
//elMaterialMappingMode.value = properties.materialMappingMode;
//setDropdownText(elMaterialMappingMode);
elPriority.value = properties.priority;
if (properties.parentMaterialID.startsWith(MATERIAL_PREFIX_STRING)) {
elParentMaterialIDString.value = properties.parentMaterialID.replace(MATERIAL_PREFIX_STRING, "");
showParentMaterialIDBox(false, elParentMaterialIDNumber, elParentMaterialIDString);
elParentMaterialIDCheckbox.checked = false;
if (properties.parentMaterialName.startsWith(MATERIAL_PREFIX_STRING)) {
elParentMaterialNameString.value = properties.parentMaterialName.replace(MATERIAL_PREFIX_STRING, "");
showParentMaterialNameBox(false, elParentMaterialNameNumber, elParentMaterialNameString);
elParentMaterialNameCheckbox.checked = false;
} else {
elParentMaterialIDNumber.value = parseInt(properties.parentMaterialID);
showParentMaterialIDBox(true, elParentMaterialIDNumber, elParentMaterialIDString);
elParentMaterialIDCheckbox.checked = true;
elParentMaterialNameNumber.value = parseInt(properties.parentMaterialName);
showParentMaterialNameBox(true, elParentMaterialNameNumber, elParentMaterialNameString);
elParentMaterialNameCheckbox.checked = true;
}
elMaterialPosX.value = properties.materialPos.x.toFixed(4);
elMaterialPosY.value = properties.materialPos.y.toFixed(4);
elMaterialScaleX.value = properties.materialScale.x.toFixed(4);
elMaterialScaleY.value = properties.materialScale.y.toFixed(4);
elMaterialRot.value = properties.materialRot.toFixed(2);
elMaterialMappingPosX.value = properties.materialMappingPos.x.toFixed(4);
elMaterialMappingPosY.value = properties.materialMappingPos.y.toFixed(4);
elMaterialMappingScaleX.value = properties.materialMappingScale.x.toFixed(4);
elMaterialMappingScaleY.value = properties.materialMappingScale.y.toFixed(4);
elMaterialMappingRot.value = properties.materialMappingRot.toFixed(2);
}
if (properties.locked) {
@ -1454,28 +1454,28 @@ function loaded() {
elModelTextures.addEventListener('change', createEmitTextPropertyUpdateFunction('textures'));
elMaterialURL.addEventListener('change', createEmitTextPropertyUpdateFunction('materialURL'));
//elMaterialMode.addEventListener('change', createEmitTextPropertyUpdateFunction('materialMode'));
//elMaterialMappingMode.addEventListener('change', createEmitTextPropertyUpdateFunction('materialMappingMode'));
elPriority.addEventListener('change', createEmitNumberPropertyUpdateFunction('priority', 0));
elParentMaterialIDString.addEventListener('change', function () { updateProperty("parentMaterialID", MATERIAL_PREFIX_STRING + this.value); });
elParentMaterialIDNumber.addEventListener('change', function () { updateProperty("parentMaterialID", this.value); });
elParentMaterialIDCheckbox.addEventListener('change', function () {
elParentMaterialNameString.addEventListener('change', function () { updateProperty("parentMaterialName", MATERIAL_PREFIX_STRING + this.value); });
elParentMaterialNameNumber.addEventListener('change', function () { updateProperty("parentMaterialName", this.value); });
elParentMaterialNameCheckbox.addEventListener('change', function () {
if (this.checked) {
updateProperty("parentMaterialID", elParentMaterialIDNumber.value);
showParentMaterialIDBox(true, elParentMaterialIDNumber, elParentMaterialIDString);
updateProperty("parentMaterialName", elParentMaterialNameNumber.value);
showParentMaterialNameBox(true, elParentMaterialNameNumber, elParentMaterialNameString);
} else {
updateProperty("parentMaterialID", MATERIAL_PREFIX_STRING + elParentMaterialIDString.value);
showParentMaterialIDBox(false, elParentMaterialIDNumber, elParentMaterialIDString);
updateProperty("parentMaterialName", MATERIAL_PREFIX_STRING + elParentMaterialNameString.value);
showParentMaterialNameBox(false, elParentMaterialNameNumber, elParentMaterialNameString);
}
});
var materialPosChangeFunction = createEmitVec2PropertyUpdateFunction('materialPos', elMaterialPosX, elMaterialPosY);
elMaterialPosX.addEventListener('change', materialPosChangeFunction);
elMaterialPosY.addEventListener('change', materialPosChangeFunction);
var materialScaleChangeFunction = createEmitVec2PropertyUpdateFunction('materialScale', elMaterialScaleX, elMaterialScaleY);
elMaterialScaleX.addEventListener('change', materialScaleChangeFunction);
elMaterialScaleY.addEventListener('change', materialScaleChangeFunction);
elMaterialRot.addEventListener('change', createEmitNumberPropertyUpdateFunction('materialRot', 2));
var materialMappingPosChangeFunction = createEmitVec2PropertyUpdateFunction('materialMappingPos', elMaterialMappingPosX, elMaterialMappingPosY);
elMaterialMappingPosX.addEventListener('change', materialMappingPosChangeFunction);
elMaterialMappingPosY.addEventListener('change', materialMappingPosChangeFunction);
var materialMappingScaleChangeFunction = createEmitVec2PropertyUpdateFunction('materialMappingScale', elMaterialMappingScaleX, elMaterialMappingScaleY);
elMaterialMappingScaleX.addEventListener('change', materialMappingScaleChangeFunction);
elMaterialMappingScaleY.addEventListener('change', materialMappingScaleChangeFunction);
elMaterialMappingRot.addEventListener('change', createEmitNumberPropertyUpdateFunction('materialMappingRot', 2));
elTextText.addEventListener('change', createEmitTextPropertyUpdateFunction('text'));
elTextFaceCamera.addEventListener('change', createEmitCheckedPropertyUpdateFunction('faceCamera'));