Mirrors/overte-HifiExperiments
3
0
Fork 0
mirror of https://github.com/HifiExperiments/overte.git synced 2025-08-09 16:18:03 +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 { ComboBox {
id: materialMode id: materialMappingMode
property var materialArray: ["UV space material", property var materialArray: ["UV space material",
"3D projected material"] "3D projected material"]
@ -142,7 +142,7 @@ Rectangle {
method: "newMaterialDialogAdd", method: "newMaterialDialogAdd",
params: { params: {
textInput: materialURL.text, 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 avatarManager = DependencyManager::get<AvatarManager>();
auto avatar = avatarManager->getAvatarBySessionID(avatarID); auto avatar = avatarManager->getAvatarBySessionID(avatarID);
if (avatar) { if (avatar) {
avatar->addMaterial(material, parentMaterialID); avatar->addMaterial(material, parentMaterialName);
return true; return true;
} }
return false; 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 avatarManager = DependencyManager::get<AvatarManager>();
auto avatar = avatarManager->getAvatarBySessionID(avatarID); auto avatar = avatarManager->getAvatarBySessionID(avatarID);
if (avatar) { if (avatar) {
avatar->removeMaterial(material, parentMaterialID); avatar->removeMaterial(material, parentMaterialName);
return true; return true;
} }
return false; 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); auto overlay = _overlays.getOverlay(overlayID);
if (overlay) { if (overlay) {
overlay->addMaterial(material, parentMaterialID); overlay->addMaterial(material, parentMaterialName);
return true; return true;
} }
return false; 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); auto overlay = _overlays.getOverlay(overlayID);
if (overlay) { if (overlay) {
overlay->removeMaterial(material, parentMaterialID); overlay->removeMaterial(material, parentMaterialName);
return true; return true;
} }
return false; 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); auto modelOverlay = static_cast<ModelOverlay*>(&data);
modelOverlay->setSubRenderItemIDs(newRenderItemIDs); modelOverlay->setSubRenderItemIDs(newRenderItemIDs);
}); });
processMaterials();
} }
if (_visibleDirty) { if (_visibleDirty) {
_visibleDirty = false; _visibleDirty = false;
@ -108,6 +109,7 @@ void ModelOverlay::update(float deltatime) {
bool ModelOverlay::addToScene(Overlay::Pointer overlay, const render::ScenePointer& scene, render::Transaction& transaction) { bool ModelOverlay::addToScene(Overlay::Pointer overlay, const render::ScenePointer& scene, render::Transaction& transaction) {
Volume3DOverlay::addToScene(overlay, scene, transaction); Volume3DOverlay::addToScene(overlay, scene, transaction);
_model->addToScene(scene, transaction); _model->addToScene(scene, transaction);
processMaterials();
return true; return true;
} }
@ -633,17 +635,17 @@ uint32_t ModelOverlay::fetchMetaSubItems(render::ItemIDs& subItems) const {
return 0; return 0;
} }
void ModelOverlay::addMaterial(graphics::MaterialPointer material, const QString& parentMaterialID) { void ModelOverlay::addMaterial(graphics::MaterialPointer material, const QString& parentMaterialName) {
Overlay::addMaterial(material, parentMaterialID); Overlay::addMaterial(material, parentMaterialName);
if (_model && _model->fetchRenderItemIDs().size() > 0) { if (_model && _model->fetchRenderItemIDs().size() > 0) {
_model->addMaterial(material, parentMaterialID); _model->addMaterial(material, parentMaterialName);
} }
} }
void ModelOverlay::removeMaterial(graphics::MaterialPointer material, const QString& parentMaterialID) { void ModelOverlay::removeMaterial(graphics::MaterialPointer material, const QString& parentMaterialName) {
Overlay::removeMaterial(material, parentMaterialID); Overlay::removeMaterial(material, parentMaterialName);
if (_model && _model->fetchRenderItemIDs().size() > 0) { 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 setDrawInFront(bool drawInFront) override;
void setDrawHUDLayer(bool drawHUDLayer) override; void setDrawHUDLayer(bool drawHUDLayer) override;
void addMaterial(graphics::MaterialPointer material, const QString& parentMaterialID) override; void addMaterial(graphics::MaterialPointer material, const QString& parentMaterialName) override;
void removeMaterial(graphics::MaterialPointer material, const QString& parentMaterialID) override; void removeMaterial(graphics::MaterialPointer material, const QString& parentMaterialName) override;
protected: protected:
Transform evalRenderTransform() override; Transform evalRenderTransform() override;

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

@ -236,12 +236,12 @@ QVector<OverlayID> qVectorOverlayIDFromScriptValue(const QScriptValue& array) {
return newVector; 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); 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); 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; } unsigned int getStackOrder() const { return _stackOrder; }
void setStackOrder(unsigned int stackOrder) { _stackOrder = stackOrder; } void setStackOrder(unsigned int stackOrder) { _stackOrder = stackOrder; }
virtual void addMaterial(graphics::MaterialPointer material, const QString& parentMaterialID); virtual void addMaterial(graphics::MaterialPointer material, const QString& parentMaterialName);
virtual void removeMaterial(graphics::MaterialPointer material, const QString& parentMaterialID); virtual void removeMaterial(graphics::MaterialPointer material, const QString& parentMaterialName);
protected: protected:
float updatePulse(); 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); std::lock_guard<std::mutex> lock(_materialsLock);
_materials[parentMaterialID].push(material); _materials[parentMaterialName].push(material);
if (_skeletonModel && _skeletonModel->fetchRenderItemIDs().size() > 0) { 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); std::lock_guard<std::mutex> lock(_materialsLock);
_materials[parentMaterialID].remove(material); _materials[parentMaterialName].remove(material);
if (_skeletonModel && _skeletonModel->fetchRenderItemIDs().size() > 0) { 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; virtual void setAvatarEntityDataChanged(bool value) override;
void addMaterial(graphics::MaterialPointer material, const QString& parentMaterialID) override; void addMaterial(graphics::MaterialPointer material, const QString& parentMaterialName) override;
void removeMaterial(graphics::MaterialPointer material, const QString& parentMaterialID) override; void removeMaterial(graphics::MaterialPointer material, const QString& parentMaterialName) override;
public slots: public slots:

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

@ -696,8 +696,8 @@ public:
bool getIsReplicated() const { return _isReplicated; } bool getIsReplicated() const { return _isReplicated; }
virtual void addMaterial(graphics::MaterialPointer material, const QString& parentMaterialID) {} virtual void addMaterial(graphics::MaterialPointer material, const QString& parentMaterialName) {}
virtual void removeMaterial(graphics::MaterialPointer material, const QString& parentMaterialID) {} virtual void removeMaterial(graphics::MaterialPointer material, const QString& parentMaterialName) {}
signals: signals:
void displayNameChanged(); 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); 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); 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); 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: public slots:
virtual void addMaterial(graphics::MaterialPointer material, const QString& parentMaterialID); virtual void addMaterial(graphics::MaterialPointer material, const QString& parentMaterialName);
virtual void removeMaterial(graphics::MaterialPointer material, const QString& parentMaterialID); virtual void removeMaterial(graphics::MaterialPointer material, const QString& parentMaterialName);
signals: signals:
void requestRenderUpdate(); 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) { if (entity->getParentID() != _parentID || entity->getClientOnly() != _clientOnly || entity->getOwningAvatarID() != _owningAvatarID) {
return true; 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 true;
} }
return false; return false;
@ -30,9 +30,9 @@ void MaterialEntityRenderer::doRenderUpdateSynchronousTyped(const ScenePointer&
_parentID = entity->getParentID(); _parentID = entity->getParentID();
_clientOnly = entity->getClientOnly(); _clientOnly = entity->getClientOnly();
_owningAvatarID = entity->getOwningAvatarID(); _owningAvatarID = entity->getOwningAvatarID();
_materialPos = entity->getMaterialPos(); _materialMappingPos = entity->getMaterialMappingPos();
_materialScale = entity->getMaterialScale(); _materialMappingScale = entity->getMaterialMappingScale();
_materialRot = entity->getMaterialRot(); _materialMappingRot = entity->getMaterialMappingRot();
_renderTransform = getModelTransform(); _renderTransform = getModelTransform();
const float MATERIAL_ENTITY_SCALE = 0.5f; const float MATERIAL_ENTITY_SCALE = 0.5f;
_renderTransform.postScale(MATERIAL_ENTITY_SCALE); _renderTransform.postScale(MATERIAL_ENTITY_SCALE);
@ -238,9 +238,9 @@ void MaterialEntityRenderer::doRender(RenderArgs* args) {
parentID = _clientOnly ? _owningAvatarID : _parentID; parentID = _clientOnly ? _owningAvatarID : _parentID;
renderTransform = _renderTransform; renderTransform = _renderTransform;
drawMaterial = _drawMaterial; drawMaterial = _drawMaterial;
textureTransform.setTranslation(glm::vec3(_materialPos, 0)); textureTransform.setTranslation(glm::vec3(_materialMappingPos, 0));
textureTransform.setRotation(glm::vec3(0, 0, glm::radians(_materialRot))); textureTransform.setRotation(glm::vec3(0, 0, glm::radians(_materialMappingRot)));
textureTransform.setScale(glm::vec3(_materialScale, 1)); textureTransform.setScale(glm::vec3(_materialMappingScale, 1));
}); });
if (!parentID.isNull() || !drawMaterial) { if (!parentID.isNull() || !drawMaterial) {
return; return;

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

@ -34,9 +34,9 @@ private:
QUuid _parentID; QUuid _parentID;
bool _clientOnly; bool _clientOnly;
QUuid _owningAvatarID; QUuid _owningAvatarID;
glm::vec2 _materialPos; glm::vec2 _materialMappingPos;
glm::vec2 _materialScale; glm::vec2 _materialMappingScale;
float _materialRot; float _materialMappingRot;
Transform _renderTransform; Transform _renderTransform;
std::shared_ptr<NetworkMaterial> _drawMaterial; 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) { void ModelEntityRenderer::addMaterial(graphics::MaterialPointer material, const QString& parentMaterialName) {
Parent::addMaterial(material, parentMaterialID); Parent::addMaterial(material, parentMaterialName);
if (_model && _model->fetchRenderItemIDs().size() > 0) { if (_model && _model->fetchRenderItemIDs().size() > 0) {
_model->addMaterial(material, parentMaterialID); _model->addMaterial(material, parentMaterialName);
} }
} }
void ModelEntityRenderer::removeMaterial(graphics::MaterialPointer material, const QString& parentMaterialID) { void ModelEntityRenderer::removeMaterial(graphics::MaterialPointer material, const QString& parentMaterialName) {
Parent::removeMaterial(material, parentMaterialID); Parent::removeMaterial(material, parentMaterialName);
if (_model && _model->fetchRenderItemIDs().size() > 0) { 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); ModelEntityRenderer(const EntityItemPointer& entity);
public slots: public slots:
void addMaterial(graphics::MaterialPointer material, const QString& parentMaterialID) override; void addMaterial(graphics::MaterialPointer material, const QString& parentMaterialName) override;
void removeMaterial(graphics::MaterialPointer material, const QString& parentMaterialID) override; void removeMaterial(graphics::MaterialPointer material, const QString& parentMaterialName) override;
protected: protected:
virtual void removeFromScene(const ScenePointer& scene, Transaction& transaction) override; 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); std::lock_guard<std::mutex> lock(_materialsLock);
_materials[parentMaterialID].push(material); _materials[parentMaterialName].push(material);
emit addMaterialToRenderItem(material, parentMaterialID); 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); std::lock_guard<std::mutex> lock(_materialsLock);
_materials[parentMaterialID].remove(material); _materials[parentMaterialName].remove(material);
emit removeMaterialFromRenderItem(material, parentMaterialID); emit removeMaterialFromRenderItem(material, parentMaterialName);
} }
std::unordered_map<QString, graphics::MultiMaterial> EntityItem::getMaterials() { 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 preDelete();
virtual void postParentFixup() {} virtual void postParentFixup() {}
void addMaterial(graphics::MaterialPointer material, const QString& parentMaterialID); void addMaterial(graphics::MaterialPointer material, const QString& parentMaterialName);
void removeMaterial(graphics::MaterialPointer material, const QString& parentMaterialID); void removeMaterial(graphics::MaterialPointer material, const QString& parentMaterialName);
std::unordered_map<QString, graphics::MultiMaterial> getMaterials(); std::unordered_map<QString, graphics::MultiMaterial> getMaterials();
signals: signals:
void requestRenderUpdate(); void requestRenderUpdate();
void addMaterialToRenderItem(graphics::MaterialPointer material, const QString& parentMaterialID); void addMaterialToRenderItem(graphics::MaterialPointer material, const QString& parentMaterialName);
void removeMaterialFromRenderItem(graphics::MaterialPointer material, const QString& parentMaterialID); void removeMaterialFromRenderItem(graphics::MaterialPointer material, const QString& parentMaterialName);
protected: protected:
QHash<ChangeHandlerId, ChangeHandlerCallback> _changeHandlers; QHash<ChangeHandlerId, ChangeHandlerCallback> _changeHandlers;

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

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

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

@ -44,7 +44,7 @@
#include "TextEntityItem.h" #include "TextEntityItem.h"
#include "ZoneEntityItem.h" #include "ZoneEntityItem.h"
#include "MaterialMode.h" #include "MaterialMappingMode.h"
const quint64 UNKNOWN_CREATED_TIME = 0; const quint64 UNKNOWN_CREATED_TIME = 0;
@ -223,12 +223,12 @@ public:
DEFINE_PROPERTY_REF(PROP_SHAPE, Shape, shape, QString, "Sphere"); DEFINE_PROPERTY_REF(PROP_SHAPE, Shape, shape, QString, "Sphere");
DEFINE_PROPERTY_REF(PROP_MATERIAL_URL, MaterialURL, materialURL, QString, ""); 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_MATERIAL_PRIORITY, Priority, priority, quint16, 0);
DEFINE_PROPERTY_REF(PROP_PARENT_MATERIAL_ID, ParentMaterialID, parentMaterialID, QString, "0"); DEFINE_PROPERTY_REF(PROP_PARENT_MATERIAL_NAME, ParentMaterialName, parentMaterialName, QString, "0");
DEFINE_PROPERTY_REF(PROP_MATERIAL_POS, MaterialPos, materialPos, glmVec2, glm::vec2(0, 0)); DEFINE_PROPERTY_REF(PROP_MATERIAL_MAPPING_POS, MaterialMappingPos, materialMappingPos, glmVec2, glm::vec2(0, 0));
DEFINE_PROPERTY_REF(PROP_MATERIAL_SCALE, MaterialScale, materialScale, glmVec2, glm::vec2(1, 1)); DEFINE_PROPERTY_REF(PROP_MATERIAL_MAPPING_SCALE, MaterialMappingScale, materialMappingScale, glmVec2, glm::vec2(1, 1));
DEFINE_PROPERTY_REF(PROP_MATERIAL_ROT, MaterialRot, materialRot, float, 0); DEFINE_PROPERTY_REF(PROP_MATERIAL_MAPPING_ROT, MaterialMappingRot, materialMappingRot, float, 0);
// Certifiable Properties - related to Proof of Purchase certificates // Certifiable Properties - related to Proof of Purchase certificates
DEFINE_PROPERTY_REF(PROP_ITEM_NAME, ItemName, itemName, QString, ENTITY_ITEM_DEFAULT_ITEM_NAME); 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_LOCAL_DIMENSIONS, // only used to convert values to and from scripts
PROP_MATERIAL_URL, PROP_MATERIAL_URL,
PROP_MATERIAL_TYPE, PROP_MATERIAL_MAPPING_MODE,
PROP_MATERIAL_PRIORITY, PROP_MATERIAL_PRIORITY,
PROP_PARENT_MATERIAL_ID, PROP_PARENT_MATERIAL_NAME,
PROP_MATERIAL_POS, PROP_MATERIAL_MAPPING_POS,
PROP_MATERIAL_SCALE, PROP_MATERIAL_MAPPING_SCALE,
PROP_MATERIAL_ROT, PROP_MATERIAL_MAPPING_ROT,
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
// ATTENTION: add new properties to end of list just ABOVE this line // 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->locationChanged(true);
entity->postParentFixup(); entity->postParentFixup();
} else if (_avatarIDs.contains(entity->getParentID())) { } else if (getIsServer() || _avatarIDs.contains(entity->getParentID())) {
if (getIsServer()) { // this is a child of an avatar, which the entity server will never have
// 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.
// a SpatiallyNestable object for. Add it to a list for cleanup when the avatar leaves. if (!_childrenOfAvatars.contains(entity->getParentID())) {
if (!_childrenOfAvatars.contains(entity->getParentID())) { _childrenOfAvatars[entity->getParentID()] = QSet<EntityItemID>();
_childrenOfAvatars[entity->getParentID()] = QSet<EntityItemID>();
}
_childrenOfAvatars[entity->getParentID()] += entity->getEntityItemID();
} }
_childrenOfAvatars[entity->getParentID()] += entity->getEntityItemID();
doMove = true; doMove = true;
iter.remove(); // and pull it out of the list iter.remove(); // and pull it out of the list
entity->postParentFixup();
} }
if (queryAACubeSuccess && doMove) { 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::_addMaterialToOverlayOperator = nullptr;
std::function<bool(const QUuid&, graphics::MaterialPointer, const QString&)> EntityTree::_removeMaterialFromOverlayOperator = 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) { if (_addMaterialToAvatarOperator) {
return _addMaterialToAvatarOperator(avatarID, material, parentMaterialID); return _addMaterialToAvatarOperator(avatarID, material, parentMaterialName);
} }
return false; 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) { if (_removeMaterialFromAvatarOperator) {
return _removeMaterialFromAvatarOperator(avatarID, material, parentMaterialID); return _removeMaterialFromAvatarOperator(avatarID, material, parentMaterialName);
} }
return false; 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) { if (_addMaterialToOverlayOperator) {
return _addMaterialToOverlayOperator(overlayID, material, parentMaterialID); return _addMaterialToOverlayOperator(overlayID, material, parentMaterialName);
} }
return false; 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) { if (_removeMaterialFromOverlayOperator) {
return _removeMaterialFromOverlayOperator(overlayID, material, parentMaterialID); return _removeMaterialFromOverlayOperator(overlayID, material, parentMaterialName);
} }
return false; 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 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 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 addMaterialToAvatar(const QUuid& avatarID, graphics::MaterialPointer material, const QString& parentMaterialName);
static bool removeMaterialFromAvatar(const QUuid& avatarID, graphics::MaterialPointer material, const QString& parentMaterialID); 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 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 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 addMaterialToOverlay(const QUuid& overlayID, graphics::MaterialPointer material, const QString& parentMaterialName);
static bool removeMaterialFromOverlay(const QUuid& overlayID, graphics::MaterialPointer material, const QString& parentMaterialID); static bool removeMaterialFromOverlay(const QUuid& overlayID, graphics::MaterialPointer material, const QString& parentMaterialName);
signals: signals:
void deletingEntity(const EntityItemID& entityID); 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 MaterialEntityItem::getProperties(EntityPropertyFlags desiredProperties) const {
EntityItemProperties properties = EntityItem::getProperties(desiredProperties); // get the properties from our base class EntityItemProperties properties = EntityItem::getProperties(desiredProperties); // get the properties from our base class
COPY_ENTITY_PROPERTY_TO_PROPERTIES(materialURL, getMaterialURL); 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(priority, getPriority);
COPY_ENTITY_PROPERTY_TO_PROPERTIES(parentMaterialID, getParentMaterialID); COPY_ENTITY_PROPERTY_TO_PROPERTIES(parentMaterialName, getParentMaterialName);
COPY_ENTITY_PROPERTY_TO_PROPERTIES(materialPos, getMaterialPos); COPY_ENTITY_PROPERTY_TO_PROPERTIES(materialMappingPos, getMaterialMappingPos);
COPY_ENTITY_PROPERTY_TO_PROPERTIES(materialScale, getMaterialScale); COPY_ENTITY_PROPERTY_TO_PROPERTIES(materialMappingScale, getMaterialMappingScale);
COPY_ENTITY_PROPERTY_TO_PROPERTIES(materialRot, getMaterialRot); COPY_ENTITY_PROPERTY_TO_PROPERTIES(materialMappingRot, getMaterialMappingRot);
return properties; return properties;
} }
@ -43,12 +43,12 @@ bool MaterialEntityItem::setProperties(const EntityItemProperties& properties) {
bool somethingChanged = EntityItem::setProperties(properties); // set the properties in our base class bool somethingChanged = EntityItem::setProperties(properties); // set the properties in our base class
SET_ENTITY_PROPERTY_FROM_PROPERTIES(materialURL, setMaterialURL); 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(priority, setPriority);
SET_ENTITY_PROPERTY_FROM_PROPERTIES(parentMaterialID, setParentMaterialID); SET_ENTITY_PROPERTY_FROM_PROPERTIES(parentMaterialName, setParentMaterialName);
SET_ENTITY_PROPERTY_FROM_PROPERTIES(materialPos, setMaterialPos); SET_ENTITY_PROPERTY_FROM_PROPERTIES(materialMappingPos, setMaterialMappingPos);
SET_ENTITY_PROPERTY_FROM_PROPERTIES(materialScale, setMaterialScale); SET_ENTITY_PROPERTY_FROM_PROPERTIES(materialMappingScale, setMaterialMappingScale);
SET_ENTITY_PROPERTY_FROM_PROPERTIES(materialRot, setMaterialRot); SET_ENTITY_PROPERTY_FROM_PROPERTIES(materialMappingRot, setMaterialMappingRot);
if (somethingChanged) { if (somethingChanged) {
bool wantDebug = false; bool wantDebug = false;
@ -72,12 +72,12 @@ int MaterialEntityItem::readEntitySubclassDataFromBuffer(const unsigned char* da
const unsigned char* dataAt = data; const unsigned char* dataAt = data;
READ_ENTITY_PROPERTY(PROP_MATERIAL_URL, QString, setMaterialURL); 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_MATERIAL_PRIORITY, quint16, setPriority);
READ_ENTITY_PROPERTY(PROP_PARENT_MATERIAL_ID, QString, setParentMaterialID); READ_ENTITY_PROPERTY(PROP_PARENT_MATERIAL_NAME, QString, setParentMaterialName);
READ_ENTITY_PROPERTY(PROP_MATERIAL_POS, glm::vec2, setMaterialPos); READ_ENTITY_PROPERTY(PROP_MATERIAL_MAPPING_POS, glm::vec2, setMaterialMappingPos);
READ_ENTITY_PROPERTY(PROP_MATERIAL_SCALE, glm::vec2, setMaterialScale); READ_ENTITY_PROPERTY(PROP_MATERIAL_MAPPING_SCALE, glm::vec2, setMaterialMappingScale);
READ_ENTITY_PROPERTY(PROP_MATERIAL_ROT, float, setMaterialRot); READ_ENTITY_PROPERTY(PROP_MATERIAL_MAPPING_ROT, float, setMaterialMappingRot);
return bytesRead; return bytesRead;
} }
@ -87,12 +87,12 @@ int MaterialEntityItem::readEntitySubclassDataFromBuffer(const unsigned char* da
EntityPropertyFlags MaterialEntityItem::getEntityProperties(EncodeBitstreamParams& params) const { EntityPropertyFlags MaterialEntityItem::getEntityProperties(EncodeBitstreamParams& params) const {
EntityPropertyFlags requestedProperties = EntityItem::getEntityProperties(params); EntityPropertyFlags requestedProperties = EntityItem::getEntityProperties(params);
requestedProperties += PROP_MATERIAL_URL; requestedProperties += PROP_MATERIAL_URL;
requestedProperties += PROP_MATERIAL_TYPE; requestedProperties += PROP_MATERIAL_MAPPING_MODE;
requestedProperties += PROP_MATERIAL_PRIORITY; requestedProperties += PROP_MATERIAL_PRIORITY;
requestedProperties += PROP_PARENT_MATERIAL_ID; requestedProperties += PROP_PARENT_MATERIAL_NAME;
requestedProperties += PROP_MATERIAL_POS; requestedProperties += PROP_MATERIAL_MAPPING_POS;
requestedProperties += PROP_MATERIAL_SCALE; requestedProperties += PROP_MATERIAL_MAPPING_SCALE;
requestedProperties += PROP_MATERIAL_ROT; requestedProperties += PROP_MATERIAL_MAPPING_ROT;
return requestedProperties; return requestedProperties;
} }
@ -106,26 +106,26 @@ void MaterialEntityItem::appendSubclassData(OctreePacketData* packetData, Encode
bool successPropertyFits = true; bool successPropertyFits = true;
APPEND_ENTITY_PROPERTY(PROP_MATERIAL_URL, getMaterialURL()); 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_MATERIAL_PRIORITY, getPriority());
APPEND_ENTITY_PROPERTY(PROP_PARENT_MATERIAL_ID, getParentMaterialID()); APPEND_ENTITY_PROPERTY(PROP_PARENT_MATERIAL_NAME, getParentMaterialName());
APPEND_ENTITY_PROPERTY(PROP_MATERIAL_POS, getMaterialPos()); APPEND_ENTITY_PROPERTY(PROP_MATERIAL_MAPPING_POS, getMaterialMappingPos());
APPEND_ENTITY_PROPERTY(PROP_MATERIAL_SCALE, getMaterialScale()); APPEND_ENTITY_PROPERTY(PROP_MATERIAL_MAPPING_SCALE, getMaterialMappingScale());
APPEND_ENTITY_PROPERTY(PROP_MATERIAL_ROT, getMaterialRot()); APPEND_ENTITY_PROPERTY(PROP_MATERIAL_MAPPING_ROT, getMaterialMappingRot());
} }
void MaterialEntityItem::debugDump() const { void MaterialEntityItem::debugDump() const {
quint64 now = usecTimestampNow(); quint64 now = usecTimestampNow();
qCDebug(entities) << " MATERIAL EntityItem id:" << getEntityItemID() << "---------------------------------------------"; qCDebug(entities) << " MATERIAL EntityItem id:" << getEntityItemID() << "---------------------------------------------";
qCDebug(entities) << " name:" << _name; qCDebug(entities) << " name:" << _name;
qCDebug(entities) << " material json:" << _materialURL; qCDebug(entities) << " material url:" << _materialURL;
qCDebug(entities) << " current material name:" << _currentMaterialName; qCDebug(entities) << " current material name:" << _currentMaterialName;
qCDebug(entities) << " material type:" << _materialMode; qCDebug(entities) << " material mapping mode:" << _materialMappingMode;
qCDebug(entities) << " priority:" << _priority; qCDebug(entities) << " priority:" << _priority;
qCDebug(entities) << " parent material ID:" << _parentMaterialID; qCDebug(entities) << " parent material name:" << _parentMaterialName;
qCDebug(entities) << " material pos:" << _materialPos; qCDebug(entities) << " material mapping pos:" << _materialMappingPos;
qCDebug(entities) << " material scale:" << _materialRot; qCDebug(entities) << " material mapping scale:" << _materialMappingRot;
qCDebug(entities) << " material rot:" << _materialScale; qCDebug(entities) << " material mapping rot:" << _materialMappingScale;
qCDebug(entities) << " position:" << debugTreeVector(getWorldPosition()); qCDebug(entities) << " position:" << debugTreeVector(getWorldPosition());
qCDebug(entities) << " dimensions:" << debugTreeVector(getScaledDimensions()); qCDebug(entities) << " dimensions:" << debugTreeVector(getScaledDimensions());
qCDebug(entities) << " getLastEdited:" << debugTime(getLastEdited(), now); qCDebug(entities) << " getLastEdited:" << debugTime(getLastEdited(), now);
@ -137,8 +137,8 @@ void MaterialEntityItem::setUnscaledDimensions(const glm::vec3& value) {
} }
std::shared_ptr<NetworkMaterial> MaterialEntityItem::getMaterial() const { std::shared_ptr<NetworkMaterial> MaterialEntityItem::getMaterial() const {
auto material = _materials.find(_currentMaterialName); auto material = _parsedMaterials.networkMaterials.find(_currentMaterialName);
if (material != _materials.end()) { if (material != _parsedMaterials.networkMaterials.end()) {
return material.value(); return material.value();
} else { } else {
return nullptr; return nullptr;
@ -151,28 +151,14 @@ void MaterialEntityItem::setMaterialURL(const QString& materialURLString, bool u
removeMaterial(); removeMaterial();
_materialURL = materialURLString; _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) { if (usingUserData) {
QJsonDocument materialJSON = QJsonDocument::fromJson(getUserData().toUtf8()); _parsedMaterials = NetworkMaterialResource::parseJSONMaterials(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);
}
}
// Since our material changed, the current name might not be valid anymore, so we need to update // Since our material changed, the current name might not be valid anymore, so we need to update
setCurrentMaterialName(_currentMaterialName); setCurrentMaterialName(_currentMaterialName);
applyMaterial(); applyMaterial();
@ -180,8 +166,7 @@ void MaterialEntityItem::setMaterialURL(const QString& materialURLString, bool u
_networkMaterial = MaterialCache::instance().getMaterial(materialURLString); _networkMaterial = MaterialCache::instance().getMaterial(materialURLString);
auto onMaterialRequestFinished = [&](bool success) { auto onMaterialRequestFinished = [&](bool success) {
if (success) { if (success) {
_materials[_networkMaterial->name] = _networkMaterial->networkMaterial; _parsedMaterials = _networkMaterial->parsedMaterials;
_materialNames.push_back(_networkMaterial->name);
setCurrentMaterialName(_currentMaterialName); setCurrentMaterialName(_currentMaterialName);
applyMaterial(); applyMaterial();
@ -199,11 +184,11 @@ void MaterialEntityItem::setMaterialURL(const QString& materialURLString, bool u
} }
void MaterialEntityItem::setCurrentMaterialName(const QString& currentMaterialName) { void MaterialEntityItem::setCurrentMaterialName(const QString& currentMaterialName) {
auto material = _materials.find(currentMaterialName); auto material = _parsedMaterials.networkMaterials.find(currentMaterialName);
if (material != _materials.end()) { if (material != _parsedMaterials.networkMaterials.end()) {
_currentMaterialName = currentMaterialName; _currentMaterialName = currentMaterialName;
} else if (_materialNames.size() > 0) { } else if (_parsedMaterials.names.size() > 0) {
_currentMaterialName = _materialNames[0]; _currentMaterialName = _parsedMaterials.names[0];
} }
} }
@ -217,26 +202,26 @@ void MaterialEntityItem::setUserData(const QString& userData) {
} }
} }
void MaterialEntityItem::setMaterialPos(const glm::vec2& materialPos) { void MaterialEntityItem::setMaterialMappingPos(const glm::vec2& materialMappingPos) {
if (_materialPos != materialPos) { if (_materialMappingPos != materialMappingPos) {
removeMaterial(); removeMaterial();
_materialPos = materialPos; _materialMappingPos = materialMappingPos;
applyMaterial(); applyMaterial();
} }
} }
void MaterialEntityItem::setMaterialScale(const glm::vec2& materialScale) { void MaterialEntityItem::setMaterialMappingScale(const glm::vec2& materialMappingScale) {
if (_materialScale != materialScale) { if (_materialMappingScale != materialMappingScale) {
removeMaterial(); removeMaterial();
_materialScale = materialScale; _materialMappingScale = materialMappingScale;
applyMaterial(); applyMaterial();
} }
} }
void MaterialEntityItem::setMaterialRot(const float& materialRot) { void MaterialEntityItem::setMaterialMappingRot(const float& materialMappingRot) {
if (_materialRot != materialRot) { if (_materialMappingRot != materialMappingRot) {
removeMaterial(); removeMaterial();
_materialRot = materialRot; _materialMappingRot = materialMappingRot;
applyMaterial(); applyMaterial();
} }
} }
@ -249,10 +234,10 @@ void MaterialEntityItem::setPriority(quint16 priority) {
} }
} }
void MaterialEntityItem::setParentMaterialID(const QString& parentMaterialID) { void MaterialEntityItem::setParentMaterialName(const QString& parentMaterialName) {
if (_parentMaterialID != parentMaterialID) { if (_parentMaterialName != parentMaterialName) {
removeMaterial(); removeMaterial();
_parentMaterialID = parentMaterialID; _parentMaterialName = parentMaterialName;
applyMaterial(); applyMaterial();
} }
} }
@ -293,16 +278,16 @@ void MaterialEntityItem::removeMaterial() {
if (tree) { if (tree) {
EntityItemPointer entity = tree->findEntityByEntityItemID(parentID); EntityItemPointer entity = tree->findEntityByEntityItemID(parentID);
if (entity) { if (entity) {
entity->removeMaterial(material, getParentMaterialID()); entity->removeMaterial(material, getParentMaterialName());
return; return;
} }
} }
if (EntityTree::removeMaterialFromAvatar(parentID, material, getParentMaterialID())) { if (EntityTree::removeMaterialFromAvatar(parentID, material, getParentMaterialName())) {
return; return;
} }
if (EntityTree::removeMaterialFromOverlay(parentID, material, getParentMaterialID())) { if (EntityTree::removeMaterialFromOverlay(parentID, material, getParentMaterialName())) {
return; return;
} }
@ -317,9 +302,9 @@ void MaterialEntityItem::applyMaterial() {
return; return;
} }
Transform textureTransform; Transform textureTransform;
textureTransform.setTranslation(glm::vec3(_materialPos, 0)); textureTransform.setTranslation(glm::vec3(_materialMappingPos, 0));
textureTransform.setRotation(glm::vec3(0, 0, glm::radians(_materialRot))); textureTransform.setRotation(glm::vec3(0, 0, glm::radians(_materialMappingRot)));
textureTransform.setScale(glm::vec3(_materialScale, 1)); textureTransform.setScale(glm::vec3(_materialMappingScale, 1));
material->setTextureTransforms(textureTransform); material->setTextureTransforms(textureTransform);
material->setPriority(getPriority()); material->setPriority(getPriority());
@ -328,16 +313,16 @@ void MaterialEntityItem::applyMaterial() {
if (tree) { if (tree) {
EntityItemPointer entity = tree->findEntityByEntityItemID(parentID); EntityItemPointer entity = tree->findEntityByEntityItemID(parentID);
if (entity) { if (entity) {
entity->addMaterial(material, getParentMaterialID()); entity->addMaterial(material, getParentMaterialName());
return; return;
} }
} }
if (EntityTree::addMaterialToAvatar(parentID, material, getParentMaterialID())) { if (EntityTree::addMaterialToAvatar(parentID, material, getParentMaterialName())) {
return; return;
} }
if (EntityTree::addMaterialToOverlay(parentID, material, getParentMaterialID())) { if (EntityTree::addMaterialToOverlay(parentID, material, getParentMaterialName())) {
return; return;
} }

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

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

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

@ -361,6 +361,8 @@ public:
const QString& getName() { return _name; } const QString& getName() { return _name; }
void setModel(const QString& model) { _model = model; }
protected: protected:
QString _name { "" }; QString _name { "" };
@ -379,6 +381,8 @@ private:
quint16 _priority { 0 }; quint16 _priority { 0 };
QString _model { "hifi_pbr" };
}; };
typedef std::shared_ptr< Material > MaterialPointer; 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) {} Resource(url) {}
void NetworkMaterialResource::downloadFinished(const QByteArray& data) { void NetworkMaterialResource::downloadFinished(const QByteArray& data) {
if (_url.toString().endsWith(".json")) { parsedMaterials.reset();
QJsonDocument materialJSON = QJsonDocument::fromJson(data);
if (!materialJSON.isNull() && materialJSON.isObject()) { if (_url.toString().contains(".json")) {
auto parsedMaterial = parseJSONMaterial(materialJSON.object()); parsedMaterials = parseJSONMaterials(QJsonDocument::fromJson(data));
name = parsedMaterial.first;
networkMaterial = parsedMaterial.second;
}
} }
// TODO: parse other material types // TODO: parse other material types
@ -46,6 +43,39 @@ bool NetworkMaterialResource::parseJSONColor(const QJsonValue& array, glm::vec3&
return false; 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) { std::pair<QString, std::shared_ptr<NetworkMaterial>> NetworkMaterialResource::parseJSONMaterial(const QJsonObject& materialJSON) {
QString name = ""; QString name = "";
std::shared_ptr<NetworkMaterial> material = std::make_shared<NetworkMaterial>(); 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()) { if (nameJSON.isString()) {
name = nameJSON.toString(); name = nameJSON.toString();
} }
} else if (key == "model") {
auto modelJSON = materialJSON.value(key);
if (modelJSON.isString()) {
material->setModel(modelJSON.toString());
}
} else if (key == "emissive") { } else if (key == "emissive") {
glm::vec3 color; glm::vec3 color;
bool isSRGB; bool isSRGB;
@ -67,6 +102,11 @@ std::pair<QString, std::shared_ptr<NetworkMaterial>> NetworkMaterialResource::pa
if (value.isDouble()) { if (value.isDouble()) {
material->setOpacity(value.toDouble()); material->setOpacity(value.toDouble());
} }
} else if (key == "unlit") {
auto value = materialJSON.value(key);
if (value.isBool()) {
material->setUnlit(value.toBool());
}
} else if (key == "albedo") { } else if (key == "albedo") {
glm::vec3 color; glm::vec3 color;
bool isSRGB; bool isSRGB;
@ -79,13 +119,6 @@ std::pair<QString, std::shared_ptr<NetworkMaterial>> NetworkMaterialResource::pa
if (value.isDouble()) { if (value.isDouble()) {
material->setRoughness(value.toDouble()); 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") { } else if (key == "metallic") {
auto value = materialJSON.value(key); auto value = materialJSON.value(key);
if (value.isDouble()) { 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; virtual void downloadFinished(const QByteArray& data) override;
QString name { "" }; typedef struct ParsedMaterials {
std::shared_ptr<NetworkMaterial> networkMaterial { nullptr }; 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); static std::pair<QString, std::shared_ptr<NetworkMaterial>> parseJSONMaterial(const QJsonObject& materialJSON);
private: private:

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

@ -33,7 +33,7 @@
#include <NLPacket.h> #include <NLPacket.h>
#include <udt/PacketHeaders.h> #include <udt/PacketHeaders.h>
#include "MaterialMode.h" #include "MaterialMappingMode.h"
#include "OctreeConstants.h" #include "OctreeConstants.h"
#include "OctreeElement.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, 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, 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, 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, QString& result);
static int unpackDataFromBytes(const unsigned char* dataBytes, QUuid& result); static int unpackDataFromBytes(const unsigned char* dataBytes, QUuid& result);
static int unpackDataFromBytes(const unsigned char* dataBytes, xColor& 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()); return !_meshStates.empty() || (isLoaded() && _renderGeometry->getMeshes().empty());
} }
std::vector<unsigned int> Model::getMeshIDsFromMaterialID(QString parentMaterialID) { std::vector<unsigned int> Model::getMeshIDsFromMaterialID(QString parentMaterialName) {
// try to find all meshes with materials that match parentMaterialID as a string // try to find all meshes with materials that match parentMaterialName as a string
// if none, return parentMaterialID as a uint // if none, return parentMaterialName as a uint
std::vector<unsigned int> toReturn; std::vector<unsigned int> toReturn;
const QString MATERIAL_NAME_PREFIX = "mat::"; const QString MATERIAL_NAME_PREFIX = "mat::";
if (parentMaterialID.startsWith(MATERIAL_NAME_PREFIX)) { if (parentMaterialName.startsWith(MATERIAL_NAME_PREFIX)) {
parentMaterialID.replace(0, MATERIAL_NAME_PREFIX.size(), QString("")); parentMaterialName.replace(0, MATERIAL_NAME_PREFIX.size(), QString(""));
for (int i = 0; i < _modelMeshMaterialNames.size(); i++) { for (unsigned int i = 0; i < (unsigned int)_modelMeshMaterialNames.size(); i++) {
if (_modelMeshMaterialNames[i] == parentMaterialID) { if (_modelMeshMaterialNames[i] == parentMaterialName) {
toReturn.push_back(i); toReturn.push_back(i);
} }
} }
} }
if (toReturn.empty()) { if (toReturn.empty()) {
toReturn.push_back(parentMaterialID.toUInt()); toReturn.push_back(parentMaterialName.toUInt());
} }
return toReturn; return toReturn;
} }
void Model::addMaterial(graphics::MaterialPointer material, const QString& parentMaterialID) { void Model::addMaterial(graphics::MaterialPointer material, const QString& parentMaterialName) {
std::vector<unsigned int> shapeIDs = getMeshIDsFromMaterialID(parentMaterialID); std::vector<unsigned int> shapeIDs = getMeshIDsFromMaterialID(parentMaterialName);
render::Transaction transaction; render::Transaction transaction;
for (auto shapeID : shapeIDs) { for (auto shapeID : shapeIDs) {
if (shapeID < _modelMeshRenderItemIDs.size()) { if (shapeID < _modelMeshRenderItemIDs.size()) {
@ -1573,8 +1573,8 @@ void Model::addMaterial(graphics::MaterialPointer material, const QString& paren
AbstractViewStateInterface::instance()->getMain3DScene()->enqueueTransaction(transaction); AbstractViewStateInterface::instance()->getMain3DScene()->enqueueTransaction(transaction);
} }
void Model::removeMaterial(graphics::MaterialPointer material, const QString& parentMaterialID) { void Model::removeMaterial(graphics::MaterialPointer material, const QString& parentMaterialName) {
std::vector<unsigned int> shapeIDs = getMeshIDsFromMaterialID(parentMaterialID); std::vector<unsigned int> shapeIDs = getMeshIDsFromMaterialID(parentMaterialName);
render::Transaction transaction; render::Transaction transaction;
for (auto shapeID : shapeIDs) { for (auto shapeID : shapeIDs) {
if (shapeID < _modelMeshRenderItemIDs.size()) { if (shapeID < _modelMeshRenderItemIDs.size()) {

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

@ -318,8 +318,8 @@ public:
void scaleToFit(); void scaleToFit();
void addMaterial(graphics::MaterialPointer material, const QString& parentMaterialID); void addMaterial(graphics::MaterialPointer material, const QString& parentMaterialName);
void removeMaterial(graphics::MaterialPointer material, const QString& parentMaterialID); void removeMaterial(graphics::MaterialPointer material, const QString& parentMaterialName);
public slots: public slots:
void loadURLFinished(bool success); void loadURLFinished(bool success);
@ -473,7 +473,7 @@ private:
void calculateTextureInfo(); void calculateTextureInfo();
std::vector<unsigned int> getMeshIDsFromMaterialID(QString parentMaterialID); std::vector<unsigned int> getMeshIDsFromMaterialID(QString parentMaterialName);
}; };
Q_DECLARE_METATYPE(ModelPointer) 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 // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
// //
#ifndef hifi_MaterialMode_h #ifndef hifi_MaterialMappingMode_h
#define hifi_MaterialMode_h #define hifi_MaterialMappingMode_h
#include "QString" #include "QString"
enum MaterialMode { enum MaterialMappingMode {
UV = 0, UV = 0,
PROJECTED PROJECTED
}; };
class MaterialModeHelpers { class MaterialMappingModeHelpers {
public: 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({ newMaterialButton = toolBar.addButton({
objectName: "newMaterialButton", objectName: "newMaterialButton",
imageURL: toolIconUrl + "model-01.svg", imageURL: toolIconUrl + "material-01.svg",
alpha: 0.9, alpha: 0.9,
visible: false visible: false
}); });

6
scripts/system/edit.js
View file

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

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

@ -805,7 +805,7 @@
<!-- TODO: support 3D projected materials <!-- TODO: support 3D projected materials
<div class="material-group material-section property dropdown"> <div class="material-group material-section property dropdown">
<label>Material mode </label> <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="uv">UV space material</option>
<option value="projected">3D projected material</option> <option value="projected">3D projected material</option>
</select> </select>
@ -815,20 +815,20 @@
<div class="material-group material-section property xy fstuple"> <div class="material-group material-section property xy fstuple">
<label>Material Position </label> <label>Material Position </label>
<div class="tuple"> <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="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-pos-y" min="0" max="1" step="0.1"><label for="property-material-pos-y">Y:</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>
<div class="material-group material-section property wh fstuple"> <div class="material-group material-section property wh fstuple">
<label>Material Scale </label> <label>Material Scale </label>
<div class="tuple"> <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="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-scale-y" min="0" step="0.1"><label for="property-material-scale-y">Height:</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>
<div class="material-group material-section property number"> <div class="material-group material-section property number">
<label>Material Rotation <span class="unit">deg</span></label> <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> </div>
</fieldset> </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) { if (number) {
$('#property-parent-material-id-number-container').show(); $('#property-parent-material-id-number-container').show();
$('#property-parent-material-id-string-container').hide(); $('#property-parent-material-id-string-container').hide();
@ -653,16 +653,16 @@ function loaded() {
var elModelOriginalTextures = document.getElementById("property-model-original-textures"); var elModelOriginalTextures = document.getElementById("property-model-original-textures");
var elMaterialURL = document.getElementById("property-material-url"); 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 elPriority = document.getElementById("property-priority");
var elParentMaterialIDString = document.getElementById("property-parent-material-id-string"); var elParentMaterialNameString = document.getElementById("property-parent-material-id-string");
var elParentMaterialIDNumber = document.getElementById("property-parent-material-id-number"); var elParentMaterialNameNumber = document.getElementById("property-parent-material-id-number");
var elParentMaterialIDCheckbox = document.getElementById("property-parent-material-id-checkbox"); var elParentMaterialNameCheckbox = document.getElementById("property-parent-material-id-checkbox");
var elMaterialPosX = document.getElementById("property-material-pos-x"); var elMaterialMappingPosX = document.getElementById("property-material-mapping-pos-x");
var elMaterialPosY = document.getElementById("property-material-pos-y"); var elMaterialMappingPosY = document.getElementById("property-material-mapping-pos-y");
var elMaterialScaleX = document.getElementById("property-material-scale-x"); var elMaterialMappingScaleX = document.getElementById("property-material-mapping-scale-x");
var elMaterialScaleY = document.getElementById("property-material-scale-y"); var elMaterialMappingScaleY = document.getElementById("property-material-mapping-scale-y");
var elMaterialRot = document.getElementById("property-material-rot"); var elMaterialMappingRot = document.getElementById("property-material-mapping-rot");
var elImageURL = document.getElementById("property-image-url"); var elImageURL = document.getElementById("property-image-url");
@ -1164,23 +1164,23 @@ function loaded() {
elZTextureURL.value = properties.zTextureURL; elZTextureURL.value = properties.zTextureURL;
} else if (properties.type === "Material") { } else if (properties.type === "Material") {
elMaterialURL.value = properties.materialURL; elMaterialURL.value = properties.materialURL;
//elMaterialMode.value = properties.materialMode; //elMaterialMappingMode.value = properties.materialMappingMode;
//setDropdownText(elMaterialMode); //setDropdownText(elMaterialMappingMode);
elPriority.value = properties.priority; elPriority.value = properties.priority;
if (properties.parentMaterialID.startsWith(MATERIAL_PREFIX_STRING)) { if (properties.parentMaterialName.startsWith(MATERIAL_PREFIX_STRING)) {
elParentMaterialIDString.value = properties.parentMaterialID.replace(MATERIAL_PREFIX_STRING, ""); elParentMaterialNameString.value = properties.parentMaterialName.replace(MATERIAL_PREFIX_STRING, "");
showParentMaterialIDBox(false, elParentMaterialIDNumber, elParentMaterialIDString); showParentMaterialNameBox(false, elParentMaterialNameNumber, elParentMaterialNameString);
elParentMaterialIDCheckbox.checked = false; elParentMaterialNameCheckbox.checked = false;
} else { } else {
elParentMaterialIDNumber.value = parseInt(properties.parentMaterialID); elParentMaterialNameNumber.value = parseInt(properties.parentMaterialName);
showParentMaterialIDBox(true, elParentMaterialIDNumber, elParentMaterialIDString); showParentMaterialNameBox(true, elParentMaterialNameNumber, elParentMaterialNameString);
elParentMaterialIDCheckbox.checked = true; elParentMaterialNameCheckbox.checked = true;
} }
elMaterialPosX.value = properties.materialPos.x.toFixed(4); elMaterialMappingPosX.value = properties.materialMappingPos.x.toFixed(4);
elMaterialPosY.value = properties.materialPos.y.toFixed(4); elMaterialMappingPosY.value = properties.materialMappingPos.y.toFixed(4);
elMaterialScaleX.value = properties.materialScale.x.toFixed(4); elMaterialMappingScaleX.value = properties.materialMappingScale.x.toFixed(4);
elMaterialScaleY.value = properties.materialScale.y.toFixed(4); elMaterialMappingScaleY.value = properties.materialMappingScale.y.toFixed(4);
elMaterialRot.value = properties.materialRot.toFixed(2); elMaterialMappingRot.value = properties.materialMappingRot.toFixed(2);
} }
if (properties.locked) { if (properties.locked) {
@ -1454,28 +1454,28 @@ function loaded() {
elModelTextures.addEventListener('change', createEmitTextPropertyUpdateFunction('textures')); elModelTextures.addEventListener('change', createEmitTextPropertyUpdateFunction('textures'));
elMaterialURL.addEventListener('change', createEmitTextPropertyUpdateFunction('materialURL')); elMaterialURL.addEventListener('change', createEmitTextPropertyUpdateFunction('materialURL'));
//elMaterialMode.addEventListener('change', createEmitTextPropertyUpdateFunction('materialMode')); //elMaterialMappingMode.addEventListener('change', createEmitTextPropertyUpdateFunction('materialMappingMode'));
elPriority.addEventListener('change', createEmitNumberPropertyUpdateFunction('priority', 0)); elPriority.addEventListener('change', createEmitNumberPropertyUpdateFunction('priority', 0));
elParentMaterialIDString.addEventListener('change', function () { updateProperty("parentMaterialID", MATERIAL_PREFIX_STRING + this.value); }); elParentMaterialNameString.addEventListener('change', function () { updateProperty("parentMaterialName", MATERIAL_PREFIX_STRING + this.value); });
elParentMaterialIDNumber.addEventListener('change', function () { updateProperty("parentMaterialID", this.value); }); elParentMaterialNameNumber.addEventListener('change', function () { updateProperty("parentMaterialName", this.value); });
elParentMaterialIDCheckbox.addEventListener('change', function () { elParentMaterialNameCheckbox.addEventListener('change', function () {
if (this.checked) { if (this.checked) {
updateProperty("parentMaterialID", elParentMaterialIDNumber.value); updateProperty("parentMaterialName", elParentMaterialNameNumber.value);
showParentMaterialIDBox(true, elParentMaterialIDNumber, elParentMaterialIDString); showParentMaterialNameBox(true, elParentMaterialNameNumber, elParentMaterialNameString);
} else { } else {
updateProperty("parentMaterialID", MATERIAL_PREFIX_STRING + elParentMaterialIDString.value); updateProperty("parentMaterialName", MATERIAL_PREFIX_STRING + elParentMaterialNameString.value);
showParentMaterialIDBox(false, elParentMaterialIDNumber, elParentMaterialIDString); showParentMaterialNameBox(false, elParentMaterialNameNumber, elParentMaterialNameString);
} }
}); });
var materialPosChangeFunction = createEmitVec2PropertyUpdateFunction('materialPos', elMaterialPosX, elMaterialPosY); var materialMappingPosChangeFunction = createEmitVec2PropertyUpdateFunction('materialMappingPos', elMaterialMappingPosX, elMaterialMappingPosY);
elMaterialPosX.addEventListener('change', materialPosChangeFunction); elMaterialMappingPosX.addEventListener('change', materialMappingPosChangeFunction);
elMaterialPosY.addEventListener('change', materialPosChangeFunction); elMaterialMappingPosY.addEventListener('change', materialMappingPosChangeFunction);
var materialScaleChangeFunction = createEmitVec2PropertyUpdateFunction('materialScale', elMaterialScaleX, elMaterialScaleY); var materialMappingScaleChangeFunction = createEmitVec2PropertyUpdateFunction('materialMappingScale', elMaterialMappingScaleX, elMaterialMappingScaleY);
elMaterialScaleX.addEventListener('change', materialScaleChangeFunction); elMaterialMappingScaleX.addEventListener('change', materialMappingScaleChangeFunction);
elMaterialScaleY.addEventListener('change', materialScaleChangeFunction); elMaterialMappingScaleY.addEventListener('change', materialMappingScaleChangeFunction);
elMaterialRot.addEventListener('change', createEmitNumberPropertyUpdateFunction('materialRot', 2)); elMaterialMappingRot.addEventListener('change', createEmitNumberPropertyUpdateFunction('materialMappingRot', 2));
elTextText.addEventListener('change', createEmitTextPropertyUpdateFunction('text')); elTextText.addEventListener('change', createEmitTextPropertyUpdateFunction('text'));
elTextFaceCamera.addEventListener('change', createEmitCheckedPropertyUpdateFunction('faceCamera')); elTextFaceCamera.addEventListener('change', createEmitCheckedPropertyUpdateFunction('faceCamera'));