// static
void LLPreviewAnim::gotAssetForSave(LLVFS *vfs,
const LLUUID& asset_uuid,
LLAssetType::EType type,
void* user_data, S32 status, LLExtStat ext_status)
{
LLPreviewAnim* self = (LLPreviewAnim*) user_data;
//const LLInventoryItem *item = self->getItem();
LLVFile file(vfs, asset_uuid, type, LLVFile::READ);
S32 size = file.getSize();
char* buffer = new char[size];
if (buffer == NULL)
{
llerrs << "Memory Allocation Failed" << llendl;
return;
}
file.read((U8*)buffer, size);
// Write it back out...
AIFilePicker* filepicker = AIFilePicker::create();
filepicker->open(LLDir::getScrubbedFileName(self->getItem()->getName()) + ".animatn", FFSAVE_ANIMATN);
filepicker->run(boost::bind(&LLPreviewAnim::gotAssetForSave_continued, buffer, size, filepicker));
}
// static
void LLPreviewAnim::auditionAnim( void *userdata )
{
LLPreviewAnim* self = (LLPreviewAnim*) userdata;
const LLInventoryItem *item = self->getItem();
if(item)
{
LLUUID itemID=item->getAssetUUID();
LLButton* btn = self->getChild<LLButton>("Anim audition btn");
if (btn)
{
btn->toggleState();
}
if (self->childGetValue("Anim audition btn").asBoolean() )
{
self->mPauseRequest = NULL;
gAgent.getAvatarObject()->startMotion(item->getAssetUUID());
LLVOAvatar* avatar = gAgent.getAvatarObject();
LLMotion* motion = avatar->findMotion(itemID);
if (motion)
{
motion->setDeactivateCallback(&endAnimCallback, (void *)(new LLHandle<LLFloater>(self->getHandle())));
}
}
else
{
gAgent.getAvatarObject()->stopMotion(itemID);
gAgent.sendAnimationRequest(itemID, ANIM_REQUEST_STOP);
}
}
}
// static
void LLPreviewAnim::exportAnim( void *userdata )
{
LLPreviewAnim* self = (LLPreviewAnim*) userdata;
const LLInventoryItem *item = self->getItem();
if(item)
{
if(self->mAnimBuffer == NULL) return;
LLUUID assetID=item->getAssetUUID();
std::string filename = item->getName() + ".bvh";
LLFilePicker& picker = LLFilePicker::instance();
if( !picker.getSaveFile( LLFilePicker::FFSAVE_ALL, filename.c_str() ) )
{
// User canceled save.
return;
}
TSBVHExporter exporter;
LLDataPackerBinaryBuffer dp(self->mAnimBuffer, self->mAnimBufferSize);
if(exporter.deserialize(dp)) {
exporter.exportBVHFile(picker.getFirstFile().c_str());
}
}
}
/*
void LLPreviewAnim::copyAnim(void *userdata)
{
LLPreviewAnim* self = (LLPreviewAnim*) userdata;
const LLInventoryItem *item = self->getItem();
if(item)
{
// Some animations aren't hosted on the servers
// I guess they're in this static vfs thing
bool static_vfile = false;
LLVFile* anim_file = new LLVFile(gStaticVFS, item->getAssetUUID(), LLAssetType::AT_ANIMATION);
if (anim_file && anim_file->getSize())
{
//S32 anim_file_size = anim_file->getSize();
//U8* anim_data = new U8[anim_file_size];
//if(anim_file->read(anim_data, anim_file_size))
//{
// static_vfile = true;
//}
static_vfile = true; // for method 2
LLPreviewAnim::gotAssetForCopy(gStaticVFS, item->getAssetUUID(), LLAssetType::AT_ANIMATION, self, 0, 0);
}
delete anim_file;
anim_file = NULL;
if(!static_vfile)
{
// Get it from the servers
gAssetStorage->getAssetData(item->getAssetUUID(), LLAssetType::AT_ANIMATION, LLPreviewAnim::gotAssetForCopy, self, TRUE);
}
}
}
struct LLSaveInfo
{
LLSaveInfo(const LLUUID& item_id, const LLUUID& object_id, const std::string& desc,
const LLTransactionID tid)
: mItemUUID(item_id), mObjectUUID(object_id), mDesc(desc), mTransactionID(tid)
{
}
LLUUID mItemUUID;
LLUUID mObjectUUID;
std::string mDesc;
LLTransactionID mTransactionID;
};
// static
void LLPreviewAnim::gotAssetForCopy(LLVFS *vfs,
const LLUUID& asset_uuid,
LLAssetType::EType type,
void* user_data, S32 status, LLExtStat ext_status)
{
LLPreviewAnim* self = (LLPreviewAnim*) user_data;
//const LLInventoryItem *item = self->getItem();
LLVFile file(vfs, asset_uuid, type, LLVFile::READ);
S32 size = file.getSize();
char* buffer = new char[size];
if (buffer == NULL)
{
llerrs << "Memory Allocation Failed" << llendl;
return;
}
file.read((U8*)buffer, size);
// Write it back out...
LLTransactionID tid;
LLAssetID asset_id;
tid.generate();
asset_id = tid.makeAssetID(gAgent.getSecureSessionID());
LLVFile ofile(gVFS, asset_id, LLAssetType::AT_ANIMATION, LLVFile::APPEND);
ofile.setMaxSize(size);
ofile.write((U8*)buffer, size);
// Upload that asset to the database
LLSaveInfo* info = new LLSaveInfo(self->mItemUUID, self->mObjectUUID, "animation", tid);
gAssetStorage->storeAssetData(tid, LLAssetType::AT_ANIMATION, onSaveCopyComplete, info, FALSE);
delete[] buffer;
buffer = NULL;
}
// static
void LLPreviewAnim::onSaveCopyComplete(const LLUUID& asset_uuid, void* user_data, S32 status, LLExtStat ext_status)
{
LLSaveInfo* info = (LLSaveInfo*)user_data;
if (status == 0)
{
std::string item_name = "New Animation";
std::string item_desc = "";
// Saving into user inventory
LLViewerInventoryItem* item;
item = (LLViewerInventoryItem*)gInventory.getItem(info->mItemUUID);
if(item)
{
item_name = item->getName();
item_desc = item->getDescription();
}
gMessageSystem->newMessageFast(_PREHASH_CreateInventoryItem);
gMessageSystem->nextBlockFast(_PREHASH_AgentData);
gMessageSystem->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
gMessageSystem->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
gMessageSystem->nextBlockFast(_PREHASH_InventoryBlock);
gMessageSystem->addU32Fast(_PREHASH_CallbackID, 0);
gMessageSystem->addUUIDFast(_PREHASH_FolderID, LLUUID::null);
gMessageSystem->addUUIDFast(_PREHASH_TransactionID, info->mTransactionID);
gMessageSystem->addU32Fast(_PREHASH_NextOwnerMask, 2147483647);
gMessageSystem->addS8Fast(_PREHASH_Type, LLAssetType::AT_ANIMATION);
gMessageSystem->addS8Fast(_PREHASH_InvType, LLInventoryType::IT_ANIMATION);
gMessageSystem->addU8Fast(_PREHASH_WearableType, 0);
gMessageSystem->addStringFast(_PREHASH_Name, item_name);
gMessageSystem->addStringFast(_PREHASH_Description, item_desc);
gMessageSystem->sendReliable(gAgent.getRegionHost());
}
else
{
llwarns << "Problem saving animation: " << status << llendl;
LLStringUtil::format_map_t args;
args["[REASON]"] = std::string(LLAssetStorage::getErrorString(status));
gViewerWindow->alertXml("CannotUploadReason",args);
}
}
*/
void LLPreviewAnim::copyAnimID(void *userdata)
{
LLPreviewAnim* self = (LLPreviewAnim*) userdata;
const LLInventoryItem *item = self->getItem();
if(item)
{
gViewerWindow->getWindow()->copyTextToClipboard(utf8str_to_wstring(item->getAssetUUID().asString()));
}
}
// static
void LLPreviewAnim::downloadCompleteCallback(LLVFS *vfs, const LLUUID& uuid, LLAssetType::EType type, void *userdata, S32 result, LLExtStat extstat)
{
LLHandle<LLFloater>* handlep = ((LLHandle<LLFloater>*)userdata);
LLPreviewAnim* self = (LLPreviewAnim*)handlep->get();
delete handlep; // done with the handle
if (self)
{
if(result == LL_ERR_NOERR) {
self->childSetEnabled("Anim remake btn", TRUE);
self->childSetEnabled("Anim export btn", TRUE);
self->childSetEnabled("Anim .anim btn", TRUE);
self->mAnimBufferSize = vfs->getSize(uuid, type);
self->mAnimBuffer = new U8[self->mAnimBufferSize];
vfs->getData(uuid, type, self->mAnimBuffer, 0, self->mAnimBufferSize);
}
}
}
void LLPreviewAnim::exportasdotAnim( void *userdata )
{
LLPreviewAnim* self = (LLPreviewAnim*) userdata;
const LLInventoryItem *item = self->getItem();
//LLVOAvatar* avatar = gAgent.getAvatarObject();
//LLMotion* motion = avatar->findMotion(item->getAssetUUID());
//LLKeyframeMotion* motionp = (LLKeyframeMotion*)motion;
//if (motionp)
{
//U32 size = motionp->getFileSize();
//U8* buffer = new U8[size];
//LLDataPackerBinaryBuffer dp(buffer, size);
//if(motionp->serialize(dp))
{
std::string filename = item->getName() + ".animatn";
LLFilePicker& picker = LLFilePicker::instance();
if(!picker.getSaveFile( LLFilePicker::FFSAVE_ALL, filename.c_str() ) )
{
// User canceled save.
return;
}
std::string name = picker.getFirstFile();
std::string save_filename(name);
LLAPRFile infile ;
infile.open(save_filename.c_str(), LL_APR_WB, LLAPRFile::local);
apr_file_t *fp = infile.getFileHandle();
if(fp)infile.write(self->mAnimBuffer, self->mAnimBufferSize);
infile.close();
}
//delete[] buffer;
}
//whole file imported from onyx thomas shikami gets credit for the exporter
}
// static
void LLPreviewAnim::gotAssetForSave(LLVFS *vfs,
const LLUUID& asset_uuid,
LLAssetType::EType type,
void* user_data, S32 status, LLExtStat ext_status)
{
LLPreviewAnim* self = (LLPreviewAnim*) user_data;
//const LLInventoryItem *item = self->getItem();
LLVFile file(vfs, asset_uuid, type, LLVFile::READ);
S32 size = file.getSize();
char* buffer = new char[size];
if (buffer == NULL)
{
llerrs << "Memory Allocation Failed" << llendl;
return;
}
file.read((U8*)buffer, size);
// Write it back out...
LLFilePicker& file_picker = LLFilePicker::instance();
if( !file_picker.getSaveFile( LLFilePicker::FFSAVE_ANIMATN, LLDir::getScrubbedFileName(self->getItem()->getName())) )
{
// User canceled or we failed to acquire save file.
return;
}
// remember the user-approved/edited file name.
std::string filename = file_picker.getFirstFile();
std::ofstream export_file(filename.c_str(), std::ofstream::binary);
export_file.write(buffer, size);
export_file.close();
delete[] buffer;
buffer = NULL;
}
void LLLocalInventory::open(LLUUID item_id)
{
LLViewerInventoryItem* item = gInventory.getItem(item_id);
if(!item)
{
llwarns << "Trying to open non-existent item" << llendl;
return;
}
LLAssetType::EType type = item->getType();
if(type == LLAssetType::AT_SOUND)
{
S32 left, top;
gFloaterView->getNewFloaterPosition(&left, &top);
LLRect rect = gSavedSettings.getRect("PreviewSoundRect");
rect.translate(left - rect.mLeft, top - rect.mTop);
LLPreviewSound* floaterp;
floaterp = new LLPreviewSound("Preview sound",
rect,
"",
item_id);
floaterp->setFocus(TRUE);
gFloaterView->adjustToFitScreen(floaterp, FALSE);
}
else if(type == LLAssetType::AT_ANIMATION)
{
S32 left, top;
gFloaterView->getNewFloaterPosition(&left, &top);
LLRect rect = gSavedSettings.getRect("PreviewAnimRect");
rect.translate(left - rect.mLeft, top - rect.mTop);
LLPreviewAnim* floaterp;
floaterp = new LLPreviewAnim("Preview anim",
rect,
"",
item_id,
LLPreviewAnim::NONE);
floaterp->setFocus(TRUE);
gFloaterView->adjustToFitScreen(floaterp, FALSE);
}
else if(type == LLAssetType::AT_TEXTURE)
{
S32 left, top;
gFloaterView->getNewFloaterPosition(&left, &top);
LLRect rect = gSavedSettings.getRect("PreviewTextureRect");
rect.translate( left - rect.mLeft, top - rect.mTop );
LLPreviewTexture* preview;
preview = new LLPreviewTexture("preview texture",
rect,
"Preview texture",
item_id,
LLUUID::null,
FALSE);
//preview->setSourceID(source_id);
preview->setFocus(TRUE);
gFloaterView->adjustToFitScreen(preview, FALSE);
}
else if(type == LLAssetType::AT_GESTURE)
{
// If only the others were like this
LLPreviewGesture::show("preview gesture", item_id, LLUUID::null, TRUE);
}
else if(type == LLAssetType::AT_LANDMARK)
{
S32 left, top;
gFloaterView->getNewFloaterPosition(&left, &top);
LLRect rect = gSavedSettings.getRect("PreviewLandmarkRect");
rect.translate( left - rect.mLeft, top - rect.mTop );
LLPreviewLandmark* preview;
preview = new LLPreviewLandmark("preview landmark",
rect,
"Preview landmark",
item_id);
preview->setFocus(TRUE);
gFloaterView->adjustToFitScreen(preview, FALSE);
}
else
{
llwarns << "Dunno how to open type " << type << llendl;
}
}
void LLPreviewAnim::dupliAnim( void *userdata )
{
LLPreviewAnim* self = (LLPreviewAnim*) userdata;
//if(!self->childGetValue("Anim play btn").asBoolean())
//{
// printchat("anim must be playing to copy by this method; please try again");
// LLPreviewAnim::playAnim( userdata );
// return;
//}
const LLInventoryItem *item = self->getItem();
if(item)
{
if(self->mAnimBuffer == NULL)
{
return;
}
LLKeyframeMotion* motionp = NULL;
//LLBVHLoader* loaderp = NULL;
LLAssetID xMotionID;
LLTransactionID xTransactionID;
// generate unique id for this motion
xTransactionID.generate();
xMotionID = xTransactionID.makeAssetID(gAgent.getSecureSessionID());
motionp = (LLKeyframeMotion*)gAgent.getAvatarObject()->createMotion(xMotionID);
/*
// pass animation data through memory buffer
//loaderp->serialize(dp);
gAgent.getAvatarObject()->startMotion(item->getAssetUUID());
LLVOAvatar* avatar = gAgent.getAvatarObject();
LLMotion* motion = avatar->findMotion(item->getAssetUUID());
LLKeyframeMotion* tmp = (LLKeyframeMotion*)motion;
S32 file_size = tmp->getFileSize();
U8* buffer = new U8[file_size];
LLDataPackerBinaryBuffer dp(buffer, file_size);*/
LLDataPackerBinaryBuffer dp(self->mAnimBuffer, self->mAnimBufferSize);
LLVOAvatar* avatar = gAgent.getAvatarObject();
LLMotion* motion = avatar->findMotion(item->getAssetUUID());
LLKeyframeMotion* tmp = (LLKeyframeMotion*)motion;
tmp->serialize(dp);
dp.reset();
BOOL success = motionp && motionp->deserialize(dp);
//delete []buffer;
if (success)
{
motionp->setName(item->getName());
gAgent.getAvatarObject()->startMotion(xMotionID);
////////////////////////////////////////////////////////////////////
/*LLKeyframeMotion* */motionp = (LLKeyframeMotion*)gAgent.getAvatarObject()->findMotion(xMotionID);
S32 file_size = motionp->getFileSize();
U8* buffer = new U8[file_size];
LLDataPackerBinaryBuffer dp(buffer, file_size);
if (motionp->serialize(dp))
{
LLVFile file(gVFS, motionp->getID(), LLAssetType::AT_ANIMATION, LLVFile::APPEND);
S32 size = dp.getCurrentSize();
file.setMaxSize(size);
if (file.write((U8*)buffer, size))
{
std::string name = item->getName();
std::string desc = item->getDescription();
upload_new_resource(xTransactionID, // tid
LLAssetType::AT_ANIMATION,
name,
desc,
0,
LLAssetType::AT_NONE,
LLInventoryType::IT_ANIMATION,
PERM_NONE,PERM_NONE,PERM_NONE,
name,0,10,0);
}
else
{
llwarns << "Failure writing animation data." << llendl;
LLNotifications::instance().add("WriteAnimationFail");
}
}
delete [] buffer;
// clear out cache for motion data
gAgent.getAvatarObject()->removeMotion(xMotionID);
LLKeyframeDataCache::removeKeyframeData(xMotionID);
////////////////////////////////////////////////////////////////////
}
}
}
