livie
/
phoenix-firestorm
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Pull merge from lindenlab/viewer-release

master
Merov Linden 2014-12-19 06:00:48 -08:00
parent d0d5a6a15c 4ec9bce3c2
commit b0f590f6ab
107 changed files with 3006 additions and 2131 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
.hgtags
View File

@ -493,3 +493,6 @@ bcc2770e21c125e0bab59141c51db9145aec068d 3.7.17-release
2729c1daf0257d68a40bdbc4acf1a16184974bbd 3.7.18-release
82973b38a6c9a457333e3519e4f2b16bb5eedf47 3.7.19-release
27094824773b907c2e559396e6f9ec3a963de52d 3.7.20-release
9ecab4b0c7d8614767724a3422d3c1dca6bd4e4f 3.7.21-release
bc61801f614022c920cb5c3df1d7d67a9561ce1f 3.7.22-release
3be800e1afad9615442159e388d6d137be7b951e 3.7.23-release

4
autobuild.xml
View File

@ -1314,9 +1314,9 @@
<key>archive</key>
<map>
<key>hash</key>
<string>54e46715e72b7805d9d3f84d45b6b1b7</string>
<string>0e15751836ac0492250001b80aea379f</string>
<key>url</key>
<string>http://s3-proxy.lindenlab.com/private-builds-secondlife-com/hg/repo/llappearanceutility-source/rev/290120/arch/Linux/installer/llappearanceutility_source-0.1-linux-20140519.tar.bz2</string>
<string>http://s3-proxy.lindenlab.com/private-builds-secondlife-com/hg/repo/llappearanceutility-source/rev/293888/arch/Linux/installer/llappearanceutility_source-0.1-linux-20140908.tar.bz2</string>
</map>
<key>name</key>
<string>linux</string>

11
doc/contributions.txt
View File

@ -324,6 +324,7 @@ Cinder Roxley
STORM-2035
STORM-2036
STORM-2037
STORM-2053
Clara Young
Coaldust Numbers
VWR-1095
@ -889,6 +890,8 @@ Mm Alder
VWR-4794
VWR-13578
Mo Hax
Moon Metty
STORM-2078
Mourna Biziou
Mr Greggan
VWR-445
@ -993,6 +996,7 @@ Nicky Perian
STORM-1087
STORM-1090
STORM-1828
STORM-2080
Nicoladie Gymnast
NiranV Dean
STORM-2040
@ -1053,6 +1057,12 @@ Peekay Semyorka
VWR-19
VWR-49
VWR-79
Pell Smit
MAINT-4323
STORM-2069
STORM-2070
STORM-2071
STORM-2072
Peter Lameth
VWR-7331
PeterPunk Mooney
@ -1396,6 +1406,7 @@ Whirly Fizzle
MAINT-873
STORM-1930
BUG-6659
STORM-2078
Whoops Babii
VWR-631
VWR-1640

38
indra/llappearance/llavatarappearance.cpp
View File

@ -584,8 +584,6 @@ BOOL LLAvatarAppearance::setupBone(const LLAvatarBoneInfo* info, LLJoint* parent
info->mRot.mV[VZ], LLQuaternion::XYZ));
joint->setScale(info->mScale);
joint->setDefaultFromCurrentXform();
if (info->mIsJoint)
{
joint->setSkinOffset( info->mPivot );
@ -677,6 +675,42 @@ void LLAvatarAppearance::clearSkeleton()
mSkeleton.clear();
}
//------------------------------------------------------------------------
// addPelvisFixup
//------------------------------------------------------------------------
void LLAvatarAppearance::addPelvisFixup( F32 fixup, const LLUUID& mesh_id )
{
LLVector3 pos(0.0,0.0,fixup);
mPelvisFixups.add(mesh_id,pos);
}
//------------------------------------------------------------------------
// addPelvisFixup
//------------------------------------------------------------------------
void LLAvatarAppearance::removePelvisFixup( const LLUUID& mesh_id )
{
mPelvisFixups.remove(mesh_id);
}
//------------------------------------------------------------------------
// hasPelvisFixup
//------------------------------------------------------------------------
bool LLAvatarAppearance::hasPelvisFixup( F32& fixup, LLUUID& mesh_id ) const
{
LLVector3 pos;
if (mPelvisFixups.findActiveOverride(mesh_id,pos))
{
fixup = pos[2];
return true;
}
return false;
}
bool LLAvatarAppearance::hasPelvisFixup( F32& fixup ) const
{
LLUUID mesh_id;
return hasPelvisFixup( fixup, mesh_id );
}
//-----------------------------------------------------------------------------
// LLAvatarAppearance::buildCharacter()
// Deferred initialization and rebuild of the avatar.

8
indra/llappearance/llavatarappearance.h
View File

@ -152,11 +152,17 @@ protected:
BOOL mIsBuilt; // state of deferred character building
typedef std::vector<LLAvatarJoint*> avatar_joint_list_t;
avatar_joint_list_t mSkeleton;
LLPosOverrideMap mPelvisFixups;
//--------------------------------------------------------------------
// Pelvis height adjustment members.
//--------------------------------------------------------------------
public:
void addPelvisFixup( F32 fixup, const LLUUID& mesh_id );
void removePelvisFixup( const LLUUID& mesh_id );
bool hasPelvisFixup( F32& fixup, LLUUID& mesh_id ) const;
bool hasPelvisFixup( F32& fixup ) const;
LLVector3 mBodySize;
LLVector3 mAvatarOffset;
protected:

2
indra/llappearance/llpolyskeletaldistortion.cpp
View File

@ -213,7 +213,7 @@ void LLPolySkeletalDistortion::apply( ESex avatar_sex )
LLVector3 scaleDelta = iter->second;
newScale = newScale + (effective_weight * scaleDelta) - (mLastWeight * scaleDelta);
//An aspect of attached mesh objects (which contain joint offsets) that need to be cleaned up when detached
joint->storeScaleForReset( newScale );
// needed? // joint->storeScaleForReset( newScale );
joint->setScale(newScale);
}

212
indra/llcharacter/lljoint.cpp
View File

@ -36,6 +36,64 @@
S32 LLJoint::sNumUpdates = 0;
S32 LLJoint::sNumTouches = 0;
template <class T>
bool attachment_map_iter_compare_key(const T& a, const T& b)
{
return a.first < b.first;
}
bool LLPosOverrideMap::findActiveOverride(LLUUID& mesh_id, LLVector3& pos) const
{
pos = LLVector3(0,0,0);
mesh_id = LLUUID();
bool found = false;
map_type::const_iterator it = std::max_element(m_map.begin(),
m_map.end(),
attachment_map_iter_compare_key<map_type::value_type>);
if (it != m_map.end())
{
found = true;
pos = it->second;
mesh_id = it->first;
}
return found;
}
void LLPosOverrideMap::showJointPosOverrides( std::ostringstream& os ) const
{
map_type::const_iterator max_it = std::max_element(m_map.begin(),
m_map.end(),
attachment_map_iter_compare_key<map_type::value_type>);
for (map_type::const_iterator it = m_map.begin();
it != m_map.end(); ++it)
{
const LLVector3& pos = it->second;
os << " " << "[" << it->first <<": " << pos << "]" << ((it==max_it) ? "*" : "");
}
}
U32 LLPosOverrideMap::count() const
{
return m_map.size();
}
void LLPosOverrideMap::add(const LLUUID& mesh_id, const LLVector3& pos)
{
m_map[mesh_id] = pos;
}
bool LLPosOverrideMap::remove(const LLUUID& mesh_id)
{
U32 remove_count = m_map.erase(mesh_id);
return (remove_count > 0);
}
void LLPosOverrideMap::clear()
{
m_map.clear();
}
//-----------------------------------------------------------------------------
// LLJoint()
// Class Constructor
@ -48,11 +106,8 @@ void LLJoint::init()
mParent = NULL;
mXform.setScaleChildOffset(TRUE);
mXform.setScale(LLVector3(1.0f, 1.0f, 1.0f));
mOldXform.setScaleChildOffset(TRUE);
mOldXform.setScale(LLVector3(1.0f, 1.0f, 1.0f));
mDirtyFlags = MATRIX_DIRTY | ROTATION_DIRTY | POSITION_DIRTY;
mUpdateXform = TRUE;
mResetAfterRestoreOldXform = false;
}
LLJoint::LLJoint() :
@ -233,52 +288,123 @@ const LLVector3& LLJoint::getPosition()
return mXform.getPosition();
}
bool do_debug_joint(const std::string& name)
{
return true;
}
//--------------------------------------------------------------------
// setPosition()
//--------------------------------------------------------------------
void LLJoint::setPosition( const LLVector3& pos )
{
if (pos != getPosition())
{
if (do_debug_joint(getName()))
{
LL_DEBUGS("Avatar") << " joint " << getName() << " set pos " << pos << LL_ENDL;
}
}
mXform.setPosition(pos);
touch(MATRIX_DIRTY | POSITION_DIRTY);
}
//--------------------------------------------------------------------
// setPosition()
//--------------------------------------------------------------------
void LLJoint::setDefaultFromCurrentXform( void )
{
mDefaultXform = mXform;
}
//--------------------------------------------------------------------
// storeCurrentXform()
//--------------------------------------------------------------------
void LLJoint::storeCurrentXform( const LLVector3& pos )
{
mOldXform = mXform;
mResetAfterRestoreOldXform = true;
setPosition( pos );
touch(ALL_DIRTY);
}
//--------------------------------------------------------------------
// storeScaleForReset()
//--------------------------------------------------------------------
void LLJoint::storeScaleForReset( const LLVector3& scale )
void showJointPosOverrides( const LLJoint& joint, const std::string& note, const std::string& av_info )
{
mOldXform.setScale( scale );
std::ostringstream os;
os << joint.m_posBeforeOverrides;
joint.m_attachmentOverrides.showJointPosOverrides(os);
LL_DEBUGS("Avatar") << av_info << " joint " << joint.getName() << " " << note << " " << os.str() << LL_ENDL;
}
//--------------------------------------------------------------------
// restoreOldXform()
// addAttachmentPosOverride()
//--------------------------------------------------------------------
void LLJoint::restoreOldXform( void )
{
mXform = mDefaultXform;
mResetAfterRestoreOldXform = false;
mDirtyFlags = ALL_DIRTY;
void LLJoint::addAttachmentPosOverride( const LLVector3& pos, const LLUUID& mesh_id, const std::string& av_info )
{
if (mesh_id.isNull())
{
return;
}
if (!m_attachmentOverrides.count())
{
if (do_debug_joint(getName()))
{
LL_DEBUGS("Avatar") << "av " << av_info << " joint " << getName() << " saving m_posBeforeOverrides " << getPosition() << LL_ENDL;
}
m_posBeforeOverrides = getPosition();
}
m_attachmentOverrides.add(mesh_id,pos);
if (do_debug_joint(getName()))
{
LL_DEBUGS("Avatar") << "av " << av_info << " joint " << getName() << " addAttachmentPosOverride for mesh " << mesh_id << " pos " << pos << LL_ENDL;
}
updatePos(av_info);
}
//--------------------------------------------------------------------
// removeAttachmentPosOverride()
//--------------------------------------------------------------------
void LLJoint::removeAttachmentPosOverride( const LLUUID& mesh_id, const std::string& av_info )
{
if (mesh_id.isNull())
{
return;
}
if (m_attachmentOverrides.remove(mesh_id))
{
if (do_debug_joint(getName()))
{
LL_DEBUGS("Avatar") << "av " << av_info << " joint " << getName()
<< " removeAttachmentPosOverride for " << mesh_id << LL_ENDL;
showJointPosOverrides(*this, "remove", av_info);
}
updatePos(av_info);
}
}
//--------------------------------------------------------------------
// hasAttachmentPosOverride()
//--------------------------------------------------------------------
bool LLJoint::hasAttachmentPosOverride( LLVector3& pos, LLUUID& mesh_id ) const
{
return m_attachmentOverrides.findActiveOverride(mesh_id,pos);
}
//--------------------------------------------------------------------
// clearAttachmentPosOverrides()
//--------------------------------------------------------------------
void LLJoint::clearAttachmentPosOverrides()
{
if (m_attachmentOverrides.count())
{
m_attachmentOverrides.clear();
setPosition(m_posBeforeOverrides);
setId( LLUUID::null );
}
}
//--------------------------------------------------------------------
// updatePos()
//--------------------------------------------------------------------
void LLJoint::updatePos(const std::string& av_info)
{
LLVector3 pos, found_pos;
LLUUID mesh_id;
if (m_attachmentOverrides.findActiveOverride(mesh_id,found_pos))
{
LL_DEBUGS("Avatar") << "av " << av_info << " joint " << getName() << " updatePos, winner of " << m_attachmentOverrides.count() << " is mesh " << mesh_id << " pos " << found_pos << LL_ENDL;
pos = found_pos;
}
else
{
LL_DEBUGS("Avatar") << "av " << av_info << " joint " << getName() << " updatePos, winner is posBeforeOverrides " << m_posBeforeOverrides << LL_ENDL;
pos = m_posBeforeOverrides;
}
setPosition(pos);
}
//--------------------------------------------------------------------
// getWorldPosition()
//--------------------------------------------------------------------
@ -325,7 +451,7 @@ void LLJoint::setWorldPosition( const LLVector3& pos )
//--------------------------------------------------------------------
// mXform.getRotation()
// getRotation()
//--------------------------------------------------------------------
const LLQuaternion& LLJoint::getRotation()
{
@ -432,7 +558,7 @@ const LLMatrix4 &LLJoint::getWorldMatrix()
//--------------------------------------------------------------------
void LLJoint::setWorldMatrix( const LLMatrix4& mat )
{
LL_INFOS() << "WARNING: LLJoint::setWorldMatrix() not correctly implemented yet" << LL_ENDL;
LL_INFOS() << "WARNING: LLJoint::setWorldMatrix() not correctly implemented yet" << LL_ENDL;
// extract global translation
LLVector3 trans( mat.mMatrix[VW][VX],
mat.mMatrix[VW][VY],
@ -548,20 +674,6 @@ void LLJoint::clampRotation(LLQuaternion old_rot, LLQuaternion new_rot)
break;
}
}
// 2003.03.26 - This code was just using up cpu cycles. AB
// LLVector3 old_axis = main_axis * old_rot;
// LLVector3 new_axis = main_axis * new_rot;
// for (S32 i = 0; i < mConstraintSilhouette.size() - 1; i++)
// {
// LLVector3 vert1 = mConstraintSilhouette[i];
// LLVector3 vert2 = mConstraintSilhouette[i + 1];
// figure out how to clamp rotation to line on 3-sphere
// }
}
// End

40
indra/llcharacter/lljoint.h
View File

@ -46,6 +46,21 @@ const U32 LL_FACE_JOINT_NUM = 30;
const S32 LL_CHARACTER_MAX_PRIORITY = 7;
const F32 LL_MAX_PELVIS_OFFSET = 5.f;
class LLPosOverrideMap
{
public:
LLPosOverrideMap() {}
bool findActiveOverride(LLUUID& mesh_id, LLVector3& pos) const;
void showJointPosOverrides(std::ostringstream& os) const;
U32 count() const;
void add(const LLUUID& mesh_id, const LLVector3& pos);
bool remove(const LLUUID& mesh_id);
void clear();
private:
typedef std::map<LLUUID,LLVector3> map_type;
map_type m_map;
};
//-----------------------------------------------------------------------------
// class LLJoint
//-----------------------------------------------------------------------------
@ -79,8 +94,6 @@ protected:
// explicit transformation members
LLXformMatrix mXform;
LLXformMatrix mOldXform;
LLXformMatrix mDefaultXform;
LLUUID mId;
@ -88,8 +101,6 @@ public:
U32 mDirtyFlags;
BOOL mUpdateXform;
BOOL mResetAfterRestoreOldXform;
// describes the skin binding pose
LLVector3 mSkinOffset;
@ -103,6 +114,11 @@ public:
static S32 sNumTouches;
static S32 sNumUpdates;
LLPosOverrideMap m_attachmentOverrides;
LLVector3 m_posBeforeOverrides;
void updatePos(const std::string& av_info);
public:
LLJoint();
LLJoint(S32 joint_num);
@ -160,7 +176,7 @@ public:
// get/set local scale
const LLVector3& getScale();
void setScale( const LLVector3& scale );
void storeScaleForReset( const LLVector3& scale );
// get/set world matrix
const LLMatrix4 &getWorldMatrix();
void setWorldMatrix( const LLMatrix4& mat );
@ -183,20 +199,16 @@ public:
virtual BOOL isAnimatable() const { return TRUE; }
S32 getJointNum() const { return mJointNum; }
void restoreOldXform( void );
void setDefaultFromCurrentXform( void );
void storeCurrentXform( const LLVector3& pos );
void addAttachmentPosOverride( const LLVector3& pos, const LLUUID& mesh_id, const std::string& av_info );
void removeAttachmentPosOverride( const LLUUID& mesh_id, const std::string& av_info );
bool hasAttachmentPosOverride( LLVector3& pos, LLUUID& mesh_id ) const;
void clearAttachmentPosOverrides();
//Accessor for the joint id
LLUUID getId( void ) { return mId; }
//Setter for the joints id
void setId( const LLUUID& id ) { mId = id;}
//If the old transform flag has been set, then the reset logic in avatar needs to be aware(test) of it
const BOOL doesJointNeedToBeReset( void ) const { return mResetAfterRestoreOldXform; }
void setJointResetFlag( bool val ) { mResetAfterRestoreOldXform = val; }
};
#endif // LL_LLJOINT_H

2
indra/llimage/llimagefilter.cpp
View File

@ -266,7 +266,7 @@ void LLImageFilter::executeFilter(LLPointer<LLImageRaw> raw_image)
}
else
{
llwarns << "Filter unknown, cannot execute filter command : " << filter_name << llendl;
LL_WARNS() << "Filter unknown, cannot execute filter command : " << filter_name << LL_ENDL;
}
}
}

18
indra/llmath/llquaternion.h
View File

