diff options
Diffstat (limited to 'indra/newview/llfloaterdebugmaterials.cpp')
| -rw-r--r-- | indra/newview/llfloaterdebugmaterials.cpp | 1278 |
1 files changed, 881 insertions, 397 deletions
diff --git a/indra/newview/llfloaterdebugmaterials.cpp b/indra/newview/llfloaterdebugmaterials.cpp index 9546220d4c..3420665883 100644 --- a/indra/newview/llfloaterdebugmaterials.cpp +++ b/indra/newview/llfloaterdebugmaterials.cpp @@ -31,7 +31,9 @@ #include <string> #include <vector> +#include <map> +#include <boost/shared_ptr.hpp> #include <boost/bind.hpp> #include <boost/function.hpp> #include <boost/signals2.hpp> @@ -45,10 +47,12 @@ #include "llhttpclient.h" #include "lllineeditor.h" #include "llmaterialid.h" +#include "llresmgr.h" #include "llscrolllistcell.h" #include "llscrolllistctrl.h" #include "llscrolllistitem.h" #include "llsd.h" +#include "llsdserialize.h" #include "llselectmgr.h" #include "llspinctrl.h" #include "llstring.h" @@ -56,6 +60,7 @@ #include "lltextbase.h" #include "lltexturectrl.h" #include "lltextvalidate.h" +#include "llthread.h" #include "lluicolortable.h" #include "lluictrl.h" #include "lluuid.h" @@ -68,6 +73,8 @@ #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" @@ -94,6 +101,13 @@ #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: @@ -113,6 +127,30 @@ private: 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"); @@ -122,6 +160,9 @@ BOOL LLFloaterDebugMaterials::postBuild() llassert(mGetButton != NULL); mGetButton->setCommitCallback(boost::bind(&LLFloaterDebugMaterials::onGetClicked, this)); + mParsingStatusText = findChild<LLTextBase>("loading_status"); + llassert(mParsingStatusText != NULL); + mGetNormalMapScrollList = findChild<LLScrollListCtrl>("get_normal_map_scroll_list"); llassert(mGetNormalMapScrollList != NULL); mGetNormalMapScrollList->setCommitCallback(boost::bind(&LLFloaterDebugMaterials::onGetScrollListSelectionChange, this, _1)); @@ -235,25 +276,28 @@ BOOL LLFloaterDebugMaterials::postBuild() llassert(mQueryViewableObjectsButton != NULL); mQueryViewableObjectsButton->setCommitCallback(boost::bind(&LLFloaterDebugMaterials::onQueryVisibleObjectsClicked, this)); + mQueryStatusText = findChild<LLTextBase>("query_status"); + llassert(mQueryStatusText != NULL); + mViewableObjectsScrollList = findChild<LLScrollListCtrl>("viewable_objects_scroll_list"); llassert(mViewableObjectsScrollList != NULL); + mViewableObjectsScrollList->setCommitCallback(boost::bind(&LLFloaterDebugMaterials::onViewableObjectsScrollListSelectionChange, this)); - mGoodPostButton = findChild<LLButton>("good_post_button"); - llassert(mGoodPostButton != NULL); - mGoodPostButton->setCommitCallback(boost::bind(&LLFloaterDebugMaterials::onGoodPostClicked, this)); - - mBadPostButton = findChild<LLButton>("bad_post_button"); - llassert(mBadPostButton != NULL); - mBadPostButton->setCommitCallback(boost::bind(&LLFloaterDebugMaterials::onBadPostClicked, this)); + mPostButton = findChild<LLButton>("post_button"); + llassert(mPostButton != NULL); + mPostButton->setCommitCallback(boost::bind(&LLFloaterDebugMaterials::onPostClicked, this)); mPostNormalMapScrollList = findChild<LLScrollListCtrl>("post_normal_map_scroll_list"); llassert(mPostNormalMapScrollList != NULL); + mPostNormalMapScrollList->setCommitCallback(boost::bind(&LLFloaterDebugMaterials::onPostScrollListSelectionChange, this, _1)); mPostSpecularMapScrollList = findChild<LLScrollListCtrl>("post_specular_map_scroll_list"); llassert(mPostSpecularMapScrollList != NULL); + mPostSpecularMapScrollList->setCommitCallback(boost::bind(&LLFloaterDebugMaterials::onPostScrollListSelectionChange, this, _1)); mPostOtherDataScrollList = findChild<LLScrollListCtrl>("post_other_data_scroll_list"); llassert(mPostOtherDataScrollList != NULL); + mPostOtherDataScrollList->setCommitCallback(boost::bind(&LLFloaterDebugMaterials::onPostScrollListSelectionChange, this, _1)); mDefaultSpecularColor = LLUIColorTable::instance().getColor("White"); @@ -318,10 +362,24 @@ void LLFloaterDebugMaterials::onClose(bool pIsAppQuitting) LLFloater::onClose(pIsAppQuitting); } +void LLFloaterDebugMaterials::draw() +{ + if (mUnparsedGetData.isDefined()) + { + parseGetResponse(); + } + if (mNextUnparsedQueryDataIndex >= 0) + { + parseQueryViewableObjects(); + } + LLFloater::draw(); +} + LLFloaterDebugMaterials::LLFloaterDebugMaterials(const LLSD& pParams) : LLFloater(pParams), mStatusText(NULL), mGetButton(NULL), + mParsingStatusText(NULL), mGetNormalMapScrollList(NULL), mGetSpecularMapScrollList(NULL), mGetOtherDataScrollList(NULL), @@ -347,9 +405,9 @@ LLFloaterDebugMaterials::LLFloaterDebugMaterials(const LLSD& pParams) mPutClearButton(NULL), mPutScrollList(NULL), mQueryViewableObjectsButton(NULL), + mQueryStatusText(NULL), mViewableObjectsScrollList(NULL), - mGoodPostButton(NULL), - mBadPostButton(NULL), + mPostButton(NULL), mPostNormalMapScrollList(NULL), mPostSpecularMapScrollList(NULL), mPostOtherDataScrollList(NULL), @@ -358,12 +416,20 @@ LLFloaterDebugMaterials::LLFloaterDebugMaterials(const LLSD& pParams) mErrorColor(), mRegionCrossConnection(), mTeleportFailedConnection(), - mSelectionUpdateConnection() + mSelectionUpdateConnection(), + mUnparsedGetData(), + mNextUnparsedGetDataIndex(-1), + mNextUnparsedQueryDataIndex(-1), + mMultiMaterialsResponder() { } LLFloaterDebugMaterials::~LLFloaterDebugMaterials() { + if (!mMultiMaterialsResponder) + { + mMultiMaterialsResponder.reset(); + } } void LLFloaterDebugMaterials::onGetClicked() @@ -383,7 +449,7 @@ void LLFloaterDebugMaterials::onValueEntered(LLUICtrl* pUICtrl) if (doResetValue) { - llwarns << "cannot parse string '" << valueString << "' to an S32 value" <<llendl; + LL_WARNS("debugMaterials") << "cannot parse string '" << valueString << "' to an S32 value" <<LL_ENDL; LLSD value = static_cast<LLSD::Integer>(intValue); pLineEditor->setValue(value); } @@ -406,17 +472,13 @@ void LLFloaterDebugMaterials::onResetPutValuesClicked() void LLFloaterDebugMaterials::onQueryVisibleObjectsClicked() { - queryViewableObjects(); -} - -void LLFloaterDebugMaterials::onGoodPostClicked() -{ - requestPostMaterials(true); + clearViewableObjectsResults(); + setUnparsedQueryData(); } -void LLFloaterDebugMaterials::onBadPostClicked() +void LLFloaterDebugMaterials::onPostClicked() { - requestPostMaterials(false); + requestPostMaterials(); } void LLFloaterDebugMaterials::onRegionCross() @@ -460,23 +522,74 @@ void LLFloaterDebugMaterials::onGetScrollListSelectionChange(LLUICtrl* pUICtrl) llassert(selectedItem != NULL); const LLSD& selectedIdValue = selectedItem->getValue(); - llinfos << "attempting to select by value '" << selectedIdValue << "'" << llendl; - if (scrollListCtrl != mGetNormalMapScrollList) { mGetNormalMapScrollList->selectByValue(selectedIdValue); + mGetNormalMapScrollList->scrollToShowSelected(); } if (scrollListCtrl != mGetSpecularMapScrollList) { mGetSpecularMapScrollList->selectByValue(selectedIdValue); + mGetSpecularMapScrollList->scrollToShowSelected(); } if (scrollListCtrl != mGetOtherDataScrollList) { mGetOtherDataScrollList->selectByValue(selectedIdValue); + mGetOtherDataScrollList->scrollToShowSelected(); + } + } +} + +void LLFloaterDebugMaterials::onPostScrollListSelectionChange(LLUICtrl* pUICtrl) +{ + LLScrollListCtrl* scrollListCtrl = dynamic_cast<LLScrollListCtrl*>(pUICtrl); + llassert(scrollListCtrl != NULL); + + if (scrollListCtrl != mPostNormalMapScrollList) + { + mPostNormalMapScrollList->deselectAllItems(TRUE); + } + if (scrollListCtrl != mPostSpecularMapScrollList) + { + mPostSpecularMapScrollList->deselectAllItems(TRUE); + } + if (scrollListCtrl != mPostOtherDataScrollList) + { + mPostOtherDataScrollList->deselectAllItems(TRUE); + } + + std::vector<LLScrollListItem*> selectedItems = scrollListCtrl->getAllSelected(); + if (!selectedItems.empty()) + { + llassert(selectedItems.size() == 1); + LLScrollListItem* selectedItem = selectedItems.front(); + + llassert(selectedItem != NULL); + const LLSD& selectedIdValue = selectedItem->getValue(); + + if (scrollListCtrl != mPostNormalMapScrollList) + { + mPostNormalMapScrollList->selectByValue(selectedIdValue); + mPostNormalMapScrollList->scrollToShowSelected(); + } + if (scrollListCtrl != mPostSpecularMapScrollList) + { + mPostSpecularMapScrollList->selectByValue(selectedIdValue); + mPostSpecularMapScrollList->scrollToShowSelected(); + } + if (scrollListCtrl != mPostOtherDataScrollList) + { + mPostOtherDataScrollList->selectByValue(selectedIdValue); + mPostOtherDataScrollList->scrollToShowSelected(); } } } +void LLFloaterDebugMaterials::onViewableObjectsScrollListSelectionChange() +{ + updateControls(); +} + void LLFloaterDebugMaterials::onDeferredCheckRegionMaterialStatus(LLUUID regionId) { checkRegionMaterialStatus(regionId); @@ -492,17 +605,13 @@ void LLFloaterDebugMaterials::onDeferredRequestPutMaterials(LLUUID regionId, boo requestPutMaterials(regionId, pIsDoSet); } -void LLFloaterDebugMaterials::onDeferredRequestPostMaterials(LLUUID regionId, bool pUseGoodData) -{ - requestPostMaterials(regionId, pUseGoodData); -} - void LLFloaterDebugMaterials::onGetResponse(bool pRequestStatus, const LLSD& pContent) { + clearGetResults(); if (pRequestStatus) { setState(kRequestCompleted); - parseGetResponse(pContent); + setUnparsedGetData(pContent); } else { @@ -534,6 +643,7 @@ void LLFloaterDebugMaterials::onPostResponse(bool pRequestStatus, const LLSD& pC { setState(kError); } + mMultiMaterialsResponder.reset(); } void LLFloaterDebugMaterials::checkRegionMaterialStatus() @@ -542,7 +652,7 @@ void LLFloaterDebugMaterials::checkRegionMaterialStatus() if (region == NULL) { - llwarns << "Region is NULL" << llendl; + LL_WARNS("debugMaterials") << "Region is NULL" << LL_ENDL; setState(kNoRegion); } else if (!region->capabilitiesReceived()) @@ -556,8 +666,8 @@ void LLFloaterDebugMaterials::checkRegionMaterialStatus() if (capURL.empty()) { - llwarns << "Capability '" << MATERIALS_CAPABILITY_NAME << "' is not defined on the current region '" - << region->getName() << "'" << llendl; + LL_WARNS("debugMaterials") << "Capability '" << MATERIALS_CAPABILITY_NAME + << "' is not defined on the current region '" << region->getName() << "'" << LL_ENDL; setState(kNotEnabled); } else @@ -583,7 +693,7 @@ void LLFloaterDebugMaterials::requestGetMaterials() if (region == NULL) { - llwarns << "Region is NULL" << llendl; + LL_WARNS("debugMaterials") << "Region is NULL" << LL_ENDL; setState(kNoRegion); } else if (!region->capabilitiesReceived()) @@ -597,16 +707,14 @@ void LLFloaterDebugMaterials::requestGetMaterials() if (capURL.empty()) { - llwarns << "Capability '" << MATERIALS_CAPABILITY_NAME << "' is not defined on the current region '" - << region->getName() << "'" << llendl; + LL_WARNS("debugMaterials") << "Capability '" << MATERIALS_CAPABILITY_NAME + << "' is not defined on the current region '" << region->getName() << "'" << LL_ENDL; setState(kNotEnabled); } else { setState(kRequestStarted); LLHTTPClient::ResponderPtr materialsResponder = new MaterialsResponder("GET", capURL, boost::bind(&LLFloaterDebugMaterials::onGetResponse, this, _1, _2)); - llinfos << "STINSON DEBUG: sending request GET to capability '" << MATERIALS_CAPABILITY_NAME - << "' with url '" << capURL << "'" << llendl; LLHTTPClient::get(capURL, materialsResponder); } } @@ -628,7 +736,7 @@ void LLFloaterDebugMaterials::requestPutMaterials(bool pIsDoSet) if (region == NULL) { - llwarns << "Region is NULL" << llendl; + LL_WARNS("debugMaterials") << "Region is NULL" << LL_ENDL; setState(kNoRegion); } else if (!region->capabilitiesReceived()) @@ -642,8 +750,8 @@ void LLFloaterDebugMaterials::requestPutMaterials(bool pIsDoSet) if (capURL.empty()) { - llwarns << "Capability '" << MATERIALS_CAPABILITY_NAME << "' is not defined on the current region '" - << region->getName() << "'" << llendl; + LL_WARNS("debugMaterials") << "Capability '" << MATERIALS_CAPABILITY_NAME + << "' is not defined on the current region '" << region->getName() << "'" << LL_ENDL; setState(kNotEnabled); } else @@ -689,7 +797,7 @@ void LLFloaterDebugMaterials::requestPutMaterials(bool pIsDoSet) const LLViewerRegion* viewerRegion = viewerObject->getRegion(); if (region != viewerRegion) { - llerrs << "cannot currently edit an object on a different region through the debug materials floater" << llendl; + LL_ERRS("debugMaterials") << "cannot currently edit an object on a different region through the debug materials floater" << llendl; } S32 numTEs = llmin(static_cast<S32>(viewerObject->getNumTEs()), viewerObject->getNumFaces()); for (S32 curTEIndex = 0; curTEIndex < numTEs; ++curTEIndex) @@ -709,13 +817,28 @@ void LLFloaterDebugMaterials::requestPutMaterials(bool pIsDoSet) } } - LLSD putData = LLSD::emptyMap(); - putData[MATERIALS_CAP_FULL_PER_FACE_FIELD] = facesData; + 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)); - llinfos << "STINSON DEBUG: sending request PUT to capability '" << MATERIALS_CAPABILITY_NAME - << "' with url '" << capURL << "' and with data " << putData << llendl; - LLHTTPClient::put(capURL, putData, materialsResponder); + LLHTTPClient::ResponderPtr materialsResponder = new MaterialsResponder("PUT", capURL, boost::bind(&LLFloaterDebugMaterials::onPutResponse, this, _1, _2)); + LLHTTPClient::put(capURL, putData, materialsResponder); + } } } } @@ -730,487 +853,703 @@ void LLFloaterDebugMaterials::requestPutMaterials(const LLUUID& regionId, bool p } } -void LLFloaterDebugMaterials::requestPostMaterials(bool pUseGoodData) +void LLFloaterDebugMaterials::requestPostMaterials() { -#if 0 - LLViewerRegion *region = gAgent.getRegion(); + llassert(!mMultiMaterialsResponder); - if (region == NULL) - { - llwarns << "Region is NULL" << llendl; - setState(kNoRegion); - } - else if (!region->capabilitiesReceived()) - { - setState(kCapabilitiesLoading); - region->setCapabilitiesReceivedCallback(boost::bind(&LLFloaterDebugMaterials::onDeferredRequestPostMaterials, this, region->getRegionID(), pUseGoodData)); - } - else - { - std::string capURL = region->getCapability(MATERIALS_CAPABILITY_NAME); + std::vector<LLScrollListItem*> selectedItems = mViewableObjectsScrollList->getAllSelected(); + std::map<LLUUID, std::string> uniqueRegions; - if (capURL.empty()) + if (!selectedItems.empty()) + { + for (std::vector<LLScrollListItem*>::const_iterator selectedItemIter = selectedItems.begin(); + selectedItemIter != selectedItems.end(); ++selectedItemIter) { - llwarns << "Capability '" << MATERIALS_CAPABILITY_NAME << "' is not defined on the current region '" - << region->getName() << "'" << llendl; - setState(kNotEnabled); + 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)); + } + } + } + } + } } - else + + unsigned int numRegions = static_cast<unsigned int>(uniqueRegions.size()); + + if (numRegions > 0U) { setState(kRequestStarted); - LLSD postData = LLSD::emptyArray(); + mMultiMaterialsResponder = MultiMaterialsResponderPtr(new MultiMaterialsResponder(boost::bind(&LLFloaterDebugMaterials::onPostResponse, this, _1, _2), numRegions)); - if (pUseGoodData) + for (std::map<LLUUID, std::string>::const_iterator regionIdIter = uniqueRegions.begin(); + regionIdIter != uniqueRegions.end(); ++regionIdIter) { - std::vector<LLScrollListItem*> selectedItems = mGetScrollList->getAllSelected(); + 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; - postData.append(selectedItem->getValue()); + 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); + } } - } - else - { - S32 crapArray[4]; - for (int i = 0; i < 4; ++i) + + if (materialIdsData.size() <= 0) + { + LL_ERRS("debugMaterials") << "no material IDs to POST to region id " << regionId.asString() + << LL_ENDL; + } + else { - crapArray[i] = ll_rand(); - if (ll_frand() < 0.5) + std::string materialsString = zip_llsd(materialIdsData); + S32 materialsSize = materialsString.size(); + + if (materialsSize <= 0) { - crapArray[i] = -crapArray[i]; + LL_ERRS("debugMaterials") << "cannot zip LLSD binary content" << LL_ENDL; } - } + else + { + LLSD::Binary materialsBinary; + materialsBinary.resize(materialsSize); + memcpy(materialsBinary.data(), materialsString.data(), materialsSize); - std::vector<unsigned char> crapMem; - crapMem.resize(16); - memcpy(&crapMem[0], &crapArray, 16 * sizeof(unsigned char)); + LLSD postData = LLSD::emptyMap(); + postData[MATERIALS_CAP_ZIP_FIELD] = materialsBinary; - LLSD::Binary crapBinary = crapMem; - LLSD crapData = crapBinary; - postData.append(crapData); + LLHTTPClient::ResponderPtr materialsResponder = new MaterialsResponder("POST", + capURL, boost::bind(&MultiMaterialsResponder::onMaterialsResponse, mMultiMaterialsResponder.get(), _1, _2)); + LLHTTPClient::post(capURL, postData, materialsResponder); + } + } } - - LLHTTPClient::ResponderPtr materialsResponder = new MaterialsResponder("POST", capURL, boost::bind(&LLFloaterDebugMaterials::onPostResponse, this, _1, _2)); - llinfos << "STINSON DEBUG: sending request POST to capability '" << MATERIALS_CAPABILITY_NAME - << "' with url '" << capURL << "' and with data " << postData << llendl; - LLHTTPClient::post(capURL, postData, materialsResponder); } } -#endif -} - -void LLFloaterDebugMaterials::requestPostMaterials(const LLUUID& regionId, bool pUseGoodData) -{ - const LLViewerRegion *region = gAgent.getRegion(); - - if ((region != NULL) && (region->getRegionID() == regionId)) - { - requestPostMaterials(pUseGoodData); - } } -void LLFloaterDebugMaterials::queryViewableObjects() +void LLFloaterDebugMaterials::parseQueryViewableObjects() { - clearViewableObjectsResults(); - - LLScrollListCell::Params cellParams; - LLScrollListItem::Params rowParams; + llassert(mNextUnparsedQueryDataIndex >= 0); - S32 numViewerObjects = gObjectList.getNumObjects(); - for (S32 viewerObjectIndex = 0; viewerObjectIndex < numViewerObjects; ++viewerObjectIndex) + if (mNextUnparsedQueryDataIndex >= 0) { - const LLViewerObject *viewerObject = gObjectList.getObject(viewerObjectIndex); - if ((viewerObject != NULL) && !viewerObject->isDead()) + LLScrollListCell::Params cellParams; + LLScrollListItem::Params rowParams; + + S32 numViewerObjects = gObjectList.getNumObjects(); + S32 viewerObjectIndex = mNextUnparsedQueryDataIndex; + for (S32 currentParseCount = 0; + (currentParseCount < 10) && (viewerObjectIndex < numViewerObjects); + ++currentParseCount, ++viewerObjectIndex) { - U8 objectNumTEs = viewerObject->getNumTEs(); - - if (objectNumTEs > 0U) + const LLViewerObject *viewerObject = gObjectList.getObject(viewerObjectIndex); + if ((viewerObject != NULL) && !viewerObject->isDead()) { - const LLUUID& objectId = viewerObject->getID(); - U32 objectLocalId = viewerObject->getLocalID(); - const LLViewerRegion* objectRegion = viewerObject->getRegion(); + U8 objectNumTEs = viewerObject->getNumTEs(); - for (U8 curTEIndex = 0U; curTEIndex < objectNumTEs; ++curTEIndex) + if (objectNumTEs > 0U) { - const LLTextureEntry* objectTE = viewerObject->getTE(curTEIndex); - llassert(objectTE != NULL); - const LLMaterialID& objectMaterialID = objectTE->getMaterialID(); - if (!objectMaterialID.isNull()) + const LLUUID& objectId = viewerObject->getID(); + U32 objectLocalId = viewerObject->getLocalID(); + const LLViewerRegion* objectRegion = viewerObject->getRegion(); + + for (U8 curTEIndex = 0U; curTEIndex < objectNumTEs; ++curTEIndex) { - cellParams.font = LLFontGL::getFontMonospace(); + const LLTextureEntry* objectTE = viewerObject->getTE(curTEIndex); + llassert(objectTE != NULL); + const LLMaterialID& objectMaterialID = objectTE->getMaterialID(); + if (!objectMaterialID.isNull()) + { + cellParams.font = LLFontGL::getFontMonospace(); - cellParams.column = "object_id"; - cellParams.value = objectId.asString(); - rowParams.columns.add(cellParams); + cellParams.column = "object_id"; + cellParams.value = objectId.asString(); + rowParams.columns.add(cellParams); - cellParams.font = LLFontGL::getFontSansSerif(); + cellParams.font = LLFontGL::getFontSansSerif(); - cellParams.column = "region"; - cellParams.value = ((objectRegion == NULL) ? "<null>" : objectRegion->getName()); - rowParams.columns.add(cellParams); + cellParams.column = "region"; + cellParams.value = ((objectRegion == NULL) ? "<null>" : objectRegion->getName()); + rowParams.columns.add(cellParams); - cellParams.column = "local_id"; - cellParams.value = llformat("%d", objectLocalId); - rowParams.columns.add(cellParams); + cellParams.column = "local_id"; + cellParams.value = llformat("%d", objectLocalId); + rowParams.columns.add(cellParams); - cellParams.column = "face_index"; - cellParams.value = llformat("%u", static_cast<unsigned int>(curTEIndex)); - rowParams.columns.add(cellParams); - cellParams.font = LLFontGL::getFontMonospace(); + cellParams.column = "face_index"; + cellParams.value = llformat("%u", static_cast<unsigned int>(curTEIndex)); + rowParams.columns.add(cellParams); + cellParams.font = LLFontGL::getFontMonospace(); - std::string materialIDString = convertToPrintableMaterialID(objectMaterialID); - cellParams.column = "material_id"; - cellParams.value = materialIDString; - rowParams.columns.add(cellParams); + std::string materialIDString = convertToPrintableMaterialID(objectMaterialID); + cellParams.column = "material_id"; + cellParams.value = materialIDString; + rowParams.columns.add(cellParams); - rowParams.value = objectId; + LLSD rowValue = LLSD::emptyMap(); + rowValue[VIEWABLE_OBJECTS_REGION_ID_FIELD] = objectRegion->getRegionID(); + rowValue[VIEWABLE_OBJECTS_OBJECT_ID_FIELD] = objectId; + rowValue[VIEWABLE_OBJECTS_MATERIAL_ID_FIELD] = objectMaterialID.asLLSD(); - mViewableObjectsScrollList->addRow(rowParams); + rowParams.value = rowValue; + + mViewableObjectsScrollList->addRow(rowParams); + } } } } + } + if (viewerObjectIndex < numViewerObjects) + { + mNextUnparsedQueryDataIndex = viewerObjectIndex; + updateQueryParsingStatus(); + } + else + { + clearUnparsedQueryData(); } } } -void LLFloaterDebugMaterials::parseGetResponse(const LLSD& pContent) +void LLFloaterDebugMaterials::parseGetResponse() { - printResponse("GET", pContent); - clearGetResults(); + llassert(mUnparsedGetData.isDefined()); + llassert(mNextUnparsedGetDataIndex >= 0); - LLScrollListCell::Params cellParams; - LLScrollListItem::Params normalMapRowParams; - LLScrollListItem::Params specularMapRowParams; - LLScrollListItem::Params otherDataRowParams; - - llassert(pContent.isArray()); - for (LLSD::array_const_iterator materialIter = pContent.beginArray(); materialIter != pContent.endArray(); - ++materialIter) + if (mUnparsedGetData.isDefined()) { - 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 &materialID = material.get(MATERIALS_CAP_OBJECT_ID_FIELD); - std::string materialIDString = convertToPrintableMaterialID(materialID); + 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 &materialID = material.get(MATERIALS_CAP_OBJECT_ID_FIELD); + std::string materialIDString = convertToPrintableMaterialID(materialID); + + llassert(material.has(MATERIALS_CAP_MATERIAL_FIELD)); + const LLSD &materialData = material.get(MATERIALS_CAP_MATERIAL_FIELD); + llassert(materialData.isMap()); - 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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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(); - 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.font = LLFontGL::getFontMonospace(); + cellParams.column = "id"; + cellParams.value = materialIDString; + normalMapRowParams.columns.add(cellParams); + specularMapRowParams.columns.add(cellParams); + otherDataRowParams.columns.add(cellParams); - 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.column = "normal_map_list_map"; - cellParams.value = normalMapID.asString(); - normalMapRowParams.columns.add(cellParams); + cellParams.font = LLFontGL::getFontSansSerif(); - 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_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_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_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_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.column = "normal_map_list_rotation"; - cellParams.value = llformat("%d", normalMapRotation); - normalMapRowParams.columns.add(cellParams); + cellParams.font = LLFontGL::getFontMonospace(); - cellParams.font = LLFontGL::getFontMonospace(); + cellParams.column = "specular_map_list_map"; + cellParams.value = specularMapID.asString(); + specularMapRowParams.columns.add(cellParams); - cellParams.column = "specular_map_list_map"; - cellParams.value = specularMapID.asString(); - specularMapRowParams.columns.add(cellParams); + cellParams.font = LLFontGL::getFontSansSerif(); - 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_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_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_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_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_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_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 = "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 = "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 = "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); - cellParams.column = "diffuse_alpha_mode"; - cellParams.value = llformat("%d", diffuseAlphaMode); - otherDataRowParams.columns.add(cellParams); + normalMapRowParams.value = materialIDString; + specularMapRowParams.value = materialIDString; + otherDataRowParams.value = materialIDString; - normalMapRowParams.value = materialIDString; - specularMapRowParams.value = materialIDString; - otherDataRowParams.value = materialIDString; + mGetNormalMapScrollList->addRow(normalMapRowParams); + mGetSpecularMapScrollList->addRow(specularMapRowParams); + mGetOtherDataScrollList->addRow(otherDataRowParams); + } - mGetNormalMapScrollList->addRow(normalMapRowParams); - mGetSpecularMapScrollList->addRow(specularMapRowParams); - mGetOtherDataScrollList->addRow(otherDataRowParams); + if (materialIter != mUnparsedGetData.endArray()) + { + mNextUnparsedGetDataIndex = materialIndex; + updateGetParsingStatus(); + } + else + { + clearUnparsedGetData(); + } } } void LLFloaterDebugMaterials::parsePutResponse(const LLSD& pContent) { - printResponse("PUT", pContent); clearPutResults(); LLScrollListCell::Params cellParams; LLScrollListItem::Params rowParams; - llassert(pContent.isArray()); - for (LLSD::array_const_iterator faceIter = pContent.beginArray(); faceIter != pContent.endArray(); - ++faceIter) + 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)) { - const LLSD &face = *faceIter; - llassert(face.isMap()); + LL_ERRS("debugMaterials") << "cannot unzip LLSD binary content" << LL_ENDL; + } + 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_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_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()); - std::string materialIDString = convertToPrintableMaterialID(face.get(MATERIALS_CAP_MATERIAL_ID_FIELD)); + llassert(face.has(MATERIALS_CAP_MATERIAL_ID_FIELD)); + llassert(face.get(MATERIALS_CAP_MATERIAL_ID_FIELD).isBinary()); + std::string materialIDString = convertToPrintableMaterialID(face.get(MATERIALS_CAP_MATERIAL_ID_FIELD)); - cellParams.font = LLFontGL::getFontMonospace(); + cellParams.font = LLFontGL::getFontMonospace(); - cellParams.column = "material_id"; - cellParams.value = materialIDString; - rowParams.columns.add(cellParams); + cellParams.column = "material_id"; + cellParams.value = materialIDString; + rowParams.columns.add(cellParams); - cellParams.font = LLFontGL::getFontSansSerif(); + cellParams.font = LLFontGL::getFontSansSerif(); - cellParams.column = "object_id"; - cellParams.value = llformat("%d", objectId); - rowParams.columns.add(cellParams); + 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); + cellParams.column = "face_index"; + cellParams.value = llformat("%d", faceId); + rowParams.columns.add(cellParams); - mPutScrollList->addRow(rowParams); + mPutScrollList->addRow(rowParams); + } } } -void LLFloaterDebugMaterials::parsePostResponse(const LLSD& pContent) +void LLFloaterDebugMaterials::parsePostResponse(const LLSD& pMultiContent) { - printResponse("POST", pContent); -#if 0 clearPostResults(); - LLScrollListCell::Params cellParams; - LLScrollListItem::Params rowParams; - - llassert(pContent.isArray()); - for (LLSD::array_const_iterator materialIter = pContent.beginArray(); materialIter != pContent.endArray(); - ++materialIter) + llassert(pMultiContent.isArray()); + for (LLSD::array_const_iterator contentIter = pMultiContent.beginArray(); + contentIter != pMultiContent.endArray(); ++contentIter) { - 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 &materialID = material.get(MATERIALS_CAP_OBJECT_ID_FIELD); - std::string materialIDString = convertToPrintableMaterialID(materialID); + const LLSD& content = *contentIter; + + 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()) + { + 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(material.has(MATERIALS_CAP_MATERIAL_FIELD)); - const LLSD &materialData = material.get(MATERIALS_CAP_MATERIAL_FIELD); - llassert(materialData.isMap()); + llassert(postData.has(MATERIALS_CAP_ZIP_FIELD)); + llassert(postData.get(MATERIALS_CAP_ZIP_FIELD).isBinary()); - 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(); + 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); - 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(); + std::istringstream postDataStream(postDataString); - 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)); + LLSD unzippedPostData; + if (!unzip_llsd(unzippedPostData, postDataStream, postDataSize)) + { + LL_ERRS("debugMaterials") << "cannot unzip LLSD binary content" << LL_ENDL; + } - 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(); + LLScrollListCell::Params cellParams; + LLScrollListItem::Params normalMapRowParams; + LLScrollListItem::Params specularMapRowParams; + LLScrollListItem::Params otherDataRowParams; - 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(unzippedPostData.isArray()); + for (LLSD::array_const_iterator materialIter = unzippedPostData.beginArray(); + materialIter != unzippedPostData.endArray(); ++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 &materialID = material.get(MATERIALS_CAP_OBJECT_ID_FIELD); + std::string materialIDString = convertToPrintableMaterialID(materialID); - 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(material.has(MATERIALS_CAP_MATERIAL_FIELD)); + const LLSD &materialData = material.get(MATERIALS_CAP_MATERIAL_FIELD); + llassert(materialData.isMap()); - 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(); + 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(); - cellParams.font = LLFontGL::getFontMonospace(); + 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(); - cellParams.column = "id"; - cellParams.value = materialIDString; - rowParams.columns.add(cellParams); + 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(); - cellParams.column = "normal_map"; - cellParams.value = normalMapID.asString(); - rowParams.columns.add(cellParams); + 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(); - cellParams.column = "specular_map"; - cellParams.value = specularMapID.asString(); - rowParams.columns.add(cellParams); + 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(); - cellParams.font = LLFontGL::getFontSansSerif(); + 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(); - cellParams.column = "specular_color"; - cellParams.value = llformat("(%d, %d, %d, %d)", specularColor.mV[0], - specularColor.mV[1], specularColor.mV[2], specularColor.mV[3]); - rowParams.columns.add(cellParams); + 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(); - cellParams.column = "specular_exponent"; - cellParams.value = llformat("%d", specularExp); - rowParams.columns.add(cellParams); + 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(); - cellParams.column = "env_intensity"; - cellParams.value = llformat("%d", envIntensity); - rowParams.columns.add(cellParams); + 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(); - cellParams.column = "alpha_mask_cutoff"; - cellParams.value = llformat("%d", alphaMaskCutoff); - rowParams.columns.add(cellParams); + 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(); - cellParams.column = "diffuse_alpha_mode"; - cellParams.value = llformat("%d", diffuseAlphaMode); - rowParams.columns.add(cellParams); - rowParams.value = materialID; + 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(); - mPostScrollList->addRow(rowParams); - } -#endif -} + 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)); -void LLFloaterDebugMaterials::printResponse(const std::string& pRequestType, const LLSD& pContent) const -{ - llinfos << "--------------------------------------------------------------------------" << llendl; - llinfos << pRequestType << " Response: '" << pContent << "'" << llendl; - llinfos << "--------------------------------------------------------------------------" << llendl; + 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); + + normalMapRowParams.value = materialIDString; + specularMapRowParams.value = materialIDString; + otherDataRowParams.value = materialIDString; + + mPostNormalMapScrollList->addRow(normalMapRowParams); + mPostSpecularMapScrollList->addRow(specularMapRowParams); + mPostOtherDataScrollList->addRow(otherDataRowParams); + } + } + } } void LLFloaterDebugMaterials::setState(EState pState) @@ -1252,6 +1591,7 @@ void LLFloaterDebugMaterials::clearGetResults() mGetNormalMapScrollList->deleteAllItems(); mGetSpecularMapScrollList->deleteAllItems(); mGetOtherDataScrollList->deleteAllItems(); + clearUnparsedGetData(); } void LLFloaterDebugMaterials::clearPutResults() @@ -1269,6 +1609,105 @@ void LLFloaterDebugMaterials::clearPostResults() void LLFloaterDebugMaterials::clearViewableObjectsResults() { mViewableObjectsScrollList->deleteAllItems(); + 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; + + updateQueryParsingStatus(); +} + +void LLFloaterDebugMaterials::clearUnparsedQueryData() +{ + mNextUnparsedQueryDataIndex = -1; + + updateQueryParsingStatus(); +} + +void LLFloaterDebugMaterials::updateQueryParsingStatus() +{ + std::string queryStatus; + + if (mNextUnparsedQueryDataIndex >= 0) + { + LLLocale locale(LLStringUtil::getLocale()); + std::string numProcessedString; + LLResMgr::getInstance()->getIntegerString(numProcessedString, mNextUnparsedQueryDataIndex); + + std::string numTotalString; + LLResMgr::getInstance()->getIntegerString(numTotalString, gObjectList.getNumObjects()); + + LLStringUtil::format_map_t stringArgs; + stringArgs["[NUM_PROCESSED]"] = numProcessedString; + stringArgs["[NUM_TOTAL]"] = numTotalString; + + queryStatus = getString("querying_status_in_progress", stringArgs); + } + else + { + queryStatus = getString("querying_status_done"); + } + + mQueryStatusText->setText(static_cast<const LLStringExplicit>(queryStatus)); } void LLFloaterDebugMaterials::updateStatusMessage() @@ -1317,8 +1756,7 @@ void LLFloaterDebugMaterials::updateControls() { LLObjectSelectionHandle selectionHandle = LLSelectMgr::getInstance()->getEditSelection(); bool isPutEnabled = (selectionHandle->valid_begin() != selectionHandle->valid_end()); - - bool isGoodPostEnabled = false; + bool isPostEnabled = (mViewableObjectsScrollList->getNumSelected() > 0); switch (getState()) { @@ -1329,8 +1767,7 @@ void LLFloaterDebugMaterials::updateControls() mGetButton->setEnabled(FALSE); mPutSetButton->setEnabled(FALSE); mPutClearButton->setEnabled(FALSE); - mGoodPostButton->setEnabled(FALSE); - mBadPostButton->setEnabled(FALSE); + mPostButton->setEnabled(FALSE); break; case kReady : case kRequestCompleted : @@ -1338,15 +1775,13 @@ void LLFloaterDebugMaterials::updateControls() mGetButton->setEnabled(TRUE); mPutSetButton->setEnabled(isPutEnabled); mPutClearButton->setEnabled(isPutEnabled); - mGoodPostButton->setEnabled(isGoodPostEnabled); - mBadPostButton->setEnabled(FALSE && TRUE); + mPostButton->setEnabled(isPostEnabled); break; default : mGetButton->setEnabled(TRUE); mPutSetButton->setEnabled(isPutEnabled); mPutClearButton->setEnabled(isPutEnabled); - mGoodPostButton->setEnabled(isGoodPostEnabled); - mBadPostButton->setEnabled(FALSE && TRUE); + mPostButton->setEnabled(isPostEnabled); llassert(0); break; } @@ -1497,11 +1932,60 @@ void MaterialsResponder::result(const LLSD& pContent) void MaterialsResponder::error(U32 pStatus, const std::string& pReason) { - llwarns << "--------------------------------------------------------------------------" << llendl; - llwarns << mMethod << " Error[" << pStatus << "] cannot access cap '" << MATERIALS_CAPABILITY_NAME - << "' with url '" << mCapabilityURL << "' because " << pReason << llendl; - llwarns << "--------------------------------------------------------------------------" << llendl; + 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); +} |