void loadPersistentNotifications()
{
llinfos << "Loading open notifications from " << mFileName << llendl;
llifstream notify_file(mFileName.c_str());
if (!notify_file.is_open())
{
llwarns << "Failed to open " << mFileName << llendl;
return;
}
LLSD input;
LLPointer<LLSDParser> parser = new LLSDXMLParser();
if (parser->parse(notify_file, input, LLSDSerialize::SIZE_UNLIMITED) < 0)
{
llwarns << "Failed to parse open notifications" << llendl;
return;
}
if (input.isUndefined()) return;
std::string version = input["version"];
if (version != NOTIFICATION_PERSIST_VERSION)
{
llwarns << "Bad open notifications version: " << version << llendl;
return;
}
LLSD& data = input["data"];
if (data.isUndefined()) return;
LLNotifications& instance = LLNotifications::instance();
for (LLSD::array_const_iterator notification_it = data.beginArray();
notification_it != data.endArray();
++notification_it)
{
instance.add(LLNotificationPtr(new LLNotification(*notification_it)));
}
}
LLViewerFetchedTexture* LLViewerTextureList::getImageFromUrl(const std::string& url,
BOOL usemipmaps,
LLViewerTexture::EBoostLevel boost_priority,
S8 texture_type,
LLGLint internal_format,
LLGLenum primary_format,
const LLUUID& force_id)
{
// generate UUID based on hash of filename
LLUUID new_id;
if (force_id.notNull())
{
new_id = force_id;
}
else
{
new_id.generate(url);
}
LLPointer<LLViewerFetchedTexture> imagep = findImage(new_id);
if (imagep.isNull())
{
switch(texture_type)
{
case LLViewerTexture::FETCHED_TEXTURE:
imagep = new LLViewerFetchedTexture(url, new_id, usemipmaps);
break ;
case LLViewerTexture::LOD_TEXTURE:
imagep = new LLViewerLODTexture(url, new_id, usemipmaps);
break ;
default:
llerrs << "Invalid texture type " << texture_type << llendl ;
}
if (internal_format && primary_format)
{
imagep->setExplicitFormat(internal_format, primary_format);
}
addImage(imagep);
if (boost_priority != 0)
{
if (boost_priority == LLViewerFetchedTexture::BOOST_UI ||
boost_priority == LLViewerFetchedTexture::BOOST_ICON)
{
imagep->dontDiscard();
}
imagep->setBoostLevel(boost_priority);
}
}
imagep->setGLTextureCreated(true);
return imagep;
}
static void handle_click_action_open_media(LLPointer<LLViewerObject> objectp)
{
//FIXME: how do we handle object in different parcel than us?
LLParcel* parcel = LLViewerParcelMgr::getInstance()->getAgentParcel();
if (!parcel) return;
// did we hit an object?
if (objectp.isNull()) return;
// did we hit a valid face on the object?
S32 face = LLToolPie::getInstance()->getPick().mObjectFace;
if( face < 0 || face >= objectp->getNumTEs() ) return;
// is media playing on this face?
if (!LLViewerMedia::isActiveMediaTexture(objectp->getTE(face)->getID()))
{
handle_click_action_play();
return;
}
std::string media_url = std::string ( parcel->getMediaURL () );
std::string media_type = std::string ( parcel->getMediaType() );
LLStringUtil::trim(media_url);
// Get the scheme, see if that is handled as well.
LLURI uri(media_url);
std::string media_scheme = uri.scheme() != "" ? uri.scheme() : "http";
// HACK: This is directly referencing an impl name. BAD!
// This can be removed when we have a truly generic media browser that only
// builds an impl based on the type of url it is passed.
if( LLMediaManager::getInstance()->supportsMediaType( "LLMediaImplLLMozLib", media_scheme, media_type ) )
{
LLWeb::loadURL(media_url);
}
}
void LLSurface::createSTexture()
{
if (!mSTexturep)
{
// Fill with dummy gray data.
// GL NOT ACTIVE HERE
LLPointer<LLImageRaw> raw = new LLImageRaw(sTextureSize, sTextureSize, 3);
U8 *default_texture = raw->getData();
for (S32 i = 0; i < sTextureSize; i++)
{
for (S32 j = 0; j < sTextureSize; j++)
{
*(default_texture + (i*sTextureSize + j)*3) = 128;
*(default_texture + (i*sTextureSize + j)*3 + 1) = 128;
*(default_texture + (i*sTextureSize + j)*3 + 2) = 128;
}
}
mSTexturep = LLViewerTextureManager::getLocalTexture(raw.get(), FALSE);
mSTexturep->dontDiscard();
gGL.getTexUnit(0)->bind(mSTexturep);
mSTexturep->setAddressMode(LLTexUnit::TAM_CLAMP);
}
}
/*
Processed menu items with such parameters:
can_allow_text_chat
can_moderate_voice
*/
bool LLParticipantList::LLParticipantListMenu::enableModerateContextMenuItem(const LLSD& userdata)
{
// only group moderators can perform actions related to this "enable callback"
if (!isGroupModerator()) return false;
const LLUUID& participant_id = mUUIDs.front();
LLPointer<LLSpeaker> speakerp = mParent.mSpeakerMgr->findSpeaker(participant_id);
// not in voice participants can not be moderated
bool speaker_in_voice = speakerp.notNull() && speakerp->isInVoiceChannel();
const std::string& item = userdata.asString();
if ("can_moderate_voice" == item)
{
return speaker_in_voice;
}
// For now non of menu actions except "can_moderate_voice" can be performed for Avaline callers.
bool is_participant_avatar = LLVoiceClient::getInstance()->isParticipantAvatar(participant_id);
if (!is_participant_avatar) return false;
return true;
}
void AscentDayCycleManager::savePresets(const std::string & fileName)
{
//Nobody currently calls me, but if they did, then its reasonable to write the data out to the user's folder
//and not over the RO system wide version.
LLSD paramsData(LLSD::emptyMap());
std::string pathName(gDirUtilp->getExpandedFilename( LL_PATH_USER_SETTINGS , "windlight", fileName));
/*for(std::map<std::string, LLWLDayCycle>::iterator mIt = mParamList.begin();
mIt != mParamList.end();
++mIt)
{
paramsData[mIt->first] = mIt->second.getAll();
}*/
llofstream presetsXML(pathName);
LLPointer<LLSDFormatter> formatter = new LLSDXMLFormatter();
formatter->format(paramsData, presetsXML, LLSDFormatter::OPTIONS_PRETTY);
presetsXML.close();
}
void LLSimInfo::setLandForSaleImage (LLUUID image_id)
{
LLPointer<LLViewerFetchedTexture> mOverlayImage;
if (mMapImageID[SIM_LAYER_OVERLAY].isNull() && image_id.notNull()) {
mOverlayImage = LLViewerTextureManager::findFetchedTexture(image_id);
if(mOverlayImage.notNull()) {
LLAppViewer::getTextureCache()->removeFromCache(image_id);
}
}
mMapImageID[SIM_LAYER_OVERLAY] = image_id;
// Fetch the image
if (mMapImageID[SIM_LAYER_OVERLAY].notNull())
{
mLayerImage[SIM_LAYER_OVERLAY] = LLViewerTextureManager::getFetchedTexture(mMapImageID[SIM_LAYER_OVERLAY], MIPMAP_TRUE, LLViewerTexture::BOOST_MAP, LLViewerTexture::LOD_TEXTURE);
mLayerImage[SIM_LAYER_OVERLAY]->forceImmediateUpdate();
mLayerImage[SIM_LAYER_OVERLAY]->setAddressMode(LLTexUnit::TAM_CLAMP);
}
else
{
mLayerImage[SIM_LAYER_OVERLAY] = NULL;
}
}
void LLSurface::createWaterTexture()
{
if (!mWaterTexturep)
{
// Create the water texture
LLPointer<LLImageRaw> raw = new LLImageRaw(sTextureSize/2, sTextureSize/2, 4);
U8 *default_texture = raw->getData();
for (S32 i = 0; i < sTextureSize/2; i++)
{
for (S32 j = 0; j < sTextureSize/2; j++)
{
*(default_texture + (i*sTextureSize/2 + j)*4) = MAX_WATER_COLOR.mV[0];
*(default_texture + (i*sTextureSize/2 + j)*4 + 1) = MAX_WATER_COLOR.mV[1];
*(default_texture + (i*sTextureSize/2 + j)*4 + 2) = MAX_WATER_COLOR.mV[2];
*(default_texture + (i*sTextureSize/2 + j)*4 + 3) = MAX_WATER_COLOR.mV[3];
}
}
mWaterTexturep = LLViewerTextureManager::getLocalTexture(raw.get(), FALSE);
mWaterTexturep->dontDiscard();
gGL.getTexUnit(0)->bind(mWaterTexturep);
mWaterTexturep->setAddressMode(LLTexUnit::TAM_CLAMP);
}
}
void LLPanelGroupNotices::setItem(LLPointer<LLInventoryItem> inv_item)
{
mInventoryItem = inv_item;
BOOL item_is_multi = FALSE;
if ( inv_item->getFlags() & LLInventoryItem::II_FLAGS_OBJECT_HAS_MULTIPLE_ITEMS )
{
item_is_multi = TRUE;
};
std::string icon_name = get_item_icon_name(inv_item->getType(),
inv_item->getInventoryType(),
inv_item->getFlags(),
item_is_multi );
mCreateInventoryIcon->setImage(icon_name);
mCreateInventoryIcon->setVisible(TRUE);
std::stringstream ss;
ss << " " << mInventoryItem->getName();
mCreateInventoryName->setText(ss.str());
mBtnRemoveAttachment->setEnabled(TRUE);
}
void LLViewerMediaFocus::setHoverFace(LLPointer<LLViewerObject> objectp, S32 face, viewer_media_t media_impl, LLVector3 pick_normal)
{
if (media_impl.notNull())
{
mHoverImplID = media_impl->getMediaTextureID();
mHoverObjectID = objectp->getID();
mHoverObjectFace = face;
mHoverObjectNormal = pick_normal;
}
else
{
mHoverObjectID = LLUUID::null;
mHoverObjectFace = 0;
mHoverImplID = LLUUID::null;
}
}
// note: modifies the argument raw_image!!!!
LLPointer<LLImageJ2C> LLViewerImageList::convertToUploadFile(LLPointer<LLImageRaw> raw_image)
{
raw_image->biasedScaleToPowerOfTwo(LLViewerImage::MAX_IMAGE_SIZE_DEFAULT);
LLPointer<LLImageJ2C> compressedImage = new LLImageJ2C();
compressedImage->setRate(0.f);
if (gSavedSettings.getBOOL("LosslessJ2CUpload") &&
(raw_image->getWidth() * raw_image->getHeight() <= LL_IMAGE_REZ_LOSSLESS_CUTOFF * LL_IMAGE_REZ_LOSSLESS_CUTOFF))
compressedImage->setReversible(TRUE);
compressedImage->encode(raw_image, 0.0f);
return compressedImage;
}
void LLDrawPoolAvatar::getRiggedGeometry(LLFace* face, LLPointer<LLVertexBuffer>& buffer, U32 data_mask, const LLMeshSkinInfo* skin, LLVolume* volume, const LLVolumeFace& vol_face)
{
face->setGeomIndex(0);
face->setIndicesIndex(0);
//rigged faces do not batch textures
face->setTextureIndex(255);
if (buffer.isNull() || buffer->getTypeMask() != data_mask || !buffer->isWriteable())
{ //make a new buffer
if (sShaderLevel > 0)
{
buffer = new LLVertexBuffer(data_mask, GL_DYNAMIC_DRAW_ARB);
}
else
{
buffer = new LLVertexBuffer(data_mask, GL_STREAM_DRAW_ARB);
}
buffer->allocateBuffer(vol_face.mNumVertices, vol_face.mNumIndices, true);
}
else //resize existing buffer
{
buffer->resizeBuffer(vol_face.mNumVertices, vol_face.mNumIndices);
}
face->setSize(vol_face.mNumVertices, vol_face.mNumIndices);
face->setVertexBuffer(buffer);
U16 offset = 0;
LLMatrix4a mat_vert;
mat_vert.loadu(skin->mBindShapeMatrix);
LLMatrix4a mat_inv_trans = mat_vert;
mat_inv_trans.invert();
mat_inv_trans.transpose();
//let getGeometryVolume know if alpha should override shiny
U32 type = gPipeline.getPoolTypeFromTE(face->getTextureEntry(), face->getTexture());
if (type == LLDrawPool::POOL_ALPHA)
{
face->setPoolType(LLDrawPool::POOL_ALPHA);
}
else
{
face->setPoolType(LLDrawPool::POOL_AVATAR);
}
//llinfos << "Rebuilt face " << face->getTEOffset() << " of " << face->getDrawable() << " at " << gFrameTimeSeconds << llendl;
face->getGeometryVolume(*volume, face->getTEOffset(), mat_vert, mat_inv_trans, offset, true);
buffer->flush();
}
LLViewerImage* LLViewerImageList::getImage(const LLUUID &image_id,
BOOL usemipmaps,
BOOL level_immediate,
LLGLint internal_format,
LLGLenum primary_format,
LLHost request_from_host)
{
// Return the image with ID image_id
// If the image is not found, creates new image and
// enqueues a request for transmission
if ((&image_id == NULL) || image_id.isNull())
{
return (getImage(IMG_DEFAULT, TRUE, TRUE));
}
LLPointer<LLViewerImage> imagep = hasImage(image_id);
if (imagep.isNull())
{
imagep = new LLViewerImage(image_id, request_from_host, usemipmaps);
if (internal_format && primary_format)
{
imagep->setExplicitFormat(internal_format, primary_format);
}
addImage(imagep);
if (level_immediate)
{
imagep->dontDiscard();
imagep->setBoostLevel(LLViewerImageBoostLevel::BOOST_UI);
}
else
{
//by default, the texure can not be removed from memory even if it is not used.
//here turn this off
//if this texture should be set to NO_DELETE, either pass level_immediate == TRUE here, or call setNoDelete() afterwards.
imagep->forceActive() ;
}
}
imagep->setGLTextureCreated(true);
return imagep;
}
LLPointer<LLInventoryCategory> ll_create_category_from_sd(const LLSD& sd_cat)
{
LLPointer<LLInventoryCategory> rv = new LLInventoryCategory;
rv->setUUID(sd_cat[INV_FOLDER_ID_LABEL].asUUID());
rv->setParent(sd_cat[INV_PARENT_ID_LABEL].asUUID());
rv->rename(sd_cat[INV_NAME_LABEL].asString());
rv->setType(
LLAssetType::lookup(sd_cat[INV_ASSET_TYPE_LABEL].asString()));
rv->setPreferredType(
LLAssetType::lookup(
sd_cat[INV_PREFERRED_TYPE_LABEL].asString()));
return rv;
}
LLSD ll_create_sd_from_inventory_category(LLPointer<LLInventoryCategory> cat)
{
LLSD rv;
if(cat.isNull()) return rv;
if (cat->getType() == LLAssetType::AT_NONE)
{
LL_WARNS() << "ll_create_sd_from_inventory_category() for cat with AT_NONE"
<< LL_ENDL;
return rv;
}
rv[INV_FOLDER_ID_LABEL] = cat->getUUID();
rv[INV_PARENT_ID_LABEL] = cat->getParentUUID();
rv[INV_NAME_LABEL] = cat->getName();
rv[INV_ASSET_TYPE_LABEL] = LLAssetType::lookup(cat->getType());
if(LLFolderType::lookupIsProtectedType(cat->getPreferredType()))
{
rv[INV_PREFERRED_TYPE_LABEL] =
LLFolderType::lookup(cat->getPreferredType()).c_str();
}
return rv;
}
LLSD ll_create_sd_from_inventory_category(LLPointer<LLInventoryCategory> cat)
{
LLSD rv;
if(cat.isNull()) return rv;
if (cat->getType() == LLAssetType::AT_NONE)
{
llwarns << "ll_create_sd_from_inventory_category() for cat with AT_NONE"
<< llendl;
return rv;
}
rv[INV_FOLDER_ID_LABEL] = cat->getUUID();
rv[INV_PARENT_ID_LABEL] = cat->getParentUUID();
rv[INV_NAME_LABEL] = cat->getName();
rv[INV_ASSET_TYPE_LABEL] = LLAssetType::lookup(cat->getType());
if(LLAssetType::AT_NONE != cat->getPreferredType())
{
rv[INV_PREFERRED_TYPE_LABEL] =
LLAssetType::lookup(cat->getPreferredType());
}
return rv;
}
// Insert a certificate into the store. If the certificate already
// exists in the store, nothing is done.
void LLBasicCertificateVector::insert(iterator _iter,
LLPointer<LLCertificate> cert)
{
LLSD cert_info;
cert->getLLSD(cert_info);
if (cert_info.isMap() && cert_info.has(CERT_SHA1_DIGEST))
{
LLSD existing_cert_info = LLSD::emptyMap();
existing_cert_info[CERT_MD5_DIGEST] = cert_info[CERT_MD5_DIGEST];
if(find(existing_cert_info) == end())
{
BasicIteratorImpl *basic_iter = dynamic_cast<BasicIteratorImpl*>(_iter.mImpl.get());
llassert(basic_iter);
if (basic_iter)
{
mCerts.insert(basic_iter->mIter, cert);
}
}
}
}
// note: modifies the argument raw_image!!!!
LLPointer<LLImageJ2C> LLViewerTextureList::convertToUploadFile(LLPointer<LLImageRaw> raw_image)
{
raw_image->biasedScaleToPowerOfTwo(LLViewerFetchedTexture::MAX_IMAGE_SIZE_DEFAULT);
LLPointer<LLImageJ2C> compressedImage = new LLImageJ2C();
compressedImage->setRate(0.f);
if (gSavedSettings.getBOOL("LosslessJ2CUpload") &&
(raw_image->getWidth() * raw_image->getHeight() <= LL_IMAGE_REZ_LOSSLESS_CUTOFF * LL_IMAGE_REZ_LOSSLESS_CUTOFF))
compressedImage->setReversible(TRUE);
compressedImage->encode(raw_image, 0.0f);
if (!compressedImage->encode(raw_image, 0.0f))
{
llinfos << "convertToUploadFile : encode returns with error!!" << llendl;
// Clear up the pointer so we don't leak that one
compressedImage = NULL;
}
return compressedImage;
}
// static
void LLFloaterAuction::onClickSnapshot(void* data)
{
LLFloaterAuction* self = (LLFloaterAuction*)(data);
LLPointer<LLImageRaw> raw = new LLImageRaw;
gForceRenderLandFence = self->getChild<LLUICtrl>("fence_check")->getValue().asBoolean();
BOOL success = gViewerWindow->rawSnapshot(raw,
gViewerWindow->getWindowWidthScaled(),
gViewerWindow->getWindowHeightScaled(),
TRUE, FALSE,
FALSE, FALSE);
gForceRenderLandFence = FALSE;
if (success)
{
self->mTransactionID.generate();
self->mImageID = self->mTransactionID.makeAssetID(gAgent.getSecureSessionID());
// <FS:PP> FIRE-8190: Preview function for "UI Sounds" Panel
// if(!gSavedSettings.getBOOL("QuietSnapshotsToDisk"))
if(!gSavedSettings.getBOOL("PlayModeUISndSnapshot"))
// </FS:PP> FIRE-8190: Preview function for "UI Sounds" Panel
{
gViewerWindow->playSnapshotAnimAndSound();
}
llinfos << "Writing TGA..." << llendl;
LLPointer<LLImageTGA> tga = new LLImageTGA;
tga->encode(raw);
LLVFile::writeFile(tga->getData(), tga->getDataSize(), gVFS, self->mImageID, LLAssetType::AT_IMAGE_TGA);
raw->biasedScaleToPowerOfTwo(LLViewerTexture::MAX_IMAGE_SIZE_DEFAULT);
llinfos << "Writing J2C..." << llendl;
LLPointer<LLImageJ2C> j2c = new LLImageJ2C;
j2c->encode(raw, 0.0f);
LLVFile::writeFile(j2c->getData(), j2c->getDataSize(), gVFS, self->mImageID, LLAssetType::AT_TEXTURE);
self->mImage = LLViewerTextureManager::getLocalTexture((LLImageRaw*)raw, FALSE);
gGL.getTexUnit(0)->bind(self->mImage);
self->mImage->setAddressMode(LLTexUnit::TAM_CLAMP);
}
else
{
llwarns << "Unable to take snapshot" << llendl;
}
}
LLViewerImage* LLViewerImageList::getImageFromUrl(const std::string& url,
BOOL usemipmaps,
BOOL level_immediate,
LLGLint internal_format,
LLGLenum primary_format,
const LLUUID& force_id)
{
if (gNoRender)
{
// Never mind that this ignores image_set_id;
// getImage() will handle that later.
return getImage(IMG_DEFAULT, TRUE, TRUE);
}
// generate UUID based on hash of filename
LLUUID new_id;
if (force_id.notNull())
{
new_id = force_id;
}
else
{
new_id.generate(url);
}
LLPointer<LLViewerImage> imagep = hasImage(new_id);
if (imagep.isNull())
{
imagep = new LLViewerImage(url, new_id, usemipmaps);
if (internal_format && primary_format)
{
imagep->setExplicitFormat(internal_format, primary_format);
}
addImage(imagep);
if (level_immediate)
{
imagep->dontDiscard();
imagep->setBoostLevel(LLViewerImageBoostLevel::BOOST_UI);
}
}
imagep->setGLTextureCreated(true);
return imagep;
}
// static
LLPointer<LLViewerPartSourceScript> LLViewerPartSourceScript::unpackPSS(LLViewerObject *source_objp, LLPointer<LLViewerPartSourceScript> pssp, const S32 block_num)
{
LLMemType mt(LLMemType::MTYPE_PARTICLES);
if (!pssp)
{
if (LLPartSysData::isNullPS(block_num))
{
return NULL;
}
LLPointer<LLViewerPartSourceScript> new_pssp = new LLViewerPartSourceScript(source_objp);
if (!new_pssp->mPartSysData.unpackBlock(block_num))
{
return NULL;
}
if (new_pssp->mPartSysData.mTargetUUID.notNull())
{
LLViewerObject *target_objp = gObjectList.findObject(new_pssp->mPartSysData.mTargetUUID);
new_pssp->setTargetObject(target_objp);
}
return new_pssp;
}
else
{
if (LLPartSysData::isNullPS(block_num))
{
return NULL;
}
if (!pssp->mPartSysData.unpackBlock(block_num))
{
return NULL;
}
if (pssp->mPartSysData.mTargetUUID.notNull())
{
LLViewerObject *target_objp = gObjectList.findObject(pssp->mPartSysData.mTargetUUID);
pssp->setTargetObject(target_objp);
}
return pssp;
}
}
// static
void LLFloaterAuction::onClickSnapshot(void* data)
{
LLFloaterAuction* self = (LLFloaterAuction*)(data);
LLPointer<LLImageRaw> raw = new LLImageRaw;
gForceRenderLandFence = self->childGetValue("fence_check").asBoolean();
BOOL success = gViewerWindow->rawSnapshot(raw,
gViewerWindow->getWindowWidth(),
gViewerWindow->getWindowHeight(),
TRUE, FALSE,
FALSE, FALSE);
gForceRenderLandFence = FALSE;
if (success)
{
self->mTransactionID.generate();
self->mImageID = self->mTransactionID.makeAssetID(gAgent.getSecureSessionID());
if(!gSavedSettings.getBOOL("QuietSnapshotsToDisk"))
{
gViewerWindow->playSnapshotAnimAndSound();
}
llinfos << "Writing TGA..." << llendl;
LLPointer<LLImageTGA> tga = new LLImageTGA;
tga->encode(raw);
LLVFile::writeFile(tga->getData(), tga->getDataSize(), gVFS, self->mImageID, LLAssetType::AT_IMAGE_TGA);
raw->biasedScaleToPowerOfTwo(LLViewerImage::MAX_IMAGE_SIZE_DEFAULT);
llinfos << "Writing J2C..." << llendl;
LLPointer<LLImageJ2C> j2c = new LLImageJ2C;
j2c->encode(raw, 0.0f);
LLVFile::writeFile(j2c->getData(), j2c->getDataSize(), gVFS, self->mImageID, LLAssetType::AT_TEXTURE);
self->mImage = new LLImageGL((LLImageRaw*)raw, FALSE);
self->mImage->bind();
self->mImage->setClamp(TRUE, TRUE);
}
else
{
llwarns << "Unable to take snapshot" << llendl;
}
}
//-----------------------------------------------------------------------------
// addJointState()
//-----------------------------------------------------------------------------
BOOL LLJointStateBlender::addJointState(const LLPointer<LLJointState>& joint_state, S32 priority, BOOL additive_blend)
{
llassert(joint_state);
if (!joint_state->getJoint())
// this joint state doesn't point to an actual joint, so we don't care about applying it
return FALSE;
for(S32 i = 0; i < JSB_NUM_JOINT_STATES; i++)
{
if (mJointStates[i].isNull())
{
mJointStates[i] = joint_state;
mPriorities[i] = priority;
mAdditiveBlends[i] = additive_blend;
return TRUE;
}
else if (priority > mPriorities[i])
{
// we're at a higher priority than the current joint state in this slot
// so shift everyone over
// previous joint states (newer motions) with same priority should stay in place
for (S32 j = JSB_NUM_JOINT_STATES - 1; j > i; j--)
{
mJointStates[j] = mJointStates[j - 1];
mPriorities[j] = mPriorities[j - 1];
mAdditiveBlends[j] = mAdditiveBlends[j - 1];
}
// now store ourselves in this slot
mJointStates[i] = joint_state;
mPriorities[i] = priority;
mAdditiveBlends[i] = additive_blend;
return TRUE;
}
}
return FALSE;
}
BOOL LLViewerTextEditor::openEmbeddedItem(LLPointer<LLInventoryItem> item, llwchar wc)
{
switch( item->getType() )
{
case LLAssetType::AT_TEXTURE:
openEmbeddedTexture( item, wc );
return TRUE;
case LLAssetType::AT_SOUND:
openEmbeddedSound( item, wc );
return TRUE;
case LLAssetType::AT_NOTECARD:
openEmbeddedNotecard( item, wc );
return TRUE;
case LLAssetType::AT_LANDMARK:
openEmbeddedLandmark( item, wc );
return TRUE;
case LLAssetType::AT_CALLINGCARD:
openEmbeddedCallingcard( item, wc );
return TRUE;
case LLAssetType::AT_LSL_TEXT:
case LLAssetType::AT_CLOTHING:
case LLAssetType::AT_OBJECT:
case LLAssetType::AT_BODYPART:
case LLAssetType::AT_ANIMATION:
case LLAssetType::AT_GESTURE:
showCopyToInvDialog( item, wc );
return TRUE;
default:
return FALSE;
}
}
// Load an image from file and return a raw (decompressed) instance of its data
LLPointer<LLImageRaw> load_image(const std::string &src_filename, int discard_level, int* region, bool output_stats)
{
LLPointer<LLImageFormatted> image = create_image(src_filename);
// This just loads the image file stream into a buffer. No decoding done.
if (!image->load(src_filename))
{
return NULL;
}
if( (image->getComponents() != 3) && (image->getComponents() != 4) )
{
std::cout << "Image files with less than 3 or more than 4 components are not supported\n";
return NULL;
}
if (output_stats)
{
output_image_stats(image, src_filename);
}
LLPointer<LLImageRaw> raw_image = new LLImageRaw;
// Set the image restriction on load in the case of a j2c image
if ((image->getCodec() == IMG_CODEC_J2C) && ((discard_level != -1) || (region != NULL)))
{
// That method doesn't exist (and likely, doesn't make sense) for any other image file format
// hence the required cryptic cast.
((LLImageJ2C*)(image.get()))->initDecode(*raw_image, discard_level, region);
}
if (!image->decode(raw_image, 0.0f))
{
return NULL;
}
return raw_image;
}
LLViewerImage* LLViewerImageList::getImage(const LLUUID &image_id,
BOOL usemipmaps,
BOOL level_immediate,
LLGLint internal_format,
LLGLenum primary_format,
LLHost request_from_host)
{
// Return the image with ID image_id
// If the image is not found, creates new image and
// enqueues a request for transmission
if ((&image_id == NULL) || image_id.isNull())
{
return (getImage(IMG_DEFAULT, TRUE, TRUE));
}
LLPointer<LLViewerImage> imagep = hasImage(image_id);
if (imagep.isNull())
{
imagep = new LLViewerImage(image_id, usemipmaps);
// Might want to request from host other than where the agent is. JC
imagep->setTargetHost(request_from_host);
if (internal_format && primary_format)
{
imagep->setExplicitFormat(internal_format, primary_format);
}
addImage(imagep);
if (level_immediate)
{
imagep->dontDiscard();
imagep->setBoostLevel(LLViewerImage::BOOST_UI);
}
}
return imagep;
}
void LLFloaterTexturePicker::updateImageStats()
{
if (mTexturep.notNull())
{
//RN: have we received header data for this image?
if (mTexturep->getWidth(0) > 0 && mTexturep->getHeight(0) > 0)
{
std::string formatted_dims = llformat("%d x %d", mTexturep->getWidth(0),mTexturep->getHeight(0));
mResolutionLabel->setTextArg("[DIMENSIONS]", formatted_dims);
}
else
{
mResolutionLabel->setTextArg("[DIMENSIONS]", std::string("[? x ?]"));
}
if (gAgent.isGodlike())
{
std::string tstring = "Pick: ";
std::string image_id_string = mTexturep->getID().asString();
tstring = tstring + image_id_string.replace(24, 35, 12, '*'); // hide last segment to discourage theft
setTitle(tstring);
}
}
}
virtual bool doCompare(const LLAvatarListItem* item1, const LLAvatarListItem* item2) const
{
LLPointer<LLSpeaker> lhs = LLActiveSpeakerMgr::instance().findSpeaker(item1->getAvatarId());
LLPointer<LLSpeaker> rhs = LLActiveSpeakerMgr::instance().findSpeaker(item2->getAvatarId());
if ( lhs.notNull() && rhs.notNull() )
{
// Compare by last speaking time
if( lhs->mLastSpokeTime != rhs->mLastSpokeTime )
return ( lhs->mLastSpokeTime > rhs->mLastSpokeTime );
}
else if ( lhs.notNull() )
{
// True if only item1 speaker info available
return true;
}
else if ( rhs.notNull() )
{
// False if only item2 speaker info available
return false;
}
// By default compare by name.
return LLAvatarItemNameComparator::doCompare(item1, item2);
}
BOOL LLVLComposition::generateTexture(const F32 x, const F32 y,
const F32 width, const F32 height)
{
llassert(mSurfacep);
llassert(x >= 0.f);
llassert(y >= 0.f);
LLTimer gen_timer;
///////////////////////////
//
// Generate raw data arrays for surface textures
//
//
// These have already been validated by generateComposition.
U8* st_data[4];
S32 st_data_size[4]; // for debugging
for (S32 i = 0; i < 4; i++)
{
if (mRawImages[i].isNull())
{
// Read back a raw image for this discard level, if it exists
mRawImages[i] = new LLImageRaw;
S32 min_dim = llmin(mDetailTextures[i]->getWidth(0), mDetailTextures[i]->getHeight(0));
S32 ddiscard = 0;
while (min_dim > BASE_SIZE && ddiscard < MAX_DISCARD_LEVEL)
{
ddiscard++;
min_dim /= 2;
}
mRawImages[i] = mDetailTextures[i]->getCachedRawImage() ;
if (!mRawImages[i])
{
llwarns << "no cached raw data for terrain detail texture: " << mDetailTextures[i]->getID() << llendl;
return FALSE;
}
if (mDetailTextures[i]->getWidth(ddiscard) != BASE_SIZE ||
mDetailTextures[i]->getHeight(ddiscard) != BASE_SIZE ||
mDetailTextures[i]->getComponents() != 3)
{
LLPointer<LLImageRaw> newraw = new LLImageRaw(BASE_SIZE, BASE_SIZE, 3);
newraw->composite(mRawImages[i]);
mRawImages[i] = newraw; // deletes old
}
}
st_data[i] = mRawImages[i]->getData();
st_data_size[i] = mRawImages[i]->getDataSize();
}
///////////////////////////////////////
//
// Generate and clamp x/y bounding box.
//
//
S32 x_begin, y_begin, x_end, y_end;
x_begin = (S32)(x * mScaleInv);
y_begin = (S32)(y * mScaleInv);
x_end = llround( (x + width) * mScaleInv );
y_end = llround( (y + width) * mScaleInv );
if (x_end > mWidth)
{
llwarns << "x end > width" << llendl;
x_end = mWidth;
}
if (y_end > mWidth)
{
llwarns << "y end > width" << llendl;
y_end = mWidth;
}
///////////////////////////////////////////
//
// Generate target texture information, stride ratios.
//
//
LLViewerImage *texturep;
U32 tex_width, tex_height, tex_comps;
U32 tex_stride;
F32 tex_x_scalef, tex_y_scalef;
S32 tex_x_begin, tex_y_begin, tex_x_end, tex_y_end;
F32 tex_x_ratiof, tex_y_ratiof;
texturep = mSurfacep->getSTexture();
tex_width = texturep->getWidth();
tex_height = texturep->getHeight();
tex_comps = texturep->getComponents();
tex_stride = tex_width * tex_comps;
S32 st_comps = 3;
S32 st_width = BASE_SIZE;
S32 st_height = BASE_SIZE;
if (tex_comps != st_comps)
{
llwarns << "Base texture comps != input texture comps" << llendl;
return FALSE;
}
tex_x_scalef = (F32)tex_width / (F32)mWidth;
tex_y_scalef = (F32)tex_height / (F32)mWidth;
tex_x_begin = (S32)((F32)x_begin * tex_x_scalef);
tex_y_begin = (S32)((F32)y_begin * tex_y_scalef);
tex_x_end = (S32)((F32)x_end * tex_x_scalef);
tex_y_end = (S32)((F32)y_end * tex_y_scalef);
tex_x_ratiof = (F32)mWidth*mScale / (F32)tex_width;
tex_y_ratiof = (F32)mWidth*mScale / (F32)tex_height;
LLPointer<LLImageRaw> raw = new LLImageRaw(tex_width, tex_height, tex_comps);
U8 *rawp = raw->getData();
F32 tex_width_inv = 1.f/tex_width;
F32 tex_height_inv = 1.f/tex_height;
F32 st_x_stride, st_y_stride;
st_x_stride = ((F32)st_width / (F32)mTexScaleX)*((F32)mWidth / (F32)tex_width);
st_y_stride = ((F32)st_height / (F32)mTexScaleY)*((F32)mWidth / (F32)tex_height);
llassert(st_x_stride > 0.f);
llassert(st_y_stride > 0.f);
////////////////////////////////
//
// Iterate through the target texture, striding through the
// subtextures and interpolating appropriately.
//
//
F32 sti, stj;
S32 st_offset;
sti = (tex_x_begin * st_x_stride) - st_width*(llfloor((tex_x_begin * st_x_stride)/st_width));
stj = (tex_y_begin * st_y_stride) - st_height*(llfloor((tex_y_begin * st_y_stride)/st_height));
st_offset = (llfloor(stj * st_width) + llfloor(sti)) * st_comps;
for (S32 j = tex_y_begin; j < tex_y_end; j++)
{
U32 offset = j * tex_stride + tex_x_begin * tex_comps;
sti = (tex_x_begin * st_x_stride) - st_width*((U32)(tex_x_begin * st_x_stride)/st_width);
for (S32 i = tex_x_begin; i < tex_x_end; i++)
{
S32 tex0, tex1;
F32 composition = getValueScaled(i*tex_x_ratiof, j*tex_y_ratiof);
tex0 = llfloor( composition );
tex0 = llclamp(tex0, 0, 3);
composition -= tex0;
tex1 = tex0 + 1;
tex1 = llclamp(tex1, 0, 3);
F32 xy_int_i, xy_int_j;
xy_int_i = i * tex_width_inv;
xy_int_j = j * tex_height_inv;
st_offset = (lltrunc(sti) + lltrunc(stj)*st_width) * st_comps;
for (U32 k = 0; k < tex_comps; k++)
{
// Linearly interpolate based on composition.
if (st_offset >= st_data_size[tex0] || st_offset >= st_data_size[tex1])
{
// SJB: This shouldn't be happening, but does... Rounding error?
//llwarns << "offset 0 [" << tex0 << "] =" << st_offset << " >= size=" << st_data_size[tex0] << llendl;
//llwarns << "offset 1 [" << tex1 << "] =" << st_offset << " >= size=" << st_data_size[tex1] << llendl;
}
else
{
F32 a = *(st_data[tex0] + st_offset);
F32 b = *(st_data[tex1] + st_offset);
rawp[ offset ] = (U8)lltrunc( a + composition * (b - a) );
}
offset++;
st_offset++;
}
sti += st_x_stride;
if (sti >= st_width)
{
sti -= st_width;
}
}
stj += st_y_stride;
if (stj >= st_height)
{
stj -= st_height;
}
}
texturep->setSubImage(raw, tex_x_begin, tex_y_begin, tex_x_end - tex_x_begin, tex_y_end - tex_y_begin);
LLSurface::sTextureUpdateTime += gen_timer.getElapsedTimeF32();
LLSurface::sTexelsUpdated += (tex_x_end - tex_x_begin) * (tex_y_end - tex_y_begin);
for (S32 i = 0; i < 4; i++)
{
// Un-boost detatil textures (will get re-boosted if rendering in high detail)
mDetailTextures[i]->setBoostLevel(LLViewerImageBoostLevel::BOOST_NONE);
mDetailTextures[i]->setMinDiscardLevel(MAX_DISCARD_LEVEL + 1);
}
return TRUE;
}
void render_disconnected_background()
{
if (!gDisconnectedImagep && gDisconnected)
{
llinfos << "Loading last bitmap..." << llendl;
std::string temp_str;
temp_str = gDirUtilp->getLindenUserDir() + gDirUtilp->getDirDelimiter() + SCREEN_LAST_FILENAME;
LLPointer<LLImageBMP> image_bmp = new LLImageBMP;
if( !image_bmp->load(temp_str) )
{
//llinfos << "Bitmap load failed" << llendl;
return;
}
LLPointer<LLImageRaw> raw = new LLImageRaw;
if (!image_bmp->decode(raw, 0.0f))
{
llinfos << "Bitmap decode failed" << llendl;
gDisconnectedImagep = NULL;
return;
}
U8 *rawp = raw->getData();
S32 npixels = (S32)image_bmp->getWidth()*(S32)image_bmp->getHeight();
for (S32 i = 0; i < npixels; i++)
{
S32 sum = 0;
sum = *rawp + *(rawp+1) + *(rawp+2);
sum /= 3;
*rawp = ((S32)sum*6 + *rawp)/7;
rawp++;
*rawp = ((S32)sum*6 + *rawp)/7;
rawp++;
*rawp = ((S32)sum*6 + *rawp)/7;
rawp++;
}
raw->expandToPowerOfTwo();
gDisconnectedImagep = LLViewerTextureManager::getLocalTexture(raw.get(), FALSE );
gStartTexture = gDisconnectedImagep;
}
// Make sure the progress view always fills the entire window.
S32 width = gViewerWindow->getWindowWidthScaled();
S32 height = gViewerWindow->getWindowHeightScaled();
if (gDisconnectedImagep)
{
if (LLGLSLShader::sNoFixedFunction)
{
gUIProgram.bind();
}
LLGLSUIDefault gls_ui;
gViewerWindow->setup2DRender();
gGL.pushMatrix();
{
// scale ui to reflect UIScaleFactor
// this can't be done in setup2DRender because it requires a
// pushMatrix/popMatrix pair
const LLVector2& display_scale = gViewerWindow->getDisplayScale();
gGL.scalef(display_scale.mV[VX], display_scale.mV[VY], 1.f);
gGL.getTexUnit(0)->bind(gDisconnectedImagep);
gGL.color4f(1.f, 1.f, 1.f, 1.f);
gl_rect_2d_simple_tex(width, height);
gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
}
gGL.popMatrix();
gGL.flush();
if (LLGLSLShader::sNoFixedFunction)
{
gUIProgram.unbind();
}
}
}