@ -71,6 +71,9 @@ public:
void quantize8(F32 lower, F32 upper); // changes the vector to reflect quatization
void loadIdentity(); // Loads the quaternion that represents the identity rotation
bool isEqualEps(const LLQuaternion &quat, F32 epsilon) const;
bool isNotEqualEps(const LLQuaternion &quat, F32 epsilon) const;
const LLQuaternion& set(F32 x, F32 y, F32 z, F32 w); // Sets Quaternion to normalize(x, y, z, w)
const LLQuaternion& set(const LLQuaternion &quat); // Copies Quaternion
const LLQuaternion& set(const F32 *q); // Sets Quaternion to normalize(quat[VX], quat[VY], quat[VZ], quat[VW])
@ -239,6 +242,21 @@ inline void LLQuaternion::loadIdentity()
mQ[VW] = 1.0f;
}
inline bool LLQuaternion::isEqualEps(const LLQuaternion &quat, F32 epsilon) const
{
return ( fabs(mQ[VX] - quat.mQ[VX]) < epsilon
&& fabs(mQ[VY] - quat.mQ[VY]) < epsilon
&& fabs(mQ[VZ] - quat.mQ[VZ]) < epsilon
&& fabs(mQ[VS] - quat.mQ[VS]) < epsilon );
}
inline bool LLQuaternion::isNotEqualEps(const LLQuaternion &quat, F32 epsilon) const
{
return ( fabs(mQ[VX] - quat.mQ[VX]) > epsilon
|| fabs(mQ[VY] - quat.mQ[VY]) > epsilon
|| fabs(mQ[VZ] - quat.mQ[VZ]) > epsilon
|| fabs(mQ[VS] - quat.mQ[VS]) > epsilon );
}
inline const LLQuaternion& LLQuaternion::set(F32 x, F32 y, F32 z, F32 w)
{

20
indra/llprimitive/llmodel.cpp
View File

@ -172,7 +172,7 @@ LLModel::EModelStatus load_face_from_dom_triangles(std::vector<LLVolumeFace>& fa
if (!pos_source)
{
llwarns << "Unable to process mesh without position data; invalid model; invalid model." << llendl;
LL_WARNS() << "Unable to process mesh without position data; invalid model; invalid model." << LL_ENDL;
return LLModel::BAD_ELEMENT;
}
@ -180,20 +180,20 @@ LLModel::EModelStatus load_face_from_dom_triangles(std::vector<LLVolumeFace>& fa
domListOfUInts& idx = p->getValue();
domListOfFloats dummy ;
domListOfFloats& v = pos_source ? pos_source->getFloat_array()->getValue() : dummy ;
domListOfFloats& tc = tc_source ? tc_source->getFloat_array()->getValue() : dummy ;
domListOfFloats& n = norm_source ? norm_source->getFloat_array()->getValue() : dummy ;
domListOfFloats& v = (pos_source && pos_source->getFloat_array()) ? pos_source->getFloat_array()->getValue() : dummy ;
domListOfFloats& tc = (tc_source && tc_source->getFloat_array()) ? tc_source->getFloat_array()->getValue() : dummy ;
domListOfFloats& n = (norm_source && norm_source->getFloat_array()) ? norm_source->getFloat_array()->getValue() : dummy ;
LLVolumeFace::VertexMapData::PointMap point_map;
U32 index_count = idx.getCount();
U32 vertex_count = pos_source ? v.getCount() : 0;
U32 tc_count = tc_source ? tc.getCount() : 0;
U32 norm_count = norm_source ? n.getCount() : 0;
U32 vertex_count = (pos_source && pos_source->getFloat_array()) ? v.getCount() : 0;
U32 tc_count = (tc_source && tc_source->getFloat_array()) ? tc.getCount() : 0;
U32 norm_count = (norm_source && norm_source->getFloat_array()) ? n.getCount(): 0;
if ((vertex_count == 0) || (tc_count == 0))
if ((vertex_count == 0))
{
llwarns << "Unable to process mesh with empty position array; invalid model." << llendl;
LL_WARNS() << "Unable to process mesh with empty position array; invalid model." << LL_ENDL;
return LLModel::BAD_ELEMENT;
}
@ -229,7 +229,7 @@ LLModel::EModelStatus load_face_from_dom_triangles(std::vector<LLVolumeFace>& fa
{
// guard against model data specifiying out of range indices or tcs
//
if (((i + tc_offset) > index_count)
|| ((idx[i+tc_offset]*2+1) > tc_count))
{

1956
indra/llrender/llglslshader.cpp
View File

File diff suppressed because it is too large Load Diff

2
indra/llrender/llrender.cpp
View File

@ -1168,7 +1168,7 @@ void LLRender::syncMatrices()
{
stop_glerror();
U32 name[] =
static const U32 name[] =
{
LLShaderMgr::MODELVIEW_MATRIX,
LLShaderMgr::PROJECTION_MATRIX,

13
indra/llrender/llshadermgr.cpp
View File

@ -674,12 +674,17 @@ GLhandleARB LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shade
if (defines)
{
for (boost::unordered_map<std::string,std::string>::iterator iter = defines->begin(); iter != defines->end(); ++iter)
{
std::string define = "#define " + iter->first + " " + iter->second + "\n";
text[count++] = (GLcharARB *) strdup(define.c_str());
}
{
std::string define = "#define " + iter->first + " " + iter->second + "\n";
text[count++] = (GLcharARB *) strdup(define.c_str());
}
}
if( gGLManager.mIsATI )
{
text[ count++ ] = strdup( "#define IS_AMD_CARD 1\n" );
}
if (texture_index_channels > 0 && type == GL_FRAGMENT_SHADER_ARB)
{
//use specified number of texture channels for indexed texture rendering

6
indra/llrender/llvertexbuffer.cpp
View File

@ -843,9 +843,11 @@ void LLVertexBuffer::drawArrays(U32 mode, U32 first, U32 count) const
{
LL_RECORD_BLOCK_TIME(FTM_GL_DRAW_ARRAYS);
stop_glerror();
LLGLSLShader::startProfile();
LLGLSLShader::startProfile();
stop_glerror();
glDrawArrays(sGLMode[mode], first, count);
LLGLSLShader::stopProfile(count, mode);
stop_glerror();
LLGLSLShader::stopProfile(count, mode);
}
stop_glerror();

21
indra/llui/llfolderviewitem.cpp
View File

@ -260,20 +260,19 @@ BOOL LLFolderViewItem::passedFilter(S32 filter_generation)
BOOL LLFolderViewItem::isPotentiallyVisible(S32 filter_generation)
{
// Item should be visible if:
// 1. item passed current filter
// 2. item was updated (gen < 0) but has descendants that passed filter
// 3. item was recently updated and was visible before update
if (filter_generation < 0)
{
filter_generation = getFolderViewModel()->getFilter().getFirstSuccessGeneration();
}
LLFolderViewModelItem* model = getViewModelItem();
if (model->getLastFilterGeneration() < 0 && !getFolderViewModel()->getFilter().isModified())
BOOL visible = model->passedFilter(filter_generation);
if (model->getMarkedDirtyGeneration() >= filter_generation)
{
return model->descendantsPassedFilter(filter_generation) || getVisible();
}
else
{
return model->passedFilter(filter_generation);
// unsure visibility state
// retaining previous visibility until item is updated or filter generation changes
visible |= getVisible();
}
return visible;
}
void LLFolderViewItem::refresh()

26
indra/llui/llfolderviewmodel.h
View File

@ -187,11 +187,13 @@ public:
virtual void setPassedFilter(bool passed, S32 filter_generation, std::string::size_type string_offset = std::string::npos, std::string::size_type string_size = 0) = 0;
virtual void setPassedFolderFilter(bool passed, S32 filter_generation) = 0;
virtual void dirtyFilter() = 0;
virtual void dirtyDescendantsFilter() = 0;
virtual bool hasFilterStringMatch() = 0;
virtual std::string::size_type getFilterStringOffset() = 0;
virtual std::string::size_type getFilterStringSize() = 0;
virtual S32 getLastFilterGeneration() const = 0;
virtual S32 getMarkedDirtyGeneration() const = 0;
virtual bool hasChildren() const = 0;
virtual void addChild(LLFolderViewModelItem* child) = 0;
@ -232,6 +234,7 @@ public:
mFolderViewItem(NULL),
mLastFilterGeneration(-1),
mLastFolderFilterGeneration(-1),
mMarkedDirtyGeneration(-1),
mMostFilteredDescendantGeneration(-1),
mParent(NULL),
mRootViewModel(root_view_model)
@ -245,8 +248,13 @@ public:
S32 getLastFilterGeneration() const { return mLastFilterGeneration; }
S32 getLastFolderFilterGeneration() const { return mLastFolderFilterGeneration; }
S32 getMarkedDirtyGeneration() const { return mMarkedDirtyGeneration; }
void dirtyFilter()
{
if(mMarkedDirtyGeneration < 0)
{
mMarkedDirtyGeneration = mLastFilterGeneration;
}
mLastFilterGeneration = -1;
mLastFolderFilterGeneration = -1;
@ -256,6 +264,14 @@ public:
mParent->dirtyFilter();
}
}
void dirtyDescendantsFilter()
{
mMostFilteredDescendantGeneration = -1;
if (mParent)
{
mParent->dirtyDescendantsFilter();
}
}
bool hasFilterStringMatch();
std::string::size_type getFilterStringOffset();
std::string::size_type getFilterStringSize();
@ -274,7 +290,7 @@ public:
return;
}
}
mChildren.push_back(child);
mChildren.push_back(child);
child->setParent(this);
dirtyFilter();
requestSort();
@ -282,7 +298,8 @@ public:
virtual void removeChild(LLFolderViewModelItem* child)
{
mChildren.remove(child);
child->setParent(NULL);
child->setParent(NULL);
dirtyDescendantsFilter();
dirtyFilter();
}
@ -292,6 +309,7 @@ public:
// This is different and not equivalent to calling removeChild() on each child
std::for_each(mChildren.begin(), mChildren.end(), DeletePointer());
mChildren.clear();
dirtyDescendantsFilter();
dirtyFilter();
}
@ -305,6 +323,7 @@ public:
mLastFilterGeneration = filter_generation;
mStringMatchOffsetFilter = string_offset;
mStringFilterSize = string_size;
mMarkedDirtyGeneration = -1;
}
void setPassedFolderFilter(bool passed, S32 filter_generation)
@ -353,7 +372,8 @@ protected:
S32 mLastFilterGeneration,
mLastFolderFilterGeneration,
mMostFilteredDescendantGeneration;
mMostFilteredDescendantGeneration,
mMarkedDirtyGeneration;
child_list_t mChildren;
LLFolderViewModelItem* mParent;

8
indra/llui/llkeywords.cpp
View File

@ -505,7 +505,7 @@ void LLKeywords::findSegments(std::vector<LLTextSegmentPtr>* seg_list, const LLW
}
// Skip white space
while( *cur && isspace(*cur) && (*cur != '\n') )
while( *cur && iswspace(*cur) && (*cur != '\n') )
{
cur++;
}
@ -548,7 +548,7 @@ void LLKeywords::findSegments(std::vector<LLTextSegmentPtr>* seg_list, const LLW
}
// Skip white space
while( *cur && isspace(*cur) && (*cur != '\n') )
while( *cur && iswspace(*cur) && (*cur != '\n') )
{
cur++;
}
@ -655,10 +655,10 @@ void LLKeywords::findSegments(std::vector<LLTextSegmentPtr>* seg_list, const LLW
// check against words
llwchar prev = cur > base ? *(cur-1) : 0;
if( !isalnum( prev ) && (prev != '_') )
if( !iswalnum( prev ) && (prev != '_') )
{
const llwchar* p = cur;
while( isalnum( *p ) || (*p == '_') )
while( iswalnum( *p ) || (*p == '_') )
{
p++;
}

15
indra/llui/llmenugl.cpp
View File

@ -1276,7 +1276,15 @@ void LLMenuItemBranchGL::openMenu()
{
// open upwards if menu extends past bottom
// adjust by the height of the menu item branch since it is a submenu
delta_y = branch_rect.getHeight() - getRect().getHeight();
if (y + 2 * branch_rect.getHeight() - getRect().getHeight() > menu_region_rect.mTop)
{
// overlaps with top border, align with top
delta_y = menu_region_rect.mTop - y - branch_rect.getHeight();
}
else
{
delta_y = branch_rect.getHeight() - getRect().getHeight();
}
}
if( x + branch_rect.getWidth() > menu_region_rect.mRight )
@ -3258,6 +3266,11 @@ void LLMenuGL::showPopup(LLView* spawning_view, LLMenuGL* menu, S32 x, S32 y)
CURSOR_WIDTH + MOUSE_CURSOR_PADDING * 2,
CURSOR_HEIGHT + MOUSE_CURSOR_PADDING * 2);
menu->translateIntoRectWithExclusion( menu_region_rect, mouse_rect );
if (menu->getRect().mTop > menu_region_rect.mTop)
{
// not enough space: align with top, ignore exclusion
menu->translateIntoRect( menu_region_rect );
}
menu->getParent()->sendChildToFront(menu);
}

2
indra/llui/llstatbar.cpp
View File

@ -638,7 +638,7 @@ void LLStatBar::drawLabelAndValue( F32 value, std::string &label, LLRect &bar_re
void LLStatBar::drawTicks( F32 min, F32 max, F32 value_scale, LLRect &bar_rect )
{
if (mAutoScaleMax || mAutoScaleMin)
if (!llisnan(min) && (mAutoScaleMax || mAutoScaleMin))
{
F32 u = LLSmoothInterpolation::getInterpolant(10.f);
mFloatingTargetMinBar = llmin(min, lerp(mFloatingTargetMinBar, min, u));

6
indra/llui/llurlentry.cpp
View File

@ -178,6 +178,12 @@ bool LLUrlEntryBase::isLinkDisabled() const
return globally_disabled;
}
bool LLUrlEntryBase::isWikiLinkCorrect(std::string url)
{
std::string label = getLabelFromWikiLink(url);
return (LLUrlRegistry::instance().hasUrl(label)) ? false : true;
}
static std::string getStringAfterToken(const std::string str, const std::string token)
{
size_t pos = str.find(token);

2
indra/llui/llurlentry.h
View File

@ -100,6 +100,8 @@ public:
bool isLinkDisabled() const;
bool isWikiLinkCorrect(std::string url);
protected:
std::string getIDStringFromUrl(const std::string &url) const;
std::string escapeUrl(const std::string &url) const;

20
indra/llui/llurlregistry.cpp
View File

@ -45,7 +45,8 @@ LLUrlRegistry::LLUrlRegistry()
registerUrl(mUrlEntryIcon);
registerUrl(new LLUrlEntrySLURL());
registerUrl(new LLUrlEntryHTTP());
registerUrl(new LLUrlEntryHTTPLabel());
mUrlEntryHTTPLabel = new LLUrlEntryHTTPLabel();
registerUrl(mUrlEntryHTTPLabel);
registerUrl(new LLUrlEntryAgentCompleteName());
registerUrl(new LLUrlEntryAgentDisplayName());
registerUrl(new LLUrlEntryAgentUserName());
@ -64,7 +65,8 @@ LLUrlRegistry::LLUrlRegistry()
//LLUrlEntrySL and LLUrlEntrySLLabel have more common pattern,
//so it should be registered in the end of list
registerUrl(new LLUrlEntrySL());
registerUrl(new LLUrlEntrySLLabel());
mUrlEntrySLLabel = new LLUrlEntrySLLabel();
registerUrl(mUrlEntrySLLabel);
// most common pattern is a URL without any protocol,
// e.g., "secondlife.com"
registerUrl(new LLUrlEntryHTTPNoProtocol());
@ -128,6 +130,11 @@ static bool matchRegex(const char *text, boost::regex regex, U32 &start, U32 &en
end--;
}
else if (text[end] == ']' && std::string(text+start, end-start).find('[') == std::string::npos)
{
end--;
}
return true;
}
@ -175,6 +182,15 @@ bool LLUrlRegistry::findUrl(const std::string &text, LLUrlMatch &match, const LL
// does this match occur in the string before any other match
if (start < match_start || match_entry == NULL)
{
if((mUrlEntryHTTPLabel == *it) || (mUrlEntrySLLabel == *it))
{
if(url_entry && !url_entry->isWikiLinkCorrect(text.substr(start, end - start + 1)))
{
continue;
}
}
match_start = start;
match_end = end;
match_entry = url_entry;

2
indra/llui/llurlregistry.h
View File

@ -94,6 +94,8 @@ private:
std::vector<LLUrlEntryBase *> mUrlEntry;
LLUrlEntryBase* mUrlEntryIcon;
LLUrlEntryBase* mUrlEntryHTTPLabel;
LLUrlEntryBase* mUrlEntrySLLabel;
};
#endif

2
indra/llui/llview.cpp
View File

@ -885,7 +885,7 @@ BOOL LLView::handleKey(KEY key, MASK mask, BOOL called_from_parent)
handled = handleKeyHere( key, mask );
if (handled)
{
LL_WARNS() << "Key handled by " << getName() << LL_ENDL;
LL_DEBUGS() << "Key handled by " << getName() << LL_ENDL;
}
}
}

1
indra/llwindow/llopenglview-objc.h
View File

@ -79,6 +79,7 @@
@interface LLNonInlineTextView : NSTextView
{
LLOpenGLView *glview;
unichar mKeyPressed;
}
- (void) setGLView:(LLOpenGLView*)view;

207
indra/llwindow/llopenglview-objc.mm
View File

@ -104,26 +104,34 @@ attributedStringInfo getSegments(NSAttributedString *str)
- (unsigned long)getVramSize
{
CGLRendererInfoObj info = 0;
GLint vram_bytes = 0;
GLint vram_mbytes = 0;
int num_renderers = 0;
CGLError the_err = CGLQueryRendererInfo (CGDisplayIDToOpenGLDisplayMask(kCGDirectMainDisplay), &info, &num_renderers);
if(0 == the_err)
{
CGLDescribeRenderer (info, 0, kCGLRPTextureMemory, &vram_bytes);
CGLDescribeRenderer (info, 0, kCGLRPTextureMemoryMegabytes, &vram_mbytes);
CGLDestroyRendererInfo (info);
}
else
{
vram_bytes = (256 << 20);
vram_mbytes = 256;
}
return (unsigned long)vram_bytes / 1048576; // We need this in megabytes.
return (unsigned long)vram_mbytes;
}
- (void)viewDidMoveToWindow
{
[[NSNotificationCenter defaultCenter] addObserver:self
selector:@selector(windowResized:) name:NSWindowDidResizeNotification
object:[self window]];
[[NSNotificationCenter defaultCenter] addObserver:self
selector:@selector(windowWillMiniaturize:) name:NSWindowWillMiniaturizeNotification
object:[self window]];
[[NSNotificationCenter defaultCenter] addObserver:self
selector:@selector(windowDidDeminiaturize:) name:NSWindowDidDeminiaturizeNotification
object:[self window]];
}
@ -141,6 +149,16 @@ attributedStringInfo getSegments(NSAttributedString *str)
}
}
- (void)windowWillMiniaturize:(NSNotification *)notification;
{
callWindowHide();
}
- (void)windowDidDeminiaturize:(NSNotification *)notification;
{
callWindowUnhide();
}
- (void)dealloc
{
[[NSNotificationCenter defaultCenter] removeObserver:self];
@ -270,14 +288,14 @@ attributedStringInfo getSegments(NSAttributedString *str)
!([theEvent modifierFlags] & NSFunctionKeyMask) &&
!([theEvent modifierFlags] & NSHelpKeyMask))
{
callRightMouseDown(mMousePos, mModifiers);
callRightMouseDown(mMousePos, [theEvent modifierFlags]);
mSimulatedRightClick = true;
} else {
if ([theEvent clickCount] >= 2)
{
callDoubleClick(mMousePos, mModifiers);
callDoubleClick(mMousePos, [theEvent modifierFlags]);
} else if ([theEvent clickCount] == 1) {
callLeftMouseDown(mMousePos, mModifiers);
callLeftMouseDown(mMousePos, [theEvent modifierFlags]);
}
}
}
@ -286,21 +304,21 @@ attributedStringInfo getSegments(NSAttributedString *str)
{
if (mSimulatedRightClick)
{
callRightMouseUp(mMousePos, mModifiers);
callRightMouseUp(mMousePos, [theEvent modifierFlags]);
mSimulatedRightClick = false;
} else {
callLeftMouseUp(mMousePos, mModifiers);
callLeftMouseUp(mMousePos, [theEvent modifierFlags]);
}
}
- (void) rightMouseDown:(NSEvent *)theEvent
{
callRightMouseDown(mMousePos, mModifiers);
callRightMouseDown(mMousePos, [theEvent modifierFlags]);
}
- (void) rightMouseUp:(NSEvent *)theEvent
{
callRightMouseUp(mMousePos, mModifiers);
callRightMouseUp(mMousePos, [theEvent modifierFlags]);
}
- (void)mouseMoved:(NSEvent *)theEvent
@ -341,17 +359,22 @@ attributedStringInfo getSegments(NSAttributedString *str)
- (void) otherMouseDown:(NSEvent *)theEvent
{
callMiddleMouseDown(mMousePos, mModifiers);
callMiddleMouseDown(mMousePos, [theEvent modifierFlags]);
}
- (void) otherMouseUp:(NSEvent *)theEvent
{
callMiddleMouseUp(mMousePos, mModifiers);
callMiddleMouseUp(mMousePos, [theEvent modifierFlags]);
}
- (void) rightMouseDragged:(NSEvent *)theEvent
{
[self mouseDragged:theEvent];
}
- (void) otherMouseDragged:(NSEvent *)theEvent
{
[self mouseDragged:theEvent];
}
- (void) scrollWheel:(NSEvent *)theEvent
@ -366,22 +389,27 @@ attributedStringInfo getSegments(NSAttributedString *str)
- (void) keyUp:(NSEvent *)theEvent
{
callKeyUp([theEvent keyCode], mModifiers);
callKeyUp([theEvent keyCode], [theEvent modifierFlags]);
}
- (void) keyDown:(NSEvent *)theEvent
{
uint keycode = [theEvent keyCode];
// We must not depend on flagsChange event to detect modifier flags changed,
// must depend on the modifire flags in the event parameter.
// Because flagsChange event handler misses event when other window is activated,
// e.g. OS Window for upload something or Input Window...
// mModifiers instance variable is for insertText: or insertText:replacementRange: (by Pell Smit)
mModifiers = [theEvent modifierFlags];
bool acceptsText = mHasMarkedText ? false : callKeyDown(keycode, mModifiers);
unichar ch;
if (acceptsText &&
!mMarkedTextAllowed &&
!(mModifiers & (NSControlKeyMask | NSCommandKeyMask)) && // commands don't invoke InputWindow
![(LLAppDelegate*)[NSApp delegate] romanScript] &&
[[theEvent charactersIgnoringModifiers] characterAtIndex:0] != NSDeleteCharacter &&
[[theEvent charactersIgnoringModifiers] characterAtIndex:0] != NSBackspaceCharacter &&
[[theEvent charactersIgnoringModifiers] characterAtIndex:0] != NSDownArrowFunctionKey &&
[[theEvent charactersIgnoringModifiers] characterAtIndex:0] != NSUpArrowFunctionKey &&
[[theEvent charactersIgnoringModifiers] characterAtIndex:0] != NSLeftArrowFunctionKey &&
[[theEvent charactersIgnoringModifiers] characterAtIndex:0] != NSRightArrowFunctionKey)
(ch = [[theEvent charactersIgnoringModifiers] characterAtIndex:0]) > ' ' &&
ch != NSDeleteCharacter &&
(ch < 0xF700 || ch > 0xF8FF)) // 0xF700-0xF8FF: reserved for function keys on the keyboard(from NSEvent.h)
{
[(LLAppDelegate*)[NSApp delegate] showInputWindow:true withEvent:theEvent];
} else
@ -498,31 +526,58 @@ attributedStringInfo getSegments(NSAttributedString *str)
- (void)setMarkedText:(id)aString selectedRange:(NSRange)selectedRange replacementRange:(NSRange)replacementRange
{
if ([aString class] == NSClassFromString(@"NSConcreteMutableAttributedString"))
// Apple says aString can be either an NSString or NSAttributedString instance.
// But actually it's NSConcreteMutableAttributedString or __NSCFConstantString.
// I observed aString was __NSCFConstantString only aString was null string(zero length).
// Apple also says when aString is an NSString object,
// the receiver is expected to render the marked text with distinguishing appearance.
// So I tried to make attributedStringInfo, but it won't be used... (Pell Smit)
if (mMarkedTextAllowed)
{
if (mMarkedTextAllowed)
unsigned int selected[2] = {
selectedRange.location,
selectedRange.length
};
unsigned int replacement[2] = {
replacementRange.location,
replacementRange.length
};
int string_length = [aString length];
unichar text[string_length];
attributedStringInfo segments;
// I used 'respondsToSelector:@selector(string)'
// to judge aString is an attributed string or not.
if ([aString respondsToSelector:@selector(string)])
{
// aString is attibuted
[[aString string] getCharacters:text range:NSMakeRange(0, string_length)];
segments = getSegments((NSAttributedString *)aString);
}
else
{
// aString is not attributed
[aString getCharacters:text range:NSMakeRange(0, string_length)];
segments.seg_lengths.push_back(string_length);
segments.seg_standouts.push_back(true);
}
setMarkedText(text, selected, replacement, string_length, segments);
if (string_length > 0)
{
unsigned int selected[2] = {
selectedRange.location,
selectedRange.length
};
unsigned int replacement[2] = {
replacementRange.location,
replacementRange.length
};
unichar text[[aString length]];
[[aString mutableString] getCharacters:text range:NSMakeRange(0, [aString length])];
attributedStringInfo segments = getSegments((NSAttributedString *)aString);
setMarkedText(text, selected, replacement, [aString length], segments);
mHasMarkedText = TRUE;
mMarkedTextLength = [aString length];
} else {
if (mHasMarkedText)
{
[self unmarkText];
}
mMarkedTextLength = string_length;
}
else
{
// we must clear the marked text when aString is null.
[self unmarkText];
}
} else {
if (mHasMarkedText)
{
[self unmarkText];
}
}
}
@ -641,37 +696,63 @@ attributedStringInfo getSegments(NSAttributedString *str)
@implementation LLNonInlineTextView
/* Input Window is a legacy of 20 century, so we want to remove related classes.
But unfortunately, Viwer web browser has no support for modern inline input,
we need to leave these classes...
We will be back to get rid of Input Window after fixing viewer web browser.
How Input Window should work:
1) Input Window must not be empty.
It must close when it become empty result of edithing.
2) Input Window must not close when it still has input data.
It must keep open user types next char before commit. by Pell Smit
*/
- (void) setGLView:(LLOpenGLView *)view
{
glview = view;
}
- (void) insertText:(id)insertString
- (void)keyDown:(NSEvent *)theEvent
{
[[self inputContext] discardMarkedText];
[self setString:@""];
[_window orderOut:_window];
[self insertText:insertString replacementRange:NSMakeRange(0, [insertString length])];
// mKeyPressed is used later to determine whethere Input Window should close or not
mKeyPressed = [[theEvent charactersIgnoringModifiers] characterAtIndex:0];
// setMarkedText and insertText is called indirectly from inside keyDown: method
[super keyDown:theEvent];
}
// setMarkedText: is called for incomplete input(on the way to conversion).
- (void)setMarkedText:(id)aString selectedRange:(NSRange)selectedRange replacementRange:(NSRange)replacementRange
{
[super setMarkedText:aString selectedRange:selectedRange replacementRange:replacementRange];
if ([aString length] == 0) // this means Input Widow becomes empty
{
[_window orderOut:_window]; // Close this to avoid empty Input Window
}
}
// insertText: is called for inserting commited text.
// There are two ways to be called here:
// a) explicitly commited (must close)
// In case of user typed commit key(usually return key) or delete key or something
// b) automatically commited (must not close)
// In case of user typed next letter after conversion
- (void) insertText:(id)aString replacementRange:(NSRange)replacementRange
{
[glview insertText:aString replacementRange:replacementRange];
}
- (void) insertNewline:(id)sender
{
[[self textStorage] setValue:@""];
[[self inputContext] discardMarkedText];
[[self inputContext] discardMarkedText];
[self setString:@""];
}
- (void)doCommandBySelector:(SEL)aSelector
{
if (aSelector == @selector(insertNewline:))
{
[self insertNewline:self];
}
[glview insertText:aString replacementRange:replacementRange];
if (mKeyPressed == NSEnterCharacter ||
mKeyPressed == NSBackspaceCharacter ||
mKeyPressed == NSTabCharacter ||
mKeyPressed == NSNewlineCharacter ||
mKeyPressed == NSCarriageReturnCharacter ||
mKeyPressed == NSDeleteCharacter ||
(mKeyPressed >= 0xF700 && mKeyPressed <= 0xF8FF))
{
// this is case a) of above comment
[_window orderOut:_window]; // to avoid empty Input Window
}
}
@end

2
indra/llwindow/llwindowmacosx-objc.h
View File

@ -116,6 +116,8 @@ void callScrollMoved(float delta);
void callMouseExit();
void callWindowFocus();
void callWindowUnfocus();
void callWindowHide();
void callWindowUnhide();
void callDeltaUpdate(float *delta, unsigned int mask);
void callMiddleMouseDown(float *pos, unsigned int mask);
void callMiddleMouseUp(float *pos, unsigned int mask);

24
indra/llwindow/llwindowmacosx.cpp
View File

@ -230,7 +230,10 @@ void callFocus()
void callFocusLost()
{
gWindowImplementation->getCallbacks()->handleFocusLost(gWindowImplementation);
if (gWindowImplementation)
{
gWindowImplementation->getCallbacks()->handleFocusLost(gWindowImplementation);
}
}
void callRightMouseDown(float *pos, MASK mask)
@ -349,6 +352,22 @@ void callWindowUnfocus()
gWindowImplementation->getCallbacks()->handleFocusLost(gWindowImplementation);
}
void callWindowHide()
{
if ( gWindowImplementation && gWindowImplementation->getCallbacks() )
{
gWindowImplementation->getCallbacks()->handleActivate(gWindowImplementation, false);
}
}
void callWindowUnhide()
{
if ( gWindowImplementation && gWindowImplementation->getCallbacks() )
{
gWindowImplementation->getCallbacks()->handleActivate(gWindowImplementation, true);
}
}
void callDeltaUpdate(float *delta, MASK mask)
{
gWindowImplementation->updateMouseDeltas(delta);
@ -1805,8 +1824,6 @@ static long getDictLong (CFDictionaryRef refDict, CFStringRef key)
void LLWindowMacOSX::allowLanguageTextInput(LLPreeditor *preeditor, BOOL b)
{
allowDirectMarkedTextInput(b, mGLView);
if (preeditor != mPreeditor && !b)
{
// This condition may occur by a call to
@ -1836,6 +1853,7 @@ void LLWindowMacOSX::allowLanguageTextInput(LLPreeditor *preeditor, BOOL b)
return;
}
mLanguageTextInputAllowed = b;
allowDirectMarkedTextInput(b, mGLView); // mLanguageTextInputAllowed and mMarkedTextAllowed should be updated at once (by Pell Smit
}
void LLWindowMacOSX::interruptLanguageTextInput()

2
indra/newview/VIEWER_VERSION.txt
View File

@ -1 +1 @@
3.7.21
3.7.24

24
indra/newview/app_settings/settings.xml
View File

@ -6182,7 +6182,7 @@
<key>Type</key>
<string>F32</string>
<key>Value</key>
<real>30.0</real>
<real>600.0</real>
</map>
<key>MemoryPrivatePoolEnabled</key>
<map>
@ -13565,6 +13565,28 @@
<key>Value</key>
<string>0</string>
</map>
<key>VivoxLogDirectory</key>
<map>
<key>Comment</key>
<string>Default log path is Application Support/SecondLife/logs specify alternate absolute path here.</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>String</string>
<key>Value</key>
<string></string>
</map>
<key>VivoxShutdownTimeout</key>
<map>
<key>Comment</key>
<string>shutdown timeout in miliseconds. The amount of time to wait for the service to shutdown gracefully after the last disconnect</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>String</string>
<key>Value</key>
<string>5</string>
</map>
<key>VivoxDebugSIPURIHostName</key>
<map>
<key>Comment</key>

6
indra/newview/app_settings/shaders/class1/avatar/avatarSkinV.glsl
View File

@ -40,4 +40,10 @@ mat4 getSkinnedTransform()
ret[3] = vec4(0,0,0,1);
return ret;
#ifdef IS_AMD_CARD
// If it's AMD make sure the GLSL compiler sees the arrays referenced once by static index. Otherwise it seems to optimise the storage awawy which leads to unfun crashes and artifacts.
vec4 dummy1 = matrixPalette[0];
vec4 dummy2 = matrixPalette[44];
#endif
}

9
indra/newview/app_settings/shaders/class1/avatar/objectSkinV.glsl
View File

@ -63,5 +63,14 @@ mat4 getObjectSkinnedTransform()
ret[3] = vec4(trans, 1.0);
return ret;
#ifdef IS_AMD_CARD
// If it's AMD make sure the GLSL compiler sees the arrays referenced once by static index. Otherwise it seems to optimise the storage awawy which leads to unfun crashes and artifacts.
mat3 dummy1 = matrixPalette[0];
vec3 dummy2 = translationPalette[0];
mat3 dummy3 = matrixPalette[51];
vec3 dummy4 = translationPalette[51];
#endif
}

