//LLImportObject::LLImportObject(std::string id, std::string parentId)
// : LLViewerObject(LLUUID::null, 9, NULL, TRUE),
// mId(id),
// mParentId(parentId),
// mPrimName("Object")
//{
// importIsAttachment = false;
//}
LLImportObject::LLImportObject(std::string id, LLSD prim)
: LLViewerObject(LLUUID::null, 9, NULL, TRUE)
{
importIsAttachment = false;
mId = id;
mParentId = "";
mPrimName = "Object";
if(prim.has("parent"))
{
mParentId = prim["parent"].asString();
}
// Stuff for attach
if(prim.has("attach"))
{
importIsAttachment = true;
importAttachPoint = (U8)prim["attach"].asInteger();
importAttachPos = ll_vector3_from_sd(prim["position"]);
importAttachRot = ll_quaternion_from_sd(prim["rotation"]);
}
// Transforms
setPosition(ll_vector3_from_sd(prim["position"]), FALSE);
setScale(ll_vector3_from_sd(prim["scale"]), FALSE);
setRotation(ll_quaternion_from_sd(prim["rotation"]), FALSE);
// Flags
setFlags(FLAGS_CAST_SHADOWS, prim["shadows"].asInteger());
setFlags(FLAGS_PHANTOM, prim["phantom"].asInteger());
setFlags(FLAGS_USE_PHYSICS, prim["physical"].asInteger());
// Volume params
LLVolumeParams volume_params;
volume_params.fromLLSD(prim["volume"]);
setVolume(volume_params, 0, false);
// Extra params
if(prim.has("flexible"))
{
LLFlexibleObjectData* wat = new LLFlexibleObjectData();
wat->fromLLSD(prim["flex"]);
LLFlexibleObjectData flex = *wat;
setParameterEntry(LLNetworkData::PARAMS_FLEXIBLE, flex, true);
setParameterEntryInUse(LLNetworkData::PARAMS_FLEXIBLE, TRUE, true);
}
if(prim.has("light"))
{
LLLightParams* wat = new LLLightParams();
wat->fromLLSD(prim["light"]);
LLLightParams light = *wat;
setParameterEntry(LLNetworkData::PARAMS_LIGHT, light, true);
setParameterEntryInUse(LLNetworkData::PARAMS_LIGHT, TRUE, true);
}
if(prim.has("sculpt"))
{
LLSculptParams *wat = new LLSculptParams();
wat->fromLLSD(prim["sculpt"]);
LLSculptParams sculpt = *wat;
if(sculpt.getSculptType() == 5)//5 is apparently mesh... yeah.
{
llinfos << "Oh no mesh, f**k you." << llendl;
sculpt.setSculptType(0);//f**k you
}
setParameterEntry(LLNetworkData::PARAMS_SCULPT, sculpt, true);
setParameterEntryInUse(LLNetworkData::PARAMS_SCULPT, TRUE, true);
}
// Textures
LLSD textures = prim["textures"];
LLSD::array_iterator array_iter = textures.beginArray();
LLSD::array_iterator array_end = textures.endArray();
int i = 0;
for( ; array_iter != array_end; ++array_iter)
{
LLTextureEntry* wat = new LLTextureEntry();
wat->fromLLSD(*array_iter);
LLTextureEntry te = *wat;
delete wat; //clean up yo memory
mTextures.push_back(te.getID());
setTE(i, te);
i++;
}
mTextures.unique();
if(prim.has("name"))
{
mPrimName = prim["name"].asString();
}
if(prim.has("description"))
{
mPrimDescription = prim["description"].asString();
}
}
// This function takes a pointer to a viewerobject and applies the prim definition that prim_llsd has
void LLObjectBackup::xmlToPrim(LLSD prim_llsd, LLViewerObject* object)
{
LLUUID id = object->getID();
mExpectingUpdate = object->getID();
LLSelectMgr::getInstance()->selectObjectAndFamily(object);
if (prim_llsd.has("name"))
{
LLSelectMgr::getInstance()->selectionSetObjectName(prim_llsd["name"]);
}
if (prim_llsd.has("description"))
{
LLSelectMgr::getInstance()->selectionSetObjectDescription(prim_llsd["description"]);
}
if (prim_llsd.has("parent"))
{
//we are not the root node.
LLVector3 pos = prim_llsd["position"];
LLQuaternion rot = ll_quaternion_from_sd(prim_llsd["rotation"]);
object->setPositionRegion(pos * mRootRot + mRootPos + mGroupOffset);
object->setRotation(rot * mRootRot);
}
else
{
object->setPositionRegion(mRootPos + mGroupOffset);
LLQuaternion rot=ll_quaternion_from_sd(prim_llsd["rotation"]);
object->setRotation(rot);
}
object->setScale(prim_llsd["scale"]);
/*if (prim_llsd.has("shadows"))
if (prim_llsd["shadows"].asInteger() == 1)
object->setFlags(FLAGS_CAST_SHADOWS, true);*/
if (prim_llsd.has("phantom"))
if (prim_llsd["phantom"].asInteger() == 1)
object->setFlags(FLAGS_PHANTOM, true);
if (prim_llsd.has("physical"))
if (prim_llsd["physical"].asInteger() == 1)
object->setFlags(FLAGS_USE_PHYSICS, true);
// Volume params
LLVolumeParams volume_params = object->getVolume()->getParams();
volume_params.fromLLSD(prim_llsd["volume"]);
object->updateVolume(volume_params);
if (prim_llsd.has("sculpt"))
{
LLSculptParams* sculpt = new LLSculptParams();
sculpt->fromLLSD(prim_llsd["sculpt"]);
// TODO: check if map is valid and only set texture if map is valid and changes
if (mAssetMap[sculpt->getSculptTexture()].notNull())
{
LLUUID replacment = mAssetMap[sculpt->getSculptTexture()];
sculpt->setSculptTexture(replacment);
}
object->setParameterEntry(LLNetworkData::PARAMS_SCULPT,(LLNetworkData&)(*sculpt), true);
}
if (prim_llsd.has("light"))
{
LLLightParams* light = new LLLightParams();
light->fromLLSD(prim_llsd["light"]);
object->setParameterEntry(LLNetworkData::PARAMS_LIGHT,(LLNetworkData&)(*light), true);
}
if (prim_llsd.has("flexible"))
{
LLFlexibleObjectData* flex = new LLFlexibleObjectData();
flex->fromLLSD(prim_llsd["flexible"]);
object->setParameterEntry(LLNetworkData::PARAMS_FLEXIBLE,(LLNetworkData&)(*flex), true);
}
// Textures
LL_INFOS("ObjectBackup") << "Processing textures for prim" << LL_ENDL;
LLSD te_llsd = prim_llsd["textures"];
LLSD::array_iterator text_it;
U8 i = 0;
for (text_it = te_llsd.beginArray(); text_it != te_llsd.endArray(); text_it++)
{
LLSD the_te = (*text_it);
LLTextureEntry te;
te.fromLLSD(the_te);
if (mAssetMap[te.getID()].notNull())
{
LLUUID replacment = mAssetMap[te.getID()];
te.setID(replacment);
}
object->setTE(i++, te);
}
LL_INFOS("ObjectBackup") << "Textures done !" << LL_ENDL;
//bump the iterator now so the callbacks hook together nicely
//if (mPrimImportIter != mThisGroup.endMap())
// mPrimImportIter++;
object->sendTEUpdate();
object->sendShapeUpdate();
LLSelectMgr::getInstance()->sendMultipleUpdate(UPD_SCALE | UPD_POSITION);
LLSelectMgr::getInstance()->deselectAll();
}
LLSD JCExportTracker::subserialize(LLViewerObject* linkset)
{
//Chalice - Changed to support exporting linkset groups.
LLViewerObject* object = linkset;
//if(!linkset)return LLSD();
// Create an LLSD object that will hold the entire tree structure that can be serialized to a file
LLSD llsd;
//if (!node)
// return llsd;
//object = root_object = node->getObject();
if (!object)
return llsd;
if(!(!object->isAvatar() && object->permYouOwner() && object->permModify() && object->permCopy() && object->permTransfer() && !gAgent.getGodLevel()))
return llsd;
// Build a list of everything that we'll actually be exporting
LLDynamicArray<LLViewerObject*> export_objects;
// Add the root object to the export list
export_objects.put(object);
// Iterate over all of this objects children
LLViewerObject::child_list_t child_list = object->getChildren();
for (LLViewerObject::child_list_t::iterator i = child_list.begin(); i != child_list.end(); ++i)
{
LLViewerObject* child = *i;
if(!child->isAvatar())
{
// Put the child objects on the export list
export_objects.put(child);
}
}
S32 object_index = 0;
while ((object_index < export_objects.count()))
{
object = export_objects.get(object_index++);
LLUUID id = object->getID();
llinfos << "Exporting prim " << object->getID().asString() << llendl;
// Create an LLSD object that represents this prim. It will be injected in to the overall LLSD
// tree structure
LLSD prim_llsd;
if (object_index == 1)
{
LLVOAvatar* avatar = find_avatar_from_object(object);
if (avatar)
{
LLViewerJointAttachment* attachment = avatar->getTargetAttachmentPoint(object);
U8 attachment_id = 0;
if (attachment)
{
for (LLVOAvatar::attachment_map_t::iterator iter = avatar->mAttachmentPoints.begin();
iter != avatar->mAttachmentPoints.end(); ++iter)
{
if (iter->second == attachment)
{
attachment_id = iter->first;
break;
}
}
}
else
{
// interpret 0 as "default location"
attachment_id = 0;
}
prim_llsd["Attachment"] = attachment_id;
prim_llsd["attachpos"] = object->getPosition().getValue();
prim_llsd["attachrot"] = ll_sd_from_quaternion(object->getRotation());
}
prim_llsd["position"] = LLVector3(0, 0, 0).getValue();
prim_llsd["rotation"] = ll_sd_from_quaternion(object->getRotation());
}
else
{
prim_llsd["position"] = object->getPosition().getValue();
prim_llsd["rotation"] = ll_sd_from_quaternion(object->getRotation());
}
//prim_llsd["name"] = "";//node->mName;
//prim_llsd["description"] = "";//node->mDescription;
// Transforms
prim_llsd["scale"] = object->getScale().getValue();
// Flags
prim_llsd["shadows"] = object->flagCastShadows();
prim_llsd["phantom"] = object->flagPhantom();
prim_llsd["physical"] = (BOOL)(object->mFlags & FLAGS_USE_PHYSICS);
LLVolumeParams params = object->getVolume()->getParams();
prim_llsd["volume"] = params.asLLSD();
if (object->isFlexible())
{
LLFlexibleObjectData* flex = (LLFlexibleObjectData*)object->getParameterEntry(LLNetworkData::PARAMS_FLEXIBLE);
prim_llsd["flexible"] = flex->asLLSD();
}
if (object->getParameterEntryInUse(LLNetworkData::PARAMS_LIGHT))
{
LLLightParams* light = (LLLightParams*)object->getParameterEntry(LLNetworkData::PARAMS_LIGHT);
prim_llsd["light"] = light->asLLSD();
}
if (object->getParameterEntryInUse(LLNetworkData::PARAMS_SCULPT))
{
LLSculptParams* sculpt = (LLSculptParams*)object->getParameterEntry(LLNetworkData::PARAMS_SCULPT);
prim_llsd["sculpt"] = sculpt->asLLSD();
}
// Textures
LLSD te_llsd;
U8 te_count = object->getNumTEs();
for (U8 i = 0; i < te_count; i++)
{
te_llsd.append(object->getTE(i)->asLLSD());
}
if(export_textures)
{
std::string path = asset_dir + gDirUtilp->getDirDelimiter();
for (U8 i = 0; i < te_count; i++)
{
LLUUID asset_id = object->getTE(i)->getID();
JCAssetInfo* info = new JCAssetInfo;
info->path = path + asset_id.asString() + ".j2c";
info->name = "Prim Texture";
//gAssetStorage->getAssetData(asset_id, LLAssetType::AT_TEXTURE, JCAssetExportCallback, info,1);
if(requested_textures.count(asset_id) == 0)
{
requested_textures.insert(asset_id);
LLViewerImage* img = gImageList.getImage(asset_id, MIPMAP_TRUE, FALSE);
img->setBoostLevel(LLViewerImageBoostLevel::BOOST_MAX_LEVEL);
img->setLoadedCallback( JCExportTracker::onFileLoadedForSave,
0, TRUE, FALSE, info );
llinfos << "Requesting texture " << asset_id.asString() << llendl;
}
}
}
//JCExportTracker::mirror(asset, obj, asset_dir, asset->getUUID().asString());
prim_llsd["textures"] = te_llsd;
prim_llsd["id"] = object->getID().asString();
if(export_properties)
{
////cmdline_printchat(llformat("yes %d",export_properties));
propertyqueries += 1;
gMessageSystem->newMessageFast(_PREHASH_ObjectSelect);
gMessageSystem->nextBlockFast(_PREHASH_AgentData);
gMessageSystem->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
gMessageSystem->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
gMessageSystem->nextBlockFast(_PREHASH_ObjectData);
gMessageSystem->addU32Fast(_PREHASH_ObjectLocalID, object->getLocalID());
gMessageSystem->sendReliable(gAgent.getRegionHost());
if(export_inventory)
{
object->registerInventoryListener(sInstance,NULL);
object->dirtyInventory();
object->requestInventory();
invqueries += 1;
}
}//else //cmdline_printchat(llformat("no %d",export_properties));
totalprims += 1;
// Changed to use link numbers zero-indexed.
llsd[object_index - 1] = prim_llsd;
}
return llsd;
}
LLSD LLObjectBackup::primsToLLSD(LLViewerObject::child_list_t child_list, bool is_attachment)
{
LLViewerObject* object;
LLSD llsd;
char localid[16];
for (LLViewerObject::child_list_t::iterator i = child_list.begin(); i != child_list.end(); ++i)
{
object = (*i);
LLUUID id = object->getID();
LL_INFOS("ObjectBackup") << "Exporting prim " << object->getID().asString() << LL_ENDL;
// Create an LLSD object that represents this prim. It will be injected in to the overall LLSD
// tree structure
LLSD prim_llsd;
if (!object->isRoot())
{
// Parent id
snprintf(localid, sizeof(localid), "%u", object->getSubParent()->getLocalID());
prim_llsd["parent"] = localid;
}
// Name and description
LLSelectNode* node = LLSelectMgr::getInstance()->getSelection()->findNode(object);
if (node)
{
prim_llsd["name"] = node->mName;
prim_llsd["description"] = node->mDescription;
}
// Transforms
if (is_attachment)
{
prim_llsd["position"] = object->getPositionEdit().getValue();
prim_llsd["rotation"] = ll_sd_from_quaternion(object->getRotationEdit());
}
else
{
prim_llsd["position"] = object->getPosition().getValue();
prim_llsd["rotation"] = ll_sd_from_quaternion(object->getRotation());
}
prim_llsd["scale"] = object->getScale().getValue();
// Flags
prim_llsd["shadows"] = FALSE;
prim_llsd["phantom"] = object->flagPhantom();
prim_llsd["physical"] = object->flagUsePhysics();
// Volume params
LLVolumeParams params = object->getVolume()->getParams();
prim_llsd["volume"] = params.asLLSD();
// Extra paramsb6fab961-af18-77f8-cf08-f021377a7244
if (object->isFlexible())
{
// Flexible
LLFlexibleObjectData* flex = (LLFlexibleObjectData*)object->getParameterEntry(LLNetworkData::PARAMS_FLEXIBLE);
prim_llsd["flexible"] = flex->asLLSD();
}
if (object->getParameterEntryInUse(LLNetworkData::PARAMS_LIGHT))
{
// Light
LLLightParams* light = (LLLightParams*)object->getParameterEntry(LLNetworkData::PARAMS_LIGHT);
prim_llsd["light"] = light->asLLSD();
}
if (object->getParameterEntryInUse(LLNetworkData::PARAMS_SCULPT))
{
// Sculpt
LLSculptParams* sculpt = (LLSculptParams*)object->getParameterEntry(LLNetworkData::PARAMS_SCULPT);
prim_llsd["sculpt"] = sculpt->asLLSD();
LLUUID sculpt_texture = sculpt->getSculptTexture();
if (sculpt_texture == validateTextureID(sculpt_texture))
{
bool alreadyseen = false;
std::list<LLUUID>::iterator iter;
for (iter = mTexturesList.begin(); iter != mTexturesList.end(); iter++)
{
if ((*iter) == sculpt_texture)
alreadyseen = true;
}
if (alreadyseen == false)
{
LL_INFOS("ObjectBackup") << "Found a sculpt texture, adding to list " << sculpt_texture << LL_ENDL;
mTexturesList.push_back(sculpt_texture);
}
}
else
{
LL_WARNS("ObjectBackup") << "Incorrect permission to export a sculpt texture." << LL_ENDL;
LLObjectBackup::getInstance()->mExportState = EXPORT_FAILED;
}
}
// Textures
LLSD te_llsd;
LLSD this_te_llsd;
LLUUID t_id;
U8 te_count = object->getNumTEs();
for (U8 i = 0; i < te_count; i++)
{
bool alreadyseen = false;
t_id = validateTextureID(object->getTE(i)->getID());
this_te_llsd = object->getTE(i)->asLLSD();
this_te_llsd["imageid"] = t_id;
te_llsd.append(this_te_llsd);
// Do not export Linden textures even though they don't taint creation.
if (t_id != LL_TEXTURE_PLYWOOD &&
t_id != LL_TEXTURE_BLANK &&
t_id != LL_TEXTURE_TRANSPARENT &&
t_id != LL_TEXTURE_INVISIBLE &&
t_id != LL_TEXTURE_MEDIA)
{
std::list<LLUUID>::iterator iter;
for (iter = mTexturesList.begin(); iter != mTexturesList.end(); iter++)
{
if ((*iter) == t_id)
alreadyseen = true;
}
if (alreadyseen == false)
mTexturesList.push_back(t_id);
}
}
prim_llsd["textures"] = te_llsd;
// The keys in the primitive maps do not have to be localids, they can be any
// string. We simply use localids because they are a unique identifier
snprintf(localid, sizeof(localid), "%u", object->getLocalID());
llsd[(const char*)localid] = prim_llsd;
}
updateExportNumbers();
return llsd;
}
void ImportTracker::send_extras(LLSD& prim)
{
LLMessageSystem* msg = gMessageSystem;
msg->newMessageFast(_PREHASH_ObjectExtraParams);
msg->nextBlockFast(_PREHASH_AgentData);
msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID() );
msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
LLPrimitive obj;
if (prim.has("flexible"))
{
LLFlexibleObjectData flexi;
flexi.fromLLSD(prim["flexible"]);
U8 tmp[MAX_OBJECT_PARAMS_SIZE];
LLDataPackerBinaryBuffer dpb(tmp, MAX_OBJECT_PARAMS_SIZE);
if (flexi.pack(dpb))
{
U32 datasize = (U32)dpb.getCurrentSize();
msg->nextBlockFast(_PREHASH_ObjectData);
msg->addU32Fast(_PREHASH_ObjectLocalID, prim["LocalID"].asInteger());
msg->addU16Fast(_PREHASH_ParamType, 0x10);
msg->addBOOLFast(_PREHASH_ParamInUse, true);
msg->addU32Fast(_PREHASH_ParamSize, datasize);
msg->addBinaryDataFast(_PREHASH_ParamData, tmp, datasize);
}
}
if (prim.has("light"))
{
LLLightParams light;
light.fromLLSD(prim["light"]);
U8 tmp[MAX_OBJECT_PARAMS_SIZE];
LLDataPackerBinaryBuffer dpb(tmp, MAX_OBJECT_PARAMS_SIZE);
if (light.pack(dpb))
{
U32 datasize = (U32)dpb.getCurrentSize();
msg->nextBlockFast(_PREHASH_ObjectData);
msg->addU32Fast(_PREHASH_ObjectLocalID, prim["LocalID"].asInteger());
msg->addU16Fast(_PREHASH_ParamType, 0x20);
msg->addBOOLFast(_PREHASH_ParamInUse, true);
msg->addU32Fast(_PREHASH_ParamSize, datasize);
msg->addBinaryDataFast(_PREHASH_ParamData, tmp, datasize);
}
}
if (prim.has("sculpt"))
{
LLSculptParams sculpt;
sculpt.fromLLSD(prim["sculpt"]);
U8 tmp[MAX_OBJECT_PARAMS_SIZE];
LLDataPackerBinaryBuffer dpb(tmp, MAX_OBJECT_PARAMS_SIZE);
if (sculpt.pack(dpb))
{
U32 datasize = (U32)dpb.getCurrentSize();
msg->nextBlockFast(_PREHASH_ObjectData);
msg->addU32Fast(_PREHASH_ObjectLocalID, prim["LocalID"].asInteger());
msg->addU16Fast(_PREHASH_ParamType, 0x30);
msg->addBOOLFast(_PREHASH_ParamInUse, true);
msg->addU32Fast(_PREHASH_ParamSize, datasize);
msg->addBinaryDataFast(_PREHASH_ParamData, tmp, datasize);
}
}
msg->sendReliable(gAgent.getRegion()->getHost());
}
LLSD LLObjectBackup::primsToLLSD(LLViewerObject::child_list_t child_list,
bool is_attachment)
{
LLViewerObject* object;
LLSD llsd;
char localid[16];
LLUUID t_id;
for (LLViewerObject::child_list_t::iterator i = child_list.begin();
i != child_list.end(); ++i)
{
object = (*i);
LLUUID id = object->getID();
LL_INFOS() << "Exporting prim " << object->getID().asString() << LL_ENDL;
// Create an LLSD object that represents this prim. It will be injected
// in to the overall LLSD tree structure
LLSD prim_llsd;
if (!object->isRoot())
{
// Parent id
snprintf(localid, sizeof(localid), "%u",
object->getSubParent()->getLocalID());
prim_llsd["parent"] = localid;
}
// Name and description
LLSelectNode* node = LLSelectMgr::getInstance()->getSelection()->findNode(object);
if (node)
{
prim_llsd["name"] = node->mName;
prim_llsd["description"] = node->mDescription;
}
// Transforms
if (is_attachment)
{
prim_llsd["position"] = object->getPositionEdit().getValue();
prim_llsd["rotation"] = ll_sd_from_quaternion(object->getRotationEdit());
}
else
{
prim_llsd["position"] = object->getPosition().getValue();
prim_llsd["rotation"] = ll_sd_from_quaternion(object->getRotation());
}
prim_llsd["scale"] = object->getScale().getValue();
// Flags
prim_llsd["phantom"] = object->flagPhantom(); // legacy
prim_llsd["physical"] = object->flagUsePhysics(); // legacy
prim_llsd["flags"] = (S32)object->getFlags(); // new way
// Extra physics flags
if (mGotExtraPhysics)
{
LLSD& physics = prim_llsd["ExtraPhysics"];
physics["PhysicsShapeType"] = object->getPhysicsShapeType();
physics["Gravity"] = object->getPhysicsGravity();
physics["Friction"] = object->getPhysicsFriction();
physics["Density"] = object->getPhysicsDensity();
physics["Restitution"] = object->getPhysicsRestitution();
}
// Click action
if (S32 action = object->getClickAction()) // Non-zero
prim_llsd["clickaction"] = action;
// Prim material
prim_llsd["material"] = object->getMaterial();
// Volume params
LLVolumeParams params = object->getVolume()->getParams();
prim_llsd["volume"] = params.asLLSD();
// Extra paramsb6fab961-af18-77f8-cf08-f021377a7244
if (object->isFlexible())
{
// Flexible
LLFlexibleObjectData* flex;
flex = (LLFlexibleObjectData*)object->getParameterEntry(LLNetworkData::PARAMS_FLEXIBLE);
prim_llsd["flexible"] = flex->asLLSD();
}
if (object->getParameterEntryInUse(LLNetworkData::PARAMS_LIGHT))
{
// Light
LLLightParams* light;
light = (LLLightParams*)object->getParameterEntry(LLNetworkData::PARAMS_LIGHT);
prim_llsd["light"] = light->asLLSD();
}
if (object->getParameterEntryInUse(LLNetworkData::PARAMS_LIGHT_IMAGE))
{
// Light image
LLLightImageParams* light_param;
light_param = (LLLightImageParams*)object->getParameterEntry(LLNetworkData::PARAMS_LIGHT_IMAGE);
t_id = validateTextureID(light_param->getLightTexture());
if (mTexturesList.count(t_id) == 0)
{
LL_INFOS() << "Found a light texture, adding to list " << t_id
<< LL_ENDL;
mTexturesList.insert(t_id);
}
prim_llsd["light_texture"] = light_param->asLLSD();
}
if (object->getParameterEntryInUse(LLNetworkData::PARAMS_SCULPT))
{
// Sculpt
LLSculptParams* sculpt;
sculpt = (LLSculptParams*)object->getParameterEntry(LLNetworkData::PARAMS_SCULPT);
prim_llsd["sculpt"] = sculpt->asLLSD();
if ((sculpt->getSculptType() & LL_SCULPT_TYPE_MASK) != LL_SCULPT_TYPE_MESH)
{
LLUUID sculpt_texture = sculpt->getSculptTexture();
if (sculpt_texture == validateTextureID(sculpt_texture))
{
if (mTexturesList.count(sculpt_texture) == 0)
{
LL_INFOS() << "Found a sculpt texture, adding to list "
<< sculpt_texture << LL_ENDL;
mTexturesList.insert(sculpt_texture);
}
}
else
{
LL_WARNS() << "Incorrect permission to export a sculpt texture."
<< LL_ENDL;
mExportState = EXPORT_FAILED;
}
}
}
// Textures and materials
LLSD te_llsd;
LLSD this_te_llsd;
LLSD te_mat_llsd;
LLSD this_te_mat_llsd;
bool has_materials = false;
for (U8 i = 0, count = object->getNumTEs(); i < count; ++i)
{
LLTextureEntry* te = object->getTE(i);
if (!te) continue; // Paranoia
// Normal texture/diffuse map
t_id = validateTextureID(te->getID());
this_te_llsd = te->asLLSD();
this_te_llsd["imageid"] = t_id;
te_llsd.append(this_te_llsd);
// Do not export non-existent default textures
if (t_id != LL_TEXTURE_BLANK && t_id != LL_TEXTURE_INVISIBLE)
{
if (mTexturesList.count(t_id) == 0)
{
mTexturesList.insert(t_id);
}
}
// Materials
LLMaterial* mat = te->getMaterialParams().get();
if (mat)
{
has_materials = true;
this_te_mat_llsd = mat->asLLSD();
t_id = validateTextureID(mat->getNormalID());
this_te_mat_llsd["NormMap"] = t_id;
if (mTexturesList.count(t_id) == 0)
{
mTexturesList.insert(t_id);
}
t_id = validateTextureID(mat->getSpecularID());
this_te_mat_llsd["SpecMap"] = t_id;
if (mTexturesList.count(t_id) == 0)
{
mTexturesList.insert(t_id);
}
te_mat_llsd.append(this_te_mat_llsd);
}
}
prim_llsd["textures"] = te_llsd;
if (has_materials)
{
prim_llsd["materials"] = te_mat_llsd;
}
// The keys in the primitive maps do not have to be localids, they can
// be any string. We simply use localids because they are a unique
// identifier
snprintf(localid, sizeof(localid), "%u", object->getLocalID());
llsd[(const char*)localid] = prim_llsd;
}
updateExportNumbers();
return llsd;
}
// This function takes a pointer to a viewerobject and applies the prim
// definition that prim_llsd has
void LLObjectBackup::xmlToPrim(LLSD prim_llsd, LLViewerObject* object)
{
LLUUID id = object->getID();
mExpectingUpdate = object->getID();
LLSelectMgr::getInstance()->selectObjectAndFamily(object);
if (prim_llsd.has("name"))
{
LLSelectMgr::getInstance()->selectionSetObjectName(prim_llsd["name"]);
}
if (prim_llsd.has("description"))
{
LLSelectMgr::getInstance()->selectionSetObjectDescription(prim_llsd["description"]);
}
if (prim_llsd.has("material"))
{
LLSelectMgr::getInstance()->selectionSetMaterial(prim_llsd["material"].asInteger());
}
if (prim_llsd.has("clickaction"))
{
LLSelectMgr::getInstance()->selectionSetClickAction(prim_llsd["clickaction"].asInteger());
}
if (prim_llsd.has("parent"))
{
//we are not the root node.
LLVector3 pos = LLVector3(prim_llsd["position"]);
LLQuaternion rot = ll_quaternion_from_sd(prim_llsd["rotation"]);
object->setPositionRegion(pos * mRootRot + mRootPos + mGroupOffset);
object->setRotation(rot * mRootRot);
}
else
{
object->setPositionRegion(mRootPos + mGroupOffset);
LLQuaternion rot=ll_quaternion_from_sd(prim_llsd["rotation"]);
object->setRotation(rot);
}
object->setScale(LLVector3(prim_llsd["scale"]));
if (prim_llsd.has("flags"))
{
U32 flags = (U32)prim_llsd["flags"].asInteger();
object->setFlags(flags, true);
}
else // Kept for backward compatibility
{
/*if (prim_llsd.has("shadows"))
if (prim_llsd["shadows"].asInteger() == 1)
object->setFlags(FLAGS_CAST_SHADOWS, true);*/
if (prim_llsd.has("phantom") && prim_llsd["phantom"].asInteger() == 1)
{
object->setFlags(FLAGS_PHANTOM, true);
}
if (prim_llsd.has("physical") &&
prim_llsd["physical"].asInteger() == 1)
{
object->setFlags(FLAGS_USE_PHYSICS, true);
}
}
if (mGotExtraPhysics && prim_llsd.has("ExtraPhysics"))
{
const LLSD& physics = prim_llsd["ExtraPhysics"];
object->setPhysicsShapeType(physics["PhysicsShapeType"].asInteger());
F32 gravity = physics.has("Gravity") ? physics["Gravity"].asReal()
: physics["GravityMultiplier"].asReal();
object->setPhysicsGravity(gravity);
object->setPhysicsFriction(physics["Friction"].asReal());
object->setPhysicsDensity(physics["Density"].asReal());
object->setPhysicsRestitution(physics["Restitution"].asReal());
object->updateFlags(true);
}
// Volume params
LLVolumeParams volume_params = object->getVolume()->getParams();
volume_params.fromLLSD(prim_llsd["volume"]);
object->updateVolume(volume_params);
if (prim_llsd.has("sculpt"))
{
LLSculptParams sculpt;
sculpt.fromLLSD(prim_llsd["sculpt"]);
// TODO: check if map is valid and only set texture if map is valid and
// changes
LLUUID t_id = sculpt.getSculptTexture();
if (mAssetMap.count(t_id))
{
sculpt.setSculptTexture(mAssetMap[t_id], sculpt.getSculptType());
}
object->setParameterEntry(LLNetworkData::PARAMS_SCULPT, sculpt, true);
}
if (prim_llsd.has("light"))
{
LLLightParams light;
light.fromLLSD(prim_llsd["light"]);
object->setParameterEntry(LLNetworkData::PARAMS_LIGHT, light, true);
}
if (prim_llsd.has("light_texture"))
{
// Light image
LLLightImageParams lightimg;
lightimg.fromLLSD(prim_llsd["light_texture"]);
LLUUID t_id = lightimg.getLightTexture();
if (mAssetMap.count(t_id))
{
lightimg.setLightTexture(mAssetMap[t_id]);
}
object->setParameterEntry(LLNetworkData::PARAMS_LIGHT_IMAGE, lightimg,
true);
}
if (prim_llsd.has("flexible"))
{
LLFlexibleObjectData flex;
flex.fromLLSD(prim_llsd["flexible"]);
object->setParameterEntry(LLNetworkData::PARAMS_FLEXIBLE, flex, true);
}
// Textures
// Check both for "textures" and "texture" since the second (buggy) case
// has already been seen in some exported prims XML files...
LL_INFOS() << "Processing textures for prim" << id << LL_ENDL;
LLSD& te_llsd = prim_llsd.has("textures") ? prim_llsd["textures"]
: prim_llsd["texture"];
U8 i = 0;
for (LLSD::array_iterator it = te_llsd.beginArray();
it != te_llsd.endArray(); ++it)
{
LLSD the_te = *it;
LLTextureEntry te;
te.fromLLSD(the_te);
LLUUID t_id = te.getID();
if (mAssetMap.count(t_id))
{
te.setID(mAssetMap[t_id]);
}
object->setTE(i++, te);
}
LL_INFOS() << "Textures done !" << LL_ENDL;
// Materials
if (prim_llsd.has("materials"))
{
LL_INFOS() << "Processing materials for prim " << id << LL_ENDL;
te_llsd = prim_llsd["materials"];
i = 0;
for (LLSD::array_iterator it = te_llsd.beginArray();
it != te_llsd.endArray(); ++it)
{
LLSD the_mat = *it;
LLMaterialPtr mat = new LLMaterial(the_mat);
LLUUID t_id = mat->getNormalID();
if (id.notNull() && mAssetMap.count(t_id))
{
mat->setNormalID(mAssetMap[t_id]);
}
t_id = mat->getSpecularID();
if (id.notNull() && mAssetMap.count(t_id))
{
mat->setSpecularID(mAssetMap[t_id]);
}
LLMaterialMgr::getInstance()->put(id, i++, *mat);
}
LL_INFOS() << "Materials done !" << LL_ENDL;
}
object->sendRotationUpdate();
object->sendTEUpdate();
object->sendShapeUpdate();
LLSelectMgr::getInstance()->sendMultipleUpdate(UPD_SCALE | UPD_POSITION);
LLSelectMgr::getInstance()->deselectAll();
}
LLSD primbackup::prims_to_llsd(LLViewerObject::child_list_t child_list)
{
LLViewerObject* object;
LLSD llsd;
char localid[16];
for (LLViewerObject::child_list_t::iterator i = child_list.begin(); i != child_list.end(); ++i)
{
object=(*i);
LLUUID id = object->getID();
llinfos << "Exporting prim " << object->getID().asString() << llendl;
// Create an LLSD object that represents this prim. It will be injected in to the overall LLSD
// tree structure
LLSD prim_llsd;
if (!object->isRoot())
{
// Parent id
snprintf(localid, sizeof(localid), "%u", object->getSubParent()->getLocalID());
prim_llsd["parent"] = localid;
}
// Transforms
prim_llsd["position"] = object->getPosition().getValue();
prim_llsd["scale"] = object->getScale().getValue();
prim_llsd["rotation"] = ll_sd_from_quaternion(object->getRotation());
// Flags
prim_llsd["shadows"] = object->flagCastShadows();
prim_llsd["phantom"] = object->flagPhantom();
prim_llsd["physical"] = (BOOL)(object->mFlags & FLAGS_USE_PHYSICS);
// Volume params
LLVolumeParams params = object->getVolume()->getParams();
prim_llsd["volume"] = params.asLLSD();
// Extra paramsb6fab961-af18-77f8-cf08-f021377a7244
if (object->isFlexible())
{
// Flexible
LLFlexibleObjectData* flex = (LLFlexibleObjectData*)object->getParameterEntry(LLNetworkData::PARAMS_FLEXIBLE);
prim_llsd["flexible"] = flex->asLLSD();
}
if (object->getParameterEntryInUse(LLNetworkData::PARAMS_LIGHT))
{
// Light
LLLightParams* light = (LLLightParams*)object->getParameterEntry(LLNetworkData::PARAMS_LIGHT);
prim_llsd["light"] = light->asLLSD();
}
if (object->getParameterEntryInUse(LLNetworkData::PARAMS_SCULPT))
{
// Sculpt
LLSculptParams* sculpt = (LLSculptParams*)object->getParameterEntry(LLNetworkData::PARAMS_SCULPT);
prim_llsd["sculpt"] = sculpt->asLLSD();
LLUUID sculpt_texture=sculpt->getSculptTexture();
bool alreadyseen=false;
std::list<LLUUID>::iterator iter;
for(iter = textures.begin(); iter != textures.end() ; iter++)
{
if( (*iter)==sculpt_texture)
alreadyseen=true;
}
if(alreadyseen==false)
{
llinfos << "Found a sculpt texture, adding to list "<<sculpt_texture<<llendl;
textures.push_back(sculpt_texture);
}
}
// Textures
LLSD te_llsd;
U8 te_count = object->getNumTEs();
for (U8 i = 0; i < te_count; i++)
{
bool alreadyseen=false;
te_llsd.append(object->getTE(i)->asLLSD());
std::list<LLUUID>::iterator iter;
for(iter = textures.begin(); iter != textures.end() ; iter++)
{
if( (*iter)==object->getTE(i)->getID())
alreadyseen=true;
}
if(alreadyseen==false)
textures.push_back(object->getTE(i)->getID());
}
prim_llsd["textures"] = te_llsd;
// The keys in the primitive maps do not have to be localids, they can be any
// string. We simply use localids because they are a unique identifier
snprintf(localid, sizeof(localid), "%u", object->getLocalID());
llsd[(const char*)localid] = prim_llsd;
}
updateexportnumbers();
return llsd;
}