Singularity-Viewer/SingularityViewer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'future' of https://github.com/Shyotl/SingularityViewer

Browse Source 
Conflicts:
	indra/newview/app_settings/shaders/class2/effects/gaussBlurF.glsl
	indra/newview/llmanipscale.cpp
	indra/newview/llmeshrepository.cpp
	indra/newview/llviewerregion.cpp
	indra/newview/llvovolume.cpp
This commit is contained in:
Siana Gearz
2011-12-24 20:12:12 +01:00
parent 3df853b74b a2fb56bf48
commit fd22d80dfd
528 changed files with 24927 additions and 13128 deletions
Download Patch File Download Diff File Expand all files Collapse all files

709
indra/newview/llhudtext.cpp
View File

@@ -64,19 +64,18 @@ const F32 SPRING_STRENGTH = 0.7f;
const F32 RESTORATION_SPRING_TIME_CONSTANT = 0.1f;
const F32 HORIZONTAL_PADDING = 15.f;
const F32 VERTICAL_PADDING = 12.f;
const F32 LINE_PADDING = 3.f; // aka "leading"
const F32 BUFFER_SIZE = 2.f;
const F32 MIN_EDGE_OVERLAP = 3.f;
F32 HUD_TEXT_MAX_WIDTH = 190.f;
const F32 HUD_TEXT_MAX_WIDTH = 190.f;
const F32 HUD_TEXT_MAX_WIDTH_NO_BUBBLE = 1000.f;
const F32 RESIZE_TIME = 0.f;
const S32 NUM_OVERLAP_ITERATIONS = 10;
const F32 NEIGHBOR_FORCE_FRACTION = 1.f;
const F32 POSITION_DAMPING_TC = 0.2f;
const F32 MAX_STABLE_CAMERA_VELOCITY = 0.1f;
const F32 LOD_0_SCREEN_COVERAGE = 0.15f;
const F32 LOD_1_SCREEN_COVERAGE = 0.30f;
const F32 LOD_2_SCREEN_COVERAGE = 0.40f;
//const F32 LOD_0_SCREEN_COVERAGE = 0.15f;
//const F32 LOD_1_SCREEN_COVERAGE = 0.30f;
//const F32 LOD_2_SCREEN_COVERAGE = 0.40f;
std::set<LLPointer<LLHUDText> > LLHUDText::sTextObjects;
std::vector<LLPointer<LLHUDText> > LLHUDText::sVisibleTextObjects;
@@ -85,15 +84,14 @@ BOOL LLHUDText::sDisplayText = TRUE ;
bool lltextobject_further_away::operator()(const LLPointer<LLHUDText>& lhs, const LLPointer<LLHUDText>& rhs) const
{
return (lhs->getDistance() > rhs->getDistance()) ? true : false;
return lhs->getDistance() > rhs->getDistance();
}
LLHUDText::LLHUDText(const U8 type) :
LLHUDObject(type),
mUseBubble(FALSE),
mUsePixelSize(TRUE),
mVisibleOffScreen(FALSE),
mOnHUDAttachment(FALSE),
// mVisibleOffScreen(FALSE),
mWidth(0.f),
mHeight(0.f),
mFontp(LLFontGL::getFontSansSerifSmall()),
@@ -103,7 +101,6 @@ LLHUDText::LLHUDText(const U8 type) :
mOffsetY(0),
mTextAlignment(ALIGN_TEXT_CENTER),
mVertAlignment(ALIGN_VERT_CENTER),
mLOD(0),
mHidden(FALSE)
{
mColor = LLColor4(1.f, 1.f, 1.f, 1.f);
@@ -111,7 +108,6 @@ LLHUDText::LLHUDText(const U8 type) :
mFadeDistance = gSavedSettings.getF32("SGTextFadeDistance");
mFadeRange = mFadeDistance/2.f;
mZCompare = TRUE;
mDropShadow = TRUE;
mOffscreen = FALSE;
mRadius = 0.1f;
LLPointer<LLHUDText> ptr(this);
@@ -123,147 +119,25 @@ LLHUDText::~LLHUDText()
{
}
BOOL LLHUDText::lineSegmentIntersect(const LLVector3& start, const LLVector3& end, LLVector3& intersection, BOOL debug_render)
{
if (!mVisible || mHidden)
{
return FALSE;
}
// don't pick text that isn't bound to a viewerobject or isn't in a bubble
if (!mSourceObject || mSourceObject->mDrawable.isNull() || !mUseBubble)
{
return FALSE;
}
F32 alpha_factor = 1.f;
LLColor4 text_color = mColor;
if (mDoFade)
{
if (mLastDistance > mFadeDistance)
{
alpha_factor = llmax(0.f, 1.f - (mLastDistance - mFadeDistance)/mFadeRange);
text_color.mV[3] = text_color.mV[3]*alpha_factor;
}
}
if (text_color.mV[3] < 0.01f)
{
return FALSE;
}
mOffsetY = lltrunc(mHeight * ((mVertAlignment == ALIGN_VERT_CENTER) ? 0.5f : 1.f));
// scale screen size of borders down
//RN: for now, text on hud objects is never occluded
LLVector3 x_pixel_vec;
LLVector3 y_pixel_vec;
if (mOnHUDAttachment)
{
x_pixel_vec = LLVector3::y_axis / (F32)gViewerWindow->getWindowWidth();
y_pixel_vec = LLVector3::z_axis / (F32)gViewerWindow->getWindowHeight();
}
else
{
LLViewerCamera::getInstance()->getPixelVectors(mPositionAgent, y_pixel_vec, x_pixel_vec);
}
LLVector3 width_vec = mWidth * x_pixel_vec;
LLVector3 height_vec = mHeight * y_pixel_vec;
LLCoordGL screen_pos;
LLViewerCamera::getInstance()->projectPosAgentToScreen(mPositionAgent, screen_pos, FALSE);
LLVector2 screen_offset;
screen_offset = updateScreenPos(mPositionOffset);
LLVector3 render_position = mPositionAgent
+ (x_pixel_vec * screen_offset.mV[VX])
+ (y_pixel_vec * screen_offset.mV[VY]);
if (mUseBubble)
{
LLVector3 bg_pos = render_position
+ (F32)mOffsetY * y_pixel_vec
- (width_vec / 2.f)
- (height_vec);
//LLUI::translate(bg_pos.mV[VX], bg_pos.mV[VY], bg_pos.mV[VZ]);
LLVector3 v[] =
{
bg_pos,
bg_pos + width_vec,
bg_pos + width_vec + height_vec,
bg_pos + height_vec,
};
if (debug_render)
{
gGL.begin(LLRender::LINE_STRIP);
gGL.vertex3fv(v[0].mV);
gGL.vertex3fv(v[1].mV);
gGL.vertex3fv(v[2].mV);
gGL.vertex3fv(v[3].mV);
gGL.vertex3fv(v[0].mV);
gGL.vertex3fv(v[2].mV);
gGL.end();
}
LLVector3 dir = end-start;
F32 t = 0.f;
F32 a, b;
if (LLTriangleRayIntersect(v[0], v[1], v[2], start, dir, a, b, t, FALSE) ||
LLTriangleRayIntersect(v[2], v[3], v[0], start, dir, a, b, t, FALSE) )
{
if (t <= 1.f)
{
intersection = start + dir*t;
return TRUE;
}
}
}
return FALSE;
}
void LLHUDText::render()
{
if (!mOnHUDAttachment && sDisplayText)
{
LLGLDepthTest gls_depth(GL_TRUE, GL_FALSE);
renderText(FALSE);
renderText();
}
}
void LLHUDText::renderText(BOOL for_select)
void LLHUDText::renderText()
{
if (!mVisible || mHidden)
{
return;
}
// don't pick text that isn't bound to a viewerobject or isn't in a bubble
if (for_select &&
(!mSourceObject || mSourceObject->mDrawable.isNull() || !mUseBubble))
{
return;
}
if (for_select)
{
gGL.getTexUnit(0)->disable();
}
else
{
gGL.getTexUnit(0)->enable(LLTexUnit::TT_TEXTURE);
}
LLGLState gls_blend(GL_BLEND, for_select ? FALSE : TRUE);
LLGLState gls_alpha(GL_ALPHA_TEST, for_select ? FALSE : TRUE);
LLGLState gls_blend(GL_BLEND, TRUE);
LLGLState gls_alpha(GL_ALPHA_TEST, TRUE);
LLColor4 shadow_color(0.f, 0.f, 0.f, 1.f);
F32 alpha_factor = 1.f;
@@ -316,8 +190,8 @@ void LLHUDText::renderText(BOOL for_select)
if (mOnHUDAttachment)
{
x_pixel_vec = LLVector3::y_axis / (F32)gViewerWindow->getWindowWidth();
y_pixel_vec = LLVector3::z_axis / (F32)gViewerWindow->getWindowHeight();
x_pixel_vec = LLVector3::y_axis / (F32)gViewerWindow->getWorldViewWidthRaw();
y_pixel_vec = LLVector3::z_axis / (F32)gViewerWindow->getWorldViewHeightRaw();
}
else
{
@@ -332,182 +206,18 @@ void LLHUDText::renderText(BOOL for_select)
mRadius = (width_vec + height_vec).magVec() * 0.5f;
LLCoordGL screen_pos;
LLViewerCamera::getInstance()->projectPosAgentToScreen(mPositionAgent, screen_pos, FALSE);
LLVector2 screen_offset;
if (!mUseBubble)
{
screen_offset = mPositionOffset;
}
else
{
screen_offset = updateScreenPos(mPositionOffset);
}
screen_offset = mPositionOffset;
LLVector3 render_position = mPositionAgent
+ (x_pixel_vec * screen_offset.mV[VX])
+ (y_pixel_vec * screen_offset.mV[VY]);
//if (mOnHUD)
//{
// render_position.mV[VY] -= fmodf(render_position.mV[VY], 1.f / (F32)gViewerWindow->getWindowWidth());
// render_position.mV[VZ] -= fmodf(render_position.mV[VZ], 1.f / (F32)gViewerWindow->getWindowHeight());
//}
//else
//{
// render_position = LLViewerCamera::getInstance()->roundToPixel(render_position);
//}
if (mUseBubble)
{
LLGLDepthTest gls_depth(GL_TRUE, GL_FALSE);
LLUI::pushMatrix();
{
LLVector3 bg_pos = render_position
+ (F32)mOffsetY * y_pixel_vec
- (width_vec / 2.f)
- (height_vec);
LLUI::translate(bg_pos.mV[VX], bg_pos.mV[VY], bg_pos.mV[VZ]);
if (for_select)
{
gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
S32 name = mSourceObject->mGLName;
LLColor4U coloru((U8)(name >> 16), (U8)(name >> 8), (U8)name);
gGL.color4ubv(coloru.mV);
gl_segmented_rect_3d_tex(border_scale_vec, scaled_border_width, scaled_border_height, width_vec, height_vec);
LLUI::popMatrix();
return;
}
else
{
gGL.getTexUnit(0)->bind(imagep->getImage());
gGL.color4fv(bg_color.mV);
gl_segmented_rect_3d_tex(border_scale_vec, scaled_border_width, scaled_border_height, width_vec, height_vec);
if ( mLabelSegments.size())
{
LLUI::pushMatrix();
{
gGL.color4f(text_color.mV[VX], text_color.mV[VY], text_color.mV[VZ], gSavedSettings.getF32("ChatBubbleOpacity") * alpha_factor);
LLVector3 label_height = (mFontp->getLineHeight() * mLabelSegments.size() + (VERTICAL_PADDING / 3.f)) * y_pixel_vec;
LLVector3 label_offset = height_vec - label_height;
LLUI::translate(label_offset.mV[VX], label_offset.mV[VY], label_offset.mV[VZ]);
gl_segmented_rect_3d_tex_top(border_scale_vec, scaled_border_width, scaled_border_height, width_vec, label_height);
}
LLUI::popMatrix();
}
}
BOOL outside_width = llabs(mPositionOffset.mV[VX]) > mWidth * 0.5f;
BOOL outside_height = llabs(mPositionOffset.mV[VY] + (mVertAlignment == ALIGN_VERT_TOP ? mHeight * 0.5f : 0.f)) > mHeight * (mVertAlignment == ALIGN_VERT_TOP ? mHeight * 0.75f : 0.5f);
// draw line segments pointing to parent object
if (!mOffscreen && (outside_width || outside_height))
{
LLUI::pushMatrix();
{
gGL.color4fv(bg_color.mV);
LLVector3 target_pos = -1.f * (mPositionOffset.mV[VX] * x_pixel_vec + mPositionOffset.mV[VY] * y_pixel_vec);
target_pos += (width_vec / 2.f);
target_pos += mVertAlignment == ALIGN_VERT_CENTER ? (height_vec * 0.5f) : LLVector3::zero;
target_pos -= 3.f * x_pixel_vec;
target_pos -= 6.f * y_pixel_vec;
LLUI::translate(target_pos.mV[VX], target_pos.mV[VY], target_pos.mV[VZ]);
gl_segmented_rect_3d_tex(border_scale_vec, 3.f * x_pixel_vec, 3.f * y_pixel_vec, 6.f * x_pixel_vec, 6.f * y_pixel_vec);
}
LLUI::popMatrix();
gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
LLGLDepthTest gls_depth(mZCompare ? GL_TRUE : GL_FALSE, GL_FALSE);
LLVector3 box_center_offset;
box_center_offset = (width_vec * 0.5f) + (height_vec * 0.5f);
LLUI::translate(box_center_offset.mV[VX], box_center_offset.mV[VY], box_center_offset.mV[VZ]);
gGL.color4fv(bg_color.mV);
LLUI::setLineWidth(2.0);
gGL.begin(LLRender::LINES);
{
if (outside_width)
{
LLVector3 vert;
// draw line in x then y
if (mPositionOffset.mV[VX] < 0.f)
{
// start at right edge
vert = width_vec * 0.5f;
gGL.vertex3fv(vert.mV);
}
else
{
// start at left edge
vert = width_vec * -0.5f;
gGL.vertex3fv(vert.mV);
}
vert = -mPositionOffset.mV[VX] * x_pixel_vec;
gGL.vertex3fv(vert.mV);
gGL.vertex3fv(vert.mV);
vert -= mPositionOffset.mV[VY] * y_pixel_vec;
vert -= ((mVertAlignment == ALIGN_VERT_TOP) ? (height_vec * 0.5f) : LLVector3::zero);
gGL.vertex3fv(vert.mV);
}
else
{
LLVector3 vert;
// draw line in y then x
if (mPositionOffset.mV[VY] < 0.f)
{
// start at top edge
vert = (height_vec * 0.5f) - (mPositionOffset.mV[VX] * x_pixel_vec);
gGL.vertex3fv(vert.mV);
}
else
{
// start at bottom edge
vert = (height_vec * -0.5f) - (mPositionOffset.mV[VX] * x_pixel_vec);
gGL.vertex3fv(vert.mV);
}
vert = -mPositionOffset.mV[VY] * y_pixel_vec - mPositionOffset.mV[VX] * x_pixel_vec;
vert -= ((mVertAlignment == ALIGN_VERT_TOP) ? (height_vec * 0.5f) : LLVector3::zero);
gGL.vertex3fv(vert.mV);
}
}
gGL.end();
LLUI::setLineWidth(1.0);
}
}
LLUI::popMatrix();
}
F32 y_offset = (F32)mOffsetY;
// Render label
{
gGL.getTexUnit(0)->setTextureBlendType(LLTexUnit::TB_MULT);
for(std::vector<LLHUDTextSegment>::iterator segment_iter = mLabelSegments.begin();
segment_iter != mLabelSegments.end(); ++segment_iter )
{
const LLFontGL* fontp = segment_iter->mFont;
y_offset -= fontp->getLineHeight();
F32 x_offset;
if (mTextAlignment == ALIGN_TEXT_CENTER)
{
x_offset = -0.5f*segment_iter->getWidth(fontp);
}
else // ALIGN_LEFT
{
x_offset = -0.5f * mWidth + (HORIZONTAL_PADDING / 2.f);
}
LLColor4 label_color(0.f, 0.f, 0.f, 1.f);
label_color.mV[VALPHA] = alpha_factor;
hud_render_text(segment_iter->getText(), render_position, *fontp, segment_iter->mStyle, x_offset, y_offset, label_color, mOnHUDAttachment);
}
}
// Render text
@@ -528,14 +238,11 @@ void LLHUDText::renderText(BOOL for_select)
for (std::vector<LLHUDTextSegment>::iterator segment_iter = mTextSegments.begin() + start_segment;
segment_iter != mTextSegments.end(); ++segment_iter )
{
const LLFontGL* fontp = (segment_iter->mStyle == LLFontGL::BOLD) ? mBoldFontp : mFontp;
const LLFontGL* fontp = segment_iter->mFont;
y_offset -= fontp->getLineHeight();
U8 style = segment_iter->mStyle;
if (mDropShadow)
{
style |= LLFontGL::DROP_SHADOW;
}
LLFontGL::ShadowType shadow = LLFontGL::DROP_SHADOW;
F32 x_offset;
if (mTextAlignment== ALIGN_TEXT_CENTER)
@@ -550,50 +257,36 @@ void LLHUDText::renderText(BOOL for_select)
text_color = segment_iter->mColor;
text_color.mV[VALPHA] *= alpha_factor;
hud_render_text(segment_iter->getText(), render_position, *fontp, style, x_offset, y_offset, text_color, mOnHUDAttachment);
hud_render_text(segment_iter->getText(), render_position, *fontp, style, shadow, x_offset, y_offset, text_color, mOnHUDAttachment);
}
}
/// Reset the default color to white. The renderer expects this to be the default.
gGL.diffuseColor4fv(LLColor4::white.mV);
if (for_select)
{
gGL.getTexUnit(0)->enable(LLTexUnit::TT_TEXTURE);
}
gGL.color4f(1.0f, 1.0f, 1.0f, 1.0f);
}
void LLHUDText::setStringUTF8(const std::string &wtext)
void LLHUDText::setString(const std::string &text_utf8)
{
// [RLVa:KB] - Checked: 2010-03-02 (RLVa-1.2.0a) | Modified: RLVa-1.0.0f
// NOTE: setString() is only called for debug beacons and the floating name tags (which we don't want to censor
// because you'd see "(Region hidden) LastName" if you happen to go to a sim who's name is your first name :p
//[RLVa:KB] - Checked: 2010-03-02 (RLVa-1.2.0a) | Modified: RLVa-1.0.0f
// NOTE: setString() is only called for debug beacons and the floating name tags (which we don't want to censor
// because you'd see "(Region hidden) LastName" if you happen to go to a sim who's name is your first name :p
std::string text(text_utf8);
mPreFilteredText = text;
if (rlv_handler_t::isEnabled())
{
std::string text(wtext);
if (gRlvHandler.canShowHoverText(mSourceObject))
{
if (gRlvHandler.hasBehaviour(RLV_BHVR_SHOWLOC))
RlvUtil::filterLocation(text);
if (gRlvHandler.hasBehaviour(RLV_BHVR_SHOWNAMES))
RlvUtil::filterNames(text);
}
else
{
text = "";
}
setString(utf8str_to_wstring(text));
return;
}
// [/RLVa:KB]
//[/RLVa:KB]
setString(utf8str_to_wstring(wtext));
}
void LLHUDText::setString(const LLWString &wtext)
{
mTextSegments.clear();
addLine(wtext, mColor);
addLine(text, mColor);
}
void LLHUDText::clearString()
@@ -602,25 +295,19 @@ void LLHUDText::clearString()
}
void LLHUDText::addLine(const std::string &str, const LLColor4& color, const LLFontGL::StyleFlags style, const LLFontGL* font)
void LLHUDText::addLine(const std::string &text_utf8,
const LLColor4& color,
const LLFontGL::StyleFlags style,
const LLFontGL* font)
{
addLine(utf8str_to_wstring(str), color, style, font);
}
void LLHUDText::addLine(const LLWString &wstr, const LLColor4& color, const LLFontGL::StyleFlags style, const LLFontGL* font)
{
if (gNoRender)
{
return;
}
if (!wstr.empty())
LLWString wline = utf8str_to_wstring(text_utf8);
if (!wline.empty())
{
// use default font for segment if custom font not specified
if (!font)
{
font = mFontp;
}
LLWString wline(wstr);
}
typedef boost::tokenizer<boost::char_separator<llwchar>, LLWString::const_iterator, LLWString > tokenizer;
LLWString seps(utf8str_to_wstring("\r\n"));
boost::char_separator<llwchar> sep(seps.c_str());
@@ -633,8 +320,10 @@ void LLHUDText::addLine(const LLWString &wstr, const LLColor4& color, const LLFo
U32 line_length = 0;
do
{
S32 segment_length = mFontp->maxDrawableChars(iter->substr(line_length).c_str(), mUseBubble ? HUD_TEXT_MAX_WIDTH : HUD_TEXT_MAX_WIDTH_NO_BUBBLE, wline.length(), TRUE);
mTextSegments.push_back(LLHUDTextSegment(iter->substr(line_length, segment_length), style, color, font));
F32 max_pixels = HUD_TEXT_MAX_WIDTH_NO_BUBBLE;
S32 segment_length = font->maxDrawableChars(iter->substr(line_length).c_str(), max_pixels, wline.length(), LLFontGL::WORD_BOUNDARY_IF_POSSIBLE);
LLHUDTextSegment segment(iter->substr(line_length, segment_length), style, color, font);
mTextSegments.push_back(segment);
line_length += segment_length;
}
while (line_length != iter->size());
@@ -643,53 +332,6 @@ void LLHUDText::addLine(const LLWString &wstr, const LLColor4& color, const LLFo
}
}
void LLHUDText::setLabel(const std::string &label)
{
setLabel(utf8str_to_wstring(label));
}
void LLHUDText::setLabel(const LLWString &wlabel)
{
mLabelSegments.clear();
addLabel(wlabel);
}
void LLHUDText::addLabel(const LLWString &wlabel)
{
if (!wlabel.empty())
{
LLWString wstr(wlabel);
LLWString seps(utf8str_to_wstring("\r\n"));
LLWString empty;
typedef boost::tokenizer<boost::char_separator<llwchar>, LLWString::const_iterator, LLWString > tokenizer;
boost::char_separator<llwchar> sep(seps.c_str(), empty.c_str(), boost::keep_empty_tokens);
tokenizer tokens(wstr, sep);
tokenizer::iterator iter = tokens.begin();
while (iter != tokens.end())
{
U32 line_length = 0;
do
{
S32 segment_length = mFontp->maxDrawableChars(iter->substr(line_length).c_str(), mUseBubble ? HUD_TEXT_MAX_WIDTH : HUD_TEXT_MAX_WIDTH_NO_BUBBLE, wstr.length(), TRUE);
mLabelSegments.push_back(LLHUDTextSegment(iter->substr(line_length, segment_length), LLFontGL::NORMAL, mColor, mFontp));
line_length += segment_length;
}
while (line_length != iter->size());
++iter;
}
}
}
void LLHUDText::setDropShadow(const BOOL do_shadow)
{
mDropShadow = do_shadow;
}
void LLHUDText::setZCompare(const BOOL zcompare)
{
mZCompare = zcompare;
@@ -722,11 +364,6 @@ void LLHUDText::setAlpha(F32 alpha)
}
void LLHUDText::setUsePixelSize(const BOOL use_pixel_size)
{
mUsePixelSize = use_pixel_size;
}
void LLHUDText::setDoFade(const BOOL do_fade)
{
mDoFade = do_fade;
@@ -807,12 +444,12 @@ void LLHUDText::updateVisibility()
}
else
{
mPositionAgent -= dir_from_camera * object_radius;
mPositionAgent -= dir_from_camera * mSourceObject->getVObjRadius();
}
mLastDistance = (mPositionAgent - LLViewerCamera::getInstance()->getOrigin()).magVec();
if (mLOD >= 3 || !mTextSegments.size() || (mDoFade && (mLastDistance > mFadeDistance + mFadeRange)))
if (!mTextSegments.size() || (mDoFade && (mLastDistance > mFadeDistance + mFadeRange)))
{
mVisible = FALSE;
return;
@@ -830,15 +467,15 @@ void LLHUDText::updateVisibility()
mOffscreen = FALSE;
if (!LLViewerCamera::getInstance()->sphereInFrustum(render_position, mRadius))
{
if (!mVisibleOffScreen)
{
// if (!mVisibleOffScreen)
// {
mVisible = FALSE;
return;
}
else
{
mOffscreen = TRUE;
}
// }
// else
// {
// mOffscreen = TRUE;
// }
}
mVisible = TRUE;
@@ -853,47 +490,25 @@ LLVector2 LLHUDText::updateScreenPos(LLVector2 &offset)
LLVector3 y_pixel_vec;
LLViewerCamera::getInstance()->getPixelVectors(mPositionAgent, y_pixel_vec, x_pixel_vec);
LLVector3 world_pos = mPositionAgent + (offset.mV[VX] * x_pixel_vec) + (offset.mV[VY] * y_pixel_vec);
if (!LLViewerCamera::getInstance()->projectPosAgentToScreen(world_pos, screen_pos, FALSE) && mVisibleOffScreen)
{
// bubble off-screen, so find a spot for it along screen edge
LLVector2 window_center(gViewerWindow->getWindowDisplayWidth() * 0.5f, gViewerWindow->getWindowDisplayHeight() * 0.5f);
LLVector2 delta_from_center(screen_pos.mX - window_center.mV[VX],
screen_pos.mY - window_center.mV[VY]);
delta_from_center.normVec();
// if (!LLViewerCamera::getInstance()->projectPosAgentToScreen(world_pos, screen_pos, FALSE) && mVisibleOffScreen)
// {
// // bubble off-screen, so find a spot for it along screen edge
// LLViewerCamera::getInstance()->projectPosAgentToScreenEdge(world_pos, screen_pos);
// }
F32 camera_aspect = LLViewerCamera::getInstance()->getAspect();
F32 delta_aspect = llabs(delta_from_center.mV[VX] / delta_from_center.mV[VY]);
if (camera_aspect / llmax(delta_aspect, 0.001f) > 1.f)
{
// camera has wider aspect ratio than offset vector, so clamp to height
delta_from_center *= llabs(window_center.mV[VY] / delta_from_center.mV[VY]);
}
else
{
// camera has narrower aspect ratio than offset vector, so clamp to width
delta_from_center *= llabs(window_center.mV[VX] / delta_from_center.mV[VX]);
}
screen_pos_vec.setVec((F32)screen_pos.mX, (F32)screen_pos.mY);
screen_pos_vec = window_center + delta_from_center;
}
else
{
screen_pos_vec.setVec((F32)screen_pos.mX, (F32)screen_pos.mY);
}
S32 bottom = STATUS_BAR_HEIGHT;
if (gChatBar->getVisible())
{
bottom += CHAT_BAR_HEIGHT;
}
LLRect world_rect = gViewerWindow->getWorldViewRectScaled();
S32 bottom = world_rect.mBottom + STATUS_BAR_HEIGHT;
LLVector2 screen_center;
screen_center.mV[VX] = llclamp((F32)screen_pos_vec.mV[VX], mWidth * 0.5f, (F32)gViewerWindow->getWindowDisplayWidth() - mWidth * 0.5f);
screen_center.mV[VX] = llclamp((F32)screen_pos_vec.mV[VX], (F32)world_rect.mLeft + mWidth * 0.5f, (F32)world_rect.mRight - mWidth * 0.5f);
if(mVertAlignment == ALIGN_VERT_TOP)
{
screen_center.mV[VY] = llclamp((F32)screen_pos_vec.mV[VY],
(F32)bottom,
(F32)gViewerWindow->getWindowDisplayHeight() - mHeight - (F32)MENU_BAR_HEIGHT);
(F32)world_rect.mTop - mHeight - (F32)MENU_BAR_HEIGHT);
mSoftScreenRect.setLeftTopAndSize(screen_center.mV[VX] - (mWidth + BUFFER_SIZE) * 0.5f,
screen_center.mV[VY] + (mHeight + BUFFER_SIZE), mWidth + BUFFER_SIZE, mHeight + BUFFER_SIZE);
}
@@ -901,7 +516,7 @@ LLVector2 LLHUDText::updateScreenPos(LLVector2 &offset)
{
screen_center.mV[VY] = llclamp((F32)screen_pos_vec.mV[VY],
(F32)bottom + mHeight * 0.5f,
(F32)gViewerWindow->getWindowDisplayHeight() - mHeight * 0.5f - (F32)MENU_BAR_HEIGHT);
(F32)world_rect.mTop - mHeight * 0.5f - (F32)MENU_BAR_HEIGHT);
mSoftScreenRect.setCenterAndSize(screen_center.mV[VX], screen_center.mV[VY], mWidth + BUFFER_SIZE, mHeight + BUFFER_SIZE);
}
@@ -914,6 +529,8 @@ void LLHUDText::updateSize()
F32 width = 0.f;
S32 max_lines = getMaxLines();
//S32 lines = (max_lines < 0) ? (S32)mTextSegments.size() : llmin((S32)mTextSegments.size(), max_lines);
//F32 height = (F32)mFontp->getLineHeight() * (lines + mLabelSegments.size());
S32 start_segment;
if (max_lines < 0) start_segment = 0;
@@ -928,14 +545,6 @@ void LLHUDText::updateSize()
++iter;
}
iter = mLabelSegments.begin();
while (iter != mLabelSegments.end())
{
height += mFontp->getLineHeight();
width = llmax(width, llmin(iter->getWidth(mFontp), HUD_TEXT_MAX_WIDTH));
++iter;
}
if (width == 0.f)
{
return;
@@ -944,18 +553,8 @@ void LLHUDText::updateSize()
width += HORIZONTAL_PADDING;
height += VERTICAL_PADDING;
if (!mResizeTimer.getStarted() && (width != mWidth || height != mHeight))
{
mResizeTimer.start();
}
// *NOTE: removed logic which did a divide by zero.
F32 u = 1.f;//llclamp(mResizeTimer.getElapsedTimeF32() / RESIZE_TIME, 0.f, 1.f);
if (u == 1.f)
{
mResizeTimer.stop();
}
// *TODO: Could do some sort of timer-based resize logic here
F32 u = 1.f;
mWidth = llmax(width, lerp(mWidth, (F32)width, u));
mHeight = llmax(height, lerp(mHeight, (F32)height, u));
}
@@ -979,146 +578,31 @@ void LLHUDText::updateAll()
// sort back to front for rendering purposes
std::sort(sVisibleTextObjects.begin(), sVisibleTextObjects.end(), lltextobject_further_away());
std::sort(sVisibleHUDTextObjects.begin(), sVisibleHUDTextObjects.end(), lltextobject_further_away());
// iterate from front to back, and set LOD based on current screen coverage
F32 screen_area = (F32)(gViewerWindow->getWindowWidth() * gViewerWindow->getWindowHeight());
F32 current_screen_area = 0.f;
std::vector<LLPointer<LLHUDText> >::reverse_iterator r_it;
for (r_it = sVisibleTextObjects.rbegin(); r_it != sVisibleTextObjects.rend(); ++r_it)
{
LLHUDText* textp = (*r_it);
if (textp->mUseBubble)
{
if (current_screen_area / screen_area > LOD_2_SCREEN_COVERAGE)
{
textp->setLOD(3);
}
else if (current_screen_area / screen_area > LOD_1_SCREEN_COVERAGE)
{
textp->setLOD(2);
}
else if (current_screen_area / screen_area > LOD_0_SCREEN_COVERAGE)
{
textp->setLOD(1);
}
else
{
textp->setLOD(0);
}
textp->updateSize();
// find on-screen position and initialize collision rectangle
textp->mTargetPositionOffset = textp->updateScreenPos(LLVector2::zero);
current_screen_area += (F32)(textp->mSoftScreenRect.getWidth() * textp->mSoftScreenRect.getHeight());
}
}
LLStat* camera_vel_stat = LLViewerCamera::getInstance()->getVelocityStat();
F32 camera_vel = camera_vel_stat->getCurrent();
if (camera_vel > MAX_STABLE_CAMERA_VELOCITY)
{
return;
}
VisibleTextObjectIterator src_it;
for (S32 i = 0; i < NUM_OVERLAP_ITERATIONS; i++)
{
for (src_it = sVisibleTextObjects.begin(); src_it != sVisibleTextObjects.end(); ++src_it)
{
LLHUDText* src_textp = (*src_it);
if (!src_textp->mUseBubble)
{
continue;
}
VisibleTextObjectIterator dst_it = src_it;
++dst_it;
for (; dst_it != sVisibleTextObjects.end(); ++dst_it)
{
LLHUDText* dst_textp = (*dst_it);
if (!dst_textp->mUseBubble)
{
continue;
}
if (src_textp->mSoftScreenRect.overlaps(dst_textp->mSoftScreenRect))
{
LLRectf intersect_rect = src_textp->mSoftScreenRect;
intersect_rect.intersectWith(dst_textp->mSoftScreenRect);
intersect_rect.stretch(-BUFFER_SIZE * 0.5f);
F32 src_center_x = src_textp->mSoftScreenRect.getCenterX();
F32 src_center_y = src_textp->mSoftScreenRect.getCenterY();
F32 dst_center_x = dst_textp->mSoftScreenRect.getCenterX();
F32 dst_center_y = dst_textp->mSoftScreenRect.getCenterY();
F32 intersect_center_x = intersect_rect.getCenterX();
F32 intersect_center_y = intersect_rect.getCenterY();
LLVector2 force = lerp(LLVector2(dst_center_x - intersect_center_x, dst_center_y - intersect_center_y),
LLVector2(intersect_center_x - src_center_x, intersect_center_y - src_center_y),
0.5f);
force.setVec(dst_center_x - src_center_x, dst_center_y - src_center_y);
force.normVec();
LLVector2 src_force = -1.f * force;
LLVector2 dst_force = force;
LLVector2 force_strength;
F32 src_mult = dst_textp->mMass / (dst_textp->mMass + src_textp->mMass);
F32 dst_mult = 1.f - src_mult;
F32 src_aspect_ratio = src_textp->mSoftScreenRect.getWidth() / src_textp->mSoftScreenRect.getHeight();
F32 dst_aspect_ratio = dst_textp->mSoftScreenRect.getWidth() / dst_textp->mSoftScreenRect.getHeight();
src_force.mV[VY] *= src_aspect_ratio;
src_force.normVec();
dst_force.mV[VY] *= dst_aspect_ratio;
dst_force.normVec();
src_force.mV[VX] *= llmin(intersect_rect.getWidth() * src_mult, intersect_rect.getHeight() * SPRING_STRENGTH);
src_force.mV[VY] *= llmin(intersect_rect.getHeight() * src_mult, intersect_rect.getWidth() * SPRING_STRENGTH);
dst_force.mV[VX] *= llmin(intersect_rect.getWidth() * dst_mult, intersect_rect.getHeight() * SPRING_STRENGTH);
dst_force.mV[VY] *= llmin(intersect_rect.getHeight() * dst_mult, intersect_rect.getWidth() * SPRING_STRENGTH);
src_textp->mTargetPositionOffset += src_force;
dst_textp->mTargetPositionOffset += dst_force;
src_textp->mTargetPositionOffset = src_textp->updateScreenPos(src_textp->mTargetPositionOffset);
dst_textp->mTargetPositionOffset = dst_textp->updateScreenPos(dst_textp->mTargetPositionOffset);
}
}
}
}
VisibleTextObjectIterator this_object_it;
for (this_object_it = sVisibleTextObjects.begin(); this_object_it != sVisibleTextObjects.end(); ++this_object_it)
{
if (!(*this_object_it)->mUseBubble)
{
continue;
}
(*this_object_it)->mPositionOffset = lerp((*this_object_it)->mPositionOffset, (*this_object_it)->mTargetPositionOffset, LLCriticalDamp::getInterpolant(POSITION_DAMPING_TC));
}
}
void LLHUDText::setLOD(S32 lod)
{
mLOD = lod;
//RN: uncomment this to visualize LOD levels
//std::string label = llformat("%d", lod);
//setLabel(label);
}
//void LLHUDText::setLOD(S32 lod)
//{
// mLOD = lod;
// //RN: uncomment this to visualize LOD levels
// //std::string label = llformat("%d", lod);
// //setLabel(label);
//}
S32 LLHUDText::getMaxLines()
{
switch(mLOD)
{
case 0:
return mMaxLines;
case 1:
return mMaxLines > 0 ? mMaxLines / 2 : 5;
case 2:
return mMaxLines > 0 ? mMaxLines / 3 : 2;
default:
// label only
return 0;
}
return mMaxLines;
//switch(mLOD)
//{
//case 0:
// return mMaxLines;
//case 1:
// return mMaxLines > 0 ? mMaxLines / 2 : 5;
//case 2:
// return mMaxLines > 0 ? mMaxLines / 3 : 2;
//default:
// // label only
// return 0;
//}
}
void LLHUDText::markDead()
@@ -1141,12 +625,14 @@ void LLHUDText::renderAllHUD()
for (text_it = sVisibleHUDTextObjects.begin(); text_it != sVisibleHUDTextObjects.end(); ++text_it)
{
(*text_it)->renderText(FALSE);
(*text_it)->renderText();
}
}
LLVertexBuffer::unbind();
LLVertexBuffer::unbind();
LLGLState::checkStates();
LLGLState::checkTextureChannels();
LLGLState::checkClientArrays();
@@ -1167,22 +653,6 @@ void LLHUDText::shift(const LLVector3& offset)
mPositionAgent += offset;
}
//static
void LLHUDText::addPickable(std::set<LLViewerObject*> &pick_list)
{
//this might put an object on the pick list a second time, overriding it's mGLName, which is ok
// *FIX: we should probably cull against pick frustum
VisibleTextObjectIterator text_it;
for (text_it = sVisibleTextObjects.begin(); text_it != sVisibleTextObjects.end(); ++text_it)
{
if (!(*text_it)->mUseBubble)
{
continue;
}
pick_list.insert((*text_it)->mSourceObject);
}
}
//static
// called when UI scale changes, to flush font width caches
void LLHUDText::reshape()
@@ -1197,11 +667,6 @@ void LLHUDText::reshape()
{
segment_iter->clearFontWidthMap();
}
for(segment_iter = textp->mLabelSegments.begin();
segment_iter != textp->mLabelSegments.end(); ++segment_iter )
{
segment_iter->clearFontWidthMap();
}
}
}
@@ -1228,10 +693,10 @@ void LLHUDText::refreshAllObjectText()
for (TextObjectIterator itText = sTextObjects.begin(); itText != sTextObjects.end(); itText++)
{
LLHUDText* pText = *itText;
if ( (pText) && (!pText->mObjText.empty() && ("" != pText->mObjText) ) &&
if ( (pText) && (!pText->getPreFilteredText().empty() && ("" != pText->getPreFilteredText()) ) &&
(pText->mSourceObject) && (LL_PCODE_VOLUME == pText->mSourceObject->getPCode()) )
{
pText->setStringUTF8(pText->mObjText);
pText->setString(pText->mPreFilteredText);
}
}
}