5
indra/newview/app_settings/shaders/class1/deferred/alphaV.glsl
View File

@ -111,10 +111,9 @@ void main()
#ifdef USE_INDEXED_TEX
passTextureIndex();
vary_texcoord0 = (texture_matrix0 * vec4(texcoord0,0,1)).xy;
#else
vary_texcoord0 = texcoord0;
#endif
vary_texcoord0 = (texture_matrix0 * vec4(texcoord0,0,1)).xy;
vary_norm = norm;
vary_position = pos.xyz;

6
indra/newview/app_settings/shaders/class1/deferred/blurLightF.glsl
View File

@ -132,5 +132,11 @@ void main()
col.y *= col.y;
frag_color = col;
#ifdef IS_AMD_CARD
// If it's AMD make sure the GLSL compiler sees the arrays referenced once by static index. Otherwise it seems to optimise the storage awawy which leads to unfun crashes and artifacts.
vec3 dummy1 = kern[0];
vec3 dummy2 = kern[3];
#endif
}

8
indra/newview/app_settings/shaders/class1/deferred/multiPointLightF.glsl
View File

@ -161,4 +161,12 @@ void main()
frag_color.rgb = out_col;
frag_color.a = 0.0;
#ifdef IS_AMD_CARD
// If it's AMD make sure the GLSL compiler sees the arrays referenced once by static index. Otherwise it seems to optimise the storage awawy which leads to unfun crashes and artifacts.
vec4 dummy1 = light[0];
vec4 dummy2 = light_col[0];
vec4 dummy3 = light[LIGHT_COUNT-1];
vec4 dummy4 = light_col[LIGHT_COUNT-1];
#endif
}

22
indra/newview/app_settings/shaders/class1/deferred/multiSpotLightF.glsl
View File

@ -127,13 +127,17 @@ vec4 texture2DLodSpecular(sampler2D projectionMap, vec2 tc, float lod)
vec4 ret = texture2DLod(projectionMap, tc, lod);
ret.rgb = srgb_to_linear(ret.rgb);
vec2 dist = tc-vec2(0.5);
vec2 dist = vec2(0.5) - abs(tc-vec2(0.5));
float det = max(1.0-lod/(proj_lod*0.5), 0.0);
float det = min(lod/(proj_lod*0.5), 1.0);
float d = dot(dist,dist);
ret *= min(clamp((0.25-d)/0.25, 0.0, 1.0)+det, 1.0);
float d = min(dist.x, dist.y);
d *= min(1, d * (proj_lod - lod));
float edge = 0.25*det;
ret *= clamp(d/edge, 0.0, 1.0);
return ret;
}
@ -311,19 +315,17 @@ void main()
vec3 pfinal = pos + ref * dot(pdelta, proj_n)/ds;
vec4 stc = (proj_mat * vec4(pfinal.xyz, 1.0));
stc /= stc.w;
if (stc.z > 0.0)
{
float fatten = clamp(envIntensity*envIntensity+envIntensity*0.25, 0.25, 1.0);
stc.xy = (stc.xy - vec2(0.5)) * fatten + vec2(0.5);
stc /= stc.w;
if (stc.x < 1.0 &&
stc.y < 1.0 &&
stc.x > 0.0 &&
stc.y > 0.0)
{
col += color.rgb*texture2DLodSpecular(projectionMap, stc.xy, proj_lod).rgb*spec.rgb;
col += color.rgb * texture2DLodSpecular(projectionMap, stc.xy, (1 - spec.a) * (proj_lod * 0.6)).rgb * envIntensity;
}
}
}

6
indra/newview/app_settings/shaders/class1/deferred/postgiF.glsl
View File

@ -99,4 +99,10 @@ void main()
col = col*col*blur_quad.x + col*blur_quad.y + blur_quad.z;
frag_color.rgb = col;
#ifdef IS_AMD_CARD
// If it's AMD make sure the GLSL compiler sees the arrays referenced once by static index. Otherwise it seems to optimise the storage awawy which leads to unfun crashes and artifacts.
vec2 dummy1 = kern[0];
vec2 dummy2 = kern[31];
#endif
}

25
indra/newview/app_settings/shaders/class1/deferred/spotLightF.glsl
View File

@ -130,15 +130,19 @@ vec4 correctWithGamma(vec4 col)
vec4 texture2DLodSpecular(sampler2D projectionMap, vec2 tc, float lod)
{
vec4 ret = texture2DLod(projectionMap, tc, lod);
ret = correctWithGamma(ret);
ret.rgb = srgb_to_linear(ret.rgb);
vec2 dist = tc-vec2(0.5);
vec2 dist = vec2(0.5) - abs(tc-vec2(0.5));
float det = max(1.0-lod/(proj_lod*0.5), 0.0);
float det = min(lod/(proj_lod*0.5), 1.0);
float d = dot(dist,dist);
ret *= min(clamp((0.25-d)/0.25, 0.0, 1.0)+det, 1.0);
float d = min(dist.x, dist.y);
d *= min(1, d * (proj_lod - lod));
float edge = 0.25*det;
ret *= clamp(d/edge, 0.0, 1.0);
return ret;
}
@ -322,19 +326,14 @@ void main()
if (stc.z > 0.0)
{
stc.xy /= stc.w;
float fatten = clamp(envIntensity*envIntensity+envIntensity*0.5, 0.25, 1.0);
//stc.xy = (stc.xy - vec2(0.5)) * fatten + vec2(0.5);
stc.xy = (stc.xy - vec2(0.5)) * fatten + vec2(0.5);
stc /= stc.w;
if (stc.x < 1.0 &&
stc.y < 1.0 &&
stc.x > 0.0 &&
stc.y > 0.0)
{
col += color.rgb*texture2DLodSpecular(projectionMap, stc.xy, proj_lod-envIntensity*proj_lod).rgb*spec.rgb;
col += color.rgb * texture2DLodSpecular(projectionMap, stc.xy, (1 - spec.a) * (proj_lod * 0.6)).rgb * envIntensity;
}
}
}

26
indra/newview/app_settings/shaders/class2/deferred/multiSpotLightF.glsl
View File

@ -131,15 +131,19 @@ vec4 correctWithGamma(vec4 col)
vec4 texture2DLodSpecular(sampler2D projectionMap, vec2 tc, float lod)
{
vec4 ret = texture2DLod(projectionMap, tc, lod);
ret = correctWithGamma(ret);
vec2 dist = tc-vec2(0.5);
ret.rgb = srgb_to_linear(ret.rgb);
float det = max(1.0-lod/(proj_lod*0.5), 0.0);
vec2 dist = vec2(0.5) - abs(tc-vec2(0.5));
float d = dot(dist,dist);
ret *= min(clamp((0.25-d)/0.25, 0.0, 1.0)+det, 1.0);
float det = min(lod/(proj_lod*0.5), 1.0);
float d = min(dist.x, dist.y);
d *= min(1, d * (proj_lod - lod));
float edge = 0.25*det;
ret *= clamp(d/edge, 0.0, 1.0);
return ret;
}
@ -334,25 +338,21 @@ void main()
vec3 pfinal = pos + ref * dot(pdelta, proj_n)/ds;
vec4 stc = (proj_mat * vec4(pfinal.xyz, 1.0));
stc /= stc.w;
if (stc.z > 0.0)
{
float fatten = clamp(envIntensity*envIntensity+envIntensity*0.25, 0.25, 1.0);
stc.xy = (stc.xy - vec2(0.5)) * fatten + vec2(0.5);
stc /= stc.w;
if (stc.x < 1.0 &&
stc.y < 1.0 &&
stc.x > 0.0 &&
stc.y > 0.0)
{
col += color.rgb*texture2DLodSpecular(projectionMap, stc.xy, proj_lod).rgb*shadow*spec.rgb;
col += color.rgb * texture2DLodSpecular(projectionMap, stc.xy, (1 - spec.a) * (proj_lod * 0.6)).rgb * shadow * envIntensity;
}
}
}
}
//not sure why, but this line prevents MATBUG-194
col = max(col, vec3(0.0));

