diff options
Diffstat (limited to 'indra/newview/llfloaterdebugmaterials.cpp')
| -rw-r--r-- | indra/newview/llfloaterdebugmaterials.cpp | 1344 |
1 files changed, 316 insertions, 1028 deletions
diff --git a/indra/newview/llfloaterdebugmaterials.cpp b/indra/newview/llfloaterdebugmaterials.cpp index d5ed667c4d..c9f15a9c35 100644 --- a/indra/newview/llfloaterdebugmaterials.cpp +++ b/indra/newview/llfloaterdebugmaterials.cpp @@ -43,6 +43,7 @@ #include "llcolorswatch.h" #include "llenvmanager.h" #include "llfloater.h" +#include "llfloaterreg.h" #include "llfontgl.h" #include "llhttpclient.h" #include "lllineeditor.h" @@ -73,84 +74,10 @@ #define MATERIALS_CAPABILITY_NAME "RenderMaterials" -#define MATERIALS_CAP_ZIP_FIELD "Zipped" - -#define MATERIALS_CAP_FULL_PER_FACE_FIELD "FullMaterialsPerFace" -#define MATERIALS_CAP_FACE_FIELD "Face" -#define MATERIALS_CAP_MATERIAL_FIELD "Material" -#define MATERIALS_CAP_OBJECT_ID_FIELD "ID" -#define MATERIALS_CAP_MATERIAL_ID_FIELD "MaterialID" - -#define MATERIALS_CAP_NORMAL_MAP_FIELD "NormMap" -#define MATERIALS_CAP_NORMAL_MAP_OFFSET_X_FIELD "NormOffsetX" -#define MATERIALS_CAP_NORMAL_MAP_OFFSET_Y_FIELD "NormOffsetY" -#define MATERIALS_CAP_NORMAL_MAP_REPEAT_X_FIELD "NormRepeatX" -#define MATERIALS_CAP_NORMAL_MAP_REPEAT_Y_FIELD "NormRepeatY" -#define MATERIALS_CAP_NORMAL_MAP_ROTATION_FIELD "NormRotation" - -#define MATERIALS_CAP_SPECULAR_MAP_FIELD "SpecMap" -#define MATERIALS_CAP_SPECULAR_MAP_OFFSET_X_FIELD "SpecOffsetX" -#define MATERIALS_CAP_SPECULAR_MAP_OFFSET_Y_FIELD "SpecOffsetY" -#define MATERIALS_CAP_SPECULAR_MAP_REPEAT_X_FIELD "SpecRepeatX" -#define MATERIALS_CAP_SPECULAR_MAP_REPEAT_Y_FIELD "SpecRepeatY" -#define MATERIALS_CAP_SPECULAR_MAP_ROTATION_FIELD "SpecRotation" - -#define MATERIALS_CAP_SPECULAR_COLOR_FIELD "SpecColor" -#define MATERIALS_CAP_SPECULAR_EXP_FIELD "SpecExp" -#define MATERIALS_CAP_ENV_INTENSITY_FIELD "EnvIntensity" -#define MATERIALS_CAP_ALPHA_MASK_CUTOFF_FIELD "AlphaMaskCutoff" -#define MATERIALS_CAP_DIFFUSE_ALPHA_MODE_FIELD "DiffuseAlphaMode" - -#define MULTI_MATERIALS_STATUS_FIELD "status" -#define MULTI_MATERIALS_DATA_FIELD "data" - #define VIEWABLE_OBJECTS_REGION_ID_FIELD "regionId" #define VIEWABLE_OBJECTS_OBJECT_ID_FIELD "objectId" #define VIEWABLE_OBJECTS_MATERIAL_ID_FIELD "materialId" -class MaterialsResponder : public LLHTTPClient::Responder -{ -public: - typedef boost::function<void (bool, const LLSD&)> CallbackFunction; - - MaterialsResponder(const std::string& pMethod, const std::string& pCapabilityURL, CallbackFunction pCallback); - virtual ~MaterialsResponder(); - - virtual void result(const LLSD& pContent); - virtual void error(U32 pStatus, const std::string& pReason); - -protected: - -private: - std::string mMethod; - std::string mCapabilityURL; - CallbackFunction mCallback; -}; - -class MultiMaterialsResponder -{ -public: - typedef boost::function<void (bool, const LLSD&)> CallbackFunction; - - MultiMaterialsResponder(CallbackFunction pCallback, unsigned int pNumRequests); - virtual ~MultiMaterialsResponder(); - - void onMaterialsResponse(bool pRequestStatus, const LLSD& pContent); - -protected: - -private: - bool appendRequestResults(bool pRequestStatus, const LLSD& pResults); - void fireResponse(); - - CallbackFunction mCallback; - unsigned int mNumRequests; - - bool mRequestStatus; - LLSD mContent; - LLMutex* mMutex; -}; - BOOL LLFloaterDebugMaterials::postBuild() { mStatusText = findChild<LLTextBase>("material_status"); @@ -178,58 +105,38 @@ BOOL LLFloaterDebugMaterials::postBuild() mNormalMap = findChild<LLTextureCtrl>("normal_map"); llassert(mNormalMap != NULL); - mNormalMapOffsetX = findChild<LLLineEditor>("normal_map_offset_x"); + mNormalMapOffsetX = findChild<LLSpinCtrl>("normal_map_offset_x"); llassert(mNormalMapOffsetX != NULL); - mNormalMapOffsetX->setPrevalidate(LLTextValidate::validateInt); - mNormalMapOffsetX->setCommitCallback(boost::bind(&LLFloaterDebugMaterials::onValueEntered, this, _1)); - mNormalMapOffsetY = findChild<LLLineEditor>("normal_map_offset_y"); + mNormalMapOffsetY = findChild<LLSpinCtrl>("normal_map_offset_y"); llassert(mNormalMapOffsetY != NULL); - mNormalMapOffsetY->setPrevalidate(LLTextValidate::validateInt); - mNormalMapOffsetY->setCommitCallback(boost::bind(&LLFloaterDebugMaterials::onValueEntered, this, _1)); - mNormalMapRepeatX = findChild<LLLineEditor>("normal_map_repeat_x"); + mNormalMapRepeatX = findChild<LLSpinCtrl>("normal_map_repeat_x"); llassert(mNormalMapRepeatX != NULL); - mNormalMapRepeatX->setPrevalidate(LLTextValidate::validateInt); - mNormalMapRepeatX->setCommitCallback(boost::bind(&LLFloaterDebugMaterials::onValueEntered, this, _1)); - mNormalMapRepeatY = findChild<LLLineEditor>("normal_map_repeat_y"); + mNormalMapRepeatY = findChild<LLSpinCtrl>("normal_map_repeat_y"); llassert(mNormalMapRepeatY != NULL); - mNormalMapRepeatY->setPrevalidate(LLTextValidate::validateInt); - mNormalMapRepeatY->setCommitCallback(boost::bind(&LLFloaterDebugMaterials::onValueEntered, this, _1)); - mNormalMapRotation = findChild<LLLineEditor>("normal_map_rotation"); + mNormalMapRotation = findChild<LLSpinCtrl>("normal_map_rotation"); llassert(mNormalMapRotation != NULL); - mNormalMapRotation->setPrevalidate(LLTextValidate::validateInt); - mNormalMapRotation->setCommitCallback(boost::bind(&LLFloaterDebugMaterials::onValueEntered, this, _1)); mSpecularMap = findChild<LLTextureCtrl>("specular_map"); llassert(mSpecularMap != NULL); - mSpecularMapOffsetX = findChild<LLLineEditor>("specular_map_offset_x"); + mSpecularMapOffsetX = findChild<LLSpinCtrl>("specular_map_offset_x"); llassert(mSpecularMapOffsetX != NULL); - mSpecularMapOffsetX->setPrevalidate(LLTextValidate::validateInt); - mSpecularMapOffsetX->setCommitCallback(boost::bind(&LLFloaterDebugMaterials::onValueEntered, this, _1)); - mSpecularMapOffsetY = findChild<LLLineEditor>("specular_map_offset_y"); + mSpecularMapOffsetY = findChild<LLSpinCtrl>("specular_map_offset_y"); llassert(mSpecularMapOffsetY != NULL); - mSpecularMapOffsetY->setPrevalidate(LLTextValidate::validateInt); - mSpecularMapOffsetY->setCommitCallback(boost::bind(&LLFloaterDebugMaterials::onValueEntered, this, _1)); - mSpecularMapRepeatX = findChild<LLLineEditor>("specular_map_repeat_x"); + mSpecularMapRepeatX = findChild<LLSpinCtrl>("specular_map_repeat_x"); llassert(mSpecularMapRepeatX != NULL); - mSpecularMapRepeatX->setPrevalidate(LLTextValidate::validateInt); - mSpecularMapRepeatX->setCommitCallback(boost::bind(&LLFloaterDebugMaterials::onValueEntered, this, _1)); - mSpecularMapRepeatY = findChild<LLLineEditor>("specular_map_repeat_y"); + mSpecularMapRepeatY = findChild<LLSpinCtrl>("specular_map_repeat_y"); llassert(mSpecularMapRepeatY != NULL); - mSpecularMapRepeatY->setPrevalidate(LLTextValidate::validateInt); - mSpecularMapRepeatY->setCommitCallback(boost::bind(&LLFloaterDebugMaterials::onValueEntered, this, _1)); - mSpecularMapRotation = findChild<LLLineEditor>("specular_map_rotation"); + mSpecularMapRotation = findChild<LLSpinCtrl>("specular_map_rotation"); llassert(mSpecularMapRotation != NULL); - mSpecularMapRotation->setPrevalidate(LLTextValidate::validateInt); - mSpecularMapRotation->setCommitCallback(boost::bind(&LLFloaterDebugMaterials::onValueEntered, this, _1)); mSpecularColor = findChild<LLColorSwatchCtrl>("specular_color"); llassert(mSpecularColor != NULL); @@ -331,7 +238,6 @@ void LLFloaterDebugMaterials::onOpen(const LLSD& pKey) checkRegionMaterialStatus(); resetObjectEditInputs(); clearGetResults(); - clearPutResults(); clearViewableObjectsResults(); clearPostResults(); } @@ -340,7 +246,6 @@ void LLFloaterDebugMaterials::onClose(bool pIsAppQuitting) { resetObjectEditInputs(); clearGetResults(); - clearPutResults(); clearViewableObjectsResults(); clearPostResults(); @@ -364,14 +269,14 @@ void LLFloaterDebugMaterials::onClose(bool pIsAppQuitting) void LLFloaterDebugMaterials::draw() { - if (mUnparsedGetData.isDefined()) - { - parseGetResponse(); - } if (mNextUnparsedQueryDataIndex >= 0) { parseQueryViewableObjects(); } + if (LLSelectMgr::instance().getSelection().notNull()) + { + refreshObjectEdit(); + } LLFloater::draw(); } @@ -417,19 +322,12 @@ LLFloaterDebugMaterials::LLFloaterDebugMaterials(const LLSD& pParams) mRegionCrossConnection(), mTeleportFailedConnection(), mSelectionUpdateConnection(), - mUnparsedGetData(), - mNextUnparsedGetDataIndex(-1), - mNextUnparsedQueryDataIndex(-1), - mMultiMaterialsResponder() + mNextUnparsedQueryDataIndex(-1) { } LLFloaterDebugMaterials::~LLFloaterDebugMaterials() { - if (!mMultiMaterialsResponder) - { - mMultiMaterialsResponder.reset(); - } } void LLFloaterDebugMaterials::onGetClicked() @@ -478,14 +376,35 @@ void LLFloaterDebugMaterials::onQueryVisibleObjectsClicked() void LLFloaterDebugMaterials::onPostClicked() { - requestPostMaterials(); + clearPostResults(); + + std::vector<LLScrollListItem*> selectedItems = mViewableObjectsScrollList->getAllSelected(); + if (!selectedItems.empty()) + { + for (std::vector<LLScrollListItem*>::const_iterator selectedItemIter = selectedItems.begin(); + selectedItemIter != selectedItems.end(); ++selectedItemIter) + { + const LLScrollListItem* selectedItem = *selectedItemIter; + const LLSD& selectedItemValue = selectedItem->getValue(); + llassert(selectedItemValue.isMap()); + + llassert(selectedItemValue.has(VIEWABLE_OBJECTS_REGION_ID_FIELD)); + llassert(selectedItemValue.get(VIEWABLE_OBJECTS_REGION_ID_FIELD).isUUID()); + const LLUUID& region_id = selectedItemValue.get(VIEWABLE_OBJECTS_REGION_ID_FIELD).asUUID(); + + llassert(selectedItemValue.has(VIEWABLE_OBJECTS_MATERIAL_ID_FIELD)); + llassert(selectedItemValue.get(VIEWABLE_OBJECTS_MATERIAL_ID_FIELD).isBinary()); + const LLMaterialID material_id(selectedItemValue.get(VIEWABLE_OBJECTS_MATERIAL_ID_FIELD).asBinary()); + + LLMaterialMgr::instance().get(region_id, material_id, boost::bind(&LLFloaterDebugMaterials::onPostMaterial, _1, _2)); + } + } } void LLFloaterDebugMaterials::onRegionCross() { checkRegionMaterialStatus(); clearGetResults(); - clearPutResults(); clearViewableObjectsResults(); clearPostResults(); } @@ -605,47 +524,6 @@ void LLFloaterDebugMaterials::onDeferredRequestPutMaterials(LLUUID regionId, boo requestPutMaterials(regionId, pIsDoSet); } -void LLFloaterDebugMaterials::onGetResponse(bool pRequestStatus, const LLSD& pContent) -{ - clearGetResults(); - if (pRequestStatus) - { - setState(kRequestCompleted); - setUnparsedGetData(pContent); - } - else - { - setState(kError); - } -} - -void LLFloaterDebugMaterials::onPutResponse(bool pRequestStatus, const LLSD& pContent) -{ - if (pRequestStatus) - { - setState(kRequestCompleted); - parsePutResponse(pContent); - } - else - { - setState(kError); - } -} - -void LLFloaterDebugMaterials::onPostResponse(bool pRequestStatus, const LLSD& pContent) -{ - if (pRequestStatus) - { - setState(kRequestCompleted); - parsePostResponse(pContent); - } - else - { - setState(kError); - } - mMultiMaterialsResponder.reset(); -} - void LLFloaterDebugMaterials::checkRegionMaterialStatus() { LLViewerRegion *region = gAgent.getRegion(); @@ -713,9 +591,8 @@ void LLFloaterDebugMaterials::requestGetMaterials() } else { - setState(kRequestStarted); - LLHTTPClient::ResponderPtr materialsResponder = new MaterialsResponder("GET", capURL, boost::bind(&LLFloaterDebugMaterials::onGetResponse, this, _1, _2)); - LLHTTPClient::get(capURL, materialsResponder); + setState(kReady); + LLMaterialMgr::instance().getAll(region->getRegionID(), boost::bind(&LLFloaterDebugMaterials::onGetMaterials, _1, _2)); } } } @@ -756,34 +633,9 @@ void LLFloaterDebugMaterials::requestPutMaterials(bool pIsDoSet) } else { - setState(kRequestStarted); - - LLSD facesData = LLSD::emptyArray(); + setState(kReady); - LLSD materialData = LLSD::emptyMap(); - if (pIsDoSet) - { - materialData[MATERIALS_CAP_NORMAL_MAP_FIELD] = mNormalMap->getImageAssetID(); - materialData[MATERIALS_CAP_NORMAL_MAP_OFFSET_X_FIELD] = static_cast<LLSD::Integer>(getNormalMapOffsetX()); - materialData[MATERIALS_CAP_NORMAL_MAP_OFFSET_Y_FIELD] = static_cast<LLSD::Integer>(getNormalMapOffsetY()); - materialData[MATERIALS_CAP_NORMAL_MAP_REPEAT_X_FIELD] = static_cast<LLSD::Integer>(getNormalMapRepeatX()); - materialData[MATERIALS_CAP_NORMAL_MAP_REPEAT_Y_FIELD] = static_cast<LLSD::Integer>(getNormalMapRepeatY()); - materialData[MATERIALS_CAP_NORMAL_MAP_ROTATION_FIELD] = static_cast<LLSD::Integer>(getNormalMapRotation()); - - materialData[MATERIALS_CAP_SPECULAR_MAP_FIELD] = mSpecularMap->getImageAssetID(); - materialData[MATERIALS_CAP_SPECULAR_MAP_OFFSET_X_FIELD] = static_cast<LLSD::Integer>(getSpecularMapOffsetX()); - materialData[MATERIALS_CAP_SPECULAR_MAP_OFFSET_Y_FIELD] = static_cast<LLSD::Integer>(getSpecularMapOffsetY()); - materialData[MATERIALS_CAP_SPECULAR_MAP_REPEAT_X_FIELD] = static_cast<LLSD::Integer>(getSpecularMapRepeatX()); - materialData[MATERIALS_CAP_SPECULAR_MAP_REPEAT_Y_FIELD] = static_cast<LLSD::Integer>(getSpecularMapRepeatY()); - materialData[MATERIALS_CAP_SPECULAR_MAP_ROTATION_FIELD] = static_cast<LLSD::Integer>(getSpecularMapRotation()); - - LLColor4U specularColor = getSpecularColor(); - materialData[MATERIALS_CAP_SPECULAR_COLOR_FIELD] = specularColor.getValue(); - materialData[MATERIALS_CAP_SPECULAR_EXP_FIELD] = static_cast<LLSD::Integer>(getSpecularExponent()); - materialData[MATERIALS_CAP_ENV_INTENSITY_FIELD] = static_cast<LLSD::Integer>(getEnvironmentExponent()); - materialData[MATERIALS_CAP_ALPHA_MASK_CUTOFF_FIELD] = static_cast<LLSD::Integer>(getAlphMaskCutoff()); - materialData[MATERIALS_CAP_DIFFUSE_ALPHA_MODE_FIELD] = static_cast<LLSD::Integer>(getDiffuseAlphaMode()); - } + LLMaterial material = (pIsDoSet) ? getMaterial() : LLMaterial::null; LLObjectSelectionHandle selectionHandle = LLSelectMgr::getInstance()->getEditSelection(); for (LLObjectSelection::valid_iterator objectIter = selectionHandle->valid_begin(); @@ -804,41 +656,11 @@ void LLFloaterDebugMaterials::requestPutMaterials(bool pIsDoSet) { if (objectNode->isTESelected(curTEIndex)) { - LLSD faceData = LLSD::emptyMap(); - faceData[MATERIALS_CAP_FACE_FIELD] = static_cast<LLSD::Integer>(curTEIndex); - faceData[MATERIALS_CAP_OBJECT_ID_FIELD] = static_cast<LLSD::Integer>(viewerObject->getLocalID()); - if (pIsDoSet) - { - faceData[MATERIALS_CAP_MATERIAL_FIELD] = materialData; - } - facesData.append(faceData); + LLMaterialMgr::instance().put(viewerObject->getID(), curTEIndex, material); } } } } - - LLSD materialsData = LLSD::emptyMap(); - materialsData[MATERIALS_CAP_FULL_PER_FACE_FIELD] = facesData; - - std::string materialString = zip_llsd(materialsData); - S32 materialSize = materialString.size(); - - if (materialSize <= 0) - { - LL_ERRS("debugMaterials") << "cannot zip LLSD binary content" << LL_ENDL; - } - else - { - LLSD::Binary materialBinary; - materialBinary.resize(materialSize); - memcpy(materialBinary.data(), materialString.data(), materialSize); - - LLSD putData = LLSD::emptyMap(); - putData[MATERIALS_CAP_ZIP_FIELD] = materialBinary; - - LLHTTPClient::ResponderPtr materialsResponder = new MaterialsResponder("PUT", capURL, boost::bind(&LLFloaterDebugMaterials::onPutResponse, this, _1, _2)); - LLHTTPClient::put(capURL, putData, materialsResponder); - } } } } @@ -853,128 +675,6 @@ void LLFloaterDebugMaterials::requestPutMaterials(const LLUUID& regionId, bool p } } -void LLFloaterDebugMaterials::requestPostMaterials() -{ - llassert(!mMultiMaterialsResponder); - - std::vector<LLScrollListItem*> selectedItems = mViewableObjectsScrollList->getAllSelected(); - std::map<LLUUID, std::string> uniqueRegions; - - if (!selectedItems.empty()) - { - for (std::vector<LLScrollListItem*>::const_iterator selectedItemIter = selectedItems.begin(); - selectedItemIter != selectedItems.end(); ++selectedItemIter) - { - const LLScrollListItem* selectedItem = *selectedItemIter; - const LLSD& selectedItemValue = selectedItem->getValue(); - llassert(selectedItemValue.isMap()); - - llassert(selectedItemValue.has(VIEWABLE_OBJECTS_REGION_ID_FIELD)); - llassert(selectedItemValue.get(VIEWABLE_OBJECTS_REGION_ID_FIELD).isUUID()); - const LLUUID& regionId = selectedItemValue.get(VIEWABLE_OBJECTS_REGION_ID_FIELD).asUUID(); - if (uniqueRegions.find(regionId) == uniqueRegions.end()) - { - llassert(selectedItemValue.has(VIEWABLE_OBJECTS_OBJECT_ID_FIELD)); - llassert(selectedItemValue.get(VIEWABLE_OBJECTS_OBJECT_ID_FIELD).isUUID()); - const LLUUID& objectId = selectedItemValue.get(VIEWABLE_OBJECTS_OBJECT_ID_FIELD).asUUID(); - LLViewerObject* viewerObject = gObjectList.findObject(objectId); - if (viewerObject != NULL) - { - LLViewerRegion* region = viewerObject->getRegion(); - if (region != NULL) - { - if (!region->capabilitiesReceived()) - { - LL_WARNS("debugMaterials") << "region '" << region->getName() << "' (id:" - << region->getRegionID().asString() << ") has not received capabilities" - << LL_ENDL; - } - else - { - std::string capURL = region->getCapability(MATERIALS_CAPABILITY_NAME); - - if (capURL.empty()) - { - LL_WARNS("debugMaterials") << "Capability '" << MATERIALS_CAPABILITY_NAME - << "' is not defined on the current region '" << region->getName() << "'" << LL_ENDL; - } - else - { - uniqueRegions.insert(std::make_pair<LLUUID, std::string>(regionId, capURL)); - } - } - } - } - } - } - - unsigned int numRegions = static_cast<unsigned int>(uniqueRegions.size()); - - if (numRegions > 0U) - { - setState(kRequestStarted); - mMultiMaterialsResponder = MultiMaterialsResponderPtr(new MultiMaterialsResponder(boost::bind(&LLFloaterDebugMaterials::onPostResponse, this, _1, _2), numRegions)); - - for (std::map<LLUUID, std::string>::const_iterator regionIdIter = uniqueRegions.begin(); - regionIdIter != uniqueRegions.end(); ++regionIdIter) - { - const LLUUID& regionId = regionIdIter->first; - std::string capURL = regionIdIter->second; - - LLSD materialIdsData = LLSD::emptyArray(); - - for (std::vector<LLScrollListItem*>::const_iterator selectedItemIter = selectedItems.begin(); - selectedItemIter != selectedItems.end(); ++selectedItemIter) - { - const LLScrollListItem* selectedItem = *selectedItemIter; - const LLSD& selectedItemValue = selectedItem->getValue(); - - llassert(selectedItemValue.has(VIEWABLE_OBJECTS_REGION_ID_FIELD)); - llassert(selectedItemValue.get(VIEWABLE_OBJECTS_REGION_ID_FIELD).isUUID()); - const LLUUID& selectedItemRegionId = selectedItemValue.get(VIEWABLE_OBJECTS_REGION_ID_FIELD).asUUID(); - if (selectedItemRegionId == regionId) - { - llassert(selectedItemValue.has(VIEWABLE_OBJECTS_MATERIAL_ID_FIELD)); - llassert(selectedItemValue.get(VIEWABLE_OBJECTS_MATERIAL_ID_FIELD).isBinary()); - const LLSD& materidIdLLSD = selectedItemValue.get(VIEWABLE_OBJECTS_MATERIAL_ID_FIELD); - - materialIdsData.append(materidIdLLSD); - } - } - - if (materialIdsData.size() <= 0) - { - LL_ERRS("debugMaterials") << "no material IDs to POST to region id " << regionId.asString() - << LL_ENDL; - } - else - { - std::string materialsString = zip_llsd(materialIdsData); - S32 materialsSize = materialsString.size(); - - if (materialsSize <= 0) - { - LL_ERRS("debugMaterials") << "cannot zip LLSD binary content" << LL_ENDL; - } - else - { - LLSD::Binary materialsBinary; - materialsBinary.resize(materialsSize); - memcpy(materialsBinary.data(), materialsString.data(), materialsSize); - - LLSD postData = LLSD::emptyMap(); - postData[MATERIALS_CAP_ZIP_FIELD] = materialsBinary; - - LLHTTPClient::ResponderPtr materialsResponder = new MaterialsResponder("POST", - capURL, boost::bind(&MultiMaterialsResponder::onMaterialsResponse, mMultiMaterialsResponder.get(), _1, _2)); - LLHTTPClient::post(capURL, postData, materialsResponder); - } - } - } - } - } -} - void LLFloaterDebugMaterials::parseQueryViewableObjects() { llassert(mNextUnparsedQueryDataIndex >= 0); @@ -1029,9 +729,8 @@ void LLFloaterDebugMaterials::parseQueryViewableObjects() rowParams.columns.add(cellParams); cellParams.font = LLFontGL::getFontMonospace(); - std::string materialIDString = objectMaterialID.asString(); cellParams.column = "material_id"; - cellParams.value = materialIDString; + cellParams.value = objectMaterialID.asString(); rowParams.columns.add(cellParams); LLSD rowValue = LLSD::emptyMap(); @@ -1060,508 +759,288 @@ void LLFloaterDebugMaterials::parseQueryViewableObjects() } } -void LLFloaterDebugMaterials::parseGetResponse() +void LLFloaterDebugMaterials::onGetMaterials(const LLUUID& region_id, const LLMaterialMgr::material_map_t& materials) { - llassert(mUnparsedGetData.isDefined()); - llassert(mNextUnparsedGetDataIndex >= 0); - - if (mUnparsedGetData.isDefined()) + LLFloaterDebugMaterials* instancep = LLFloaterReg::findTypedInstance<LLFloaterDebugMaterials>("floater_debug_materials"); + if (!instancep) { - LLScrollListCell::Params cellParams; - LLScrollListItem::Params normalMapRowParams; - LLScrollListItem::Params specularMapRowParams; - LLScrollListItem::Params otherDataRowParams; - - llassert(mUnparsedGetData.isArray()); - LLSD::array_const_iterator materialIter = mUnparsedGetData.beginArray(); - S32 materialIndex; - - for (materialIndex = 0; - (materialIndex < mNextUnparsedGetDataIndex) && (materialIter != mUnparsedGetData.endArray()); - ++materialIndex, ++materialIter) - { - } - - for (S32 currentParseCount = 0; - (currentParseCount < 10) && (materialIter != mUnparsedGetData.endArray()); - ++currentParseCount, ++materialIndex, ++materialIter) - { - const LLSD &material = *materialIter; - llassert(material.isMap()); - llassert(material.has(MATERIALS_CAP_OBJECT_ID_FIELD)); - llassert(material.get(MATERIALS_CAP_OBJECT_ID_FIELD).isBinary()); - const LLSD &materialIdLLSD = material.get(MATERIALS_CAP_OBJECT_ID_FIELD); - LLMaterialID materialID(materialIdLLSD); - std::string materialIDString = materialID.asString(); - - llassert(material.has(MATERIALS_CAP_MATERIAL_FIELD)); - const LLSD &materialData = material.get(MATERIALS_CAP_MATERIAL_FIELD); - llassert(materialData.isMap()); - - llassert(materialData.has(MATERIALS_CAP_NORMAL_MAP_FIELD)); - llassert(materialData.get(MATERIALS_CAP_NORMAL_MAP_FIELD).isUUID()); - const LLUUID &normalMapID = materialData.get(MATERIALS_CAP_NORMAL_MAP_FIELD).asUUID(); - - llassert(materialData.has(MATERIALS_CAP_NORMAL_MAP_OFFSET_X_FIELD)); - llassert(materialData.get(MATERIALS_CAP_NORMAL_MAP_OFFSET_X_FIELD).isInteger()); - S32 normalMapOffsetX = materialData.get(MATERIALS_CAP_NORMAL_MAP_OFFSET_X_FIELD).asInteger(); - - llassert(materialData.has(MATERIALS_CAP_NORMAL_MAP_OFFSET_Y_FIELD)); - llassert(materialData.get(MATERIALS_CAP_NORMAL_MAP_OFFSET_Y_FIELD).isInteger()); - S32 normalMapOffsetY = materialData.get(MATERIALS_CAP_NORMAL_MAP_OFFSET_Y_FIELD).asInteger(); - - llassert(materialData.has(MATERIALS_CAP_NORMAL_MAP_REPEAT_X_FIELD)); - llassert(materialData.get(MATERIALS_CAP_NORMAL_MAP_REPEAT_X_FIELD).isInteger()); - S32 normalMapRepeatX = materialData.get(MATERIALS_CAP_NORMAL_MAP_REPEAT_X_FIELD).asInteger(); - - llassert(materialData.has(MATERIALS_CAP_NORMAL_MAP_REPEAT_Y_FIELD)); - llassert(materialData.get(MATERIALS_CAP_NORMAL_MAP_REPEAT_Y_FIELD).isInteger()); - S32 normalMapRepeatY = materialData.get(MATERIALS_CAP_NORMAL_MAP_REPEAT_Y_FIELD).asInteger(); - - llassert(materialData.has(MATERIALS_CAP_NORMAL_MAP_ROTATION_FIELD)); - llassert(materialData.get(MATERIALS_CAP_NORMAL_MAP_ROTATION_FIELD).isInteger()); - S32 normalMapRotation = materialData.get(MATERIALS_CAP_NORMAL_MAP_ROTATION_FIELD).asInteger(); - - llassert(materialData.has(MATERIALS_CAP_SPECULAR_MAP_FIELD)); - llassert(materialData.get(MATERIALS_CAP_SPECULAR_MAP_FIELD).isUUID()); - const LLUUID &specularMapID = materialData.get(MATERIALS_CAP_SPECULAR_MAP_FIELD).asUUID(); - - llassert(materialData.has(MATERIALS_CAP_SPECULAR_MAP_OFFSET_X_FIELD)); - llassert(materialData.get(MATERIALS_CAP_SPECULAR_MAP_OFFSET_X_FIELD).isInteger()); - S32 specularMapOffsetX = materialData.get(MATERIALS_CAP_SPECULAR_MAP_OFFSET_X_FIELD).asInteger(); - - llassert(materialData.has(MATERIALS_CAP_SPECULAR_MAP_OFFSET_Y_FIELD)); - llassert(materialData.get(MATERIALS_CAP_SPECULAR_MAP_OFFSET_Y_FIELD).isInteger()); - S32 specularMapOffsetY = materialData.get(MATERIALS_CAP_SPECULAR_MAP_OFFSET_Y_FIELD).asInteger(); - - llassert(materialData.has(MATERIALS_CAP_SPECULAR_MAP_REPEAT_X_FIELD)); - llassert(materialData.get(MATERIALS_CAP_SPECULAR_MAP_REPEAT_X_FIELD).isInteger()); - S32 specularMapRepeatX = materialData.get(MATERIALS_CAP_SPECULAR_MAP_REPEAT_X_FIELD).asInteger(); - - llassert(materialData.has(MATERIALS_CAP_SPECULAR_MAP_REPEAT_Y_FIELD)); - llassert(materialData.get(MATERIALS_CAP_SPECULAR_MAP_REPEAT_Y_FIELD).isInteger()); - S32 specularMapRepeatY = materialData.get(MATERIALS_CAP_SPECULAR_MAP_REPEAT_Y_FIELD).asInteger(); - - llassert(materialData.has(MATERIALS_CAP_SPECULAR_MAP_ROTATION_FIELD)); - llassert(materialData.get(MATERIALS_CAP_SPECULAR_MAP_ROTATION_FIELD).isInteger()); - S32 specularMapRotation = materialData.get(MATERIALS_CAP_SPECULAR_MAP_ROTATION_FIELD).asInteger(); - - llassert(materialData.has(MATERIALS_CAP_SPECULAR_COLOR_FIELD)); - llassert(materialData.get(MATERIALS_CAP_SPECULAR_COLOR_FIELD).isArray()); - LLColor4U specularColor; - specularColor.setValue(materialData.get(MATERIALS_CAP_SPECULAR_COLOR_FIELD)); - - llassert(materialData.has(MATERIALS_CAP_SPECULAR_EXP_FIELD)); - llassert(materialData.get(MATERIALS_CAP_SPECULAR_EXP_FIELD).isInteger()); - S32 specularExp = materialData.get(MATERIALS_CAP_SPECULAR_EXP_FIELD).asInteger(); - - llassert(materialData.has(MATERIALS_CAP_ENV_INTENSITY_FIELD)); - llassert(materialData.get(MATERIALS_CAP_ENV_INTENSITY_FIELD).isInteger()); - S32 envIntensity = materialData.get(MATERIALS_CAP_ENV_INTENSITY_FIELD).asInteger(); - - llassert(materialData.has(MATERIALS_CAP_ALPHA_MASK_CUTOFF_FIELD)); - llassert(materialData.get(MATERIALS_CAP_ALPHA_MASK_CUTOFF_FIELD).isInteger()); - S32 alphaMaskCutoff = materialData.get(MATERIALS_CAP_ALPHA_MASK_CUTOFF_FIELD).asInteger(); - - llassert(materialData.has(MATERIALS_CAP_DIFFUSE_ALPHA_MODE_FIELD)); - llassert(materialData.get(MATERIALS_CAP_DIFFUSE_ALPHA_MODE_FIELD).isInteger()); - S32 diffuseAlphaMode = materialData.get(MATERIALS_CAP_DIFFUSE_ALPHA_MODE_FIELD).asInteger(); - - cellParams.font = LLFontGL::getFontMonospace(); - - cellParams.column = "id"; - cellParams.value = materialIDString; - normalMapRowParams.columns.add(cellParams); - specularMapRowParams.columns.add(cellParams); - otherDataRowParams.columns.add(cellParams); - - cellParams.column = "normal_map_list_map"; - cellParams.value = normalMapID.asString(); - normalMapRowParams.columns.add(cellParams); - - cellParams.font = LLFontGL::getFontSansSerif(); - - cellParams.column = "normal_map_list_offset_x"; - cellParams.value = llformat("%d", normalMapOffsetX); - normalMapRowParams.columns.add(cellParams); - - cellParams.column = "normal_map_list_offset_y"; - cellParams.value = llformat("%d", normalMapOffsetY); - normalMapRowParams.columns.add(cellParams); - - cellParams.column = "normal_map_list_repeat_x"; - cellParams.value = llformat("%d", normalMapRepeatX); - normalMapRowParams.columns.add(cellParams); - - cellParams.column = "normal_map_list_repeat_y"; - cellParams.value = llformat("%d", normalMapRepeatY); - normalMapRowParams.columns.add(cellParams); - - cellParams.column = "normal_map_list_rotation"; - cellParams.value = llformat("%d", normalMapRotation); - normalMapRowParams.columns.add(cellParams); - - cellParams.font = LLFontGL::getFontMonospace(); - - cellParams.column = "specular_map_list_map"; - cellParams.value = specularMapID.asString(); - specularMapRowParams.columns.add(cellParams); - - cellParams.font = LLFontGL::getFontSansSerif(); - - cellParams.column = "specular_map_list_offset_x"; - cellParams.value = llformat("%d", specularMapOffsetX); - specularMapRowParams.columns.add(cellParams); - - cellParams.column = "specular_map_list_offset_y"; - cellParams.value = llformat("%d", specularMapOffsetY); - specularMapRowParams.columns.add(cellParams); - - cellParams.column = "specular_map_list_repeat_x"; - cellParams.value = llformat("%d", specularMapRepeatX); - specularMapRowParams.columns.add(cellParams); - - cellParams.column = "specular_map_list_repeat_y"; - cellParams.value = llformat("%d", specularMapRepeatY); - specularMapRowParams.columns.add(cellParams); - - cellParams.column = "specular_map_list_rotation"; - cellParams.value = llformat("%d", specularMapRotation); - specularMapRowParams.columns.add(cellParams); - - cellParams.column = "specular_color"; - cellParams.value = llformat("(%d, %d, %d, %d)", specularColor.mV[0], - specularColor.mV[1], specularColor.mV[2], specularColor.mV[3]); - otherDataRowParams.columns.add(cellParams); - - cellParams.column = "specular_exponent"; - cellParams.value = llformat("%d", specularExp); - otherDataRowParams.columns.add(cellParams); - - cellParams.column = "env_intensity"; - cellParams.value = llformat("%d", envIntensity); - otherDataRowParams.columns.add(cellParams); - - cellParams.column = "alpha_mask_cutoff"; - cellParams.value = llformat("%d", alphaMaskCutoff); - otherDataRowParams.columns.add(cellParams); - - cellParams.column = "diffuse_alpha_mode"; - cellParams.value = llformat("%d", diffuseAlphaMode); - otherDataRowParams.columns.add(cellParams); + return; + } - normalMapRowParams.value = materialIDString; - specularMapRowParams.value = materialIDString; - otherDataRowParams.value = materialIDString; + LLViewerRegion* regionp = gAgent.getRegion(); + if ( (!regionp) || (regionp->getRegionID() != region_id) ) + { + return; + } - mGetNormalMapScrollList->addRow(normalMapRowParams); - mGetSpecularMapScrollList->addRow(specularMapRowParams); - mGetOtherDataScrollList->addRow(otherDataRowParams); - } + LLScrollListCell::Params cellParams; + LLScrollListItem::Params normalMapRowParams; + LLScrollListItem::Params specularMapRowParams; + LLScrollListItem::Params otherDataRowParams; - if (materialIter != mUnparsedGetData.endArray()) - { - mNextUnparsedGetDataIndex = materialIndex; - updateGetParsingStatus(); - } - else - { - clearUnparsedGetData(); - } + instancep->clearGetResults(); + for (LLMaterialMgr::material_map_t::const_iterator itMaterial = materials.begin(); itMaterial != materials.end(); ++itMaterial) + { + const LLMaterialID& material_id = itMaterial->first; + const LLMaterialPtr material = itMaterial->second; + + F32 x, y; + + cellParams.font = LLFontGL::getFontMonospace(); + + cellParams.column = "id"; + cellParams.value = material_id.asString(); + normalMapRowParams.columns.add(cellParams); + specularMapRowParams.columns.add(cellParams); + otherDataRowParams.columns.add(cellParams); + + cellParams.column = "normal_map_list_map"; + cellParams.value = material->getNormalID().asString(); + normalMapRowParams.columns.add(cellParams); + + cellParams.font = LLFontGL::getFontSansSerif(); + + material->getNormalOffset(x, y); + cellParams.column = "normal_map_list_offset_x"; + cellParams.value = llformat("%f", x); + normalMapRowParams.columns.add(cellParams); + cellParams.column = "normal_map_list_offset_y"; + cellParams.value = llformat("%f", y); + normalMapRowParams.columns.add(cellParams); + + material->getNormalRepeat(x, y); + cellParams.column = "normal_map_list_repeat_x"; + cellParams.value = llformat("%f", x); + normalMapRowParams.columns.add(cellParams); + cellParams.column = "normal_map_list_repeat_y"; + cellParams.value = llformat("%f", y); + normalMapRowParams.columns.add(cellParams); + + cellParams.column = "normal_map_list_rotation"; + cellParams.value = llformat("%f", material->getNormalRotation()); + normalMapRowParams.columns.add(cellParams); + + cellParams.font = LLFontGL::getFontMonospace(); + + cellParams.column = "specular_map_list_map"; + cellParams.value = material->getSpecularID().asString(); + specularMapRowParams.columns.add(cellParams); + + cellParams.font = LLFontGL::getFontSansSerif(); + + material->getSpecularOffset(x, y); + cellParams.column = "specular_map_list_offset_x"; + cellParams.value = llformat("%f", x); + specularMapRowParams.columns.add(cellParams); + cellParams.column = "specular_map_list_offset_y"; + cellParams.value = llformat("%f", y); + specularMapRowParams.columns.add(cellParams); + + material->getSpecularRepeat(x, y); + cellParams.column = "specular_map_list_repeat_x"; + cellParams.value = llformat("%f", x); + specularMapRowParams.columns.add(cellParams); + + cellParams.column = "specular_map_list_repeat_y"; + cellParams.value = llformat("%f", y); + specularMapRowParams.columns.add(cellParams); + + cellParams.column = "specular_map_list_rotation"; + cellParams.value = llformat("%f", material->getSpecularRotation()); + specularMapRowParams.columns.add(cellParams); + + const LLColor4U& specularColor = material->getSpecularLightColor(); + cellParams.column = "specular_color"; + cellParams.value = llformat("(%d, %d, %d, %d)", specularColor.mV[0], + specularColor.mV[1], specularColor.mV[2], specularColor.mV[3]); + otherDataRowParams.columns.add(cellParams); + + cellParams.column = "specular_exponent"; + cellParams.value = llformat("%d", material->getSpecularLightExponent()); + otherDataRowParams.columns.add(cellParams); + + cellParams.column = "env_intensity"; + cellParams.value = llformat("%d", material->getEnvironmentIntensity()); + otherDataRowParams.columns.add(cellParams); + + cellParams.column = "alpha_mask_cutoff"; + cellParams.value = llformat("%d", material->getAlphaMaskCutoff()); + otherDataRowParams.columns.add(cellParams); + + cellParams.column = "diffuse_alpha_mode"; + cellParams.value = llformat("%d", material->getDiffuseAlphaMode()); + otherDataRowParams.columns.add(cellParams); + + normalMapRowParams.value = cellParams.value; + specularMapRowParams.value = cellParams.value; + otherDataRowParams.value = cellParams.value; + + instancep->mGetNormalMapScrollList->addRow(normalMapRowParams); + instancep->mGetSpecularMapScrollList->addRow(specularMapRowParams); + instancep->mGetOtherDataScrollList->addRow(otherDataRowParams); } } -void LLFloaterDebugMaterials::parsePutResponse(const LLSD& pContent) +void LLFloaterDebugMaterials::onPostMaterial(const LLMaterialID& material_id, const LLMaterialPtr materialp) { - clearPutResults(); - - LLScrollListCell::Params cellParams; - LLScrollListItem::Params rowParams; - - llassert(pContent.isMap()); - llassert(pContent.has(MATERIALS_CAP_ZIP_FIELD)); - llassert(pContent.get(MATERIALS_CAP_ZIP_FIELD).isBinary()); - - LLSD::Binary responseBinary = pContent.get(MATERIALS_CAP_ZIP_FIELD).asBinary(); - S32 responseSize = static_cast<S32>(responseBinary.size()); - std::string responseString(reinterpret_cast<const char*>(responseBinary.data()), responseSize); - - std::istringstream responseStream(responseString); - - LLSD responseContent; - if (!unzip_llsd(responseContent, responseStream, responseSize)) + LLFloaterDebugMaterials* instancep = LLFloaterReg::findTypedInstance<LLFloaterDebugMaterials>("floater_debug_materials"); + if ( (!instancep) || (!materialp.get()) ) { - LL_ERRS("debugMaterials") << "cannot unzip LLSD binary content" << LL_ENDL; + return; } - else - { - llassert(responseContent.isArray()); - for (LLSD::array_const_iterator faceIter = responseContent.beginArray(); faceIter != responseContent.endArray(); - ++faceIter) - { - const LLSD &face = *faceIter; - llassert(face.isMap()); - - llassert(face.has(MATERIALS_CAP_FACE_FIELD)); - llassert(face.get(MATERIALS_CAP_FACE_FIELD).isInteger()); - S32 faceId = face.get(MATERIALS_CAP_FACE_FIELD).asInteger(); - - llassert(face.has(MATERIALS_CAP_OBJECT_ID_FIELD)); - llassert(face.get(MATERIALS_CAP_OBJECT_ID_FIELD).isInteger()); - S32 objectId = face.get(MATERIALS_CAP_OBJECT_ID_FIELD).asInteger(); - - llassert(face.has(MATERIALS_CAP_MATERIAL_ID_FIELD)); - llassert(face.get(MATERIALS_CAP_MATERIAL_ID_FIELD).isBinary()); - LLMaterialID materialID(face.get(MATERIALS_CAP_MATERIAL_ID_FIELD)); - std::string materialIDString = materialID.asString(); - cellParams.font = LLFontGL::getFontMonospace(); - - cellParams.column = "material_id"; - cellParams.value = materialIDString; - rowParams.columns.add(cellParams); - - cellParams.font = LLFontGL::getFontSansSerif(); - - cellParams.column = "object_id"; - cellParams.value = llformat("%d", objectId); - rowParams.columns.add(cellParams); - - cellParams.column = "face_index"; - cellParams.value = llformat("%d", faceId); - rowParams.columns.add(cellParams); + LLScrollListCell::Params cellParams; + LLScrollListItem::Params normalMapRowParams; + LLScrollListItem::Params specularMapRowParams; + LLScrollListItem::Params otherDataRowParams; + + cellParams.font = LLFontGL::getFontMonospace(); + + cellParams.column = "id"; + cellParams.value = material_id.asString(); + normalMapRowParams.columns.add(cellParams); + specularMapRowParams.columns.add(cellParams); + otherDataRowParams.columns.add(cellParams); + + cellParams.column = "normal_map_list_map"; + cellParams.value = materialp->getNormalID().asString(); + normalMapRowParams.columns.add(cellParams); + + cellParams.font = LLFontGL::getFontSansSerif(); + + F32 x, y; + materialp->getNormalOffset(x, y); + cellParams.column = "normal_map_list_offset_x"; + cellParams.value = llformat("%f", x); + normalMapRowParams.columns.add(cellParams); + cellParams.column = "normal_map_list_offset_y"; + cellParams.value = llformat("%f", y); + normalMapRowParams.columns.add(cellParams); + + materialp->getNormalRepeat(x, y); + cellParams.column = "normal_map_list_repeat_x"; + cellParams.value = llformat("%f", x); + normalMapRowParams.columns.add(cellParams); + cellParams.column = "normal_map_list_repeat_y"; + cellParams.value = llformat("%f", y); + normalMapRowParams.columns.add(cellParams); + + cellParams.column = "normal_map_list_rotation"; + cellParams.value = llformat("%f", materialp->getNormalRotation()); + normalMapRowParams.columns.add(cellParams); + + cellParams.font = LLFontGL::getFontMonospace(); + + cellParams.column = "specular_map_list_map"; + cellParams.value = materialp->getSpecularID().asString(); + specularMapRowParams.columns.add(cellParams); + + cellParams.font = LLFontGL::getFontSansSerif(); + + materialp->getSpecularOffset(x, y); + cellParams.column = "specular_map_list_offset_x"; + cellParams.value = llformat("%f", x); + specularMapRowParams.columns.add(cellParams); + cellParams.column = "specular_map_list_offset_y"; + cellParams.value = llformat("%f", y); + specularMapRowParams.columns.add(cellParams); + + materialp->getSpecularRepeat(x, y); + cellParams.column = "specular_map_list_repeat_x"; + cellParams.value = llformat("%f", x); + specularMapRowParams.columns.add(cellParams); + cellParams.column = "specular_map_list_repeat_y"; + cellParams.value = llformat("%f", y); + specularMapRowParams.columns.add(cellParams); + + cellParams.column = "specular_map_list_rotation"; + cellParams.value = llformat("%d", materialp->getSpecularRotation()); + specularMapRowParams.columns.add(cellParams); + + const LLColor4U& specularColor =materialp->getSpecularLightColor(); + cellParams.column = "specular_color"; + cellParams.value = llformat("(%d, %d, %d, %d)", specularColor.mV[0], + specularColor.mV[1], specularColor.mV[2], specularColor.mV[3]); + otherDataRowParams.columns.add(cellParams); + + cellParams.column = "specular_exponent"; + cellParams.value = llformat("%d", materialp->getSpecularLightExponent()); + otherDataRowParams.columns.add(cellParams); + + cellParams.column = "env_intensity"; + cellParams.value = llformat("%d", materialp->getEnvironmentIntensity()); + otherDataRowParams.columns.add(cellParams); + + cellParams.column = "alpha_mask_cutoff"; + cellParams.value = llformat("%d", materialp->getAlphaMaskCutoff()); + otherDataRowParams.columns.add(cellParams); + + cellParams.column = "diffuse_alpha_mode"; + cellParams.value = llformat("%d", materialp->getDiffuseAlphaMode()); + otherDataRowParams.columns.add(cellParams); + + normalMapRowParams.value = cellParams.value; + specularMapRowParams.value = cellParams.value; + otherDataRowParams.value = cellParams.value; + + instancep->mPostNormalMapScrollList->addRow(normalMapRowParams); + instancep->mPostSpecularMapScrollList->addRow(specularMapRowParams); + instancep->mPostOtherDataScrollList->addRow(otherDataRowParams); +} - mPutScrollList->addRow(rowParams); - } - } +void LLFloaterDebugMaterials::setState(EState pState) +{ + mState = pState; + updateStatusMessage(); + updateControls(); } -void LLFloaterDebugMaterials::parsePostResponse(const LLSD& pMultiContent) +void LLFloaterDebugMaterials::refreshObjectEdit() { - clearPostResults(); + mPutScrollList->deleteAllItems(); + + LLScrollListCell::Params cellParams; + LLScrollListItem::Params rowParams; - llassert(pMultiContent.isArray()); - for (LLSD::array_const_iterator contentIter = pMultiContent.beginArray(); - contentIter != pMultiContent.endArray(); ++contentIter) + LLObjectSelectionHandle selectionHandle = LLSelectMgr::getInstance()->getEditSelection(); + for (LLObjectSelection::valid_iterator objectIter = selectionHandle->valid_begin(); + objectIter != selectionHandle->valid_end(); ++objectIter) { - const LLSD& content = *contentIter; + LLSelectNode* nodep = *objectIter; - llassert(content.isMap()); - llassert(content.has(MULTI_MATERIALS_STATUS_FIELD)); - llassert(content.get(MULTI_MATERIALS_STATUS_FIELD).isBoolean()); - if (content.get(MULTI_MATERIALS_STATUS_FIELD).asBoolean()) + LLViewerObject* objectp = nodep->getObject(); + if (objectp != NULL) { - llassert(content.has(MULTI_MATERIALS_DATA_FIELD)); - llassert(content.get(MULTI_MATERIALS_DATA_FIELD).isMap()); - const LLSD& postData = content.get(MULTI_MATERIALS_DATA_FIELD); - - llassert(postData.has(MATERIALS_CAP_ZIP_FIELD)); - llassert(postData.get(MATERIALS_CAP_ZIP_FIELD).isBinary()); - - LLSD::Binary postDataBinary = postData.get(MATERIALS_CAP_ZIP_FIELD).asBinary(); - S32 postDataSize = static_cast<S32>(postDataBinary.size()); - std::string postDataString(reinterpret_cast<const char*>(postDataBinary.data()), postDataSize); - - std::istringstream postDataStream(postDataString); - - LLSD unzippedPostData; - if (!unzip_llsd(unzippedPostData, postDataStream, postDataSize)) - { - LL_ERRS("debugMaterials") << "cannot unzip LLSD binary content" << LL_ENDL; - } - - LLScrollListCell::Params cellParams; - LLScrollListItem::Params normalMapRowParams; - LLScrollListItem::Params specularMapRowParams; - LLScrollListItem::Params otherDataRowParams; - - llassert(unzippedPostData.isArray()); - for (LLSD::array_const_iterator materialIter = unzippedPostData.beginArray(); - materialIter != unzippedPostData.endArray(); ++materialIter) + S32 numTEs = llmin(static_cast<S32>(objectp->getNumTEs()), objectp->getNumFaces()); + for (S32 curTEIndex = 0; curTEIndex < numTEs; ++curTEIndex) { - const LLSD &material = *materialIter; - llassert(material.isMap()); - llassert(material.has(MATERIALS_CAP_OBJECT_ID_FIELD)); - llassert(material.get(MATERIALS_CAP_OBJECT_ID_FIELD).isBinary()); - const LLSD &materialIdLLSD = material.get(MATERIALS_CAP_OBJECT_ID_FIELD); - LLMaterialID materialID(materialIdLLSD); - std::string materialIDString = materialID.asString(); - - llassert(material.has(MATERIALS_CAP_MATERIAL_FIELD)); - const LLSD &materialData = material.get(MATERIALS_CAP_MATERIAL_FIELD); - llassert(materialData.isMap()); - - llassert(materialData.has(MATERIALS_CAP_NORMAL_MAP_FIELD)); - llassert(materialData.get(MATERIALS_CAP_NORMAL_MAP_FIELD).isUUID()); - const LLUUID &normalMapID = materialData.get(MATERIALS_CAP_NORMAL_MAP_FIELD).asUUID(); - - llassert(materialData.has(MATERIALS_CAP_NORMAL_MAP_OFFSET_X_FIELD)); - llassert(materialData.get(MATERIALS_CAP_NORMAL_MAP_OFFSET_X_FIELD).isInteger()); - S32 normalMapOffsetX = materialData.get(MATERIALS_CAP_NORMAL_MAP_OFFSET_X_FIELD).asInteger(); - - llassert(materialData.has(MATERIALS_CAP_NORMAL_MAP_OFFSET_Y_FIELD)); - llassert(materialData.get(MATERIALS_CAP_NORMAL_MAP_OFFSET_Y_FIELD).isInteger()); - S32 normalMapOffsetY = materialData.get(MATERIALS_CAP_NORMAL_MAP_OFFSET_Y_FIELD).asInteger(); - - llassert(materialData.has(MATERIALS_CAP_NORMAL_MAP_REPEAT_X_FIELD)); - llassert(materialData.get(MATERIALS_CAP_NORMAL_MAP_REPEAT_X_FIELD).isInteger()); - S32 normalMapRepeatX = materialData.get(MATERIALS_CAP_NORMAL_MAP_REPEAT_X_FIELD).asInteger(); - - llassert(materialData.has(MATERIALS_CAP_NORMAL_MAP_REPEAT_Y_FIELD)); - llassert(materialData.get(MATERIALS_CAP_NORMAL_MAP_REPEAT_Y_FIELD).isInteger()); - S32 normalMapRepeatY = materialData.get(MATERIALS_CAP_NORMAL_MAP_REPEAT_Y_FIELD).asInteger(); - - llassert(materialData.has(MATERIALS_CAP_NORMAL_MAP_ROTATION_FIELD)); - llassert(materialData.get(MATERIALS_CAP_NORMAL_MAP_ROTATION_FIELD).isInteger()); - S32 normalMapRotation = materialData.get(MATERIALS_CAP_NORMAL_MAP_ROTATION_FIELD).asInteger(); - - llassert(materialData.has(MATERIALS_CAP_SPECULAR_MAP_FIELD)); - llassert(materialData.get(MATERIALS_CAP_SPECULAR_MAP_FIELD).isUUID()); - const LLUUID &specularMapID = materialData.get(MATERIALS_CAP_SPECULAR_MAP_FIELD).asUUID(); - - llassert(materialData.has(MATERIALS_CAP_SPECULAR_MAP_OFFSET_X_FIELD)); - llassert(materialData.get(MATERIALS_CAP_SPECULAR_MAP_OFFSET_X_FIELD).isInteger()); - S32 specularMapOffsetX = materialData.get(MATERIALS_CAP_SPECULAR_MAP_OFFSET_X_FIELD).asInteger(); - - llassert(materialData.has(MATERIALS_CAP_SPECULAR_MAP_OFFSET_Y_FIELD)); - llassert(materialData.get(MATERIALS_CAP_SPECULAR_MAP_OFFSET_Y_FIELD).isInteger()); - S32 specularMapOffsetY = materialData.get(MATERIALS_CAP_SPECULAR_MAP_OFFSET_Y_FIELD).asInteger(); - - llassert(materialData.has(MATERIALS_CAP_SPECULAR_MAP_REPEAT_X_FIELD)); - llassert(materialData.get(MATERIALS_CAP_SPECULAR_MAP_REPEAT_X_FIELD).isInteger()); - S32 specularMapRepeatX = materialData.get(MATERIALS_CAP_SPECULAR_MAP_REPEAT_X_FIELD).asInteger(); - - llassert(materialData.has(MATERIALS_CAP_SPECULAR_MAP_REPEAT_Y_FIELD)); - llassert(materialData.get(MATERIALS_CAP_SPECULAR_MAP_REPEAT_Y_FIELD).isInteger()); - S32 specularMapRepeatY = materialData.get(MATERIALS_CAP_SPECULAR_MAP_REPEAT_Y_FIELD).asInteger(); - - llassert(materialData.has(MATERIALS_CAP_SPECULAR_MAP_ROTATION_FIELD)); - llassert(materialData.get(MATERIALS_CAP_SPECULAR_MAP_ROTATION_FIELD).isInteger()); - S32 specularMapRotation = materialData.get(MATERIALS_CAP_SPECULAR_MAP_ROTATION_FIELD).asInteger(); - - llassert(materialData.has(MATERIALS_CAP_SPECULAR_COLOR_FIELD)); - llassert(materialData.get(MATERIALS_CAP_SPECULAR_COLOR_FIELD).isArray()); - LLColor4U specularColor; - specularColor.setValue(materialData.get(MATERIALS_CAP_SPECULAR_COLOR_FIELD)); - - llassert(materialData.has(MATERIALS_CAP_SPECULAR_EXP_FIELD)); - llassert(materialData.get(MATERIALS_CAP_SPECULAR_EXP_FIELD).isInteger()); - S32 specularExp = materialData.get(MATERIALS_CAP_SPECULAR_EXP_FIELD).asInteger(); - - llassert(materialData.has(MATERIALS_CAP_ENV_INTENSITY_FIELD)); - llassert(materialData.get(MATERIALS_CAP_ENV_INTENSITY_FIELD).isInteger()); - S32 envIntensity = materialData.get(MATERIALS_CAP_ENV_INTENSITY_FIELD).asInteger(); - - llassert(materialData.has(MATERIALS_CAP_ALPHA_MASK_CUTOFF_FIELD)); - llassert(materialData.get(MATERIALS_CAP_ALPHA_MASK_CUTOFF_FIELD).isInteger()); - S32 alphaMaskCutoff = materialData.get(MATERIALS_CAP_ALPHA_MASK_CUTOFF_FIELD).asInteger(); - - llassert(materialData.has(MATERIALS_CAP_DIFFUSE_ALPHA_MODE_FIELD)); - llassert(materialData.get(MATERIALS_CAP_DIFFUSE_ALPHA_MODE_FIELD).isInteger()); - S32 diffuseAlphaMode = materialData.get(MATERIALS_CAP_DIFFUSE_ALPHA_MODE_FIELD).asInteger(); - - cellParams.font = LLFontGL::getFontMonospace(); - - cellParams.column = "id"; - cellParams.value = materialIDString; - normalMapRowParams.columns.add(cellParams); - specularMapRowParams.columns.add(cellParams); - otherDataRowParams.columns.add(cellParams); - - cellParams.column = "normal_map_list_map"; - cellParams.value = normalMapID.asString(); - normalMapRowParams.columns.add(cellParams); - - cellParams.font = LLFontGL::getFontSansSerif(); - - cellParams.column = "normal_map_list_offset_x"; - cellParams.value = llformat("%d", normalMapOffsetX); - normalMapRowParams.columns.add(cellParams); - - cellParams.column = "normal_map_list_offset_y"; - cellParams.value = llformat("%d", normalMapOffsetY); - normalMapRowParams.columns.add(cellParams); - - cellParams.column = "normal_map_list_repeat_x"; - cellParams.value = llformat("%d", normalMapRepeatX); - normalMapRowParams.columns.add(cellParams); - - cellParams.column = "normal_map_list_repeat_y"; - cellParams.value = llformat("%d", normalMapRepeatY); - normalMapRowParams.columns.add(cellParams); - - cellParams.column = "normal_map_list_rotation"; - cellParams.value = llformat("%d", normalMapRotation); - normalMapRowParams.columns.add(cellParams); - - cellParams.font = LLFontGL::getFontMonospace(); - - cellParams.column = "specular_map_list_map"; - cellParams.value = specularMapID.asString(); - specularMapRowParams.columns.add(cellParams); - - cellParams.font = LLFontGL::getFontSansSerif(); - - cellParams.column = "specular_map_list_offset_x"; - cellParams.value = llformat("%d", specularMapOffsetX); - specularMapRowParams.columns.add(cellParams); - - cellParams.column = "specular_map_list_offset_y"; - cellParams.value = llformat("%d", specularMapOffsetY); - specularMapRowParams.columns.add(cellParams); - - cellParams.column = "specular_map_list_repeat_x"; - cellParams.value = llformat("%d", specularMapRepeatX); - specularMapRowParams.columns.add(cellParams); - - cellParams.column = "specular_map_list_repeat_y"; - cellParams.value = llformat("%d", specularMapRepeatY); - specularMapRowParams.columns.add(cellParams); - - cellParams.column = "specular_map_list_rotation"; - cellParams.value = llformat("%d", specularMapRotation); - specularMapRowParams.columns.add(cellParams); - - cellParams.column = "specular_color"; - cellParams.value = llformat("(%d, %d, %d, %d)", specularColor.mV[0], - specularColor.mV[1], specularColor.mV[2], specularColor.mV[3]); - otherDataRowParams.columns.add(cellParams); + if (nodep->isTESelected(curTEIndex)) + { + const LLTextureEntry* tep = objectp->getTE(curTEIndex); - cellParams.column = "specular_exponent"; - cellParams.value = llformat("%d", specularExp); - otherDataRowParams.columns.add(cellParams); + cellParams.font = LLFontGL::getFontMonospace(); - cellParams.column = "env_intensity"; - cellParams.value = llformat("%d", envIntensity); - otherDataRowParams.columns.add(cellParams); + cellParams.column = "material_id"; + cellParams.value = tep->getMaterialID().asString(); + rowParams.columns.add(cellParams); - cellParams.column = "alpha_mask_cutoff"; - cellParams.value = llformat("%d", alphaMaskCutoff); - otherDataRowParams.columns.add(cellParams); + cellParams.font = LLFontGL::getFontSansSerif(); - cellParams.column = "diffuse_alpha_mode"; - cellParams.value = llformat("%d", diffuseAlphaMode); - otherDataRowParams.columns.add(cellParams); + cellParams.column = "object_id"; + cellParams.value = objectp->getID().asString(); + rowParams.columns.add(cellParams); - normalMapRowParams.value = materialIDString; - specularMapRowParams.value = materialIDString; - otherDataRowParams.value = materialIDString; + cellParams.column = "face_index"; + cellParams.value = llformat("%d", curTEIndex); + rowParams.columns.add(cellParams); - mPostNormalMapScrollList->addRow(normalMapRowParams); - mPostSpecularMapScrollList->addRow(specularMapRowParams); - mPostOtherDataScrollList->addRow(otherDataRowParams); + mPutScrollList->addRow(rowParams); + } } } } } -void LLFloaterDebugMaterials::setState(EState pState) -{ - mState = pState; - updateStatusMessage(); - updateControls(); -} - void LLFloaterDebugMaterials::resetObjectEditInputs() { const LLSD zeroValue = static_cast<LLSD::Integer>(0); @@ -1594,12 +1073,6 @@ void LLFloaterDebugMaterials::clearGetResults() mGetNormalMapScrollList->deleteAllItems(); mGetSpecularMapScrollList->deleteAllItems(); mGetOtherDataScrollList->deleteAllItems(); - clearUnparsedGetData(); -} - -void LLFloaterDebugMaterials::clearPutResults() -{ - mPutScrollList->deleteAllItems(); } void LLFloaterDebugMaterials::clearPostResults() @@ -1615,63 +1088,6 @@ void LLFloaterDebugMaterials::clearViewableObjectsResults() clearUnparsedQueryData(); } -void LLFloaterDebugMaterials::setUnparsedGetData(const LLSD& pGetData) -{ - llassert(pGetData.isMap()); - llassert(pGetData.has(MATERIALS_CAP_ZIP_FIELD)); - llassert(pGetData.get(MATERIALS_CAP_ZIP_FIELD).isBinary()); - - LLSD::Binary getDataBinary = pGetData.get(MATERIALS_CAP_ZIP_FIELD).asBinary(); - S32 getDataSize = static_cast<S32>(getDataBinary.size()); - std::string getDataString(reinterpret_cast<const char*>(getDataBinary.data()), getDataSize); - - std::istringstream getDataStream(getDataString); - - llassert(!mUnparsedGetData.isDefined()); - if (!unzip_llsd(mUnparsedGetData, getDataStream, getDataSize)) - { - LL_ERRS("debugMaterials") << "cannot unzip LLSD binary content" << LL_ENDL; - } - mNextUnparsedGetDataIndex = 0; - - updateGetParsingStatus(); -} - -void LLFloaterDebugMaterials::clearUnparsedGetData() -{ - mUnparsedGetData.clear(); - mNextUnparsedGetDataIndex = -1; - - updateGetParsingStatus(); -} - -void LLFloaterDebugMaterials::updateGetParsingStatus() -{ - std::string parsingStatus; - - if (mUnparsedGetData.isDefined()) - { - LLLocale locale(LLStringUtil::getLocale()); - std::string numProcessedString; - LLResMgr::getInstance()->getIntegerString(numProcessedString, mNextUnparsedGetDataIndex); - - std::string numTotalString; - LLResMgr::getInstance()->getIntegerString(numTotalString, mUnparsedGetData.size()); - - LLStringUtil::format_map_t stringArgs; - stringArgs["[NUM_PROCESSED]"] = numProcessedString; - stringArgs["[NUM_TOTAL]"] = numTotalString; - - parsingStatus = getString("loading_status_in_progress", stringArgs); - } - else - { - parsingStatus = getString("loading_status_done"); - } - - mParsingStatusText->setText(static_cast<const LLStringExplicit>(parsingStatus)); -} - void LLFloaterDebugMaterials::setUnparsedQueryData() { mNextUnparsedQueryDataIndex = 0; @@ -1790,168 +1206,40 @@ void LLFloaterDebugMaterials::updateControls() } } -S32 LLFloaterDebugMaterials::getNormalMapOffsetX() const -{ - return getLineEditorValue(mNormalMapOffsetX); -} - -S32 LLFloaterDebugMaterials::getNormalMapOffsetY() const -{ - return getLineEditorValue(mNormalMapOffsetY); -} - -S32 LLFloaterDebugMaterials::getNormalMapRepeatX() const -{ - return getLineEditorValue(mNormalMapRepeatX); -} - -S32 LLFloaterDebugMaterials::getNormalMapRepeatY() const -{ - return getLineEditorValue(mNormalMapRepeatY); -} +template<typename T> T getLineEditorValue(const LLLineEditor *pLineEditor); -S32 LLFloaterDebugMaterials::getNormalMapRotation() const +template<> U8 getLineEditorValue(const LLLineEditor *pLineEditor) { - return getLineEditorValue(mNormalMapRotation); -} + U8 value = 0; -S32 LLFloaterDebugMaterials::getSpecularMapOffsetX() const -{ - return getLineEditorValue(mSpecularMapOffsetX); -} + LLStringUtil::convertToU8(pLineEditor->getText(), value); -S32 LLFloaterDebugMaterials::getSpecularMapOffsetY() const -{ - return getLineEditorValue(mSpecularMapOffsetY); + return value; } -S32 LLFloaterDebugMaterials::getSpecularMapRepeatX() const +LLMaterial LLFloaterDebugMaterials::getMaterial() const { - return getLineEditorValue(mSpecularMapRepeatX); -} + LLMaterial material; -S32 LLFloaterDebugMaterials::getSpecularMapRepeatY() const -{ - return getLineEditorValue(mSpecularMapRepeatY); -} + material.setNormalID(mNormalMap->getImageAssetID()); + material.setNormalOffset(mNormalMapOffsetX->get(), mNormalMapOffsetY->get()); + material.setNormalRepeat(mNormalMapRepeatX->get(), mNormalMapRepeatY->get()); + material.setNormalRotation(mNormalMapRotation->get()); -S32 LLFloaterDebugMaterials::getSpecularMapRotation() const -{ - return getLineEditorValue(mSpecularMapRotation); -} + material.setSpecularID(mSpecularMap->getImageAssetID()); + material.setSpecularOffset(mSpecularMapOffsetX->get(), mSpecularMapOffsetY->get()); + material.setSpecularRepeat(mSpecularMapRepeatX->get(), mSpecularMapRepeatY->get()); + material.setSpecularRotation(mSpecularMapRotation->get()); -LLColor4U LLFloaterDebugMaterials::getSpecularColor() const -{ const LLColor4& specularColor = mSpecularColor->get(); LLColor4U specularColor4U = specularColor; - specularColor4U.setAlpha(static_cast<U8>(llclamp(llround(mSpecularColorAlpha->get()), 0, 255))); + material.setSpecularLightColor(specularColor4U); - return specularColor4U; -} - -S32 LLFloaterDebugMaterials::getSpecularExponent() const -{ - return getLineEditorValue(mSpecularExponent); -} + material.setSpecularLightExponent(getLineEditorValue<U8>(mSpecularExponent)); + material.setEnvironmentIntensity(getLineEditorValue<U8>(mEnvironmentExponent)); + material.setDiffuseAlphaMode(getLineEditorValue<U8>(mDiffuseAlphaMode)); + material.setAlphaMaskCutoff(getLineEditorValue<U8>(mAlphaMaskCutoff)); -S32 LLFloaterDebugMaterials::getEnvironmentExponent() const -{ - return getLineEditorValue(mEnvironmentExponent); -} - -S32 LLFloaterDebugMaterials::getAlphMaskCutoff() const -{ - return getLineEditorValue(mAlphaMaskCutoff); -} - -S32 LLFloaterDebugMaterials::getDiffuseAlphaMode() const -{ - return getLineEditorValue(mDiffuseAlphaMode); -} - -S32 LLFloaterDebugMaterials::getLineEditorValue(const LLLineEditor *pLineEditor) const -{ - S32 value = 0; - - LLStringUtil::convertToS32(pLineEditor->getText(), value); - - return value; -} - -MaterialsResponder::MaterialsResponder(const std::string& pMethod, const std::string& pCapabilityURL, CallbackFunction pCallback) - : LLHTTPClient::Responder(), - mMethod(pMethod), - mCapabilityURL(pCapabilityURL), - mCallback(pCallback) -{ -} - -MaterialsResponder::~MaterialsResponder() -{ -} - -void MaterialsResponder::result(const LLSD& pContent) -{ - mCallback(true, pContent); -} - -void MaterialsResponder::error(U32 pStatus, const std::string& pReason) -{ - LL_WARNS("debugMaterials") << "--------------------------------------------------------------------------" << LL_ENDL; - LL_WARNS("debugMaterials") << mMethod << " Error[" << pStatus << "] cannot access cap '" << MATERIALS_CAPABILITY_NAME - << "' with url '" << mCapabilityURL << "' because " << pReason << LL_ENDL; - LL_WARNS("debugMaterials") << "--------------------------------------------------------------------------" << LL_ENDL; - - LLSD emptyResult; - mCallback(false, emptyResult); -} - -MultiMaterialsResponder::MultiMaterialsResponder(CallbackFunction pCallback, unsigned int pNumRequests) - : mCallback(pCallback), - mNumRequests(pNumRequests), - mRequestStatus(true), - mContent(LLSD::emptyArray()), - mMutex(NULL) -{ - mMutex = new LLMutex(NULL); - llassert(mMutex); -} - -MultiMaterialsResponder::~MultiMaterialsResponder() -{ - llassert(mMutex); - if (mMutex) - { - delete mMutex; - } -} - -void MultiMaterialsResponder::onMaterialsResponse(bool pRequestStatus, const LLSD& pContent) -{ - LLSD result = LLSD::emptyMap(); - - result[MULTI_MATERIALS_STATUS_FIELD] = static_cast<LLSD::Boolean>(pRequestStatus); - result[MULTI_MATERIALS_DATA_FIELD] = pContent; - - if (appendRequestResults(pRequestStatus, result)) - { - fireResponse(); - } -} - -bool MultiMaterialsResponder::appendRequestResults(bool pRequestStatus, const LLSD& pResults) -{ - llassert(mMutex); - LLMutexLock mutexLock(mMutex); - - mRequestStatus = mRequestStatus && pRequestStatus; - mContent.append(pResults); - llassert(mNumRequests > 0U); - return (--mNumRequests == 0U); -} - -void MultiMaterialsResponder::fireResponse() -{ - mCallback(mRequestStatus, mContent); + return material; } |