void LLMaterialMgr::onPutResponse(bool success, const LLSD& content) { if (!success) { // *TODO: is there any kind of error handling we can do here? LL_WARNS("Materials")<< "failed"<<LL_ENDL; return; } llassert(content.isMap()); llassert(content.has(MATERIALS_CAP_ZIP_FIELD)); llassert(content[MATERIALS_CAP_ZIP_FIELD].isBinary()); LLSD::Binary content_binary = content[MATERIALS_CAP_ZIP_FIELD].asBinary(); std::string content_string(reinterpret_cast<const char*>(content_binary.data()), content_binary.size()); std::istringstream content_stream(content_string); LLSD response_data; if (!unzip_llsd(response_data, content_stream, content_binary.size())) { LL_WARNS("Materials") << "Cannot unzip LLSD binary content" << LL_ENDL; return; } else { llassert(response_data.isArray()); LL_DEBUGS("Materials") << "response has "<< response_data.size() << " materials" << LL_ENDL; for (LLSD::array_const_iterator faceIter = response_data.beginArray(); faceIter != response_data.endArray(); ++faceIter) { # ifndef LL_RELEASE_FOR_DOWNLOAD const LLSD& face_data = *faceIter; // conditional to avoid unused variable warning # endif llassert(face_data.isMap()); llassert(face_data.has(MATERIALS_CAP_OBJECT_ID_FIELD)); llassert(face_data[MATERIALS_CAP_OBJECT_ID_FIELD].isInteger()); // U32 local_id = face_data[MATERIALS_CAP_OBJECT_ID_FIELD].asInteger(); llassert(face_data.has(MATERIALS_CAP_FACE_FIELD)); llassert(face_data[MATERIALS_CAP_FACE_FIELD].isInteger()); // S32 te = face_data[MATERIALS_CAP_FACE_FIELD].asInteger(); llassert(face_data.has(MATERIALS_CAP_MATERIAL_ID_FIELD)); llassert(face_data[MATERIALS_CAP_MATERIAL_ID_FIELD].isBinary()); // LLMaterialID material_id(face_data[MATERIALS_CAP_MATERIAL_ID_FIELD].asBinary()); // *TODO: do we really still need to process this? } } }
bool LLModel::loadDecomposition(LLSD& header, std::istream& is) { S32 offset = header["physics_convex"]["offset"].asInteger(); S32 size = header["physics_convex"]["size"].asInteger(); if (offset >= 0 && size > 0 && !mSubmodelID) { is.seekg(offset, std::ios_base::cur); LLSD data; if (unzip_llsd(data, is, size)) { mPhysics.fromLLSD(data); updateHullCenters(); } } return true; }
bool LLModel::loadSkinInfo(LLSD& header, std::istream &is) { S32 offset = header["skin"]["offset"].asInteger(); S32 size = header["skin"]["size"].asInteger(); if (offset >= 0 && size > 0) { is.seekg(offset, std::ios_base::cur); LLSD skin_data; if (unzip_llsd(skin_data, is, size)) { mSkinInfo.fromLLSD(skin_data); return true; } } return false; }
void LLMaterialMgr::onGetResponse(bool success, const LLSD& content, const LLUUID& region_id) { if (!success) { // *TODO: is there any kind of error handling we can do here? LL_WARNS("Materials")<< "failed"<<LL_ENDL; return; } llassert(content.isMap()); llassert(content.has(MATERIALS_CAP_ZIP_FIELD)); llassert(content[MATERIALS_CAP_ZIP_FIELD].isBinary()); LLSD::Binary content_binary = content[MATERIALS_CAP_ZIP_FIELD].asBinary(); std::string content_string(reinterpret_cast<const char*>(content_binary.data()), content_binary.size()); std::istringstream content_stream(content_string); LLSD response_data; if (!unzip_llsd(response_data, content_stream, content_binary.size())) { LL_WARNS("Materials") << "Cannot unzip LLSD binary content" << LL_ENDL; return; } llassert(response_data.isArray()); LL_DEBUGS("Materials") << "response has "<< response_data.size() << " materials" << LL_ENDL; for (LLSD::array_const_iterator itMaterial = response_data.beginArray(); itMaterial != response_data.endArray(); ++itMaterial) { const LLSD& material_data = *itMaterial; llassert(material_data.isMap()); llassert(material_data.has(MATERIALS_CAP_OBJECT_ID_FIELD)); llassert(material_data[MATERIALS_CAP_OBJECT_ID_FIELD].isBinary()); LLMaterialID material_id(material_data[MATERIALS_CAP_OBJECT_ID_FIELD].asBinary()); llassert(material_data.has(MATERIALS_CAP_MATERIAL_FIELD)); llassert(material_data[MATERIALS_CAP_MATERIAL_FIELD].isMap()); setMaterial(region_id, material_id, material_data[MATERIALS_CAP_MATERIAL_FIELD]); } }
//return a string containing gzipped bytes of binary serialized LLSD // VERY inefficient -- creates several copies of LLSD block in memory std::string zip_llsd(LLSD& data) { std::stringstream llsd_strm; LLSDSerialize::toBinary(data, llsd_strm); const U32 CHUNK = 65536; z_stream strm; strm.zalloc = Z_NULL; strm.zfree = Z_NULL; strm.opaque = Z_NULL; S32 ret = deflateInit(&strm, Z_BEST_COMPRESSION); if (ret != Z_OK) { llwarns << "Failed to compress LLSD block." << llendl; return std::string(); } std::string source = llsd_strm.str(); U8 out[CHUNK]; strm.avail_in = source.size(); strm.next_in = (U8*) source.data(); U8* output = NULL; U32 cur_size = 0; U32 have = 0; do { strm.avail_out = CHUNK; strm.next_out = out; ret = deflate(&strm, Z_FINISH); if (ret == Z_OK || ret == Z_STREAM_END) { //copy result into output if (strm.avail_out >= CHUNK) { free(output); llwarns << "Failed to compress LLSD block." << llendl; return std::string(); } have = CHUNK-strm.avail_out; output = (U8*) realloc(output, cur_size+have); memcpy(output+cur_size, out, have); cur_size += have; } else { free(output); llwarns << "Failed to compress LLSD block." << llendl; return std::string(); } } while (ret == Z_OK); std::string::size_type size = cur_size; std::string result((char*) output, size); deflateEnd(&strm); free(output); #if 0 //verify results work with unzip_llsd std::istringstream test(result); LLSD test_sd; if (!unzip_llsd(test_sd, test, result.size())) { llerrs << "Invalid compression result!" << llendl; } #endif return result; }
void LLMaterialMgr::onGetAllResponse(bool success, const LLSD& content, const LLUUID& region_id) { if (!success) { // *TODO: is there any kind of error handling we can do here? LL_WARNS("Materials")<< "failed"<<LL_ENDL; return; } llassert(content.isMap()); llassert(content.has(MATERIALS_CAP_ZIP_FIELD)); llassert(content[MATERIALS_CAP_ZIP_FIELD].isBinary()); LLSD::Binary content_binary = content[MATERIALS_CAP_ZIP_FIELD].asBinary(); std::string content_string(reinterpret_cast<const char*>(content_binary.data()), content_binary.size()); std::istringstream content_stream(content_string); LLSD response_data; if (!unzip_llsd(response_data, content_stream, content_binary.size())) { LL_WARNS("Materials") << "Cannot unzip LLSD binary content" << LL_ENDL; return; } get_queue_t::iterator itQueue = mGetQueue.find(region_id); material_map_t materials; llassert(response_data.isArray()); LL_DEBUGS("Materials") << "response has "<< response_data.size() << " materials" << LL_ENDL; for (LLSD::array_const_iterator itMaterial = response_data.beginArray(); itMaterial != response_data.endArray(); ++itMaterial) { const LLSD& material_data = *itMaterial; llassert(material_data.isMap()); llassert(material_data.has(MATERIALS_CAP_OBJECT_ID_FIELD)); llassert(material_data[MATERIALS_CAP_OBJECT_ID_FIELD].isBinary()); LLMaterialID material_id(material_data[MATERIALS_CAP_OBJECT_ID_FIELD].asBinary()); if (mGetQueue.end() != itQueue) { itQueue->second.erase(material_id); } llassert(material_data.has(MATERIALS_CAP_MATERIAL_FIELD)); llassert(material_data[MATERIALS_CAP_MATERIAL_FIELD].isMap()); LLMaterialPtr material = setMaterial(region_id, material_id, material_data[MATERIALS_CAP_MATERIAL_FIELD]); materials[material_id] = material; } getall_callback_map_t::iterator itCallback = mGetAllCallbacks.find(region_id); if (itCallback != mGetAllCallbacks.end()) { (*itCallback->second)(region_id, materials); delete itCallback->second; mGetAllCallbacks.erase(itCallback); } if ( (mGetQueue.end() != itQueue) && (itQueue->second.empty()) ) { mGetQueue.erase(itQueue); } LL_DEBUGS("Materials")<< "recording that getAll has been done for region id " << region_id << LL_ENDL; mGetAllRequested.insert(region_id); // prevents subsequent getAll requests for this region mGetAllPending.erase(region_id); // Invalidates region_id }