25
indra/newview/app_settings/shaders/class2/deferred/spotLightF.glsl
View File

@ -131,15 +131,19 @@ vec4 correctWithGamma(vec4 col)
vec4 texture2DLodSpecular(sampler2D projectionMap, vec2 tc, float lod)
{
vec4 ret = texture2DLod(projectionMap, tc, lod);
ret = correctWithGamma(ret);
ret.rgb = srgb_to_linear(ret.rgb);
vec2 dist = tc-vec2(0.5);
vec2 dist = vec2(0.5) - abs(tc-vec2(0.5));
float det = max(1.0-lod/(proj_lod*0.5), 0.0);
float det = min(lod/(proj_lod*0.5), 1.0);
float d = dot(dist,dist);
ret *= min(clamp((0.25-d)/0.25, 0.0, 1.0)+det, 1.0);
float d = min(dist.x, dist.y);
d *= min(1, d * (proj_lod - lod));
float edge = 0.25*det;
ret *= clamp(d/edge, 0.0, 1.0);
return ret;
}
@ -336,19 +340,14 @@ void main()
if (stc.z > 0.0)
{
stc.xy /= stc.w;
float fatten = clamp(envIntensity*envIntensity+envIntensity*0.5, 0.25, 1.0);
//stc.xy = (stc.xy - vec2(0.5)) * fatten + vec2(0.5);
stc.xy = (stc.xy - vec2(0.5)) * fatten + vec2(0.5);
stc /= stc.w;
if (stc.x < 1.0 &&
stc.y < 1.0 &&
stc.x > 0.0 &&
stc.y > 0.0)
{
col += color.rgb*texture2DLodSpecular(projectionMap, stc.xy, proj_lod-envIntensity*proj_lod).rgb*shadow*spec.rgb;
col += color.rgb * texture2DLodSpecular(projectionMap, stc.xy, (1 - spec.a) * (proj_lod * 0.6)).rgb * shadow * envIntensity;
}
}
}

17
indra/newview/llagent.cpp
View File

@ -3808,6 +3808,10 @@ void LLAgent::restartFailedTeleportRequest()
void LLAgent::clearTeleportRequest()
{
if(LLVoiceClient::instanceExists())
{
LLVoiceClient::getInstance()->setHidden(FALSE);
}
mTeleportRequest.reset();
}
@ -3826,6 +3830,10 @@ bool LLAgent::hasPendingTeleportRequest()
void LLAgent::startTeleportRequest()
{
if(LLVoiceClient::instanceExists())
{
LLVoiceClient::getInstance()->setHidden(TRUE);
}
if (hasPendingTeleportRequest())
{
if (!isMaturityPreferenceSyncedWithServer())
@ -3877,6 +3885,11 @@ void LLAgent::handleTeleportFinished()
void LLAgent::handleTeleportFailed()
{
if(LLVoiceClient::instanceExists())
{
LLVoiceClient::getInstance()->setHidden(FALSE);
}
if (mTeleportRequest != NULL)
{
mTeleportRequest->setStatus(LLTeleportRequest::kFailed);
@ -4122,8 +4135,8 @@ void LLAgent::stopCurrentAnimations()
anim_it != gAgentAvatarp->mPlayingAnimations.end();
anim_it++)
{
if (anim_it->first ==
ANIM_AGENT_SIT_GROUND_CONSTRAINED)
if ((anim_it->first == ANIM_AGENT_DO_NOT_DISTURB)||
(anim_it->first == ANIM_AGENT_SIT_GROUND_CONSTRAINED))
{
// don't cancel a ground-sit anim, as viewers
// use this animation's status in

31
indra/newview/llagentwearables.cpp
View File

@ -1009,6 +1009,10 @@ void LLAgentWearables::setWearableOutfit(const LLInventoryItem::item_array_t& it
continue;
}
// Don't care about this case - ordering of wearables with the same asset id has no effect.
// Causes the two-alphas error case in MAINT-4158.
// We should actually disallow wearing two wearables with the same asset id.
#if 0
if (curr_wearable->getName() != new_item->getName() ||
curr_wearable->getItemID() != new_item->getUUID())
{
@ -1019,6 +1023,7 @@ void LLAgentWearables::setWearableOutfit(const LLInventoryItem::item_array_t& it
mismatched++;
continue;
}
#endif
// If we got here, everything matches.
matched++;
}
@ -1083,7 +1088,6 @@ void LLAgentWearables::setWearableOutfit(const LLInventoryItem::item_array_t& it
if (isAgentAvatarValid())
{
gAgentAvatarp->setCompositeUpdatesEnabled(TRUE);
gAgentAvatarp->updateVisualParams();
// If we have not yet declouded, we may want to use
// baked texture UUIDs sent from the first objectUpdate message
@ -1101,6 +1105,12 @@ void LLAgentWearables::setWearableOutfit(const LLInventoryItem::item_array_t& it
notifyLoadingFinished();
// Copy wearable params to avatar.
gAgentAvatarp->writeWearablesToAvatar();
// Then update the avatar based on the copied params.
gAgentAvatarp->updateVisualParams();
gAgentAvatarp->dumpAvatarTEs("setWearableOutfit");
LL_DEBUGS("Avatar") << "setWearableOutfit() end" << LL_ENDL;
@ -1243,9 +1253,12 @@ void LLAgentWearables::userRemoveWearablesOfType(const LLWearableType::EType &ty
}
}
// Combines userRemoveMulipleAttachments() and userAttachMultipleAttachments() logic to
// get attachments into desired state with minimal number of adds/removes.
void LLAgentWearables::userUpdateAttachments(LLInventoryModel::item_array_t& obj_item_array)
// Given a desired set of attachments, find what objects need to be
// removed, and what additional inventory items need to be added.
void LLAgentWearables::findAttachmentsAddRemoveInfo(LLInventoryModel::item_array_t& obj_item_array,
llvo_vec_t& objects_to_remove,
llvo_vec_t& objects_to_retain,
LLInventoryModel::item_array_t& items_to_add)
{
// Possible cases:
// already wearing but not in request set -> take off.
@ -1264,7 +1277,6 @@ void LLAgentWearables::userUpdateAttachments(LLInventoryModel::item_array_t& obj
}
// Build up list of objects to be removed and items currently attached.
llvo_vec_t objects_to_remove;
for (LLVOAvatar::attachment_map_t::iterator iter = gAgentAvatarp->mAttachmentPoints.begin();
iter != gAgentAvatarp->mAttachmentPoints.end();)
{
@ -1299,12 +1311,12 @@ void LLAgentWearables::userUpdateAttachments(LLInventoryModel::item_array_t& obj
{
// LL_INFOS() << "found object to keep, id " << objectp->getID() << ", item " << objectp->getAttachmentItemID() << LL_ENDL;
current_item_ids.insert(object_item_id);
objects_to_retain.push_back(objectp);
}
}
}
}
LLInventoryModel::item_array_t items_to_add;
for (LLInventoryModel::item_array_t::iterator it = obj_item_array.begin();
it != obj_item_array.end();
++it)
@ -1323,12 +1335,6 @@ void LLAgentWearables::userUpdateAttachments(LLInventoryModel::item_array_t& obj
// S32 remove_count = objects_to_remove.size();
// S32 add_count = items_to_add.size();
// LL_INFOS() << "remove " << remove_count << " add " << add_count << LL_ENDL;
// Remove everything in objects_to_remove
userRemoveMultipleAttachments(objects_to_remove);
// Add everything in items_to_add
userAttachMultipleAttachments(items_to_add);
}
void LLAgentWearables::userRemoveMultipleAttachments(llvo_vec_t& objects_to_remove)
@ -1348,6 +1354,7 @@ void LLAgentWearables::userRemoveMultipleAttachments(llvo_vec_t& objects_to_remo
++it)
{
LLViewerObject *objectp = *it;
//gAgentAvatarp->resetJointPositionsOnDetach(objectp);
gMessageSystem->nextBlockFast(_PREHASH_ObjectData);
gMessageSystem->addU32Fast(_PREHASH_ObjectLocalID, objectp->getLocalID());
}

5
indra/newview/llagentwearables.h
View File

@ -178,7 +178,10 @@ public:
typedef std::vector<LLViewerObject*> llvo_vec_t;
static void userUpdateAttachments(LLInventoryModel::item_array_t& obj_item_array);
static void findAttachmentsAddRemoveInfo(LLInventoryModel::item_array_t& obj_item_array,
llvo_vec_t& objects_to_remove,
llvo_vec_t& objects_to_retain,
LLInventoryModel::item_array_t& items_to_add);
static void userRemoveMultipleAttachments(llvo_vec_t& llvo_array);
static void userAttachMultipleAttachments(LLInventoryModel::item_array_t& obj_item_array);

1
indra/newview/llaisapi.cpp
View File

@ -34,6 +34,7 @@
#include "llsdutil.h"
#include "llviewerregion.h"
#include "llinventoryobserver.h"
#include "llviewercontrol.h"
///----------------------------------------------------------------------------
/// Classes for AISv3 support.

10
indra/newview/llappdelegate-objc.mm Normal file → Executable file
View File

@ -84,6 +84,16 @@
callWindowUnfocus();
}
- (void) applicationDidHide:(NSNotification *)notification
{
callWindowHide();
}
- (void) applicationDidUnhide:(NSNotification *)notification
{
callWindowUnhide();
}
- (NSApplicationDelegateReply) applicationShouldTerminate:(NSApplication *)sender
{
if (!runMainLoop())

88
indra/newview/llappearancemgr.cpp
View File

@ -807,15 +807,48 @@ void LLWearableHoldingPattern::onAllComplete()
}
}
// Update wearables.
LL_INFOS("Avatar") << self_av_string() << "HP " << index() << " updating agent wearables with " << mResolved << " wearable items " << LL_ENDL;
LLAppearanceMgr::instance().updateAgentWearables(this);
// Update attachments to match those requested.
if (isAgentAvatarValid())
{
LL_DEBUGS("Avatar") << self_av_string() << "Updating " << mObjItems.size() << " attachments" << LL_ENDL;
LLAgentWearables::userUpdateAttachments(mObjItems);
LLAgentWearables::llvo_vec_t objects_to_remove;
LLAgentWearables::llvo_vec_t objects_to_retain;
LLInventoryModel::item_array_t items_to_add;
LLAgentWearables::findAttachmentsAddRemoveInfo(mObjItems,
objects_to_remove,
objects_to_retain,
items_to_add);
LL_DEBUGS("Avatar") << self_av_string() << "Removing " << objects_to_remove.size()
<< " attachments" << LL_ENDL;
// Here we remove the attachment pos overrides for *all*
// attachments, even those that are not being removed. This is
// needed to get joint positions all slammed down to their
// pre-attachment states.
gAgentAvatarp->clearAttachmentPosOverrides();
// Take off the attachments that will no longer be in the outfit.
LLAgentWearables::userRemoveMultipleAttachments(objects_to_remove);
// Update wearables.
LL_INFOS("Avatar") << self_av_string() << "HP " << index() << " updating agent wearables with "
<< mResolved << " wearable items " << LL_ENDL;
LLAppearanceMgr::instance().updateAgentWearables(this);
// Restore attachment pos overrides for the attachments that
// are remaining in the outfit.
for (LLAgentWearables::llvo_vec_t::iterator it = objects_to_retain.begin();
it != objects_to_retain.end();
++it)
{
LLViewerObject *objectp = *it;
gAgentAvatarp->addAttachmentPosOverridesForObject(objectp);
}
// Add new attachments to match those requested.
LL_DEBUGS("Avatar") << self_av_string() << "Adding " << items_to_add.size() << " attachments" << LL_ENDL;
LLAgentWearables::userAttachMultipleAttachments(items_to_add);
}
if (isFetchCompleted() && isMissingCompleted())
@ -2699,7 +2732,12 @@ void LLAppearanceMgr::removeCOFItemLinks(const LLUUID& item_id, LLPointer<LLInve
const LLInventoryItem* item = item_array.at(i).get();
if (item->getIsLinkType() && item->getLinkedUUID() == item_id)
{
remove_inventory_item(item->getUUID(), cb);
bool immediate_delete = false;
if (item->getType() == LLAssetType::AT_OBJECT)
{
immediate_delete = true;
}
remove_inventory_item(item->getUUID(), cb, immediate_delete);
}
}
}
@ -4056,17 +4094,33 @@ public:
bool handle(const LLSD& tokens, const LLSD& query_map,
LLMediaCtrl* web)
{
LLPointer<LLInventoryCategory> category = new LLInventoryCategory(query_map["folder_id"],
LLUUID::null,
LLFolderType::FT_CLOTHING,
"Quick Appearance");
LLSD::UUID folder_uuid = query_map["folder_id"].asUUID();
if ( gInventory.getCategory( folder_uuid ) != NULL )
{
LLAppearanceMgr::getInstance()->wearInventoryCategory(category, true, false);
LLSD::UUID folder_uuid;
// *TODOw: This may not be necessary if initial outfit is chosen already -- josh
gAgent.setOutfitChosen(TRUE);
if (folder_uuid.isNull() && query_map.has("folder_name"))
{
std::string outfit_folder_name = query_map["folder_name"];
folder_uuid = findDescendentCategoryIDByName(
gInventory.getLibraryRootFolderID(),
outfit_folder_name);
}
if (folder_uuid.isNull() && query_map.has("folder_id"))
{
folder_uuid = query_map["folder_id"].asUUID();
}
if (folder_uuid.notNull())
{
LLPointer<LLInventoryCategory> category = new LLInventoryCategory(folder_uuid,
LLUUID::null,
LLFolderType::FT_CLOTHING,
"Quick Appearance");
if ( gInventory.getCategory( folder_uuid ) != NULL )
{
LLAppearanceMgr::getInstance()->wearInventoryCategory(category, true, false);
// *TODOw: This may not be necessary if initial outfit is chosen already -- josh
gAgent.setOutfitChosen(TRUE);
}
}
// release avatar picker keyboard focus

5
indra/newview/llappviewer.cpp
View File

@ -4896,7 +4896,10 @@ void LLAppViewer::idle()
// Handle the regular UI idle callbacks as well as
// hover callbacks
//
#ifdef LL_DARWIN
if (!mQuitRequested) //MAINT-4243
#endif
{
// LL_RECORD_BLOCK_TIME(FTM_IDLE_CB);

2
indra/newview/lldrawpool.cpp
View File

@ -443,7 +443,7 @@ void LLRenderPass::pushMaskBatches(U32 type, U32 mask, BOOL texture, BOOL batch_
}
}
void LLRenderPass::applyModelMatrix(LLDrawInfo& params)
void LLRenderPass::applyModelMatrix(const LLDrawInfo& params)
{
if (params.mModelMatrix != gGLLastMatrix)
{

2
indra/newview/lldrawpool.h
View File

@ -168,7 +168,7 @@ public:
BOOL isDead() { return FALSE; }
void resetDrawOrders() { }
static void applyModelMatrix(LLDrawInfo& params);
static void applyModelMatrix(const LLDrawInfo& params);
virtual void pushBatches(U32 type, U32 mask, BOOL texture = TRUE, BOOL batch_textures = FALSE);
virtual void pushMaskBatches(U32 type, U32 mask, BOOL texture = TRUE, BOOL batch_textures = FALSE);
virtual void pushBatch(LLDrawInfo& params, U32 mask, BOOL texture, BOOL batch_textures = FALSE);

5
indra/newview/lldrawpoolavatar.cpp
View File

@ -375,7 +375,7 @@ void LLDrawPoolAvatar::endPostDeferredAlpha()
void LLDrawPoolAvatar::renderPostDeferred(S32 pass)
{
const S32 actual_pass[] =
static const S32 actual_pass[] =
{ //map post deferred pass numbers to what render() expects
2, //skinned
4, // rigged fullbright
@ -1626,7 +1626,8 @@ void LLDrawPoolAvatar::updateRiggedFaceVertexBuffer(LLVOAvatar* avatar, LLFace*
{
F32 w = weight[j][k];
idx[k] = llclamp((S32) floorf(w), 0, 63);
idx[k] = llclamp((S32) floorf(w), 0, JOINT_COUNT-1);
wght[k] = w - floorf(w);
scale += wght[k];
}

2
indra/newview/lldrawpoolmaterials.cpp
View File

@ -96,7 +96,7 @@ void LLDrawPoolMaterials::endDeferredPass(S32 pass)
void LLDrawPoolMaterials::renderDeferred(S32 pass)
{
U32 type_list[] =
static const U32 type_list[] =
{
LLRenderPass::PASS_MATERIAL,
//LLRenderPass::PASS_MATERIAL_ALPHA,

221
indra/newview/llfeaturemanager.cpp
View File

@ -76,9 +76,6 @@ const char FEATURE_TABLE_FILENAME[] = "featuretable%s.txt";
const char FEATURE_TABLE_VER_FILENAME[] = "featuretable%s.%s.txt";
#endif
const char GPU_TABLE_FILENAME[] = "gpu_table.txt";
const char GPU_TABLE_VER_FILENAME[] = "gpu_table.%s.txt";
LLFeatureInfo::LLFeatureInfo(const std::string& name, const BOOL available, const F32 level)
: mValid(TRUE), mName(name), mAvailable(available), mRecommendedLevel(level)
{
@ -428,6 +425,7 @@ bool LLFeatureManager::loadGPUClass()
{ //couldn't bench, use GLVersion
#if LL_DARWIN
//GLVersion is misleading on OSX, just default to class 3 if we can't bench
LL_WARNS() << "Unable to get an accurate benchmark; defaulting to class 3" << LL_ENDL;
mGPUClass = GPU_CLASS_3;
#else
if (gGLManager.mGLVersion < 2.f)
@ -452,23 +450,31 @@ bool LLFeatureManager::loadGPUClass()
}
#endif
}
else if (gbps < 5.f)
else if (gGLManager.mGLVersion <= 2.f)
{
mGPUClass = GPU_CLASS_0;
}
else if (gbps < 10.f)
else if (gGLManager.mGLVersion <= 3.f)
{
mGPUClass = GPU_CLASS_1;
}
else if (gbps < 20.f)
else if (gbps <= 5.f)
{
mGPUClass = GPU_CLASS_0;
}
else if (gbps <= 8.f)
{
mGPUClass = GPU_CLASS_1;
}
else if (gbps <= 16.f)
{
mGPUClass = GPU_CLASS_2;
}
else if (gbps < 40.f)
else if (gbps <= 40.f)
{
mGPUClass = GPU_CLASS_3;
}
else if (gbps < 80.f)
else if (gbps <= 80.f)
{
mGPUClass = GPU_CLASS_4;
}
@ -476,195 +482,15 @@ bool LLFeatureManager::loadGPUClass()
{
mGPUClass = GPU_CLASS_5;
}
// defaults
mGPUString = gGLManager.getRawGLString();
mGPUSupported = TRUE;
#if 0
// first table is in the app dir
std::string app_path = gDirUtilp->getAppRODataDir();
app_path += gDirUtilp->getDirDelimiter();
app_path += GPU_TABLE_FILENAME;
// second table is downloaded with HTTP
std::string http_filename = llformat(GPU_TABLE_VER_FILENAME, LLVersionInfo::getVersion().c_str());
std::string http_path = gDirUtilp->getExpandedFilename(LL_PATH_USER_SETTINGS, http_filename);
// use HTTP table if it exists
std::string path;
bool parse_ok = false;
if (gDirUtilp->fileExists(http_path))
{
parse_ok = parseGPUTable(http_path);
if (!parse_ok)
{
// the HTTP table failed to parse, so delete it
LLFile::remove(http_path);
LL_WARNS("RenderInit") << "Removed invalid gpu table '" << http_path << "'" << LL_ENDL;
}
}
if (!parse_ok)
{
parse_ok = parseGPUTable(app_path);
}
#endif
return true; // indicates that the file parsed correctly, not that the gpu was recognized
return true; // indicates that a gpu value was established
}
bool LLFeatureManager::parseGPUTable(std::string filename)
{
llifstream file;
LL_INFOS("RenderInit") << "Attempting to parse GPU table from " << filename << LL_ENDL;
file.open(filename);
if (file)
{
const char recognizer[] = "//GPU_TABLE";
char first_line[MAX_STRING];
file.getline(first_line, MAX_STRING);
if (0 != strncmp(first_line, recognizer, strlen(recognizer)))
{
LL_WARNS("RenderInit") << "Invalid GPU table: " << filename << "!" << LL_ENDL;
return false;
}
}
else
{
LL_WARNS("RenderInit") << "Unable to open GPU table: " << filename << "!" << LL_ENDL;
return false;
}
std::string rawRenderer = gGLManager.getRawGLString();
std::string renderer = rawRenderer;
for (std::string::iterator i = renderer.begin(); i != renderer.end(); ++i)
{
*i = tolower(*i);
}
#if LL_EXPORT_GPU_TABLE
llofstream json;
json.open("gpu_table.json");
json << "var gpu_table = [" << std::endl;
#endif
bool gpuFound;
U32 lineNumber;
for (gpuFound = false, lineNumber = 0; !gpuFound && !file.eof(); lineNumber++)
{
char buffer[MAX_STRING]; /*Flawfinder: ignore*/
buffer[0] = 0;
file.getline(buffer, MAX_STRING);
if (strlen(buffer) >= 2 && /*Flawfinder: ignore*/
buffer[0] == '/' &&
buffer[1] == '/')
{
// This is a comment.
continue;
}
if (strlen(buffer) == 0) /*Flawfinder: ignore*/
{
// This is a blank line
continue;
}
// setup the tokenizer
std::string buf(buffer);
std::string cls, label, expr, supported, stats_based, expected_gl_version;
boost_tokenizer tokens(buf, boost::char_separator<char>("\t\n"));
boost_tokenizer::iterator token_iter = tokens.begin();
// grab the label, pseudo regular expression, and class
if(token_iter != tokens.end())
{
label = *token_iter++;
}
if(token_iter != tokens.end())
{
expr = *token_iter++;
}
if(token_iter != tokens.end())
{
cls = *token_iter++;
}
if(token_iter != tokens.end())
{
supported = *token_iter++;
}
if (token_iter != tokens.end())
{
stats_based = *token_iter++;
}
if (token_iter != tokens.end())
{
expected_gl_version = *token_iter++;
}
if (label.empty() || expr.empty() || cls.empty() || supported.empty())
{
LL_WARNS("RenderInit") << "invald gpu_table.txt:" << lineNumber << ": '" << buffer << "'" << LL_ENDL;
continue;
}
#if LL_EXPORT_GPU_TABLE
json << "{'label' : '" << label << "',\n" <<
"'regexp' : '" << expr << "',\n" <<
"'class' : '" << cls << "',\n" <<
"'supported' : '" << supported << "',\n" <<
"'stats_based' : " << stats_based << ",\n" <<
"'gl_version' : " << expected_gl_version << "\n},\n";
#endif
for (U32 i = 0; i < expr.length(); i++) /*Flawfinder: ignore*/
{
expr[i] = tolower(expr[i]);
}
// run the regular expression against the renderer
boost::regex re(expr.c_str());
if(boost::regex_search(renderer, re))
{
// if we found it, stop!
#if !LL_EXPORT_GPU_TABLE
gpuFound = true;
#endif
mGPUString = label;
mGPUClass = (EGPUClass) strtol(cls.c_str(), NULL, 10);
mGPUSupported = (BOOL) strtol(supported.c_str(), NULL, 10);
sscanf(expected_gl_version.c_str(), "%f", &mExpectedGLVersion);
}
}
#if LL_EXPORT_GPU_TABLE
json << "];\n\n";
json.close();
#endif
file.close();
if ( gpuFound )
{
LL_INFOS("RenderInit") << "GPU '" << rawRenderer << "' recognized as '" << mGPUString << "'" << LL_ENDL;
if (!mGPUSupported)
{
LL_INFOS("RenderInit") << "GPU '" << mGPUString << "' is not supported." << LL_ENDL;
}
}
else
{
LL_WARNS("RenderInit") << "GPU '" << rawRenderer << "' not recognized" << LL_ENDL;
}
#if LL_DARWIN // never go over "Mid" settings by default on OS X
mGPUClass = llmin(mGPUClass, GPU_CLASS_2);
#endif
return true;
}
// responder saves table into file
class LLHTTPFeatureTableResponder : public LLHTTPClient::Responder
{
@ -745,26 +571,11 @@ void fetch_feature_table(std::string table)
LLHTTPClient::get(url, new LLHTTPFeatureTableResponder(path));
}
void fetch_gpu_table(std::string table)
{
const std::string base = gSavedSettings.getString("FeatureManagerHTTPTable");
const std::string filename = llformat(table.c_str(), LLVersionInfo::getVersion().c_str());
const std::string url = base + "/" + filename;
const std::string path = gDirUtilp->getExpandedFilename(LL_PATH_USER_SETTINGS, filename);
LL_INFOS() << "LLFeatureManager fetching " << url << " into " << path << LL_ENDL;
LLHTTPClient::get(url, new LLHTTPFeatureTableResponder(path));
}
// fetch table(s) from a website (S3)
void LLFeatureManager::fetchHTTPTables()
{
fetch_feature_table(FEATURE_TABLE_VER_FILENAME);
fetch_gpu_table(GPU_TABLE_VER_FILENAME);
}

3
indra/newview/llfeaturemanager.h
View File

@ -162,9 +162,6 @@ protected:
bool parseFeatureTable(std::string filename);
///< @returns TRUE is file parsed correctly, FALSE if not
bool parseGPUTable(std::string filename);
///< @returns true if file parsed correctly, false if not - does not reflect whether or not the gpu was recognized
void initBaseMask();

21
indra/newview/llfilepicker.cpp
View File

@ -600,6 +600,9 @@ std::vector<std::string>* LLFilePicker::navOpenFilterProc(ELoadFilter filter) //
allowedv->push_back("slg");
break;
#endif
case FFLOAD_XML:
allowedv->push_back("xml");
break;
case FFLOAD_RAW:
allowedv->push_back("raw");
break;
@ -702,7 +705,14 @@ bool LLFilePicker::doNavSaveDialog(ESaveFilter filter, const std::string& filena
creator = "\?\?\?\?";
extension = "slg";
break;
#endif
#endif
case FFSAVE_XML:
type = "\?\?\?\?";
creator = "\?\?\?\?";
extension = "xml";
break;
case FFSAVE_RAW:
type = "\?\?\?\?";
creator = "\?\?\?\?";
@ -1100,6 +1110,12 @@ static std::string add_anim_filter_to_gtkchooser(GtkWindow *picker)
return filtername;
}
static std::string add_xml_filter_to_gtkchooser(GtkWindow *picker)
{
return add_simple_pattern_filter_to_gtkchooser(picker, "*.xml",
LLTrans::getString("xml_files") + " (*.xml)");
}
static std::string add_collada_filter_to_gtkchooser(GtkWindow *picker)
{
return add_simple_pattern_filter_to_gtkchooser(picker, "*.dae",
@ -1293,6 +1309,9 @@ BOOL LLFilePicker::getOpenFile( ELoadFilter filter, bool blocking )
case FFLOAD_ANIM:
filtername = add_anim_filter_to_gtkchooser(picker);
break;
case FFLOAD_XML:
filtername = add_xml_filter_to_gtkchooser(picker);
break;
case FFLOAD_COLLADA:
filtername = add_collada_filter_to_gtkchooser(picker);
break;

2
indra/newview/llflickrconnect.cpp
View File

@ -400,7 +400,7 @@ void LLFlickrConnect::uploadPhoto(LLPointer<LLImageFormatted> image, const std::
}
else
{
llwarns << "Image to upload is not a PNG or JPEG" << llendl;
LL_WARNS() << "Image to upload is not a PNG or JPEG" << LL_ENDL;
return;
}

2
indra/newview/llfloatergroupbulkban.cpp
View File

@ -101,7 +101,7 @@ void LLFloaterGroupBulkBan::showForGroup(const LLUUID& group_id, uuid_vec_t* age
// Make sure group_id isn't null
if (group_id.isNull())
{
llwarns << "LLFloaterGroupInvite::showForGroup with null group_id!" << llendl;
LL_WARNS() << "LLFloaterGroupInvite::showForGroup with null group_id!" << LL_ENDL;
return;
}

2
indra/newview/llfloaterimsessiontab.cpp
View File

@ -47,7 +47,7 @@
const F32 REFRESH_INTERVAL = 1.0f;
LLFloaterIMSessionTab::LLFloaterIMSessionTab(const LLSD& session_id)
: LLTransientDockableFloater(NULL, true, session_id),
: LLTransientDockableFloater(NULL, false, session_id),
mIsP2PChat(false),
mExpandCollapseBtn(NULL),
mTearOffBtn(NULL),

10
indra/newview/llfloatermodelpreview.cpp
View File

@ -1935,7 +1935,9 @@ bool LLModelLoader::doLoadModel()
LLJoint* pJoint = mPreview->getPreviewAvatar()->getJoint( lookingForJoint );
if ( pJoint )
{
pJoint->storeCurrentXform( jointTransform.getTranslation() );
LLUUID fake_mesh_id;
fake_mesh_id.generate();
pJoint->addAttachmentPosOverride( jointTransform.getTranslation(), fake_mesh_id, gAgentAvatarp->avString());
}
else
{
@ -3242,7 +3244,11 @@ U32 LLModelPreview::calcResourceCost()
if ( mFMP && mFMP->childGetValue("upload_joints").asBoolean() )
{
getPreviewAvatar()->setPelvisOffset( mPelvisZOffset );
// FIXME if preview avatar ever gets reused, this fake mesh ID stuff will fail.
// see also call to addAttachmentPosOverride.
LLUUID fake_mesh_id;
fake_mesh_id.generate();
getPreviewAvatar()->addPelvisFixup( mPelvisZOffset, fake_mesh_id );
}
F32 streaming_cost = 0.f;

23
indra/newview/llfloateropenobject.cpp
View File

@ -58,6 +58,8 @@ LLFloaterOpenObject::LLFloaterOpenObject(const LLSD& key)
{
mCommitCallbackRegistrar.add("OpenObject.MoveToInventory", boost::bind(&LLFloaterOpenObject::onClickMoveToInventory, this));
mCommitCallbackRegistrar.add("OpenObject.MoveAndWear", boost::bind(&LLFloaterOpenObject::onClickMoveAndWear, this));
mCommitCallbackRegistrar.add("OpenObject.ReplaceOutfit", boost::bind(&LLFloaterOpenObject::onClickReplace, this));
mCommitCallbackRegistrar.add("OpenObject.Cancel", boost::bind(&LLFloaterOpenObject::onClickCancel, this));
}
LLFloaterOpenObject::~LLFloaterOpenObject()
@ -115,6 +117,7 @@ void LLFloaterOpenObject::refresh()
getChild<LLUICtrl>("object_name")->setTextArg("[DESC]", name);
getChildView("copy_to_inventory_button")->setEnabled(enabled);
getChildView("copy_and_wear_button")->setEnabled(enabled);
getChildView("copy_and_replace_button")->setEnabled(enabled);
}
@ -135,7 +138,7 @@ void LLFloaterOpenObject::dirty()
void LLFloaterOpenObject::moveToInventory(bool wear)
void LLFloaterOpenObject::moveToInventory(bool wear, bool replace)
{
if (mObjectSelection->getRootObjectCount() != 1)
{
@ -163,7 +166,7 @@ void LLFloaterOpenObject::moveToInventory(bool wear)
parent_category_id = gInventory.getRootFolderID();
}
inventory_func_type func = boost::bind(LLFloaterOpenObject::callbackCreateInventoryCategory,_1,object_id,wear);
inventory_func_type func = boost::bind(LLFloaterOpenObject::callbackCreateInventoryCategory,_1,object_id,wear,replace);
LLUUID category_id = gInventory.createNewCategory(parent_category_id,
LLFolderType::FT_NONE,
name,
@ -177,6 +180,7 @@ void LLFloaterOpenObject::moveToInventory(bool wear)
data->mCatID = category_id;
data->mWear = wear;
data->mFolderResponded = false;
data->mReplace = replace;
// Copy and/or move the items into the newly created folder.
// Ignore any "you're going to break this item" messages.
@ -194,13 +198,14 @@ void LLFloaterOpenObject::moveToInventory(bool wear)
}
// static
void LLFloaterOpenObject::callbackCreateInventoryCategory(const LLUUID& category_id, LLUUID object_id, bool wear)
void LLFloaterOpenObject::callbackCreateInventoryCategory(const LLUUID& category_id, LLUUID object_id, bool wear, bool replace)
{
LLCatAndWear* wear_data = new LLCatAndWear;
wear_data->mCatID = category_id;
wear_data->mWear = wear;
wear_data->mFolderResponded = true;
wear_data->mReplace = replace;
// Copy and/or move the items into the newly created folder.
// Ignore any "you're going to break this item" messages.
@ -241,7 +246,17 @@ void LLFloaterOpenObject::onClickMoveToInventory()
void LLFloaterOpenObject::onClickMoveAndWear()
{
moveToInventory(true);
moveToInventory(true, false);
closeFloater();
}
void LLFloaterOpenObject::onClickReplace()
{
moveToInventory(true, true);
closeFloater();
}
void LLFloaterOpenObject::onClickCancel()
{
closeFloater();
}

7
indra/newview/llfloateropenobject.h
View File

@ -50,6 +50,7 @@ public:
LLUUID mCatID;
bool mWear;
bool mFolderResponded;
bool mReplace;
};
protected:
@ -59,11 +60,13 @@ protected:
void draw();
virtual void onOpen(const LLSD& key);
void moveToInventory(bool wear);
void moveToInventory(bool wear, bool replace = false);
void onClickMoveToInventory();
void onClickMoveAndWear();
static void callbackCreateInventoryCategory(const LLUUID& category_id, LLUUID object_id, bool wear);
void onClickReplace();
void onClickCancel();
static void callbackCreateInventoryCategory(const LLUUID& category_id, LLUUID object_id, bool wear, bool replace = false);
static void callbackMoveInventory(S32 result, void* data);
private:

75
indra/newview/llfloaterpay.cpp
View File

@ -40,8 +40,10 @@
#include "lltextbox.h"
#include "lllineeditor.h"
#include "llmutelist.h"
#include "llnotificationsutil.h"
#include "llfloaterreporter.h"
#include "llslurl.h"
#include "llstatusbar.h"
#include "llviewerobject.h"
#include "llviewerobjectlist.h"
#include "llviewerregion.h"
@ -90,6 +92,9 @@ public:
static void payDirectly(money_callback callback,
const LLUUID& target_id,
bool is_group);
static bool payConfirmationCallback(const LLSD& notification,
const LLSD& response,
LLGiveMoneyInfo* info);
private:
static void onCancel(void* data);
@ -111,14 +116,12 @@ protected:
LLGiveMoneyInfo* mQuickPayInfo[MAX_PAY_BUTTONS];
LLSafeHandle<LLObjectSelection> mObjectSelection;
static S32 sLastAmount;
};
S32 LLFloaterPay::sLastAmount = 0;
const S32 MAX_AMOUNT_LENGTH = 10;
const S32 FASTPAY_BUTTON_WIDTH = 80;
const S32 PAY_AMOUNT_NOTIFICATION = 200;
LLFloaterPay::LLFloaterPay(const LLSD& key)
: LLFloater(key),
@ -188,17 +191,9 @@ BOOL LLFloaterPay::postBuild()
getChildView("amount text")->setVisible(FALSE);
std::string last_amount;
if(sLastAmount > 0)
{
last_amount = llformat("%d", sLastAmount);
}
getChildView("amount")->setVisible(FALSE);
getChild<LLLineEditor>("amount")->setKeystrokeCallback(&LLFloaterPay::onKeystroke, this);
getChild<LLUICtrl>("amount")->setValue(last_amount);
getChild<LLLineEditor>("amount")->setPrevalidate(LLTextValidate::validateNonNegativeS32);
info = new LLGiveMoneyInfo(this, 0);
@ -207,7 +202,7 @@ BOOL LLFloaterPay::postBuild()
childSetAction("pay btn",&LLFloaterPay::onGive,info);
setDefaultBtn("pay btn");
getChildView("pay btn")->setVisible(FALSE);
getChildView("pay btn")->setEnabled((sLastAmount > 0));
getChildView("pay btn")->setEnabled(FALSE);
childSetAction("cancel btn",&LLFloaterPay::onCancel,this);
@ -419,7 +414,24 @@ void LLFloaterPay::payDirectly(money_callback callback,
floater->finishPayUI(target_id, is_group);
}
bool LLFloaterPay::payConfirmationCallback(const LLSD& notification, const LLSD& response, LLGiveMoneyInfo* info)
{
if (!info || !info->mFloater)
{
return false;
}
S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
if (option == 0)
{
info->mFloater->give(info->mAmount);
info->mFloater->closeFloater();
}
return false;
}
void LLFloaterPay::finishPayUI(const LLUUID& target_id, BOOL is_group)
{
std::string slurl;
@ -470,10 +482,40 @@ void LLFloaterPay::onKeystroke(LLLineEditor*, void* data)
void LLFloaterPay::onGive(void* data)
{
LLGiveMoneyInfo* info = reinterpret_cast<LLGiveMoneyInfo*>(data);
if(info && info->mFloater)
LLFloaterPay* floater = info->mFloater;
if(info && floater)
{
info->mFloater->give(info->mAmount);
info->mFloater->closeFloater();
S32 amount = info->mAmount;
if(amount == 0)
{
amount = atoi(floater->getChild<LLUICtrl>("amount")->getValue().asString().c_str());
}
if (amount > PAY_AMOUNT_NOTIFICATION && gStatusBar && gStatusBar->getBalance() > amount)
{
LLUUID payee_id;
BOOL is_group;
if (floater->mObjectSelection.notNull())
{
LLSelectNode* node = floater->mObjectSelection->getFirstRootNode();
node->mPermissions->getOwnership(payee_id, is_group);
}
else
{
is_group = floater->mTargetIsGroup;
payee_id = floater->mTargetUUID;
}
LLSD args;
args["TARGET"] = LLSLURL( is_group ? "group" : "agent", payee_id, "completename").getSLURLString();
args["AMOUNT"] = amount;
LLNotificationsUtil::add("PayConfirmation", args, LLSD(), boost::bind(&LLFloaterPay::payConfirmationCallback, _1, _2, info));
}
else
{
floater->give(amount);
floater->closeFloater();
}
}
}
@ -487,7 +529,6 @@ void LLFloaterPay::give(S32 amount)
{
amount = atoi(getChild<LLUICtrl>("amount")->getValue().asString().c_str());
}
sLastAmount = amount;
// Try to pay an object.
if (mObjectSelection.notNull())

7
indra/newview/llfloaterwebcontent.cpp
View File

@ -293,6 +293,7 @@ void LLFloaterWebContent::onOpen(const LLSD& key)
void LLFloaterWebContent::onClose(bool app_quitting)
{
// If we close the web browsing window showing the facebook login, we need to signal to this object that the connection will not happen
// MAINT-3440 note change here to use findInstance and not getInstance - latter creates an instance if it's not there which is bad.
LLFloater* fbc_web = LLFloaterReg::findInstance("fbc_web");
if (fbc_web == this)
{
@ -302,7 +303,8 @@ void LLFloaterWebContent::onClose(bool app_quitting)
}
}
// Same with Flickr
LLFloater* flickr_web = LLFloaterReg::getInstance("flickr_web");
// MAINT-3440 note change here to use findInstance and not getInstance - latter creates an instance if it's not there which is bad.
LLFloater* flickr_web = LLFloaterReg::findInstance("flickr_web");
if (flickr_web == this)
{
if (!LLFlickrConnect::instance().isConnected())
@ -311,7 +313,8 @@ void LLFloaterWebContent::onClose(bool app_quitting)
}
}
// And Twitter
LLFloater* twitter_web = LLFloaterReg::getInstance("twitter_web");
// MAINT-3440 note change here to use findInstance and not getInstance - latter creates an instance if it's not there which is bad.
LLFloater* twitter_web = LLFloaterReg::findInstance("twitter_web");
if (twitter_web == this)
{
if (!LLTwitterConnect::instance().isConnected())

12
indra/newview/llfolderviewmodelinventory.cpp
View File

@ -130,13 +130,18 @@ void LLFolderViewModelItemInventory::requestSort()
void LLFolderViewModelItemInventory::setPassedFilter(bool passed, S32 filter_generation, std::string::size_type string_offset, std::string::size_type string_size)
{
bool generation_skip = mMarkedDirtyGeneration >= 0
&& mPrevPassedAllFilters
&& mMarkedDirtyGeneration < mRootViewModel.getFilter().getFirstSuccessGeneration();
LLFolderViewModelItemCommon::setPassedFilter(passed, filter_generation, string_offset, string_size);
bool before = mPrevPassedAllFilters;
mPrevPassedAllFilters = passedFilter(filter_generation);
if (before != mPrevPassedAllFilters)
if (before != mPrevPassedAllFilters || generation_skip)
{
// Need to rearrange the folder if the filtered state of the item changed
// Need to rearrange the folder if the filtered state of the item changed,
// previously passed item skipped filter generation changes while being dirty
// or previously passed not yet filtered item was marked dirty
LLFolderViewFolder* parent_folder = mFolderViewItem->getParentFolder();
if (parent_folder)
{
@ -145,6 +150,9 @@ void LLFolderViewModelItemInventory::setPassedFilter(bool passed, S32 filter_gen
}
}
bool LLFolderViewModelItemInventory::filterChildItem( LLFolderViewModelItem* item, LLFolderViewFilter& filter )
{
S32 filter_generation = filter.getCurrentGeneration();

52
indra/newview/llglsandbox.cpp
View File

@ -881,13 +881,14 @@ void LLViewerObjectList::renderObjectBeacons()
F32 gpu_benchmark()
{
if (!gGLManager.mHasShaderObjects)
{ //don't bother benchmarking the fixed function
if (!gGLManager.mHasShaderObjects || !gGLManager.mHasTimerQuery)
{ // don't bother benchmarking the fixed function
// or venerable drivers which don't support accurate timing anyway
// and are likely to be correctly identified by the GPU table already.
return -1.f;
}
if (gBenchmarkProgram.mProgramObject == 0)
if (gBenchmarkProgram.mProgramObject == 0)
{
LLViewerShaderMgr::instance()->initAttribsAndUniforms();
@ -920,7 +921,10 @@ F32 gpu_benchmark()
//number of samples to take
const S32 samples = 64;
LLGLSLShader::initProfile();
if (gGLManager.mHasTimerQuery)
{
LLGLSLShader::initProfile();
}
LLRenderTarget dest[count];
U32 source[count];
@ -964,16 +968,16 @@ F32 gpu_benchmark()
v[0].set(-1,1,0);
v[1].set(-1,-3,0);
v[2].set(3,1,0);
buff->flush();
gBenchmarkProgram.bind();
buff->setBuffer(LLVertexBuffer::MAP_VERTEX);
//wait for any previoius GL commands to finish
glFinish();
bool busted_finish = false;
buff->setBuffer(LLVertexBuffer::MAP_VERTEX);
glFinish();
for (S32 c = -1; c < samples; ++c)
{
LLTimer timer;
@ -1013,6 +1017,7 @@ F32 gpu_benchmark()
if (!gGLManager.mHasTimerQuery && !busted_finish && gbps > 128.f)
{ //unrealistically high bandwidth for a card without timer queries, glFinish is probably ignored
busted_finish = true;
LL_WARNS() << "GPU Benchmark detected GL driver with broken glFinish implementation." << LL_ENDL;
}
else
{
@ -1023,10 +1028,12 @@ F32 gpu_benchmark()
gBenchmarkProgram.unbind();
LLGLSLShader::finishProfile(false);
LLImageGL::deleteTextures(count, source);
if (gGLManager.mHasTimerQuery)
{
LLGLSLShader::finishProfile(false);
}
LLImageGL::deleteTextures(count, source);
std::sort(results.begin(), results.end());
@ -1037,27 +1044,20 @@ F32 gpu_benchmark()
#if LL_DARWIN
if (gbps > 512.f)
{
LL_INFOS() << "Memory bandwidth is improbably high and likely incorrect." << LL_ENDL;
LL_WARNS() << "Memory bandwidth is improbably high and likely incorrect; discarding result." << LL_ENDL;
//OSX is probably lying, discard result
gbps = -1.f;
}
#endif
if (gGLManager.mHasTimerQuery)
{
F32 ms = gBenchmarkProgram.mTimeElapsed/1000000.f;
F32 seconds = ms/1000.f;
F32 ms = gBenchmarkProgram.mTimeElapsed/1000000.f;
F32 seconds = ms/1000.f;
F64 samples_drawn = res*res*count*samples;
F32 samples_sec = (samples_drawn/1000000000.0)/seconds;
gbps = samples_sec*8;
F64 samples_drawn = res*res*count*samples;
F32 samples_sec = (samples_drawn/1000000000.0)/seconds;
gbps = samples_sec*8;
LL_INFOS() << "Memory bandwidth is " << llformat("%.3f", gbps) << "GB/sec according to ARB_timer_query" << LL_ENDL;
}
else
{
LL_INFOS() << "ARB_timer_query unavailable." << LL_ENDL;
}
LL_INFOS() << "Memory bandwidth is " << llformat("%.3f", gbps) << "GB/sec according to ARB_timer_query" << LL_ENDL;
return gbps;
}

82
indra/newview/llinventorybridge.cpp
View File

@ -84,6 +84,8 @@ void copy_slurl_to_clipboard_callback_inv(const std::string& slurl);
typedef std::pair<LLUUID, LLUUID> two_uuids_t;
typedef std::list<two_uuids_t> two_uuids_list_t;
const F32 SOUND_GAIN = 1.0f;
struct LLMoveInv
{
LLUUID mObjectID;
@ -2935,8 +2937,8 @@ void LLRightClickInventoryFetchDescendentsObserver::execute(bool clear_observer)
class LLInventoryCopyAndWearObserver : public LLInventoryObserver
{
public:
LLInventoryCopyAndWearObserver(const LLUUID& cat_id, int count, bool folder_added=false) :
mCatID(cat_id), mContentsCount(count), mFolderAdded(folder_added) {}
LLInventoryCopyAndWearObserver(const LLUUID& cat_id, int count, bool folder_added=false, bool replace=false) :
mCatID(cat_id), mContentsCount(count), mFolderAdded(folder_added), mReplace(replace){}
virtual ~LLInventoryCopyAndWearObserver() {}
virtual void changed(U32 mask);
@ -2944,6 +2946,7 @@ protected:
LLUUID mCatID;
int mContentsCount;
bool mFolderAdded;
bool mReplace;
};
@ -2982,7 +2985,7 @@ void LLInventoryCopyAndWearObserver::changed(U32 mask)
mContentsCount)
{
gInventory.removeObserver(this);
LLAppearanceMgr::instance().wearInventoryCategory(category, FALSE, TRUE);
LLAppearanceMgr::instance().wearInventoryCategory(category, FALSE, !mReplace);
delete this;
}
}
@ -4131,24 +4134,21 @@ void LLFolderBridge::modifyOutfit(BOOL append)
// checking amount of items to wear
U32 max_items = gSavedSettings.getU32("WearFolderLimit");
if (cat->getDescendentCount() > max_items)
{
LLInventoryModel::cat_array_t cats;
LLInventoryModel::item_array_t items;
LLFindWearablesEx not_worn(/*is_worn=*/ false, /*include_body_parts=*/ false);
gInventory.collectDescendentsIf(cat->getUUID(),
cats,
items,
LLInventoryModel::EXCLUDE_TRASH,
not_worn);
LLInventoryModel::cat_array_t cats;
LLInventoryModel::item_array_t items;
LLFindWearablesEx not_worn(/*is_worn=*/ false, /*include_body_parts=*/ false);
gInventory.collectDescendentsIf(cat->getUUID(),
cats,
items,
LLInventoryModel::EXCLUDE_TRASH,
not_worn);
if (items.size() > max_items)
{
LLSD args;
args["AMOUNT"] = llformat("%d", max_items);
LLNotificationsUtil::add("TooManyWearables", args);
return;
}
if (items.size() > max_items)
{
LLSD args;
args["AMOUNT"] = llformat("%d", max_items);
LLNotificationsUtil::add("TooManyWearables", args);
return;
}
LLAppearanceMgr::instance().wearInventoryCategory( cat, FALSE, append );
@ -4168,7 +4168,8 @@ bool move_task_inventory_callback(const LLSD& notification, const LLSD& response
LLInventoryObject::object_list_t inventory_objects;
object->getInventoryContents(inventory_objects);
int contents_count = inventory_objects.size()-1; //subtract one for containing folder
LLInventoryCopyAndWearObserver* inventoryObserver = new LLInventoryCopyAndWearObserver(cat_and_wear->mCatID, contents_count, cat_and_wear->mFolderResponded);
LLInventoryCopyAndWearObserver* inventoryObserver = new LLInventoryCopyAndWearObserver(cat_and_wear->mCatID, contents_count, cat_and_wear->mFolderResponded,
cat_and_wear->mReplace);
gInventory.addObserver(inventoryObserver);
}
@ -4938,6 +4939,23 @@ void LLSoundBridge::buildContextMenu(LLMenuGL& menu, U32 flags)
hide_context_entries(menu, items, disabled_items);
}
void LLSoundBridge::performAction(LLInventoryModel* model, std::string action)
{
if ("sound_play" == action)
{
LLViewerInventoryItem* item = getItem();
if(item)
{
send_sound_trigger(item->getAssetUUID(), SOUND_GAIN);
}
}
else if ("open" == action)
{
openSoundPreview((void*)this);
}
else LLItemBridge::performAction(model, action);
}
// +=================================================+
// | LLLandmarkBridge |
// +=================================================+
@ -5781,16 +5799,20 @@ std::string LLObjectBridge::getLabelSuffix() const
{
return LLItemBridge::getLabelSuffix() + LLTrans::getString("worn");
}
std::string attachment_point_name = gAgentAvatarp->getAttachedPointName(mUUID);
if (attachment_point_name == LLStringUtil::null) // Error condition, invalid attach point
std::string attachment_point_name;
if (gAgentAvatarp->getAttachedPointName(mUUID, attachment_point_name))
{
attachment_point_name = "Invalid Attachment";
}
// e.g. "(worn on ...)" / "(attached to ...)"
LLStringUtil::format_map_t args;
args["[ATTACHMENT_POINT]"] = LLTrans::getString(attachment_point_name);
LLStringUtil::format_map_t args;
args["[ATTACHMENT_POINT]"] = LLTrans::getString(attachment_point_name);
return LLItemBridge::getLabelSuffix() + LLTrans::getString("WornOnAttachmentPoint", args);
return LLItemBridge::getLabelSuffix() + LLTrans::getString("WornOnAttachmentPoint", args);
}
else
{
LLStringUtil::format_map_t args;
args["[ATTACHMENT_ERROR]"] = LLTrans::getString(attachment_point_name);
return LLItemBridge::getLabelSuffix() + LLTrans::getString("AttachmentErrorMessage", args);
}
}
return LLItemBridge::getLabelSuffix();
}
@ -6611,7 +6633,7 @@ public:
LLViewerInventoryItem* item = getItem();
if (item)
{
LLFloaterReg::showInstance("preview_sound", LLSD(mUUID), TAKE_FOCUS_YES);
send_sound_trigger(item->getAssetUUID(), SOUND_GAIN);
}
LLInvFVBridgeAction::doIt();
}

1
indra/newview/llinventorybridge.h
View File

@ -403,6 +403,7 @@ public:
LLItemBridge(inventory, root, uuid) {}
virtual void openItem();
virtual void buildContextMenu(LLMenuGL& menu, U32 flags);
virtual void performAction(LLInventoryModel* model, std::string action);
static void openSoundPreview(void*);
};

18
indra/newview/llinventoryfilter.cpp
View File

@ -128,6 +128,15 @@ bool LLInventoryFilter::checkFolder(const LLFolderViewModelItem* item) const
bool LLInventoryFilter::checkFolder(const LLUUID& folder_id) const
{
// Always check against the clipboard
const BOOL passed_clipboard = checkAgainstClipboard(folder_id);
// we're showing all folders, overriding filter
if (mFilterOps.mShowFolderState == LLInventoryFilter::SHOW_ALL_FOLDERS)
{
return passed_clipboard;
}
// when applying a filter, matching folders get their contents downloaded first
if (isNotDefault()
&& !gInventory.isCategoryComplete(folder_id))
@ -168,15 +177,6 @@ bool LLInventoryFilter::checkFolder(const LLUUID& folder_id) const
}
}
// Always check against the clipboard
const BOOL passed_clipboard = checkAgainstClipboard(folder_id);
// we're showing all folders, overriding filter
if (mFilterOps.mShowFolderState == LLInventoryFilter::SHOW_ALL_FOLDERS)
{
return passed_clipboard;
}
// show folder links
LLViewerInventoryItem* item = gInventory.getItem(folder_id);
if (item && item->getActualType() == LLAssetType::AT_LINK_FOLDER)

30
indra/newview/llinventorypanel.cpp
View File

@ -548,12 +548,13 @@ void LLInventoryPanel::modelChanged(U32 mask)
// This item already exists in both memory and UI. It was probably reparented.
else if (model_item && view_item)
{
LLFolderViewFolder* old_parent = view_item->getParentFolder();
// Don't process the item if it is the root
if (view_item->getParentFolder())
if (old_parent)
{
LLFolderViewFolder* new_parent = (LLFolderViewFolder*)getItemByID(model_item->getParentUUID());
// Item has been moved.
if (view_item->getParentFolder() != new_parent)
if (old_parent != new_parent)
{
if (new_parent != NULL)
{
@ -579,6 +580,7 @@ void LLInventoryPanel::modelChanged(U32 mask)
// doesn't include trash). Just remove the item's UI.
view_item->destroyView();
}
old_parent->getViewModelItem()->dirtyDescendantsFilter();
}
}
}
@ -589,28 +591,16 @@ void LLInventoryPanel::modelChanged(U32 mask)
else if (!model_item && view_item && viewmodel_item)
{
// Remove the item's UI.
const LLUUID& idp = viewmodel_item->getUUID();
removeItemID(idp);
LLFolderViewFolder* parent = view_item->getParentFolder();
removeItemID(viewmodel_item->getUUID());
view_item->destroyView();
if(parent)
{
parent->getViewModelItem()->dirtyDescendantsFilter();
}
}
}
}
if (mask & (LLInventoryObserver::STRUCTURE | LLInventoryObserver::REMOVE))
{
// STRUCTURE and REMOVE model changes usually fail to update (clean)
// mMostFilteredDescendantGeneration of parent folder and dirtyFilter()
// is not sufficient for successful filter update, so we need to check
// all already passed element over again to remove obsolete elements.
// New items or moved items should be sufficiently covered by
// dirtyFilter().
LLInventoryFilter& filter = getFilter();
if (filter.getFilterTypes() & LLInventoryFilter::FILTERTYPE_DATE
|| filter.isNotDefault())
{
filter.setModified(LLFolderViewFilter::FILTER_MORE_RESTRICTIVE);
}
}
}
LLUUID LLInventoryPanel::getRootFolderID()

2
indra/newview/lllogchat.cpp
View File

@ -1021,6 +1021,8 @@ void LLLoadHistoryThread::run()
if(mNewLoad)
{
loadHistory(mFileName, mMessages, mLoadParams);
int count = mMessages->size();
LL_INFOS() << "mMessages->size(): " << count << LL_ENDL;
setFinished();
}
}

10
indra/newview/llmaniprotate.cpp
View File

@ -1240,10 +1240,10 @@ LLQuaternion LLManipRotate::dragUnconstrained( S32 x, S32 y )
F32 dist_from_sphere_center = sqrt(delta_x * delta_x + delta_y * delta_y);
LLVector3 axis = mMouseDown % mMouseCur;
F32 angle = atan2(sqrtf(axis * axis), mMouseDown * mMouseCur);
axis.normVec();
F32 angle = acos(mMouseDown * mMouseCur);
LLQuaternion sphere_rot( angle, axis );
if (is_approx_zero(1.f - mMouseDown * mMouseCur))
{
return LLQuaternion::DEFAULT;
@ -1638,9 +1638,9 @@ LLQuaternion LLManipRotate::dragConstrained( S32 x, S32 y )
mInSnapRegime = FALSE;
}
angle = acos(mMouseCur * mMouseDown);
F32 dir = (mMouseDown % mMouseCur) * constraint_axis; // cross product
LLVector3 cross_product = mMouseDown % mMouseCur;
angle = atan2(sqrtf(cross_product * cross_product), mMouseCur * mMouseDown);
F32 dir = cross_product * constraint_axis; // cross product
if( dir < 0.f )
{
angle *= -1.f;

2
indra/newview/llpanelface.cpp
View File

@ -1848,6 +1848,8 @@ void LLPanelFace::onCancelNormalTexture(const LLSD& data)
U8 bumpy = 0;
bool identical_bumpy = false;
LLSelectedTE::getBumpmap(bumpy, identical_bumpy);
LLUUID spec_map_id = getChild<LLTextureCtrl>("bumpytexture control")->getImageAssetID();
bumpy = spec_map_id.isNull() ? bumpy : BUMPY_TEXTURE;
sendBump(bumpy);
}

2
indra/newview/llpanelgroupbulk.cpp
View File

@ -387,7 +387,7 @@ void LLPanelGroupBulk::addUsers(uuid_vec_t& agent_ids)
}
else
{
llwarns << "llPanelGroupBulk: Selected avatar has no name: " << dest->getID() << llendl;
LL_WARNS() << "llPanelGroupBulk: Selected avatar has no name: " << dest->getID() << LL_ENDL;
names.push_back("(Unknown)");
}
}

2
indra/newview/llpanelgroupinvite.cpp
View File

@ -492,7 +492,7 @@ void LLPanelGroupInvite::addUsers(uuid_vec_t& agent_ids)
}
else
{
llwarns << "llPanelGroupInvite: Selected avatar has no name: " << dest->getID() << llendl;
LL_WARNS() << "llPanelGroupInvite: Selected avatar has no name: " << dest->getID() << LL_ENDL;
names.push_back("(Unknown)");
}
}

8
indra/newview/llpanelmaininventory.cpp
View File

@ -153,7 +153,9 @@ BOOL LLPanelMainInventory::postBuild()
recent_items_panel->setSinceLogoff(TRUE);
recent_items_panel->setSortOrder(LLInventoryFilter::SO_DATE);
recent_items_panel->setShowFolderState(LLInventoryFilter::SHOW_NON_EMPTY_FOLDERS);
recent_items_panel->getFilter().markDefault();
LLInventoryFilter& recent_filter = recent_items_panel->getFilter();
recent_filter.setFilterObjectTypes(recent_filter.getFilterObjectTypes() & ~(0x1 << LLInventoryType::IT_CATEGORY));
recent_filter.markDefault();
recent_items_panel->setSelectCallback(boost::bind(&LLPanelMainInventory::onSelectionChange, this, recent_items_panel, _1, _2));
}
@ -853,9 +855,9 @@ void LLFloaterInventoryFinder::draw()
filtered_by_all_types = FALSE;
}
if (!filtered_by_all_types)
if (!filtered_by_all_types || (mPanelMainInventory->getPanel()->getFilter().getFilterTypes() & LLInventoryFilter::FILTERTYPE_DATE))
{
// don't include folders in filter, unless I've selected everything
// don't include folders in filter, unless I've selected everything or filtering by date
filter &= ~(0x1 << LLInventoryType::IT_CATEGORY);
}

4
indra/newview/llpanelobjectinventory.cpp
View File

@ -698,6 +698,10 @@ void LLTaskInvFVBridge::buildContextMenu(LLMenuGL& menu, U32 flags)
if(isItemRenameable())
{
items.push_back(std::string("Task Rename"));
if ((flags & FIRST_SELECTED_ITEM) == 0)
{
disabled_items.push_back(std::string("Task Rename"));
}
}
if(isItemRemovable())
{

26
indra/newview/llpreviewscript.cpp
View File

@ -663,12 +663,13 @@ void LLScriptEdCore::updateDynamicHelp(BOOL immediate)
LLTextSegmentPtr segment = NULL;
std::vector<LLTextSegmentPtr> selected_segments;
mEditor->getSelectedSegments(selected_segments);
LLKeywordToken* token;
// try segments in selection range first
std::vector<LLTextSegmentPtr>::iterator segment_iter;
for (segment_iter = selected_segments.begin(); segment_iter != selected_segments.end(); ++segment_iter)
{
if((*segment_iter)->getToken() && (*segment_iter)->getToken()->getType() == LLKeywordToken::TT_WORD)
token = (*segment_iter)->getToken();
if(token && isKeyword(token))
{
segment = *segment_iter;
break;
@ -679,7 +680,8 @@ void LLScriptEdCore::updateDynamicHelp(BOOL immediate)
if (!segment)
{
const LLTextSegmentPtr test_segment = mEditor->getPreviousSegment();
if(test_segment->getToken() && test_segment->getToken()->getType() == LLKeywordToken::TT_WORD)
token = test_segment->getToken();
if(token && isKeyword(token))
{
segment = test_segment;
}
@ -708,6 +710,24 @@ void LLScriptEdCore::updateDynamicHelp(BOOL immediate)
}
}
bool LLScriptEdCore::isKeyword(LLKeywordToken* token)
{
switch(token->getType())
{
case LLKeywordToken::TT_CONSTANT:
case LLKeywordToken::TT_CONTROL:
case LLKeywordToken::TT_EVENT:
case LLKeywordToken::TT_FUNCTION:
case LLKeywordToken::TT_SECTION:
case LLKeywordToken::TT_TYPE:
case LLKeywordToken::TT_WORD:
return true;
default:
return false;
}
}
void LLScriptEdCore::setHelpPage(const std::string& help_string)
{
LLFloater* help_floater = mLiveHelpHandle.get();

1
indra/newview/llpreviewscript.h
View File

@ -133,6 +133,7 @@ protected:
void deleteBridges();
void setHelpPage(const std::string& help_string);
void updateDynamicHelp(BOOL immediate = FALSE);
bool isKeyword(LLKeywordToken* token);
void addHelpItemToHistory(const std::string& help_string);
static void onErrorList(LLUICtrl*, void* user_data);

2
indra/newview/llspatialpartition.cpp
View File

@ -1632,7 +1632,7 @@ void pushVertsColorCoded(LLSpatialGroup* group, U32 mask)
{
LLDrawInfo* params = NULL;
LLColor4 colors[] = {
static const LLColor4 colors[] = {
LLColor4::green,
LLColor4::green1,
LLColor4::green2,

10
indra/newview/llspeakers.cpp
View File

@ -544,10 +544,18 @@ void LLSpeakerMgr::updateSpeakerList()
LLIMModel::LLIMSession* session = LLIMModel::getInstance()->findIMSession(session_id);
if (session->isGroupSessionType() && (mSpeakers.size() <= 1))
{
const F32 load_group_timeout = gSavedSettings.getF32("ChatLoadGroupTimeout");
// For groups, we need to hit the group manager.
// Note: The session uuid and the group uuid are actually one and the same. If that was to change, this will fail.
LLGroupMgrGroupData* gdatap = LLGroupMgr::getInstance()->getGroupData(session_id);
F32 large_group_delay = 0.f;
if (gdatap)
{
//This is a viewer-side bandaid for maint-4414 it does not fix the core issue.
large_group_delay = (F32)(gdatap->mMemberCount / 5000);
}
const F32 load_group_timeout = gSavedSettings.getF32("ChatLoadGroupTimeout") + large_group_delay;
if (!gdatap && (mGetListTime.getElapsedTimeF32() >= load_group_timeout))
{
// Request the data the first time around

15
indra/newview/lltexturectrl.cpp
View File

@ -118,7 +118,7 @@ public:
/*virtual*/ void onClose(bool app_settings);
// New functions
void setImageID( const LLUUID& image_asset_id);
void setImageID( const LLUUID& image_asset_id, bool set_selection = true);
void updateImageStats();
const LLUUID& getAssetID() { return mImageAssetID; }
const LLUUID& findItemID(const LLUUID& asset_id, BOOL copyable_only);
@ -232,7 +232,7 @@ LLFloaterTexturePicker::~LLFloaterTexturePicker()
{
}
void LLFloaterTexturePicker::setImageID(const LLUUID& image_id)
void LLFloaterTexturePicker::setImageID(const LLUUID& image_id, bool set_selection /*=true*/)
{
if( mImageAssetID != image_id && mActive)
{
@ -253,6 +253,10 @@ void LLFloaterTexturePicker::setImageID(const LLUUID& image_id)
getChild<LLUICtrl>("apply_immediate_check")->setValue(FALSE);
mNoCopyTextureSelected = TRUE;
}
}
if (set_selection)
{
mInventoryPanel->setSelection(item_id, TAKE_FOCUS_NO);
}
}
@ -461,7 +465,10 @@ BOOL LLFloaterTexturePicker::postBuild()
// don't put keyboard focus on selected item, because the selection callback
// will assume that this was user input
mInventoryPanel->setSelection(findItemID(mImageAssetID, FALSE), TAKE_FOCUS_NO);
if(!mImageAssetID.isNull())
{
mInventoryPanel->setSelection(findItemID(mImageAssetID, FALSE), TAKE_FOCUS_NO);
}
}
mModeSelector = getChild<LLRadioGroup>("mode_selection");
@ -820,7 +827,7 @@ void LLFloaterTexturePicker::onSelectionChange(const std::deque<LLFolderViewItem
{
mNoCopyTextureSelected = TRUE;
}
setImageID(itemp->getAssetUUID());
setImageID(itemp->getAssetUUID(),false);
mViewModel->setDirty(); // *TODO: shouldn't we be using setValue() here?
if (user_action && mCanPreview)
{

29
indra/newview/lltooldraganddrop.cpp
View File

@ -2188,23 +2188,20 @@ EAcceptance LLToolDragAndDrop::dad3dWearCategory(
}
U32 max_items = gSavedSettings.getU32("WearFolderLimit");
if (category->getDescendentCount()>max_items)
LLInventoryModel::cat_array_t cats;
LLInventoryModel::item_array_t items;
LLFindWearablesEx not_worn(/*is_worn=*/ false, /*include_body_parts=*/ false);
gInventory.collectDescendentsIf(category->getUUID(),
cats,
items,
LLInventoryModel::EXCLUDE_TRASH,
not_worn);
if (items.size() > max_items)
{
LLInventoryModel::cat_array_t cats;
LLInventoryModel::item_array_t items;
LLFindWearablesEx not_worn(/*is_worn=*/ false, /*include_body_parts=*/ false);
gInventory.collectDescendentsIf(category->getUUID(),
cats,
items,
LLInventoryModel::EXCLUDE_TRASH,
not_worn);
if (items.size() > max_items)
{
LLStringUtil::format_map_t args;
args["AMOUNT"] = llformat("%d", max_items);
mCustomMsg = LLTrans::getString("TooltipTooManyWearables",args);
return ACCEPT_NO_CUSTOM;
}
LLStringUtil::format_map_t args;
args["AMOUNT"] = llformat("%d", max_items);
mCustomMsg = LLTrans::getString("TooltipTooManyWearables",args);
return ACCEPT_NO_CUSTOM;
}
if(mSource == SOURCE_AGENT)

2
indra/newview/lltwitterconnect.cpp
View File

@ -397,7 +397,7 @@ void LLTwitterConnect::uploadPhoto(LLPointer<LLImageFormatted> image, const std:
}
else
{
llwarns << "Image to upload is not a PNG or JPEG" << llendl;
LL_WARNS() << "Image to upload is not a PNG or JPEG" << LL_ENDL;
return;
}

16
indra/newview/llviewerinventory.cpp
View File

@ -1481,7 +1481,8 @@ void update_inventory_category(
void remove_inventory_items(
LLInventoryObject::object_list_t& items_to_kill,
LLPointer<LLInventoryCallback> cb)
LLPointer<LLInventoryCallback> cb
)
{
for (LLInventoryObject::object_list_t::iterator it = items_to_kill.begin();
it != items_to_kill.end();
@ -1493,12 +1494,13 @@ void remove_inventory_items(
void remove_inventory_item(
const LLUUID& item_id,
LLPointer<LLInventoryCallback> cb)
LLPointer<LLInventoryCallback> cb,
bool immediate_delete)
{
LLPointer<LLInventoryObject> obj = gInventory.getItem(item_id);
if (obj)
{
remove_inventory_item(obj, cb);
remove_inventory_item(obj, cb, immediate_delete);
}
else
{
@ -1508,7 +1510,8 @@ void remove_inventory_item(
void remove_inventory_item(
LLPointer<LLInventoryObject> obj,
LLPointer<LLInventoryCallback> cb)
LLPointer<LLInventoryCallback> cb,
bool immediate_delete)
{
if(obj)
{
@ -1518,6 +1521,11 @@ void remove_inventory_item(
{
LLPointer<AISCommand> cmd_ptr = new RemoveItemCommand(item_id, cb);
cmd_ptr->run_command();
if (immediate_delete)
{
gInventory.onObjectDeletedFromServer(item_id);
}
}
else // no cap
{

6
indra/newview/llviewerinventory.h
View File

@ -397,11 +397,13 @@ void remove_inventory_items(
void remove_inventory_item(
LLPointer<LLInventoryObject> obj,
LLPointer<LLInventoryCallback> cb);
LLPointer<LLInventoryCallback> cb,
bool immediate_delete = false);
void remove_inventory_item(
const LLUUID& item_id,
LLPointer<LLInventoryCallback> cb);
LLPointer<LLInventoryCallback> cb,
bool immediate_delete = false);
void remove_inventory_category(
const LLUUID& cat_id,

37
indra/newview/llviewerkeyboard.cpp
View File

@ -88,18 +88,25 @@ void agent_push_down( EKeystate s )
gAgent.moveUp(-1);
}
static void agent_check_temporary_run(LLAgent::EDoubleTapRunMode mode)
{
if (gAgent.mDoubleTapRunMode == mode &&
gAgent.getRunning() &&
!gAgent.getAlwaysRun())
{
// Turn off temporary running.
gAgent.clearRunning();
gAgent.sendWalkRun(gAgent.getRunning());
}
}
static void agent_handle_doubletap_run(EKeystate s, LLAgent::EDoubleTapRunMode mode)
{
if (KEYSTATE_UP == s)
{
if (gAgent.mDoubleTapRunMode == mode &&
gAgent.getRunning() &&
!gAgent.getAlwaysRun())
{
// Turn off temporary running.
gAgent.clearRunning();
gAgent.sendWalkRun(gAgent.getRunning());
}
// Note: in case shift is already released, slide left/right run
// will be released in agent_turn_left()/agent_turn_right()
agent_check_temporary_run(mode);
}
else if (gSavedSettings.getBOOL("AllowTapTapHoldRun") &&
KEYSTATE_DOWN == s &&
@ -218,7 +225,12 @@ void agent_turn_left( EKeystate s )
}
else
{
if (KEYSTATE_UP == s) return;
if (KEYSTATE_UP == s)
{
// Check temporary running. In case user released 'left' key with shift already released.
agent_check_temporary_run(LLAgent::DOUBLETAP_SLIDELEFT);
return;
}
F32 time = gKeyboard->getCurKeyElapsedTime();
gAgent.moveYaw( LLFloaterMove::getYawRate( time ) );
}
@ -241,7 +253,12 @@ void agent_turn_right( EKeystate s )
}
else
{
if (KEYSTATE_UP == s) return;
if (KEYSTATE_UP == s)
{
// Check temporary running. In case user released 'right' key with shift already released.
agent_check_temporary_run(LLAgent::DOUBLETAP_SLIDERIGHT);
return;
}
F32 time = gKeyboard->getCurKeyElapsedTime();
gAgent.moveYaw( -LLFloaterMove::getYawRate( time ) );
}

36
indra/newview/llviewerobject.cpp
View File

@ -359,10 +359,17 @@ void LLViewerObject::markDead()
//LL_INFOS() << "Marking self " << mLocalID << " as dead." << LL_ENDL;
// Root object of this hierarchy unlinks itself.
LLVOAvatar *av = getAvatarAncestor();
if (getParent())
{
((LLViewerObject *)getParent())->removeChild(this);
}
LLUUID mesh_id;
if (av && LLVOAvatar::getRiggedMeshID(this,mesh_id))
{
// This case is needed for indirectly attached mesh objects.
av->resetJointPositionsOnDetach(mesh_id);
}
// Mark itself as dead
mDead = TRUE;
@ -2274,7 +2281,7 @@ U32 LLViewerObject::processUpdateMessage(LLMessageSystem *mesgsys,
}
}
if ((new_rot != getRotation())
if ((new_rot.isNotEqualEps(getRotation(), F_ALMOST_ZERO))
|| (new_angv != old_angv))
{
if (new_rot != mPreviousRotation)
@ -5006,6 +5013,22 @@ LLVOAvatar* LLViewerObject::asAvatar()
return NULL;
}
// If this object is directly or indirectly parented by an avatar, return it.
LLVOAvatar* LLViewerObject::getAvatarAncestor()
{
LLViewerObject *pobj = (LLViewerObject*) getParent();
while (pobj)
{
LLVOAvatar *av = pobj->asAvatar();
if (av)
{
return av;
}
pobj = (LLViewerObject*) pobj->getParent();
}
return NULL;
}
BOOL LLViewerObject::isParticleSource() const
{
return !mPartSourcep.isNull() && !mPartSourcep->isDead();
@ -6193,6 +6216,17 @@ const LLUUID &LLViewerObject::extractAttachmentItemID()
return getAttachmentItemID();
}
const std::string& LLViewerObject::getAttachmentItemName()
{
static std::string empty;
LLInventoryItem *item = gInventory.getItem(getAttachmentItemID());
if (isAttachment() && item)
{
return item->getName();
}
return empty;
}
//virtual
LLVOAvatar* LLViewerObject::getAvatar() const
{

4
indra/newview/llviewerobject.h
View File

@ -135,6 +135,8 @@ public:
virtual LLVOAvatar* asAvatar();
LLVOAvatar* getAvatarAncestor();
static void initVOClasses();
static void cleanupVOClasses();
@ -170,6 +172,8 @@ public:
void setOnActiveList(BOOL on_active) { mOnActiveList = on_active; }
virtual BOOL isAttachment() const { return FALSE; }
const std::string& getAttachmentItemName();
virtual LLVOAvatar* getAvatar() const; //get the avatar this object is attached to, or NULL if object is not an attachment
virtual BOOL isHUDAttachment() const { return FALSE; }
virtual BOOL isTempAttachment() const;

608
indra/newview/llvoavatar.cpp
View File

File diff suppressed because it is too large Load Diff

14
indra/newview/llvoavatar.h
View File

@ -199,7 +199,10 @@ public:
virtual LLJoint* getJoint(const std::string &name);
void resetJointPositionsToDefault( void );
void addAttachmentPosOverridesForObject(LLViewerObject *vo);
void resetJointPositionsOnDetach(const LLUUID& mesh_id);
void resetJointPositionsOnDetach(LLViewerObject *vo);
void clearAttachmentPosOverrides();
/*virtual*/ const LLUUID& getID() const;
/*virtual*/ void addDebugText(const std::string& text);
@ -356,19 +359,11 @@ protected:
/*virtual*/ LLAvatarJointMesh* createAvatarJointMesh(); // Returns LLViewerJointMesh
public:
void updateHeadOffset();
void setPelvisOffset( bool hasOffset, const LLVector3& translation, F32 offset ) ;
bool hasPelvisOffset( void ) { return mHasPelvisOffset; }
void postPelvisSetRecalc( void );
void setPelvisOffset( F32 pelvixFixupAmount );
/*virtual*/ BOOL loadSkeletonNode();
/*virtual*/ void buildCharacter();
bool mHasPelvisOffset;
LLVector3 mPelvisOffset;
F32 mLastPelvisToFoot;
F32 mPelvisFixup;
F32 mLastPelvisFixup;
LLVector3 mCurRootToHeadOffset;
LLVector3 mTargetRootToHeadOffset;
@ -719,6 +714,7 @@ public:
void clampAttachmentPositions();
virtual const LLViewerJointAttachment* attachObject(LLViewerObject *viewer_object);
virtual BOOL detachObject(LLViewerObject *viewer_object);
static bool getRiggedMeshID( LLViewerObject* pVO, LLUUID& mesh_id );
void cleanupAttachedMesh( LLViewerObject* pVO );
static LLVOAvatar* findAvatarFromAttachment(LLViewerObject* obj);
/*virtual*/ BOOL isWearingWearableType(LLWearableType::EType type ) const;

40
indra/newview/llvoavatarself.cpp
View File

@ -262,7 +262,7 @@ void LLVOAvatarSelf::markDead()
{
BOOL success = LLVOAvatar::loadAvatar();
// set all parameters sotred directly in the avatar to have
// set all parameters stored directly in the avatar to have
// the isSelfParam to be TRUE - this is used to prevent
// them from being animated or trigger accidental rebakes
// when we copy params from the wearable to the base avatar.
@ -718,13 +718,8 @@ void LLVOAvatarSelf::updateVisualParams()
LLVOAvatar::updateVisualParams();
}
/*virtual*/
void LLVOAvatarSelf::idleUpdateAppearanceAnimation()
void LLVOAvatarSelf::writeWearablesToAvatar()
{
// Animate all top-level wearable visual parameters
gAgentWearables.animateAllWearableParams(calcMorphAmount());
// apply wearable visual params to avatar
for (U32 type = 0; type < LLWearableType::WT_COUNT; type++)
{
LLWearable *wearable = gAgentWearables.getTopWearable((LLWearableType::EType)type);
@ -734,6 +729,17 @@ void LLVOAvatarSelf::idleUpdateAppearanceAnimation()
}
}
}
/*virtual*/
void LLVOAvatarSelf::idleUpdateAppearanceAnimation()
{
// Animate all top-level wearable visual parameters
gAgentWearables.animateAllWearableParams(calcMorphAmount());
// Apply wearable visual params to avatar
writeWearablesToAvatar();
//allow avatar to process updates
LLVOAvatar::idleUpdateAppearanceAnimation();
@ -1093,9 +1099,19 @@ LLViewerObject* LLVOAvatarSelf::getWornAttachment(const LLUUID& inv_item_id)
return NULL;
}
const std::string LLVOAvatarSelf::getAttachedPointName(const LLUUID& inv_item_id) const
bool LLVOAvatarSelf::getAttachedPointName(const LLUUID& inv_item_id, std::string& name) const
{
if (!gInventory.getItem(inv_item_id))
{
name = "ATTACHMENT_MISSING_ITEM";
return false;
}
const LLUUID& base_inv_item_id = gInventory.getLinkedItemID(inv_item_id);
if (!gInventory.getItem(base_inv_item_id))
{
name = "ATTACHMENT_MISSING_BASE_ITEM";
return false;
}
for (attachment_map_t::const_iterator iter = mAttachmentPoints.begin();
iter != mAttachmentPoints.end();
++iter)
@ -1103,11 +1119,13 @@ const std::string LLVOAvatarSelf::getAttachedPointName(const LLUUID& inv_item_id
const LLViewerJointAttachment* attachment = iter->second;
if (attachment->getAttachedObject(base_inv_item_id))
{
return attachment->getName();
name = attachment->getName();
return true;
}
}
return LLStringUtil::null;
name = "ATTACHMENT_NOT_ATTACHED";
return false;
}
//virtual
@ -1142,8 +1160,6 @@ BOOL LLVOAvatarSelf::detachObject(LLViewerObject *viewer_object)
const LLUUID attachment_id = viewer_object->getAttachmentItemID();
if ( LLVOAvatar::detachObject(viewer_object) )
{
LLVOAvatar::cleanupAttachedMesh( viewer_object );
// the simulator should automatically handle permission revocation
stopMotionFromSource(attachment_id);

5
indra/newview/llvoavatarself.h
View File

@ -86,12 +86,11 @@ public:
/*virtual*/ void requestStopMotion(LLMotion* motion);
/*virtual*/ LLJoint* getJoint(const std::string &name);
void resetJointPositions( void );
/*virtual*/ BOOL setVisualParamWeight(const LLVisualParam *which_param, F32 weight);
/*virtual*/ BOOL setVisualParamWeight(const char* param_name, F32 weight);
/*virtual*/ BOOL setVisualParamWeight(S32 index, F32 weight);
/*virtual*/ void updateVisualParams();
void writeWearablesToAvatar();
/*virtual*/ void idleUpdateAppearanceAnimation();
private:
@ -293,7 +292,7 @@ public:
void addAttachmentRequest(const LLUUID& inv_item_id);
void removeAttachmentRequest(const LLUUID& inv_item_id);
LLViewerObject* getWornAttachment(const LLUUID& inv_item_id);
const std::string getAttachedPointName(const LLUUID& inv_item_id) const;
bool getAttachedPointName(const LLUUID& inv_item_id, std::string& name) const;
/*virtual*/ const LLViewerJointAttachment *attachObject(LLViewerObject *viewer_object);
/*virtual*/ BOOL detachObject(LLViewerObject *viewer_object);
static BOOL detachAttachmentIntoInventory(const LLUUID& item_id);

2
indra/newview/llvoicechannel.cpp
View File

@ -725,6 +725,8 @@ void LLVoiceChannelProximal::handleStatusChange(EStatusType status)
// do not notify user when leaving proximal channel
return;
case STATUS_VOICE_DISABLED:
LLVoiceClient::getInstance()->setUserPTTState(false);
gAgent.setVoiceConnected(false);
//skip showing "Voice not available at your current location" when agent voice is disabled (EXT-4749)
if(LLVoiceClient::getInstance()->voiceEnabled() && LLVoiceClient::getInstance()->isVoiceWorking())
{

7
indra/newview/llvoiceclient.cpp
View File

@ -161,6 +161,13 @@ void LLVoiceClient::userAuthorized(const std::string& user_id, const LLUUID &age
mVoiceModule->userAuthorized(user_id, agentID);
}
void LLVoiceClient::setHidden(bool hidden)
{
if (mVoiceModule)
{
mVoiceModule->setHidden(hidden);
}
}
void LLVoiceClient::terminate()
{

3
indra/newview/llvoiceclient.h
View File

@ -105,6 +105,8 @@ public:
virtual void updateSettings()=0; // call after loading settings and whenever they change
virtual bool isVoiceWorking() const = 0; // connected to a voice server and voice channel
virtual void setHidden(bool hidden)=0; // Hides the user from voice.
virtual const LLVoiceVersionInfo& getVersion()=0;
@ -342,6 +344,7 @@ public:
void setCaptureDevice(const std::string& name);
void setRenderDevice(const std::string& name);
void setHidden(bool hidden);
const LLVoiceDeviceList& getCaptureDevices();
const LLVoiceDeviceList& getRenderDevices();

95
indra/newview/llvoicevivox.cpp
View File

@ -70,6 +70,7 @@
#include "apr_base64.h"
#define USE_SESSION_GROUPS 0
#define VX_NULL_POSITION -2147483648.0 /*The Silence*/
extern LLMenuBarGL* gMenuBarView;
extern void handle_voice_morphing_subscribe();
@ -322,6 +323,7 @@ LLVivoxVoiceClient::LLVivoxVoiceClient() :
mCaptureBufferRecording(false),
mCaptureBufferRecorded(false),
mCaptureBufferPlaying(false),
mShutdownComplete(true),
mPlayRequestCount(0),
mAvatarNameCacheConnection()
@ -376,7 +378,16 @@ void LLVivoxVoiceClient::terminate()
if(mConnected)
{
logout();
connectorShutdown();
connectorShutdown();
#ifdef LL_WINDOWS
int count=0;
while (!mShutdownComplete && 10 > count++)
{
stateMachine();
_sleep(1000);
}
#endif
closeSocket(); // Need to do this now -- bad things happen if the destructor does it later.
cleanUp();
}
@ -476,10 +487,9 @@ void LLVivoxVoiceClient::connectorCreate()
std::string savedLogLevel = gSavedSettings.getString("VivoxDebugLevel");
if(savedLogLevel != "-0")
if(savedLogLevel != "0")
{
LL_DEBUGS("Voice") << "creating connector with logging enabled" << LL_ENDL;
loglevel = "0";
}
stream
@ -488,13 +498,14 @@ void LLVivoxVoiceClient::connectorCreate()
<< "<AccountManagementServer>" << mVoiceAccountServerURI << "</AccountManagementServer>"
<< "<Mode>Normal</Mode>"
<< "<Logging>"
<< "<Folder>" << logpath << "</Folder>"
<< "<FileNamePrefix>Connector</FileNamePrefix>"
<< "<FileNameSuffix>.log</FileNameSuffix>"
<< "<LogLevel>" << loglevel << "</LogLevel>"
<< "<Folder>" << logpath << "</Folder>"
<< "<FileNamePrefix>Connector</FileNamePrefix>"
<< "<FileNameSuffix>.log</FileNameSuffix>"
<< "<LogLevel>" << loglevel << "</LogLevel>"
<< "</Logging>"
<< "<Application>SecondLifeViewer.1</Application>"
<< "</Request>\n\n\n";
<< "<Application></Application>" //Name can cause problems per vivox.
<< "<MaxCalls>12</MaxCalls>"
<< "</Request>\n\n\n";
writeString(stream.str());
}
@ -512,6 +523,7 @@ void LLVivoxVoiceClient::connectorShutdown()
<< "</Request>"
<< "\n\n\n";
mShutdownComplete = false;
mConnectorHandle.clear();
writeString(stream.str());
@ -788,15 +800,32 @@ void LLVivoxVoiceClient::stateMachine()
// vivox executable exists. Build the command line and launch the daemon.
LLProcess::Params params;
params.executable = exe_path;
// SLIM SDK: these arguments are no longer necessary.
// std::string args = " -p tcp -h -c";
std::string loglevel = gSavedSettings.getString("VivoxDebugLevel");
std::string shutdown_timeout = gSavedSettings.getString("VivoxShutdownTimeout");
if(loglevel.empty())
{
loglevel = "0"; // turn logging off completely
}
params.args.add("-ll");
params.args.add(loglevel);
std::string log_folder = gSavedSettings.getString("VivoxLogDirectory");
if (log_folder.empty())
{
log_folder = gDirUtilp->getExpandedFilename(LL_PATH_LOGS, "");
}
params.args.add("-lf");
params.args.add(log_folder);
if(!shutdown_timeout.empty())
{
params.args.add("-st");
params.args.add(shutdown_timeout);
}
params.cwd = gDirUtilp->getAppRODataDir();
sGatewayPtr = LLProcess::create(params);
@ -1334,7 +1363,7 @@ void LLVivoxVoiceClient::stateMachine()
{
// Connect to a session by URI
sessionCreateSendMessage(mAudioSession, true, false);
}
}
notifyStatusObservers(LLVoiceClientStatusObserver::STATUS_JOINING);
setState(stateJoiningSession);
@ -1510,7 +1539,7 @@ void LLVivoxVoiceClient::stateMachine()
// Always reset the terminate request flag when we get here.
mSessionTerminateRequested = false;
if((mVoiceEnabled || !mIsInitialized) && !mRelogRequested)
if((mVoiceEnabled || !mIsInitialized) && !mRelogRequested && !LLApp::isExiting())
{
// Just leaving a channel, go back to stateNoChannel (the "logged in but have no channel" state).
setState(stateNoChannel);
@ -1553,6 +1582,7 @@ void LLVivoxVoiceClient::stateMachine()
//MARK: stateConnectorStopping
case stateConnectorStopping: // waiting for connector stop
// The handler for the Connector.InitiateShutdown response will transition from here to stateConnectorStopped.
mShutdownComplete = true;
break;
//MARK: stateConnectorStopped
@ -2318,6 +2348,14 @@ static void oldSDKTransform (LLVector3 &left, LLVector3 &up, LLVector3 &at, LLVe
#endif
}
void LLVivoxVoiceClient::setHidden(bool hidden)
{
mHidden = hidden;
sendPositionalUpdate();
return;
}
void LLVivoxVoiceClient::sendPositionalUpdate(void)
{
std::ostringstream stream;
@ -2339,14 +2377,23 @@ void LLVivoxVoiceClient::sendPositionalUpdate(void)
l = mAvatarRot.getLeftRow();
u = mAvatarRot.getUpRow();
a = mAvatarRot.getFwdRow();
pos = mAvatarPosition;
pos = mAvatarPosition;
vel = mAvatarVelocity;
// SLIM SDK: the old SDK was doing a transform on the passed coordinates that the new one doesn't do anymore.
// The old transform is replicated by this function.
oldSDKTransform(l, u, a, pos, vel);
if (mHidden)
{
for (int i=0;i<3;++i)
{
pos.mdV[i] = VX_NULL_POSITION;
}
}
stream
stream
<< "<Position>"
<< "<X>" << pos.mdV[VX] << "</X>"
<< "<Y>" << pos.mdV[VY] << "</Y>"
@ -2406,14 +2453,23 @@ void LLVivoxVoiceClient::sendPositionalUpdate(void)
l = earRot.getLeftRow();
u = earRot.getUpRow();
a = earRot.getFwdRow();
pos = earPosition;
pos = earPosition;
vel = earVelocity;
// LL_DEBUGS("Voice") << "Sending listener position " << earPosition << LL_ENDL;
oldSDKTransform(l, u, a, pos, vel);
stream
if (mHidden)
{
for (int i=0;i<3;++i)
{
pos.mdV[i] = VX_NULL_POSITION;
}
}
stream
<< "<Position>"
<< "<X>" << pos.mdV[VX] << "</X>"
<< "<Y>" << pos.mdV[VY] << "</Y>"
@ -3169,7 +3225,7 @@ void LLVivoxVoiceClient::mediaStreamUpdatedEvent(
session->mErrorStatusCode = statusCode;
break;
}
switch(state)
{
case streamStateIdle:
@ -5433,7 +5489,8 @@ void LLVivoxVoiceClient::notifyStatusObservers(LLVoiceClientStatusObserver::ESta
// skipped to avoid speak button blinking
if ( status != LLVoiceClientStatusObserver::STATUS_JOINING
&& status != LLVoiceClientStatusObserver::STATUS_LEFT_CHANNEL)
&& status != LLVoiceClientStatusObserver::STATUS_LEFT_CHANNEL
&& status != LLVoiceClientStatusObserver::STATUS_VOICE_DISABLED)
{
bool voice_status = LLVoiceClient::getInstance()->voiceEnabled() && LLVoiceClient::getInstance()->isVoiceWorking();

3
indra/newview/llvoicevivox.h
View File

@ -723,6 +723,7 @@ private:
bool mRenderDeviceDirty;
bool mIsInitialized;
bool mShutdownComplete;
bool checkParcelChanged(bool update = false);
@ -747,6 +748,7 @@ private:
std::string getAudioSessionURI();
std::string getAudioSessionHandle();
void setHidden(bool hidden); //virtual
void sendPositionalUpdate(void);
void buildSetCaptureDevice(std::ostringstream &stream);
@ -775,6 +777,7 @@ private:
bool mMuteMic;
bool mMuteMicDirty;
bool mHidden; //Set to true during teleport to hide the agent's position.
// Set to true when the friends list is known to have changed.
bool mFriendsListDirty;

74
indra/newview/llvovolume.cpp
View File

@ -2040,7 +2040,18 @@ S32 LLVOVolume::setTEMaterialID(const U8 te, const LLMaterialID& pMaterialID)
S32 LLVOVolume::setTEMaterialParams(const U8 te, const LLMaterialPtr pMaterialParams)
{
S32 res = LLViewerObject::setTEMaterialParams(te, pMaterialParams);
S32 res = 0;
if (pMaterialParams && getTEImage(te) && 3 == getTEImage(te)->getComponents() && pMaterialParams->getDiffuseAlphaMode())
{
LLViewerObject::setTEMaterialID(te, LLMaterialID::null);
res = LLViewerObject::setTEMaterialParams(te, NULL);
}
else
{
res = LLViewerObject::setTEMaterialParams(te, pMaterialParams);
}
LL_DEBUGS("MaterialTEs") << "te " << (S32)te << " material " << ((pMaterialParams) ? pMaterialParams->asLLSD() : LLSD("null")) << " res " << res
<< ( LLSelectMgr::getInstance()->getSelection()->contains(const_cast<LLVOVolume*>(this), te) ? " selected" : " not selected" )
<< LL_ENDL;
@ -4328,7 +4339,7 @@ void LLVolumeGeometryManager::registerFace(LLSpatialGroup* group, LLFace* facep,
draw_info->mBump = bump;
draw_info->mShiny = shiny;
float alpha[4] =
static const float alpha[4] =
{
0.00f,
0.25f,
@ -4517,7 +4528,9 @@ void LLVolumeGeometryManager::rebuildGeom(LLSpatialGroup* group)
//Determine if we've received skininfo that contains an
//alternate bind matrix - if it does then apply the translational component
//to the joints of the avatar.
#if 0
bool pelvisGotSet = false;
#endif
{
LL_RECORD_BLOCK_TIME(FTM_REBUILD_VOLUME_FACE_LIST);
@ -4602,53 +4615,12 @@ void LLVolumeGeometryManager::rebuildGeom(LLSpatialGroup* group)
//get drawpool of avatar with rigged face
LLDrawPoolAvatar* pool = get_avatar_drawpool(vobj);
// FIXME should this be inside the face loop?
// doesn't seem to depend on any per-face state.
if ( pAvatarVO )
{
LLUUID currentId = vobj->getVolume()->getParams().getSculptID();
const LLMeshSkinInfo* pSkinData = gMeshRepo.getSkinInfo( currentId, vobj );
if ( pSkinData )
{
const int bindCnt = pSkinData->mAlternateBindMatrix.size();
if ( bindCnt > 0 )
{
const int jointCnt = pSkinData->mJointNames.size();
const F32 pelvisZOffset = pSkinData->mPelvisOffset;
bool fullRig = (jointCnt>=JOINT_COUNT_REQUIRED_FOR_FULLRIG) ? true : false;
if ( fullRig )
{
for ( int i=0; i<jointCnt; ++i )
{
std::string lookingForJoint = pSkinData->mJointNames[i].c_str();
LLJoint* pJoint = pAvatarVO->getJoint( lookingForJoint );
if ( pJoint && pJoint->getId() != currentId )
{
pJoint->setId( currentId );
const LLVector3& jointPos = pSkinData->mAlternateBindMatrix[i].getTranslation();
//Set the joint position
pJoint->storeCurrentXform( jointPos );
//If joint is a pelvis then handle old/new pelvis to foot values
if ( lookingForJoint == "mPelvis" )
{
if ( !pAvatarVO->hasPelvisOffset() )
{
pAvatarVO->setPelvisOffset( true, jointPos, pelvisZOffset );
pelvisGotSet = true;
}
}
}
}
}
}
}
pAvatarVO->addAttachmentPosOverridesForObject(vobj);
}
//Rebuild body data if we altered joints/pelvis
if ( pelvisGotSet && pAvatarVO )
{
pAvatarVO->postPelvisSetRecalc();
}
if (pool)
{
@ -5006,14 +4978,6 @@ void LLVolumeGeometryManager::rebuildGeom(LLSpatialGroup* group)
}
}
}
group->mBufferUsage = useage;
@ -5652,7 +5616,7 @@ void LLVolumeGeometryManager::genDrawInfo(LLSpatialGroup* group, U32 mask, LLFac
if (material_pass)
{
U32 pass[] =
static const U32 pass[] =
{
LLRenderPass::PASS_MATERIAL,
LLRenderPass::PASS_ALPHA, //LLRenderPass::PASS_MATERIAL_ALPHA,

10
indra/newview/llwearableitemslist.cpp
View File

@ -364,8 +364,14 @@ void LLPanelAttachmentListItem::updateItem(const std::string& name,
LLViewerInventoryItem* inv_item = getItem();
if (inv_item && isAgentAvatarValid() && gAgentAvatarp->isWearingAttachment(inv_item->getLinkedUUID()))
{
std::string joint = LLTrans::getString(gAgentAvatarp->getAttachedPointName(inv_item->getLinkedUUID()));
title_joint = title_joint + " (" + joint + ")";
std::string found_name;
bool found = gAgentAvatarp->getAttachedPointName(inv_item->getLinkedUUID(),found_name);
std::string trans_name = LLTrans::getString(found_name);
if (!found)
{
LL_WARNS() << "invalid attachment joint, err " << found_name << LL_ENDL;
}
title_joint = title_joint + " (" + trans_name + ")";
}
LLPanelInventoryListItemBase::updateItem(title_joint, item_state);

2
indra/newview/skins/default/xui/en/floater_joystick.xml
View File

@ -4,7 +4,7 @@
height="500"
layout="topleft"
name="Joystick"
help_topic="joystick"
help_topic="Viewerhelp:Joystick_Configuration"
title="JOYSTICK CONFIGURATION"
width="569">
<floater.string

Some files were not shown because too many files have changed in this diff Show More