void LLModalDialog::centerOnScreen()
{
LLVector2 window_size = LLUI::getWindowSize();
centerWithin(LLRect(0, 0, llround(window_size.mV[VX]), llround(window_size.mV[VY])));
}
// Returns true if you got at least one object
void LLToolSelectRect::handleRectangleSelection(S32 x, S32 y, MASK mask)
{
// [RLVa:KB] - Checked: 2010-11-29 (RLVa-1.3.0c) | Modified: RLVa-1.3.0c
// Block rectangle selection if:
// - prevented from editing and no exceptions are set (see below for the case where exceptions are set)
// - prevented from interacting at all
if ( (rlv_handler_t::isEnabled()) &&
( ((gRlvHandler.hasBehaviour(RLV_BHVR_EDIT)) && (!gRlvHandler.hasException(RLV_BHVR_EDIT))) ||
(gRlvHandler.hasBehaviour(RLV_BHVR_INTERACT)) ) )
{
return;
}
// [/RLVa:KB]
LLVector3 av_pos = gAgent.getPositionAgent();
F32 select_dist_squared = gSavedSettings.getF32("MaxSelectDistance");
select_dist_squared = select_dist_squared * select_dist_squared;
BOOL deselect = (mask == MASK_CONTROL);
S32 left = llmin(x, mDragStartX);
S32 right = llmax(x, mDragStartX);
S32 top = llmax(y, mDragStartY);
S32 bottom =llmin(y, mDragStartY);
left = llround((F32) left * LLUI::getScaleFactor().mV[VX]);
right = llround((F32) right * LLUI::getScaleFactor().mV[VX]);
top = llround((F32) top * LLUI::getScaleFactor().mV[VY]);
bottom = llround((F32) bottom * LLUI::getScaleFactor().mV[VY]);
F32 old_far_plane = LLViewerCamera::getInstance()->getFar();
F32 old_near_plane = LLViewerCamera::getInstance()->getNear();
S32 width = right - left + 1;
S32 height = top - bottom + 1;
BOOL grow_selection = FALSE;
BOOL shrink_selection = FALSE;
if (height > mDragLastHeight || width > mDragLastWidth)
{
grow_selection = TRUE;
}
if (height < mDragLastHeight || width < mDragLastWidth)
{
shrink_selection = TRUE;
}
if (!grow_selection && !shrink_selection)
{
// nothing to do
return;
}
mDragLastHeight = height;
mDragLastWidth = width;
S32 center_x = (left + right) / 2;
S32 center_y = (top + bottom) / 2;
// save drawing mode
gGL.matrixMode(LLRender::MM_PROJECTION);
gGL.pushMatrix();
BOOL limit_select_distance = gSavedSettings.getBOOL("LimitSelectDistance");
if (limit_select_distance)
{
// ...select distance from control
LLVector3 relative_av_pos = av_pos;
relative_av_pos -= LLViewerCamera::getInstance()->getOrigin();
F32 new_far = relative_av_pos * LLViewerCamera::getInstance()->getAtAxis() + gSavedSettings.getF32("MaxSelectDistance");
F32 new_near = relative_av_pos * LLViewerCamera::getInstance()->getAtAxis() - gSavedSettings.getF32("MaxSelectDistance");
new_near = llmax(new_near, 0.1f);
LLViewerCamera::getInstance()->setFar(new_far);
LLViewerCamera::getInstance()->setNear(new_near);
}
// [RLVa:KB] - Checked: 2010-04-11 (RLVa-1.2.0e) | Modified: RLVa-1.0.0g
if (gRlvHandler.hasBehaviour(RLV_BHVR_FARTOUCH))
{
// We'll allow drag selection under fartouch, but only within the fartouch range
// (just copy/paste the code above us to make that work, thank you Lindens!)
LLVector3 relative_av_pos = av_pos;
relative_av_pos -= LLViewerCamera::getInstance()->getOrigin();
F32 new_far = relative_av_pos * LLViewerCamera::getInstance()->getAtAxis() + 1.5f;
F32 new_near = relative_av_pos * LLViewerCamera::getInstance()->getAtAxis() - 1.5f;
new_near = llmax(new_near, 0.1f);
LLViewerCamera::getInstance()->setFar(new_far);
LLViewerCamera::getInstance()->setNear(new_near);
// Usurp these two
limit_select_distance = TRUE;
select_dist_squared = 1.5f * 1.5f;
}
// [/RLVa:KB]
LLViewerCamera::getInstance()->setPerspective(FOR_SELECTION,
center_x-width/2, center_y-height/2, width, height,
limit_select_distance);
if (shrink_selection)
{
struct f : public LLSelectedObjectFunctor
{
virtual bool apply(LLViewerObject* vobjp)
{
LLDrawable* drawable = vobjp->mDrawable;
if (!drawable || vobjp->getPCode() != LL_PCODE_VOLUME || vobjp->isAttachment())
{
return true;
}
S32 result = LLViewerCamera::getInstance()->sphereInFrustum(drawable->getPositionAgent(), drawable->getRadius());
switch (result)
{
case 0:
LLSelectMgr::getInstance()->unhighlightObjectOnly(vobjp);
break;
case 1:
// check vertices
if (!LLViewerCamera::getInstance()->areVertsVisible(vobjp, LLSelectMgr::sRectSelectInclusive))
{
LLSelectMgr::getInstance()->unhighlightObjectOnly(vobjp);
}
break;
default:
break;
}
return true;
}
} func;
LLSelectMgr::getInstance()->getHighlightedObjects()->applyToObjects(&func);
}
if (grow_selection)
{
std::vector<LLDrawable*> potentials;
for (LLWorld::region_list_t::const_iterator iter = LLWorld::getInstance()->getRegionList().begin();
iter != LLWorld::getInstance()->getRegionList().end(); ++iter)
{
LLViewerRegion* region = *iter;
for (U32 i = 0; i < LLViewerRegion::NUM_PARTITIONS; i++)
{
LLSpatialPartition* part = region->getSpatialPartition(i);
if (part)
{
part->cull(*LLViewerCamera::getInstance(), &potentials, TRUE);
}
}
}
for (std::vector<LLDrawable*>::iterator iter = potentials.begin();
iter != potentials.end(); iter++)
{
LLDrawable* drawable = *iter;
LLViewerObject* vobjp = drawable->getVObj();
if (!drawable || !vobjp ||
vobjp->getPCode() != LL_PCODE_VOLUME ||
vobjp->isAttachment() ||
(deselect && !vobjp->isSelected()))
{
continue;
}
if (limit_select_distance && dist_vec_squared(drawable->getWorldPosition(), av_pos) > select_dist_squared)
{
continue;
}
// [RLVa:KB] - Checked: 2010-11-29 (RLVa-1.3.0c) | Added: RLVa-1.3.0c
if ( (rlv_handler_t::isEnabled()) && (!gRlvHandler.canEdit(vobjp)) )
{
continue;
}
// [/RLVa:KB]
S32 result = LLViewerCamera::getInstance()->sphereInFrustum(drawable->getPositionAgent(), drawable->getRadius());
if (result)
{
switch (result)
{
case 1:
// check vertices
if (LLViewerCamera::getInstance()->areVertsVisible(vobjp, LLSelectMgr::sRectSelectInclusive))
{
LLSelectMgr::getInstance()->highlightObjectOnly(vobjp);
}
break;
case 2:
LLSelectMgr::getInstance()->highlightObjectOnly(vobjp);
break;
default:
break;
}
}
}
}
// restore drawing mode
gGL.matrixMode(LLRender::MM_PROJECTION);
gGL.popMatrix();
gGL.matrixMode(LLRender::MM_MODELVIEW);
// restore camera
LLViewerCamera::getInstance()->setFar(old_far_plane);
LLViewerCamera::getInstance()->setNear(old_near_plane);
gViewerWindow->setup3DRender();
}
void LLNetMap::draw()
{
static LLFrameTimer map_timer;
if (mObjectImagep.isNull())
{
createObjectImage();
}
mCurPanX = lerp(mCurPanX, mTargetPanX, LLCriticalDamp::getInterpolant(0.1f));
mCurPanY = lerp(mCurPanY, mTargetPanY, LLCriticalDamp::getInterpolant(0.1f));
F32 rotation = 0;
// Prepare a scissor region
{
LLGLEnable scissor(GL_SCISSOR_TEST);
{
gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
LLLocalClipRect clip(getLocalRect());
glMatrixMode(GL_MODELVIEW);
// Draw background rectangle
if(isBackgroundVisible())
{
gGL.color4fv(isBackgroundOpaque() ? getBackgroundColor().mV : getTransparentColor().mV);
gl_rect_2d(0, getRect().getHeight(), getRect().getWidth(), 0);
}
}
// region 0,0 is in the middle
S32 center_sw_left = getRect().getWidth() / 2 + llfloor(mCurPanX);
S32 center_sw_bottom = getRect().getHeight() / 2 + llfloor(mCurPanY);
gGL.pushMatrix();
gGL.translatef( (F32) center_sw_left, (F32) center_sw_bottom, 0.f);
BOOL rotate_map = gSavedSettings.getBOOL( "MiniMapRotate" );
if( rotate_map )
{
// rotate subsequent draws to agent rotation
rotation = atan2( LLViewerCamera::getInstance()->getAtAxis().mV[VX], LLViewerCamera::getInstance()->getAtAxis().mV[VY] );
glRotatef( rotation * RAD_TO_DEG, 0.f, 0.f, 1.f);
}
// figure out where agent is
S32 region_width = llround(LLWorld::getInstance()->getRegionWidthInMeters());
LLColor4 this_region_color = gColors.getColor( "NetMapThisRegion" );
LLColor4 live_region_color = gColors.getColor( "NetMapLiveRegion" );
LLColor4 dead_region_color = gColors.getColor( "NetMapDeadRegion" );
for (LLWorld::region_list_t::const_iterator iter = LLWorld::getInstance()->getRegionList().begin();
iter != LLWorld::getInstance()->getRegionList().end(); ++iter)
{
LLViewerRegion* regionp = *iter;
// Find x and y position relative to camera's center.
LLVector3 origin_agent = regionp->getOriginAgent();
LLVector3 rel_region_pos = origin_agent - gAgent.getCameraPositionAgent();
F32 relative_x = (rel_region_pos.mV[0] / region_width) * mScale;
F32 relative_y = (rel_region_pos.mV[1] / region_width) * mScale;
// background region rectangle
F32 bottom = relative_y;
F32 left = relative_x;
F32 top = bottom + mScale ;
F32 right = left + mScale ;
gGL.color4fv(regionp == gAgent.getRegion() ? this_region_color.mV : live_region_color.mV);
if (!regionp->isAlive())
{
gGL.color4fv(dead_region_color.mV);
}
// Draw using texture.
gGL.getTexUnit(0)->bind(regionp->getLand().getSTexture());
gGL.begin(LLRender::QUADS);
gGL.texCoord2f(0.f, 1.f);
gGL.vertex2f(left, top);
gGL.texCoord2f(0.f, 0.f);
gGL.vertex2f(left, bottom);
gGL.texCoord2f(1.f, 0.f);
gGL.vertex2f(right, bottom);
gGL.texCoord2f(1.f, 1.f);
gGL.vertex2f(right, top);
gGL.end();
// Draw water
gGL.setAlphaRejectSettings(LLRender::CF_GREATER, ABOVE_WATERLINE_ALPHA / 255.f);
{
if (regionp->getLand().getWaterTexture())
{
gGL.getTexUnit(0)->bind(regionp->getLand().getWaterTexture());
gGL.begin(LLRender::QUADS);
gGL.texCoord2f(0.f, 1.f);
gGL.vertex2f(left, top);
gGL.texCoord2f(0.f, 0.f);
gGL.vertex2f(left, bottom);
gGL.texCoord2f(1.f, 0.f);
gGL.vertex2f(right, bottom);
gGL.texCoord2f(1.f, 1.f);
gGL.vertex2f(right, top);
gGL.end();
}
}
gGL.setAlphaRejectSettings(LLRender::CF_DEFAULT);
}
LLVector3d old_center = mObjectImageCenterGlobal;
LLVector3d new_center = gAgent.getCameraPositionGlobal();
new_center.mdV[0] = (5.f/mObjectMapTPM)*floor(0.2f*mObjectMapTPM*new_center.mdV[0]);
new_center.mdV[1] = (5.f/mObjectMapTPM)*floor(0.2f*mObjectMapTPM*new_center.mdV[1]);
new_center.mdV[2] = 0.f;
if (mUpdateNow || (map_timer.getElapsedTimeF32() > 0.5f))
{
mUpdateNow = FALSE;
mObjectImageCenterGlobal = new_center;
// Center moved enough.
// Create the base texture.
U8 *default_texture = mObjectRawImagep->getData();
memset( default_texture, 0, mObjectImagep->getWidth() * mObjectImagep->getHeight() * mObjectImagep->getComponents() );
// Draw buildings
gObjectList.renderObjectsForMap(*this);
mObjectImagep->setSubImage(mObjectRawImagep, 0, 0, mObjectImagep->getWidth(), mObjectImagep->getHeight());
map_timer.reset();
}
LLVector3 map_center_agent = gAgent.getPosAgentFromGlobal(mObjectImageCenterGlobal);
map_center_agent -= gAgent.getCameraPositionAgent();
map_center_agent.mV[VX] *= mScale/region_width;
map_center_agent.mV[VY] *= mScale/region_width;
gGL.getTexUnit(0)->bind(mObjectImagep);
F32 image_half_width = 0.5f*mObjectMapPixels;
F32 image_half_height = 0.5f*mObjectMapPixels;
gGL.begin(LLRender::QUADS);
gGL.texCoord2f(0.f, 1.f);
gGL.vertex2f(map_center_agent.mV[VX] - image_half_width, image_half_height + map_center_agent.mV[VY]);
gGL.texCoord2f(0.f, 0.f);
gGL.vertex2f(map_center_agent.mV[VX] - image_half_width, map_center_agent.mV[VY] - image_half_height);
gGL.texCoord2f(1.f, 0.f);
gGL.vertex2f(image_half_width + map_center_agent.mV[VX], map_center_agent.mV[VY] - image_half_height);
gGL.texCoord2f(1.f, 1.f);
gGL.vertex2f(image_half_width + map_center_agent.mV[VX], image_half_height + map_center_agent.mV[VY]);
gGL.end();
gGL.popMatrix();
LLVector3d pos_global;
LLVector3 pos_map;
// Mouse pointer in local coordinates
S32 local_mouse_x;
S32 local_mouse_y;
LLUI::getCursorPositionLocal(this, &local_mouse_x, &local_mouse_y);
mClosestAgentToCursor.setNull();
F32 closest_dist = F32_MAX;
F32 min_pick_dist = mDotRadius * MIN_PICK_SCALE;
// Draw avatars
LLColor4 avatar_color = gColors.getColor( "MapAvatar" );
LLColor4 friend_color = gColors.getColor( "MapFriend" );
std::vector<LLUUID> avatar_ids;
std::vector<LLVector3d> positions;
LLWorld::getInstance()->getAvatars(&avatar_ids, &positions);
for(U32 i=0; i<avatar_ids.size(); i++)
{
// TODO: it'd be very cool to draw these in sorted order from lowest Z to highest.
// just be careful to sort the avatar IDs along with the positions. -MG
pos_map = globalPosToView(positions[i], rotate_map);
LLWorldMapView::drawAvatar(
pos_map.mV[VX], pos_map.mV[VY],
is_agent_friend(avatar_ids[i]) ? friend_color : avatar_color,
pos_map.mV[VZ],
mDotRadius);
F32 dist_to_cursor = dist_vec(LLVector2(pos_map.mV[VX], pos_map.mV[VY]), LLVector2(local_mouse_x,local_mouse_y));
if(dist_to_cursor < min_pick_dist && dist_to_cursor < closest_dist)
{
closest_dist = dist_to_cursor;
mClosestAgentToCursor = avatar_ids[i];
}
}
// Draw dot for autopilot target
if (gAgent.getAutoPilot())
{
drawTracking( gAgent.getAutoPilotTargetGlobal(), rotate_map, gTrackColor );
}
else
{
LLTracker::ETrackingStatus tracking_status = LLTracker::getTrackingStatus();
if ( LLTracker::TRACKING_AVATAR == tracking_status )
{
drawTracking( LLAvatarTracker::instance().getGlobalPos(), rotate_map, gTrackColor );
}
else if ( LLTracker::TRACKING_LANDMARK == tracking_status
|| LLTracker::TRACKING_LOCATION == tracking_status )
{
drawTracking( LLTracker::getTrackedPositionGlobal(), rotate_map, gTrackColor );
}
}
// Draw dot for self avatar position
pos_global = gAgent.getPositionGlobal();
pos_map = globalPosToView(pos_global, rotate_map);
LLUIImagePtr you = LLWorldMapView::sAvatarYouLargeImage;
S32 dot_width = llround(mDotRadius * 2.f);
you->draw(
llround(pos_map.mV[VX] - mDotRadius),
llround(pos_map.mV[VY] - mDotRadius),
dot_width,
dot_width);
// Draw frustum
F32 meters_to_pixels = mScale/ LLWorld::getInstance()->getRegionWidthInMeters();
F32 horiz_fov = LLViewerCamera::getInstance()->getView() * LLViewerCamera::getInstance()->getAspect();
F32 far_clip_meters = LLViewerCamera::getInstance()->getFar();
F32 far_clip_pixels = far_clip_meters * meters_to_pixels;
F32 half_width_meters = far_clip_meters * tan( horiz_fov / 2 );
F32 half_width_pixels = half_width_meters * meters_to_pixels;
F32 ctr_x = (F32)center_sw_left;
F32 ctr_y = (F32)center_sw_bottom;
gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
if( rotate_map )
{
gGL.color4fv(gColors.getColor("NetMapFrustum").mV);
gGL.begin( LLRender::TRIANGLES );
gGL.vertex2f( ctr_x, ctr_y );
gGL.vertex2f( ctr_x - half_width_pixels, ctr_y + far_clip_pixels );
gGL.vertex2f( ctr_x + half_width_pixels, ctr_y + far_clip_pixels );
gGL.end();
}
else
{
gGL.color4fv(gColors.getColor("NetMapFrustumRotating").mV);
// If we don't rotate the map, we have to rotate the frustum.
gGL.pushMatrix();
gGL.translatef( ctr_x, ctr_y, 0 );
glRotatef( atan2( LLViewerCamera::getInstance()->getAtAxis().mV[VX], LLViewerCamera::getInstance()->getAtAxis().mV[VY] ) * RAD_TO_DEG, 0.f, 0.f, -1.f);
gGL.begin( LLRender::TRIANGLES );
gGL.vertex2f( 0, 0 );
gGL.vertex2f( -half_width_pixels, far_clip_pixels );
gGL.vertex2f( half_width_pixels, far_clip_pixels );
gGL.end();
gGL.popMatrix();
}
}
// Rotation of 0 means that North is up
setDirectionPos( getChild<LLTextBox>("e_label"), rotation);
setDirectionPos( getChild<LLTextBox>("n_label"), rotation + F_PI_BY_TWO);
setDirectionPos( getChild<LLTextBox>("w_label"), rotation + F_PI);
setDirectionPos( getChild<LLTextBox>("s_label"), rotation + F_PI + F_PI_BY_TWO);
setDirectionPos( getChild<LLTextBox>("ne_label"), rotation + F_PI_BY_TWO / 2);
setDirectionPos( getChild<LLTextBox>("nw_label"), rotation + F_PI_BY_TWO + F_PI_BY_TWO / 2);
setDirectionPos( getChild<LLTextBox>("sw_label"), rotation + F_PI + F_PI_BY_TWO / 2);
setDirectionPos( getChild<LLTextBox>("se_label"), rotation + F_PI + F_PI_BY_TWO + F_PI_BY_TWO / 2);
LLView::draw();
}
void LLFloaterWorldMap::updateLocation()
{
bool gotSimName;
LLTracker::ETrackingStatus status = LLTracker::getTrackingStatus();
// These values may get updated by a message, so need to check them every frame
// The fields may be changed by the user, so only update them if the data changes
LLVector3d pos_global = LLTracker::getTrackedPositionGlobal();
if (pos_global.isExactlyZero())
{
LLVector3d agentPos = gAgent.getPositionGlobal();
// Set to avatar's current postion if nothing is selected
if ( status == LLTracker::TRACKING_NOTHING && mSetToUserPosition )
{
// Make sure we know where we are before setting the current user position
std::string agent_sim_name;
gotSimName = LLWorldMap::getInstance()->simNameFromPosGlobal( agentPos, agent_sim_name );
if ( gotSimName )
{
mSetToUserPosition = FALSE;
// Fill out the location field
childSetValue("location", agent_sim_name);
// Figure out where user is
LLVector3d agentPos = gAgent.getPositionGlobal();
S32 agent_x = llround( (F32)fmod( agentPos.mdV[VX], (F64)REGION_WIDTH_METERS ) );
S32 agent_y = llround( (F32)fmod( agentPos.mdV[VY], (F64)REGION_WIDTH_METERS ) );
S32 agent_z = llround( (F32)agentPos.mdV[VZ] );
childSetValue("spin x", LLSD(agent_x) );
childSetValue("spin y", LLSD(agent_y) );
childSetValue("spin z", LLSD(agent_z) );
// Set the current SLURL
mSLURL = LLURLDispatcher::buildSLURL(agent_sim_name, agent_x, agent_y, agent_z);
// [RLVa:KB] - Checked: 2009-07-04 (RLVa-1.0.0a)
if (gRlvHandler.hasBehaviour(RLV_BHVR_SHOWLOC))
{
childSetValue("location", rlv_handler_t::cstrHiddenRegion);
mSLURL.clear();
}
// [/RLVa:KB]
}
}
return; // invalid location
}
std::string sim_name;
gotSimName = LLWorldMap::getInstance()->simNameFromPosGlobal( pos_global, sim_name );
if ((status != LLTracker::TRACKING_NOTHING) &&
(status != mTrackedStatus || pos_global != mTrackedLocation || sim_name != mTrackedSimName))
{
mTrackedStatus = status;
mTrackedLocation = pos_global;
mTrackedSimName = sim_name;
if (status == LLTracker::TRACKING_AVATAR)
{
// *HACK: Adjust Z values automatically for liaisons &
// gods so they swoop down when they click on the
// map. Requested convenience.
if(gAgent.isGodlike())
{
pos_global[2] = 200;
}
}
childSetValue("location", sim_name);
F32 region_x = (F32)fmod( pos_global.mdV[VX], (F64)REGION_WIDTH_METERS );
F32 region_y = (F32)fmod( pos_global.mdV[VY], (F64)REGION_WIDTH_METERS );
childSetValue("spin x", LLSD(region_x) );
childSetValue("spin y", LLSD(region_y) );
childSetValue("spin z", LLSD((F32)pos_global.mdV[VZ]) );
// simNameFromPosGlobal can fail, so don't give the user an invalid SLURL
if ( gotSimName )
{
mSLURL = LLURLDispatcher::buildSLURL(sim_name, llround(region_x), llround(region_y), llround((F32)pos_global.mdV[VZ]));
}
else
{ // Empty SLURL will disable the "Copy SLURL to clipboard" button
mSLURL = "";
}
// [RLVa:KB] - Checked: 2009-07-04 (RLVa-1.0.0a)
if (gRlvHandler.hasBehaviour(RLV_BHVR_SHOWLOC))
{
childSetValue("location", rlv_handler_t::cstrHiddenRegion);
mSLURL.clear();
}
// [/RLVa:KB]
}
}
//static
void LLUI::screenPointToGL(S32 screen_x, S32 screen_y, S32 *gl_x, S32 *gl_y)
{
*gl_x = llround((F32)screen_x * getScaleFactor().mV[VX]);
*gl_y = llround((F32)screen_y * getScaleFactor().mV[VY]);
}
//static
void LLPanelPick::processPickInfoReply(LLMessageSystem *msg, void **)
{
// Extract the agent id and verify the message is for this
// client.
LLUUID agent_id;
msg->getUUID("AgentData", "AgentID", agent_id );
if (agent_id != gAgent.getID())
{
llwarns << "Agent ID mismatch in processPickInfoReply"
<< llendl;
return;
}
LLUUID pick_id;
msg->getUUID("Data", "PickID", pick_id);
LLUUID creator_id;
msg->getUUID("Data", "CreatorID", creator_id);
BOOL top_pick;
msg->getBOOL("Data", "TopPick", top_pick);
LLUUID parcel_id;
msg->getUUID("Data", "ParcelID", parcel_id);
std::string name;
msg->getString("Data", "Name", name);
std::string desc;
msg->getString("Data", "Desc", desc);
LLUUID snapshot_id;
msg->getUUID("Data", "SnapshotID", snapshot_id);
// "Location text" is actually the owner name, the original
// name that owner gave the parcel, and the location.
std::string location_text;
msg->getString("Data", "User", location_text);
location_text.append(", ");
std::string original_name;
msg->getString("Data", "OriginalName", original_name);
if (!original_name.empty())
{
location_text.append(original_name);
location_text.append(", ");
}
std::string sim_name;
msg->getString("Data", "SimName", sim_name);
location_text.append(sim_name);
location_text.append(" ");
//Fix for location text importing - RK
for (panel_list_t::iterator iter = sAllPanels.begin(); iter != sAllPanels.end(); ++iter)
{
LLPanelPick* self = *iter;
if(!self->mImporting) self->mLocationText = location_text;
else location_text = self->mLocationText;
self->mImporting = false;
}
LLVector3d pos_global;
msg->getVector3d("Data", "PosGlobal", pos_global);
S32 region_x = llround((F32)pos_global.mdV[VX]) % REGION_WIDTH_UNITS;
S32 region_y = llround((F32)pos_global.mdV[VY]) % REGION_WIDTH_UNITS;
S32 region_z = llround((F32)pos_global.mdV[VZ]);
location_text.append(llformat("(%d, %d, %d)", region_x, region_y, region_z));
S32 sort_order;
msg->getS32("Data", "SortOrder", sort_order);
BOOL enabled;
msg->getBOOL("Data", "Enabled", enabled);
// Look up the panel to fill in
for (panel_list_t::iterator iter = sAllPanels.begin(); iter != sAllPanels.end(); ++iter)
{
LLPanelPick* self = *iter;
// For top picks, must match pick id
if (self->mPickID != pick_id)
{
continue;
}
self->mDataReceived = TRUE;
// Found the panel, now fill in the information
self->mPickID = pick_id;
self->mCreatorID = creator_id;
self->mParcelID = parcel_id;
self->mSimName.assign(sim_name);
self->mPosGlobal = pos_global;
// Update UI controls
self->mNameEditor->setText(std::string(name));
self->mDescEditor->setText(std::string(desc));
self->mSnapshotCtrl->setImageAssetID(snapshot_id);
self->mLocationEditor->setText(location_text);
self->mEnabledCheck->set(enabled);
self->mSortOrderEditor->setText(llformat("%d", sort_order));
}
}
ull ShiftHashTable::scale_hash(ull hash)
{
return llround(hash * scale_multiplier);
}
BOOL LLPanelGeneral::postBuild()
{
LLComboBox* fade_out_combobox = getChild<LLComboBox>("fade_out_combobox");
fade_out_combobox->setCurrentByIndex(gSavedSettings.getS32("RenderName"));
LLComboBox* combo = getChild<LLComboBox>("default_location_combo");
childSetCommitCallback("default_location_combo", onLocationChanged, this);
combo->setAllowTextEntry(TRUE, 128, FALSE);
// The XML file loads the combo with the following labels:
// 0 - "My Home"
// 1 - "My Last Location"
// 2 - "<Type region name>"
BOOL login_last = gSavedSettings.getBOOL("LoginLastLocation");
std::string sim_string = LLURLSimString::sInstance.mSimString;
if (!sim_string.empty())
{
// Replace "<Type region name>" with this region name
combo->remove(2);
combo->add( sim_string );
combo->setTextEntry(sim_string);
combo->setCurrentByIndex( 2 );
}
else if (login_last)
{
combo->setCurrentByIndex( 1 );
}
else
{
combo->setCurrentByIndex( 0 );
}
childSetValue("show_location_checkbox", gSavedSettings.getBOOL("ShowStartLocation"));
childSetValue("show_all_title_checkbox", gSavedSettings.getBOOL("RenderHideGroupTitleAll"));
childSetValue("show_my_name_checkbox", gSavedSettings.getBOOL("RenderNameHideSelf"));
childSetValue("large_avatar_names_checkbox", !gSavedSettings.getBOOL("SmallAvatarNames"));
childSetValue("highlight_friends_checkbox", gSavedSettings.getBOOL("HighlightFriends"));
//childSetValue("show_my_title_checkbox", gSavedSettings.getBOOL("RenderHideGroupTitle")); -- MC
childSetEnabled("afk_timeout_spinner", gSavedSettings.getBOOL("AllowIdleAFK"));
childSetValue("afk_timeout_spinner", llround(gSavedSettings.getF32("AFKTimeout") / 60)); // User enters minutes, we store as seconds -- MC
childSetValue("afk_timeout_checkbox", gSavedSettings.getBOOL("AllowIdleAFK"));
childSetCommitCallback("afk_timeout_checkbox", onCommitAFKCheckbox, this);
childSetValue("mini_map_notify_chat", gSavedSettings.getBOOL("MiniMapNotifyChatRange"));
childSetValue("mini_map_notify_sim", gSavedSettings.getBOOL("MiniMapNotifySimRange"));
// mDisplayNamesUsage = gSavedSettings.getU32("DisplayNamesUsage");
// mLegacyNamesForFriends = gSavedSettings.getBOOL("LegacyNamesForFriends");
LLComboBox* time_combobox = getChild<LLComboBox>("time_combobox");
time_combobox->setCurrentByIndex(gSavedSettings.getU32("TimeFormat"));
childSetValue("language_combobox", gSavedSettings.getString("Language"));
// if we have no agent, we can't let them choose anything
// if we have an agent, then we only let them choose if they have a choice
bool can_choose = gAgent.getID().notNull() &&
(gAgent.isMature() || gAgent.isGodlike());
if (can_choose)
{
// if they're not adult or a god, they shouldn't see the adult selection, so delete it
if (!gAgent.isAdult() && !gAgent.isGodlike())
{
LLComboBox* maturity_combo = getChild<LLComboBox>("maturity_desired_combobox");
// we're going to remove the adult entry from the combo. This obviously depends
// on the order of items in the XML file, but there doesn't seem to be a reasonable
// way to depend on the field in XML called 'name'.
maturity_combo->remove(0);
}
}
U32 preferred_maturity = gSavedSettings.getU32("PreferredMaturity");
childSetValue("maturity_desired_combobox", int(preferred_maturity));
std::string selected_item_label = getChild<LLComboBox>("maturity_desired_combobox")->getSelectedItemLabel();
childSetValue("maturity_desired_textbox", selected_item_label);
childSetVisible("maturity_desired_combobox", can_choose);
childSetVisible("maturity_desired_textbox", !can_choose);
childSetAction("grid_btn", onClickGrid, this);
return TRUE;
}
// static
void LLFloaterLandHoldings::processPlacesReply(LLMessageSystem* msg, void**)
{
LLFloaterLandHoldings* self = sInstance;
// Is this packet from an old, closed window?
if (!self)
{
return;
}
LLCtrlListInterface *list = self->childGetListInterface("parcel list");
if (!list) return;
// If this is the first packet, clear out the "loading..." indicator
if (!self->mFirstPacketReceived)
{
self->mFirstPacketReceived = TRUE;
list->operateOnAll(LLCtrlSelectionInterface::OP_DELETE);
}
LLUUID owner_id;
std::string name;
std::string desc;
S32 actual_area;
S32 billable_area;
U8 flags;
F32 global_x;
F32 global_y;
std::string sim_name;
std::string land_sku;
std::string land_type;
S32 i;
S32 count = msg->getNumberOfBlocks("QueryData");
for (i = 0; i < count; i++)
{
msg->getUUID("QueryData", "OwnerID", owner_id, i);
msg->getString("QueryData", "Name", name, i);
msg->getString("QueryData", "Desc", desc, i);
msg->getS32("QueryData", "ActualArea", actual_area, i);
msg->getS32("QueryData", "BillableArea", billable_area, i);
msg->getU8("QueryData", "Flags", flags, i);
msg->getF32("QueryData", "GlobalX", global_x, i);
msg->getF32("QueryData", "GlobalY", global_y, i);
msg->getString("QueryData", "SimName", sim_name, i);
if ( msg->getSizeFast(_PREHASH_QueryData, i, _PREHASH_ProductSKU) > 0 )
{
msg->getStringFast( _PREHASH_QueryData, _PREHASH_ProductSKU, land_sku, i);
llinfos << "Land sku: " << land_sku << llendl;
land_type = LLProductInfoRequestManager::instance().getDescriptionForSku(land_sku);
}
else
{
land_sku.clear();
land_type = LLTrans::getString("land_type_unknown");
}
self->mActualArea += actual_area;
self->mBillableArea += billable_area;
S32 region_x = llround(global_x) % REGION_WIDTH_UNITS;
S32 region_y = llround(global_y) % REGION_WIDTH_UNITS;
std::string location;
location = llformat("%s (%d, %d)", sim_name.c_str(), region_x, region_y);
std::string area;
if(billable_area == actual_area)
{
area = llformat("%d", billable_area);
}
else
{
area = llformat("%d / %d", billable_area, actual_area);
}
std::string hidden;
hidden = llformat("%f %f", global_x, global_y);
LLSD element;
element["columns"][0]["column"] = "name";
element["columns"][0]["value"] = name;
element["columns"][0]["font"] = "SANSSERIF";
element["columns"][1]["column"] = "location";
element["columns"][1]["value"] = location;
element["columns"][1]["font"] = "SANSSERIF";
element["columns"][2]["column"] = "area";
element["columns"][2]["value"] = area;
element["columns"][2]["font"] = "SANSSERIF";
element["columns"][3]["column"] = "type";
element["columns"][3]["value"] = land_type;
element["columns"][3]["font"] = "SANSSERIF";
// hidden is always last column
element["columns"][4]["column"] = "hidden";
element["columns"][4]["value"] = hidden;
list->addElement(element);
}
self->refreshAggregates();
}
void LLManip::renderTickValue(const LLVector3& pos, F32 value, const std::string& suffix, const LLColor4 &color)
{
LLLocale locale(LLLocale::USER_LOCALE);
const LLFontGL* big_fontp = LLResMgr::getInstance()->getRes( LLFONT_SANSSERIF );
const LLFontGL* small_fontp = LLResMgr::getInstance()->getRes( LLFONT_SANSSERIF_SMALL );
std::string val_string;
std::string fraction_string;
F32 val_to_print = llround(value, 0.001f);
S32 fractional_portion = llround(fmodf(llabs(val_to_print), 1.f) * 100.f);
if (val_to_print < 0.f)
{
if (fractional_portion == 0)
{
val_string = llformat("-%d%s", lltrunc(llabs(val_to_print)), suffix.c_str());
}
else
{
val_string = llformat("-%d", lltrunc(llabs(val_to_print)));
}
}
else
{
if (fractional_portion == 0)
{
val_string = llformat("%d%s", lltrunc(llabs(val_to_print)), suffix.c_str());
}
else
{
val_string = llformat("%d", lltrunc(val_to_print));
}
}
BOOL hud_selection = mObjectSelection->getSelectType() == SELECT_TYPE_HUD;
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
LLVector3 render_pos = pos;
if (hud_selection)
{
F32 zoom_amt = gAgent.mHUDCurZoom;
F32 inv_zoom_amt = 1.f / zoom_amt;
// scale text back up to counter-act zoom level
render_pos = pos * zoom_amt;
glScalef(inv_zoom_amt, inv_zoom_amt, inv_zoom_amt);
}
LLColor4 shadow_color = LLColor4::black;
shadow_color.mV[VALPHA] = color.mV[VALPHA] * 0.5f;
if (fractional_portion != 0)
{
fraction_string = llformat("%c%02d%s", LLResMgr::getInstance()->getDecimalPoint(), fractional_portion, suffix.c_str());
gViewerWindow->setupViewport(1, -1);
hud_render_utf8text(val_string, render_pos, *big_fontp, LLFontGL::NORMAL, -1.f * big_fontp->getWidthF32(val_string), 3.f, shadow_color, hud_selection);
hud_render_utf8text(fraction_string, render_pos, *small_fontp, LLFontGL::NORMAL, 1.f, 3.f, shadow_color, hud_selection);
gViewerWindow->setupViewport();
hud_render_utf8text(val_string, render_pos, *big_fontp, LLFontGL::NORMAL, -1.f * big_fontp->getWidthF32(val_string), 3.f, color, hud_selection);
hud_render_utf8text(fraction_string, render_pos, *small_fontp, LLFontGL::NORMAL, 1.f, 3.f, color, hud_selection);
}
else
{
gViewerWindow->setupViewport(1, -1);
hud_render_utf8text(val_string, render_pos, *big_fontp, LLFontGL::NORMAL, -0.5f * big_fontp->getWidthF32(val_string), 3.f, shadow_color, hud_selection);
gViewerWindow->setupViewport();
hud_render_utf8text(val_string, render_pos, *big_fontp, LLFontGL::NORMAL, -0.5f * big_fontp->getWidthF32(val_string), 3.f, color, hud_selection);
}
glPopMatrix();
}
static void
F(compile_test) (void)
{
TYPE a, b, c = 1.0;
complex TYPE d;
int i;
int saved_count;
long int j;
long long int k;
a = cos (cos (x));
b = acos (acos (a));
a = sin (sin (x));
b = asin (asin (a));
a = tan (tan (x));
b = atan (atan (a));
c = atan2 (atan2 (a, c), atan2 (b, x));
a = cosh (cosh (x));
b = acosh (acosh (a));
a = sinh (sinh (x));
b = asinh (asinh (a));
a = tanh (tanh (x));
b = atanh (atanh (a));
a = exp (exp (x));
b = log (log (a));
a = log10 (log10 (x));
b = ldexp (ldexp (a, 1), 5);
a = frexp (frexp (x, &i), &i);
b = expm1 (expm1 (a));
a = log1p (log1p (x));
b = logb (logb (a));
a = exp2 (exp2 (x));
b = log2 (log2 (a));
a = pow (pow (x, a), pow (c, b));
b = sqrt (sqrt (a));
a = hypot (hypot (x, b), hypot (c, a));
b = cbrt (cbrt (a));
a = ceil (ceil (x));
b = fabs (fabs (a));
a = floor (floor (x));
b = fmod (fmod (a, b), fmod (c, x));
a = nearbyint (nearbyint (x));
b = round (round (a));
a = trunc (trunc (x));
b = remquo (remquo (a, b, &i), remquo (c, x, &i), &i);
j = lrint (x) + lround (a);
k = llrint (b) + llround (c);
a = erf (erf (x));
b = erfc (erfc (a));
a = tgamma (tgamma (x));
b = lgamma (lgamma (a));
a = rint (rint (x));
b = nextafter (nextafter (a, b), nextafter (c, x));
a = nextdown (nextdown (a));
b = nexttoward (nexttoward (x, a), c);
a = nextup (nextup (a));
b = remainder (remainder (a, b), remainder (c, x));
a = scalb (scalb (x, a), (TYPE) (6));
k = scalbn (a, 7) + scalbln (c, 10l);
i = ilogb (x);
j = llogb (x);
a = fdim (fdim (x, a), fdim (c, b));
b = fmax (fmax (a, x), fmax (c, b));
a = fmin (fmin (x, a), fmin (c, b));
b = fma (sin (a), sin (x), sin (c));
a = totalorder (totalorder (x, b), totalorder (c, x));
b = totalordermag (totalordermag (x, a), totalordermag (c, x));
#ifdef TEST_INT
a = atan2 (i, b);
b = remquo (i, a, &i);
c = fma (i, b, i);
a = pow (i, c);
#endif
x = a + b + c + i + j + k;
saved_count = count;
if (ccount != 0)
ccount = -10000;
d = cos (cos (z));
z = acos (acos (d));
d = sin (sin (z));
z = asin (asin (d));
d = tan (tan (z));
z = atan (atan (d));
d = cosh (cosh (z));
z = acosh (acosh (d));
d = sinh (sinh (z));
z = asinh (asinh (d));
d = tanh (tanh (z));
z = atanh (atanh (d));
d = exp (exp (z));
z = log (log (d));
d = sqrt (sqrt (z));
z = conj (conj (d));
d = fabs (conj (a));
z = pow (pow (a, d), pow (b, z));
d = cproj (cproj (z));
z += fabs (cproj (a));
a = carg (carg (z));
b = creal (creal (d));
c = cimag (cimag (z));
x += a + b + c + i + j + k;
z += d;
if (saved_count != count)
count = -10000;
if (0)
{
a = cos (y);
a = acos (y);
a = sin (y);
a = asin (y);
a = tan (y);
a = atan (y);
a = atan2 (y, y);
a = cosh (y);
a = acosh (y);
a = sinh (y);
a = asinh (y);
a = tanh (y);
a = atanh (y);
a = exp (y);
a = log (y);
a = log10 (y);
a = ldexp (y, 5);
a = frexp (y, &i);
a = expm1 (y);
a = log1p (y);
a = logb (y);
a = exp2 (y);
a = log2 (y);
a = pow (y, y);
a = sqrt (y);
a = hypot (y, y);
a = cbrt (y);
a = ceil (y);
a = fabs (y);
a = floor (y);
a = fmod (y, y);
a = nearbyint (y);
a = round (y);
a = trunc (y);
a = remquo (y, y, &i);
j = lrint (y) + lround (y);
k = llrint (y) + llround (y);
a = erf (y);
a = erfc (y);
a = tgamma (y);
a = lgamma (y);
a = rint (y);
a = nextafter (y, y);
a = nexttoward (y, y);
a = remainder (y, y);
a = scalb (y, (const TYPE) (6));
k = scalbn (y, 7) + scalbln (y, 10l);
i = ilogb (y);
j = llogb (y);
a = fdim (y, y);
a = fmax (y, y);
a = fmin (y, y);
a = fma (y, y, y);
a = totalorder (y, y);
a = totalordermag (y, y);
#ifdef TEST_INT
a = atan2 (i, y);
a = remquo (i, y, &i);
a = fma (i, y, i);
a = pow (i, y);
#endif
d = cos ((const complex TYPE) z);
d = acos ((const complex TYPE) z);
d = sin ((const complex TYPE) z);
d = asin ((const complex TYPE) z);
d = tan ((const complex TYPE) z);
d = atan ((const complex TYPE) z);
d = cosh ((const complex TYPE) z);
d = acosh ((const complex TYPE) z);
d = sinh ((const complex TYPE) z);
d = asinh ((const complex TYPE) z);
d = tanh ((const complex TYPE) z);
d = atanh ((const complex TYPE) z);
d = exp ((const complex TYPE) z);
d = log ((const complex TYPE) z);
d = sqrt ((const complex TYPE) z);
d = pow ((const complex TYPE) z, (const complex TYPE) z);
d = fabs ((const complex TYPE) z);
d = carg ((const complex TYPE) z);
d = creal ((const complex TYPE) z);
d = cimag ((const complex TYPE) z);
d = conj ((const complex TYPE) z);
d = cproj ((const complex TYPE) z);
}
}
void LLMediaCtrl::draw()
{
if ( ! mWebBrowserImage || mWebBrowserImage->getNeedsUpdate())
return;
if ( gRestoreGL == 1 )
{
LLRect r = getRect();
reshape( r.getWidth(), r.getHeight(), FALSE );
return;
};
// NOTE: optimization needed here - probably only need to do this once
// unless tearoffs change the parent which they probably do.
const LLUICtrl* ptr = findRootMostFocusRoot();
if ( ptr && ptr->hasFocus() )
{
setFrequentUpdates( true );
}
else
{
setFrequentUpdates( false );
};
// alpha off for this
LLGLSUIDefault gls_ui;
LLGLDisable gls_alphaTest( GL_ALPHA_TEST );
bool draw_media = false;
LLPluginClassMedia* media_plugin = NULL;
LLWebBrowserTexture* media_texture = mWebBrowserImage;
if(mMediaSource && mMediaSource->hasMedia())
{
media_plugin = mMediaSource->getMediaPlugin();
if(media_plugin && (media_plugin->textureValid()))
{
media_texture = mWebBrowserImage;
if(media_texture)
{
draw_media = true;
}
}
}
if(draw_media)
{
gGL.pushMatrix();
{
if (mIgnoreUIScale)
{
gGL.loadIdentity();
// font system stores true screen origin, need to scale this by UI scale factor
// to get render origin for this view (with unit scale)
gGL.translatef(floorf(LLFontGL::sCurOrigin.mX * LLUI::getScaleFactor().mV[VX]),
floorf(LLFontGL::sCurOrigin.mY * LLUI::getScaleFactor().mV[VY]),
LLFontGL::sCurDepth);
}
// scale texture to fit the space using texture coords
gGL.getTexUnit(0)->bind(media_texture);
LLColor4 media_color = LLColor4::white;
gGL.color4fv( media_color.mV );
F32 max_u = ( F32 )media_plugin->getWidth() / ( F32 )media_plugin->getTextureWidth();
F32 max_v = ( F32 )media_plugin->getHeight() / ( F32 )media_plugin->getTextureHeight();
LLRect r = getRect();
S32 width, height;
S32 x_offset = 0;
S32 y_offset = 0;
if(mStretchToFill)
{
if(mMaintainAspectRatio)
{
F32 media_aspect = (F32)(media_plugin->getWidth()) / (F32)(media_plugin->getHeight());
F32 view_aspect = (F32)(r.getWidth()) / (F32)(r.getHeight());
if(media_aspect > view_aspect)
{
// max width, adjusted height
width = r.getWidth();
height = llmin(llmax(llround(width / media_aspect), 0), r.getHeight());
}
else
{
// max height, adjusted width
height = r.getHeight();
width = llmin(llmax(llround(height * media_aspect), 0), r.getWidth());
}
}
else
{
width = r.getWidth();
height = r.getHeight();
}
}
else
{
width = llmin(media_plugin->getWidth(), r.getWidth());
height = llmin(media_plugin->getHeight(), r.getHeight());
}
x_offset = (r.getWidth() - width) / 2;
y_offset = (r.getHeight() - height) / 2;
if (mIgnoreUIScale)
{
x_offset = llround((F32)x_offset * LLUI::getScaleFactor().mV[VX]);
y_offset = llround((F32)y_offset * LLUI::getScaleFactor().mV[VY]);
width = llround((F32)width * LLUI::getScaleFactor().mV[VX]);
height = llround((F32)height * LLUI::getScaleFactor().mV[VY]);
}
// draw the browser
gGL.setSceneBlendType(LLRender::BT_REPLACE);
gGL.begin( LLRender::QUADS );
if (! media_plugin->getTextureCoordsOpenGL())
{
// render using web browser reported width and height, instead of trying to invert GL scale
gGL.texCoord2f( max_u, 0.f );
gGL.vertex2i( x_offset + width, y_offset + height );
gGL.texCoord2f( 0.f, 0.f );
gGL.vertex2i( x_offset, y_offset + height );
gGL.texCoord2f( 0.f, max_v );
gGL.vertex2i( x_offset, y_offset );
gGL.texCoord2f( max_u, max_v );
gGL.vertex2i( x_offset + width, y_offset );
}
else
{
// render using web browser reported width and height, instead of trying to invert GL scale
gGL.texCoord2f( max_u, max_v );
gGL.vertex2i( x_offset + width, y_offset + height );
gGL.texCoord2f( 0.f, max_v );
gGL.vertex2i( x_offset, y_offset + height );
gGL.texCoord2f( 0.f, 0.f );
gGL.vertex2i( x_offset, y_offset );
gGL.texCoord2f( max_u, 0.f );
gGL.vertex2i( x_offset + width, y_offset );
}
gGL.end();
gGL.setSceneBlendType(LLRender::BT_ALPHA);
}
gGL.popMatrix();
}
// highlight if keyboard focus here. (TODO: this needs some work)
if ( mBorder && mBorder->getVisible() )
mBorder->setKeyboardFocusHighlight( gFocusMgr.childHasKeyboardFocus( this ) );
LLUICtrl::draw();
}
//static
void LLPanelGroupLandMoney::impl::processGroupLand(LLMessageSystem* msg)
{
S32 count = msg->getNumberOfBlocks("QueryData");
if(count > 0)
{
S32 first_block = 0;
LLUUID owner_id;
LLUUID trans_id;
msg->getUUID("QueryData", "OwnerID", owner_id, 0);
msg->getUUID("TransactionData", "TransactionID", trans_id);
if(owner_id.isNull())
{
// special block which has total contribution
++first_block;
S32 total_contribution;
msg->getS32("QueryData", "ActualArea", total_contribution, 0);
mPanel.getChild<LLUICtrl>("total_contributed_land_value")->setTextArg("[AREA]", llformat("%d", total_contribution));
S32 committed;
msg->getS32("QueryData", "BillableArea", committed, 0);
mPanel.getChild<LLUICtrl>("total_land_in_use_value")->setTextArg("[AREA]", llformat("%d", committed));
S32 available = total_contribution - committed;
mPanel.getChild<LLUICtrl>("land_available_value")->setTextArg("[AREA]", llformat("%d", available));
if ( mGroupOverLimitTextp && mGroupOverLimitIconp )
{
mGroupOverLimitIconp->setVisible(available < 0);
mGroupOverLimitTextp->setVisible(available < 0);
}
}
if ( trans_id != mTransID ) return;
// This power was removed to make group roles simpler
//if ( !gAgent.hasPowerInGroup(mGroupID, GP_LAND_VIEW_OWNED) ) return;
if (!gAgent.isInGroup(mPanel.mGroupID)) return;
mGroupParcelsp->setCommentText(mEmptyParcelsText);
std::string name;
std::string desc;
S32 actual_area;
S32 billable_area;
U8 flags;
F32 global_x;
F32 global_y;
std::string sim_name;
std::string land_sku;
std::string land_type;
for(S32 i = first_block; i < count; ++i)
{
msg->getUUID("QueryData", "OwnerID", owner_id, i);
msg->getString("QueryData", "Name", name, i);
msg->getString("QueryData", "Desc", desc, i);
msg->getS32("QueryData", "ActualArea", actual_area, i);
msg->getS32("QueryData", "BillableArea", billable_area, i);
msg->getU8("QueryData", "Flags", flags, i);
msg->getF32("QueryData", "GlobalX", global_x, i);
msg->getF32("QueryData", "GlobalY", global_y, i);
msg->getString("QueryData", "SimName", sim_name, i);
if ( msg->getSizeFast(_PREHASH_QueryData, i, _PREHASH_ProductSKU) > 0 )
{
msg->getStringFast( _PREHASH_QueryData, _PREHASH_ProductSKU, land_sku, i);
llinfos << "Land sku: " << land_sku << llendl;
land_type = LLProductInfoRequestManager::instance().getDescriptionForSku(land_sku);
}
else
{
land_sku.clear();
land_type = LLTrans::getString("land_type_unknown");
}
S32 region_x = llround(global_x) % REGION_WIDTH_UNITS;
S32 region_y = llround(global_y) % REGION_WIDTH_UNITS;
std::string location = sim_name + llformat(" (%d, %d)", region_x, region_y);
std::string area;
if(billable_area == actual_area)
{
area = llformat("%d", billable_area);
}
else
{
area = llformat("%d / %d", billable_area, actual_area);
}
std::string hidden;
hidden = llformat("%f %f", global_x, global_y);
LLSD row;
row["columns"][0]["column"] = "name";
row["columns"][0]["value"] = name;
row["columns"][0]["font"] = "SANSSERIF_SMALL";
row["columns"][1]["column"] = "location";
row["columns"][1]["value"] = location;
row["columns"][1]["font"] = "SANSSERIF_SMALL";
row["columns"][2]["column"] = "area";
row["columns"][2]["value"] = area;
row["columns"][2]["font"] = "SANSSERIF_SMALL";
row["columns"][3]["column"] = "type";
row["columns"][3]["value"] = land_type;
row["columns"][3]["font"] = "SANSSERIF_SMALL";
// hidden is always last column
row["columns"][4]["column"] = "hidden";
row["columns"][4]["value"] = hidden;
mGroupParcelsp->addElement(row);
}
}
}
__global__ void test_llround(double* a, long long int* b) {
int tid = threadIdx.x;
b[tid] = llround(a[tid]);
}
__global__ void test_llround(hipLaunchParm lp, double *a, long long int *b){
int tid = hipThreadIdx_x;
b[tid] = llround(a[tid]);
}
static jlong GTime_get_utc_time_millis(JNIEnv* env, jobject thiz)
{
gtime_t t;
t = gpst2utc(get_gtime_t(env, thiz));
return (jlong)(1000ll * t.time + llround(1000.0 * t.sec));
}
void LLToolSelectLand::roundXY(LLVector3d &vec)
{
vec.mdV[VX] = llround( vec.mdV[VX], (F64)PARCEL_GRID_STEP_METERS );
vec.mdV[VY] = llround( vec.mdV[VY], (F64)PARCEL_GRID_STEP_METERS );
}
LLCheckBoxCtrl::LLCheckBoxCtrl(const std::string& name, const LLRect& rect,
const std::string& label,
const LLFontGL* font,
void (*commit_callback)(LLUICtrl* ctrl, void* userdata),
void* callback_user_data,
BOOL initial_value,
BOOL use_radio_style,
const std::string& control_which)
: LLUICtrl(name, rect, TRUE, commit_callback, callback_user_data, FOLLOWS_LEFT | FOLLOWS_TOP),
mTextEnabledColor( LLUI::sColorsGroup->getColor( "LabelTextColor" ) ),
mTextDisabledColor( LLUI::sColorsGroup->getColor( "LabelDisabledColor" ) ),
mRadioStyle( use_radio_style ),
mInitialValue( initial_value ),
mSetValue( initial_value )
{
if (font)
{
mFont = font;
}
else
{
mFont = LLFontGL::getFontSansSerifSmall();
}
// must be big enough to hold all children
setUseBoundingRect(TRUE);
mKeyboardFocusOnClick = TRUE;
// Label (add a little space to make sure text actually renders)
const S32 FUDGE = 10;
S32 text_width = mFont->getWidth( label ) + FUDGE;
S32 text_height = llround(mFont->getLineHeight());
LLRect label_rect;
label_rect.setOriginAndSize(
LLCHECKBOXCTRL_HPAD + LLCHECKBOXCTRL_BTN_SIZE + LLCHECKBOXCTRL_SPACING,
LLCHECKBOXCTRL_VPAD + 1, // padding to get better alignment
text_width + LLCHECKBOXCTRL_HPAD,
text_height );
// *HACK Get rid of this with SL-55508...
// this allows blank check boxes and radio boxes for now
std::string local_label = label;
if(local_label.empty())
{
local_label = " ";
}
mLabel = new LLTextBox( std::string("CheckboxCtrl Label"), label_rect, local_label, mFont );
mLabel->setFollowsLeft();
mLabel->setFollowsBottom();
addChild(mLabel);
// Button
// Note: button cover the label by extending all the way to the right.
LLRect btn_rect;
btn_rect.setOriginAndSize(
LLCHECKBOXCTRL_HPAD,
LLCHECKBOXCTRL_VPAD,
LLCHECKBOXCTRL_BTN_SIZE + LLCHECKBOXCTRL_SPACING + text_width + LLCHECKBOXCTRL_HPAD,
llmax( text_height, LLCHECKBOXCTRL_BTN_SIZE ) + LLCHECKBOXCTRL_VPAD);
std::string active_true_id, active_false_id;
std::string inactive_true_id, inactive_false_id;
if (mRadioStyle)
{
active_true_id = "UIImgRadioActiveSelectedUUID";
active_false_id = "UIImgRadioActiveUUID";
inactive_true_id = "UIImgRadioInactiveSelectedUUID";
inactive_false_id = "UIImgRadioInactiveUUID";
mButton = new LLButton(std::string("Radio control button"), btn_rect,
active_false_id, active_true_id, control_which,
&LLCheckBoxCtrl::onButtonPress, this, LLFontGL::getFontSansSerif() );
mButton->setDisabledImages( inactive_false_id, inactive_true_id );
mButton->setHoverGlowStrength(0.35f);
}
else
{
active_false_id = "UIImgCheckboxActiveUUID";
active_true_id = "UIImgCheckboxActiveSelectedUUID";
inactive_true_id = "UIImgCheckboxInactiveSelectedUUID";
inactive_false_id = "UIImgCheckboxInactiveUUID";
mButton = new LLButton(std::string("Checkbox control button"), btn_rect,
active_false_id, active_true_id, control_which,
&LLCheckBoxCtrl::onButtonPress, this, LLFontGL::getFontSansSerif() );
mButton->setDisabledImages( inactive_false_id, inactive_true_id );
mButton->setHoverGlowStrength(0.35f);
}
mButton->setIsToggle(TRUE);
mButton->setToggleState( initial_value );
mButton->setFollowsLeft();
mButton->setFollowsBottom();
mButton->setCommitOnReturn(FALSE);
addChild(mButton);
}
long long llroundf (float x)
{
return (long long) llround( (double)x );
}
void KVFloaterFlickrUpload::uploadSnapshot()
{
mTitle = childGetValue("title_form").asString();
LLSD params;
params["title"] = childGetValue("title_form");
params["safety_level"] = childGetValue("rating_combo");
std::string tags = childGetValue("tags_form");
std::string description = childGetValue("description_form");
if(childGetValue("show_position_check").asBoolean())
{
// Work out where this was taken.
LLVector3d clamped_global = LLWorld::getInstance()->clipToVisibleRegions(gAgent.getPositionGlobal(), mPosTakenGlobal);
LLViewerRegion* region = LLWorld::getInstance()->getRegionFromPosGlobal(clamped_global);
if(!region)
{
// Clamping failed? Shouldn't happen.
// Use the agent's position instead; if the region the agent is in doesn't exist we have some serious issues,
// and crashing is an entirely reasonable thing to do.
region = gAgent.getRegion();
clamped_global = gAgent.getPositionGlobal();
}
std::string region_name = region->getName();
LLVector3 region_pos = region->getPosRegionFromGlobal(clamped_global);
std::ostringstream region_tags;
region_tags << " \"secondlife:region=" << region_name << "\"";
region_tags << " secondlife:x=" << llround(region_pos[VX]);
region_tags << " secondlife:y=" << llround(region_pos[VY]);
region_tags << " secondlife:z=" << llround(region_pos[VZ]);
// Now let's give some precise camera values.
region_tags << " secondlife:camera_pos_x=" << (mPosTakenGlobal[VX] - region->getOriginGlobal()[VX]);
region_tags << " secondlife:camera_pos_y=" << (mPosTakenGlobal[VY] - region->getOriginGlobal()[VY]);
region_tags << " secondlife:camera_pos_z=" << mPosTakenGlobal[VZ];
tags += region_tags.str();
// Include an SLurl in the description, too (maybe).
if(gSavedSettings.getBOOL("KittyFlickrIncludeSLURL"))
{
LLSLURL url(region_name, region_pos);
std::ostringstream region_desc;
region_desc << "<em><a href='" << url.getSLURLString() << "'>";
region_desc << "Taken at " << region_name << " (";
region_desc << llround(region_pos[VX]) << ", ";
region_desc << llround(region_pos[VY]) << ", ";
region_desc << llround(region_pos[VZ]) << ")";
region_desc << "</a></em>";
if(description != "")
{
description += "\n\n";
}
description += region_desc.str();
}
}
params["tags"] = tags;
params["description"] = description;
LL_INFOS("FlickrAPI") << "Uploading snapshot with metadata: " << params << LL_ENDL;
params["auth_token"] = gSavedPerAccountSettings.getLLSD("KittyFlickrToken");
LLUploadDialog::modalUploadDialog(getString("uploading"));
KVFlickrRequest::uploadPhoto(params, mCompressedImage, boost::bind(&KVFloaterFlickrUpload::imageUploaded, this, _1, _2));
}
void LLPanelPrimMediaControls::updateShape()
{
LLViewerMediaImpl* media_impl = getTargetMediaImpl();
LLViewerObject* objectp = getTargetObject();
if(!media_impl || gFloaterTools->getVisible())
{
setVisible(FALSE);
return;
}
LLPluginClassMedia* media_plugin = NULL;
if(media_impl->hasMedia())
{
media_plugin = media_impl->getMediaPlugin();
}
LLParcel *parcel = LLViewerParcelMgr::getInstance()->getAgentParcel();
bool can_navigate = parcel->getMediaAllowNavigate();
bool enabled = false;
bool is_zoomed = (mCurrentZoom != ZOOM_NONE) && (mTargetObjectID == mZoomObjectID) && (mTargetObjectFace == mZoomObjectFace);
// There is no such thing as "has_focus" being different from normal controls set
// anymore (as of user feedback from bri 10/09). So we cheat here and force 'has_focus'
// to 'true' (or, actually, we use a setting)
bool has_focus = (gSavedSettings.getBOOL("PrimMediaControlsUseHoverControlSet")) ? media_impl->hasFocus() : true;
setVisible(enabled);
if (objectp)
{
bool mini_controls = false;
LLMediaEntry *media_data = objectp->getTE(mTargetObjectFace)->getMediaData();
if (media_data && NULL != dynamic_cast<LLVOVolume*>(objectp))
{
// Don't show the media controls if we do not have permissions
enabled = dynamic_cast<LLVOVolume*>(objectp)->hasMediaPermission(media_data, LLVOVolume::MEDIA_PERM_CONTROL);
mini_controls = (LLMediaEntry::MINI == media_data->getControls());
}
const bool is_hud = objectp->isHUDAttachment();
//
// Set the state of the buttons
//
// XXX RSP: TODO: FIXME: clean this up so that it is clearer what mode we are in,
// and that only the proper controls get made visible/enabled according to that mode.
mBackCtrl->setVisible(has_focus);
mFwdCtrl->setVisible(has_focus);
mReloadCtrl->setVisible(has_focus);
mStopCtrl->setVisible(false);
mHomeCtrl->setVisible(has_focus);
mZoomCtrl->setVisible(!is_zoomed);
mUnzoomCtrl->setVisible(is_zoomed);
mOpenCtrl->setVisible(true);
mMediaAddressCtrl->setVisible(has_focus && !mini_controls);
mMediaPlaySliderPanel->setVisible(has_focus && !mini_controls);
mVolumeCtrl->setVisible(false);
mWhitelistIcon->setVisible(!mini_controls && (media_data)?media_data->getWhiteListEnable():false);
// Disable zoom if HUD
mZoomCtrl->setEnabled(!is_hud);
mUnzoomCtrl->setEnabled(!is_hud);
mSecureLockIcon->setVisible(false);
mCurrentURL = media_impl->getCurrentMediaURL();
mBackCtrl->setEnabled((media_impl != NULL) && media_impl->canNavigateBack() && can_navigate);
mFwdCtrl->setEnabled((media_impl != NULL) && media_impl->canNavigateForward() && can_navigate);
mStopCtrl->setEnabled(has_focus && can_navigate);
mHomeCtrl->setEnabled(has_focus && can_navigate);
LLPluginClassMediaOwner::EMediaStatus result = ((media_impl != NULL) && media_impl->hasMedia()) ? media_plugin->getStatus() : LLPluginClassMediaOwner::MEDIA_NONE;
mVolumeCtrl->setVisible(has_focus);
mVolumeCtrl->setEnabled(has_focus);
mVolumeSliderCtrl->setEnabled(has_focus && shouldVolumeSliderBeVisible());
mVolumeSliderCtrl->setVisible(has_focus && shouldVolumeSliderBeVisible());
if(media_plugin && media_plugin->pluginSupportsMediaTime())
{
mReloadCtrl->setEnabled(false);
mReloadCtrl->setVisible(false);
mMediaStopCtrl->setVisible(has_focus);
mHomeCtrl->setVisible(has_focus);
mBackCtrl->setVisible(false);
mFwdCtrl->setVisible(false);
mMediaAddressCtrl->setVisible(false);
mMediaAddressCtrl->setEnabled(false);
mMediaPlaySliderPanel->setVisible(has_focus && !mini_controls);
mMediaPlaySliderPanel->setEnabled(has_focus && !mini_controls);
mSkipFwdCtrl->setVisible(has_focus && !mini_controls);
mSkipFwdCtrl->setEnabled(has_focus && !mini_controls);
mSkipBackCtrl->setVisible(has_focus && !mini_controls);
mSkipBackCtrl->setEnabled(has_focus && !mini_controls);
mVolumeCtrl->setVisible(has_focus);
mVolumeCtrl->setEnabled(has_focus);
mVolumeSliderCtrl->setEnabled(has_focus && shouldVolumeSliderBeVisible());
mVolumeSliderCtrl->setVisible(has_focus && shouldVolumeSliderBeVisible());
mWhitelistIcon->setVisible(false);
mSecureLockIcon->setVisible(false);
if (mMediaPanelScroll)
{
mMediaPanelScroll->setVisible(false);
mScrollUpCtrl->setVisible(false);
mScrollDownCtrl->setVisible(false);
mScrollRightCtrl->setVisible(false);
mScrollDownCtrl->setVisible(false);
}
F32 volume = media_impl->getVolume();
// movie's url changed
if(mCurrentURL!=mPreviousURL)
{
mMovieDuration = media_plugin->getDuration();
mPreviousURL = mCurrentURL;
}
if(mMovieDuration == 0)
{
mMovieDuration = media_plugin->getDuration();
mMediaPlaySliderCtrl->setValue(0);
mMediaPlaySliderCtrl->setEnabled(false);
}
// TODO: What if it's not fully loaded
if(mUpdateSlider && mMovieDuration!= 0)
{
F64 current_time = media_plugin->getCurrentTime();
F32 percent = current_time / mMovieDuration;
mMediaPlaySliderCtrl->setValue(percent);
mMediaPlaySliderCtrl->setEnabled(true);
}
// video vloume
if(volume <= 0.0)
{
mMuteBtn->setToggleState(true);
}
else if (volume >= 1.0)
{
mMuteBtn->setToggleState(false);
}
else
{
mMuteBtn->setToggleState(false);
}
switch(result)
{
case LLPluginClassMediaOwner::MEDIA_PLAYING:
mPlayCtrl->setEnabled(FALSE);
mPlayCtrl->setVisible(FALSE);
mPauseCtrl->setEnabled(TRUE);
mPauseCtrl->setVisible(has_focus);
break;
case LLPluginClassMediaOwner::MEDIA_PAUSED:
default:
mPauseCtrl->setEnabled(FALSE);
mPauseCtrl->setVisible(FALSE);
mPlayCtrl->setEnabled(TRUE);
mPlayCtrl->setVisible(has_focus);
break;
}
}
else // web based
{
if(media_plugin)
{
mCurrentURL = media_plugin->getLocation();
}
else
{
mCurrentURL.clear();
}
mPlayCtrl->setVisible(FALSE);
mPauseCtrl->setVisible(FALSE);
mMediaStopCtrl->setVisible(FALSE);
mMediaAddressCtrl->setVisible(has_focus && !mini_controls);
mMediaAddressCtrl->setEnabled(has_focus && !mini_controls);
mMediaPlaySliderPanel->setVisible(FALSE);
mMediaPlaySliderPanel->setEnabled(FALSE);
mSkipFwdCtrl->setVisible(FALSE);
mSkipFwdCtrl->setEnabled(FALSE);
mSkipBackCtrl->setVisible(FALSE);
mSkipBackCtrl->setEnabled(FALSE);
if(media_impl->getVolume() <= 0.0)
{
mMuteBtn->setToggleState(true);
}
else
{
mMuteBtn->setToggleState(false);
}
if (mMediaPanelScroll)
{
mMediaPanelScroll->setVisible(has_focus);
mScrollUpCtrl->setVisible(has_focus);
mScrollDownCtrl->setVisible(has_focus);
mScrollRightCtrl->setVisible(has_focus);
mScrollDownCtrl->setVisible(has_focus);
}
// TODO: get the secure lock bool from media plug in
std::string prefix = std::string("https://");
std::string test_prefix = mCurrentURL.substr(0, prefix.length());
LLStringUtil::toLower(test_prefix);
if(test_prefix == prefix)
{
mSecureLockIcon->setVisible(has_focus);
}
if(mCurrentURL!=mPreviousURL)
{
setCurrentURL();
mPreviousURL = mCurrentURL;
}
if(result == LLPluginClassMediaOwner::MEDIA_LOADING)
{
mReloadCtrl->setEnabled(FALSE);
mReloadCtrl->setVisible(FALSE);
mStopCtrl->setEnabled(TRUE);
mStopCtrl->setVisible(has_focus);
}
else
{
mReloadCtrl->setEnabled(TRUE);
mReloadCtrl->setVisible(has_focus);
mStopCtrl->setEnabled(FALSE);
mStopCtrl->setVisible(FALSE);
}
}
if(media_plugin)
{
//
// Handle progress bar
//
if(LLPluginClassMediaOwner::MEDIA_LOADING == media_plugin->getStatus())
{
mMediaProgressPanel->setVisible(true);
mMediaProgressBar->setPercent(media_plugin->getProgressPercent());
}
else
{
mMediaProgressPanel->setVisible(false);
}
}
if(media_impl)
{
//
// Handle Scrolling
//
switch (mScrollState)
{
case SCROLL_UP:
media_impl->scrollWheel(0, -1, MASK_NONE);
break;
case SCROLL_DOWN:
media_impl->scrollWheel(0, 1, MASK_NONE);
break;
case SCROLL_LEFT:
media_impl->scrollWheel(1, 0, MASK_NONE);
// media_impl->handleKeyHere(KEY_LEFT, MASK_NONE);
break;
case SCROLL_RIGHT:
media_impl->scrollWheel(-1, 0, MASK_NONE);
// media_impl->handleKeyHere(KEY_RIGHT, MASK_NONE);
break;
case SCROLL_NONE:
default:
break;
}
}
setVisible(enabled);
//
// Calculate position and shape of the controls
//
std::vector<LLVector3>::iterator vert_it;
std::vector<LLVector3>::iterator vert_end;
std::vector<LLVector3> vect_face;
LLVolume* volume = objectp->getVolume();
if (volume)
{
const LLVolumeFace& vf = volume->getVolumeFace(mTargetObjectFace);
const LLVector3* ext = vf.mExtents;
LLVector3 center = (ext[0]+ext[1])*0.5f;
LLVector3 size = (ext[1]-ext[0])*0.5f;
LLVector3 vert[] =
{
center + size.scaledVec(LLVector3(1,1,1)),
center + size.scaledVec(LLVector3(-1,1,1)),
center + size.scaledVec(LLVector3(1,-1,1)),
center + size.scaledVec(LLVector3(-1,-1,1)),
center + size.scaledVec(LLVector3(1,1,-1)),
center + size.scaledVec(LLVector3(-1,1,-1)),
center + size.scaledVec(LLVector3(1,-1,-1)),
center + size.scaledVec(LLVector3(-1,-1,-1)),
};
LLVOVolume* vo = (LLVOVolume*) objectp;
for (U32 i = 0; i < 8; i++)
{
vect_face.push_back(vo->volumePositionToAgent(vert[i]));
}
}
vert_it = vect_face.begin();
vert_end = vect_face.end();
glh::matrix4f mat;
if (!is_hud)
{
mat = glh_get_current_projection() * glh_get_current_modelview();
}
else {
glh::matrix4f proj, modelview;
if (get_hud_matrices(proj, modelview))
mat = proj * modelview;
}
LLVector3 min = LLVector3(1,1,1);
LLVector3 max = LLVector3(-1,-1,-1);
for(; vert_it != vert_end; ++vert_it)
{
// project silhouette vertices into screen space
glh::vec3f screen_vert = glh::vec3f(vert_it->mV);
mat.mult_matrix_vec(screen_vert);
// add to screenspace bounding box
update_min_max(min, max, LLVector3(screen_vert.v));
}
// convert screenspace bbox to pixels (in screen coords)
LLRect window_rect = gViewerWindow->getWorldViewRectScaled();
LLCoordGL screen_min;
screen_min.mX = llround((F32)window_rect.getWidth() * (min.mV[VX] + 1.f) * 0.5f);
screen_min.mY = llround((F32)window_rect.getHeight() * (min.mV[VY] + 1.f) * 0.5f);
LLCoordGL screen_max;
screen_max.mX = llround((F32)window_rect.getWidth() * (max.mV[VX] + 1.f) * 0.5f);
screen_max.mY = llround((F32)window_rect.getHeight() * (max.mV[VY] + 1.f) * 0.5f);
// grow panel so that screenspace bounding box fits inside "media_region" element of panel
LLRect media_panel_rect;
// Get the height of the controls (less the volume slider)
S32 controls_height = mMediaControlsStack->getRect().getHeight() - mVolumeSliderCtrl->getRect().getHeight();
getParent()->screenRectToLocal(LLRect(screen_min.mX, screen_max.mY, screen_max.mX, screen_min.mY), &media_panel_rect);
media_panel_rect.mTop += controls_height;
// keep all parts of panel on-screen
// Area of the top of the world view to avoid putting the controls
window_rect.mTop -= mTopWorldViewAvoidZone;
// Don't include "spacing" bookends on left & right of the media controls
window_rect.mLeft -= mLeftBookend->getRect().getWidth();
window_rect.mRight += mRightBookend->getRect().getWidth();
// Don't include the volume slider
window_rect.mBottom -= mVolumeSliderCtrl->getRect().getHeight();
media_panel_rect.intersectWith(window_rect);
// clamp to minimum size, keeping rect inside window
S32 centerX = media_panel_rect.getCenterX();
S32 centerY = media_panel_rect.getCenterY();
// Shrink screen rect by min width and height, to ensure containment
window_rect.stretch(-mMinWidth/2, -mMinHeight/2);
window_rect.clampPointToRect(centerX, centerY);
media_panel_rect.setCenterAndSize(centerX, centerY,
llmax(mMinWidth, media_panel_rect.getWidth()),
llmax(mMinHeight, media_panel_rect.getHeight()));
// Finally set the size of the panel
setShape(media_panel_rect, true);
// Test mouse position to see if the cursor is stationary
LLCoordWindow cursor_pos_window;
getWindow()->getCursorPosition(&cursor_pos_window);
// If last pos is not equal to current pos, the mouse has moved
// We need to reset the timer, and make sure the panel is visible
if(cursor_pos_window.mX != mLastCursorPos.mX ||
cursor_pos_window.mY != mLastCursorPos.mY ||
mScrollState != SCROLL_NONE)
{
mInactivityTimer.start();
mLastCursorPos = cursor_pos_window;
}
if(isMouseOver() || hasFocus())
{
// Never fade the controls if the mouse is over them or they have keyboard focus.
mFadeTimer.stop();
}
else if(!mClearFaceOnFade && (mInactivityTimer.getElapsedTimeF32() < mInactiveTimeout))
{
// Mouse is over the object, but has not been stationary for long enough to fade the UI
mFadeTimer.stop();
}
else if(! mFadeTimer.getStarted() )
{
// we need to start fading the UI (and we have not already started)
mFadeTimer.reset();
mFadeTimer.start();
}
else
{
// I don't think this is correct anymore. This is done in draw() after the fade has completed.
// setVisible(FALSE);
}
}
}
void LLImageRaw::compositeRowScaled4onto3( U8* in, U8* out, S32 in_pixel_len, S32 out_pixel_len )
{
llassert( getComponents() == 3 );
const S32 IN_COMPONENTS = 4;
const S32 OUT_COMPONENTS = 3;
const F32 ratio = F32(in_pixel_len) / out_pixel_len; // ratio of old to new
const F32 norm_factor = 1.f / ratio;
for( S32 x = 0; x < out_pixel_len; x++ )
{
// Sample input pixels in range from sample0 to sample1.
// Avoid floating point accumulation error... don't just add ratio each time. JC
const F32 sample0 = x * ratio;
const F32 sample1 = (x+1) * ratio;
const S32 index0 = S32(sample0); // left integer (floor)
const S32 index1 = S32(sample1); // right integer (floor)
const F32 fract0 = 1.f - (sample0 - F32(index0)); // spill over on left
const F32 fract1 = sample1 - F32(index1); // spill-over on right
U8 in_scaled_r;
U8 in_scaled_g;
U8 in_scaled_b;
U8 in_scaled_a;
if( index0 == index1 )
{
// Interval is embedded in one input pixel
S32 t1 = index0 * IN_COMPONENTS;
in_scaled_r = in[t1 + 0];
in_scaled_g = in[t1 + 0];
in_scaled_b = in[t1 + 0];
in_scaled_a = in[t1 + 0];
}
else
{
// Left straddle
S32 t1 = index0 * IN_COMPONENTS;
F32 r = in[t1 + 0] * fract0;
F32 g = in[t1 + 1] * fract0;
F32 b = in[t1 + 2] * fract0;
F32 a = in[t1 + 3] * fract0;
// Central interval
for( S32 u = index0 + 1; u < index1; u++ )
{
S32 t2 = u * IN_COMPONENTS;
r += in[t2 + 0];
g += in[t2 + 1];
b += in[t2 + 2];
a += in[t2 + 3];
}
// right straddle
// Watch out for reading off of end of input array.
if( fract1 && index1 < in_pixel_len )
{
S32 t3 = index1 * IN_COMPONENTS;
r += in[t3 + 0] * fract1;
g += in[t3 + 1] * fract1;
b += in[t3 + 2] * fract1;
a += in[t3 + 3] * fract1;
}
r *= norm_factor;
g *= norm_factor;
b *= norm_factor;
a *= norm_factor;
in_scaled_r = U8(llround(r));
in_scaled_g = U8(llround(g));
in_scaled_b = U8(llround(b));
in_scaled_a = U8(llround(a));
}
if( in_scaled_a )
{
if( 255 == in_scaled_a )
{
out[0] = in_scaled_r;
out[1] = in_scaled_g;
out[2] = in_scaled_b;
}
else
{
U8 transparency = 255 - in_scaled_a;
out[0] = fastFractionalMult( out[0], transparency ) + fastFractionalMult( in_scaled_r, in_scaled_a );
out[1] = fastFractionalMult( out[1], transparency ) + fastFractionalMult( in_scaled_g, in_scaled_a );
out[2] = fastFractionalMult( out[2], transparency ) + fastFractionalMult( in_scaled_b, in_scaled_a );
}
}
out += OUT_COMPONENTS;
}
}
void LLFloaterBuyLandUI::updateParcelInfo()
{
LLParcel* parcel = mParcel->getParcel();
mParcelValid = parcel && mRegion;
mParcelIsForSale = false;
mParcelIsGroupLand = false;
mParcelGroupContribution = 0;
mParcelPrice = 0;
mParcelActualArea = 0;
mParcelBillableArea = 0;
mParcelSupportedObjects = 0;
mParcelSoldWithObjects = false;
mParcelLocation = "";
mParcelSnapshot.setNull();
mParcelSellerName = "";
mCanBuy = false;
mCannotBuyIsError = false;
if (!mParcelValid)
{
mCannotBuyReason = getString("no_land_selected");
return;
}
if (mParcel->getMultipleOwners())
{
mCannotBuyReason = getString("multiple_parcels_selected");
return;
}
const LLUUID& parcelOwner = parcel->getOwnerID();
mIsClaim = parcel->isPublic();
if (!mIsClaim)
{
mParcelActualArea = parcel->getArea();
mParcelIsForSale = parcel->getForSale();
mParcelIsGroupLand = parcel->getIsGroupOwned();
mParcelPrice = mParcelIsForSale ? parcel->getSalePrice() : 0;
if (mParcelIsGroupLand)
{
LLUUID group_id = parcel->getGroupID();
mParcelGroupContribution = gAgent.getGroupContribution(group_id);
}
}
else
{
mParcelActualArea = mParcel->getClaimableArea();
mParcelIsForSale = true;
mParcelPrice = mParcelActualArea * parcel->getClaimPricePerMeter();
}
mParcelBillableArea =
llround(mRegion->getBillableFactor() * mParcelActualArea);
mParcelSupportedObjects = llround(
parcel->getMaxPrimCapacity() * parcel->getParcelPrimBonus());
// Can't have more than region max tasks, regardless of parcel
// object bonus factor.
LLViewerRegion* region = LLViewerParcelMgr::getInstance()->getSelectionRegion();
if(region)
{
S32 max_tasks_per_region = (S32)region->getMaxTasks();
mParcelSupportedObjects = llmin(
mParcelSupportedObjects, max_tasks_per_region);
}
mParcelSoldWithObjects = parcel->getSellWithObjects();
LLVector3 center = parcel->getCenterpoint();
mParcelLocation = llformat("%s %d,%d",
mRegion->getName().c_str(),
(int)center[VX], (int)center[VY]
);
mParcelSnapshot = parcel->getSnapshotID();
updateNames();
bool haveEnoughCash = mParcelPrice <= mAgentCashBalance;
S32 cashBuy = haveEnoughCash ? 0 : (mParcelPrice - mAgentCashBalance);
mCurrency.setAmount(cashBuy, true);
mCurrency.setZeroMessage(haveEnoughCash ? getString("none_needed") : LLStringUtil::null);
// checks that we can buy the land
if(mIsForGroup && !gAgent.hasPowerInActiveGroup(GP_LAND_DEED))
{
mCannotBuyReason = getString("cant_buy_for_group");
return;
}
if (!mIsClaim)
{
const LLUUID& authorizedBuyer = parcel->getAuthorizedBuyerID();
const LLUUID buyer = gAgent.getID();
const LLUUID newOwner = mIsForGroup ? gAgent.getGroupID() : buyer;
if (!mParcelIsForSale
|| (mParcelPrice == 0 && authorizedBuyer.isNull()))
{
mCannotBuyReason = getString("parcel_not_for_sale");
return;
}
if (parcelOwner == newOwner)
{
if (mIsForGroup)
{
mCannotBuyReason = getString("group_already_owns");
}
else
{
mCannotBuyReason = getString("you_already_own");
}
return;
}
if (!authorizedBuyer.isNull() && buyer != authorizedBuyer)
{
// Maybe the parcel is set for sale to a group we are in.
bool authorized_group =
gAgent.hasPowerInGroup(authorizedBuyer,GP_LAND_DEED)
&& gAgent.hasPowerInGroup(authorizedBuyer,GP_LAND_SET_SALE_INFO);
if (!authorized_group)
{
mCannotBuyReason = getString("set_to_sell_to_other");
return;
}
}
}
else
{
if (mParcelActualArea == 0)
{
mCannotBuyReason = getString("no_public_land");
return;
}
if (mParcel->hasOthersSelected())
{
// Policy: Must not have someone else's land selected
mCannotBuyReason = getString("not_owned_by_you");
return;
}
}
mCanBuy = true;
}
void LLImageRaw::copyLineScaled( U8* in, U8* out, S32 in_pixel_len, S32 out_pixel_len, S32 in_pixel_step, S32 out_pixel_step )
{
const S32 components = getComponents();
llassert( components >= 1 && components <= 4 );
const F32 ratio = F32(in_pixel_len) / out_pixel_len; // ratio of old to new
const F32 norm_factor = 1.f / ratio;
S32 goff = components >= 2 ? 1 : 0;
S32 boff = components >= 3 ? 2 : 0;
for( S32 x = 0; x < out_pixel_len; x++ )
{
// Sample input pixels in range from sample0 to sample1.
// Avoid floating point accumulation error... don't just add ratio each time. JC
const F32 sample0 = x * ratio;
const F32 sample1 = (x+1) * ratio;
const S32 index0 = llfloor(sample0); // left integer (floor)
const S32 index1 = llfloor(sample1); // right integer (floor)
const F32 fract0 = 1.f - (sample0 - F32(index0)); // spill over on left
const F32 fract1 = sample1 - F32(index1); // spill-over on right
if( index0 == index1 )
{
// Interval is embedded in one input pixel
S32 t0 = x * out_pixel_step * components;
S32 t1 = index0 * in_pixel_step * components;
U8* outp = out + t0;
U8* inp = in + t1;
for (S32 i = 0; i < components; ++i)
{
*outp = *inp;
++outp;
++inp;
}
}
else
{
// Left straddle
S32 t1 = index0 * in_pixel_step * components;
F32 r = in[t1 + 0] * fract0;
F32 g = in[t1 + goff] * fract0;
F32 b = in[t1 + boff] * fract0;
F32 a = 0;
if( components == 4)
{
a = in[t1 + 3] * fract0;
}
// Central interval
if (components < 4)
{
for( S32 u = index0 + 1; u < index1; u++ )
{
S32 t2 = u * in_pixel_step * components;
r += in[t2 + 0];
g += in[t2 + goff];
b += in[t2 + boff];
}
}
else
{
for( S32 u = index0 + 1; u < index1; u++ )
{
S32 t2 = u * in_pixel_step * components;
r += in[t2 + 0];
g += in[t2 + 1];
b += in[t2 + 2];
a += in[t2 + 3];
}
}
// right straddle
// Watch out for reading off of end of input array.
if( fract1 && index1 < in_pixel_len )
{
S32 t3 = index1 * in_pixel_step * components;
if (components < 4)
{
U8 in0 = in[t3 + 0];
U8 in1 = in[t3 + goff];
U8 in2 = in[t3 + boff];
r += in0 * fract1;
g += in1 * fract1;
b += in2 * fract1;
}
else
{
U8 in0 = in[t3 + 0];
U8 in1 = in[t3 + 1];
U8 in2 = in[t3 + 2];
U8 in3 = in[t3 + 3];
r += in0 * fract1;
g += in1 * fract1;
b += in2 * fract1;
a += in3 * fract1;
}
}
r *= norm_factor;
g *= norm_factor;
b *= norm_factor;
a *= norm_factor; // skip conditional
S32 t4 = x * out_pixel_step * components;
out[t4 + 0] = U8(llround(r));
if (components >= 2)
out[t4 + 1] = U8(llround(g));
if (components >= 3)
out[t4 + 2] = U8(llround(b));
if( components == 4)
out[t4 + 3] = U8(llround(a));
}
}
}
//static
void LLUI::glPointToScreen(S32 gl_x, S32 gl_y, S32 *screen_x, S32 *screen_y)
{
*screen_x = llround((F32)gl_x / getScaleFactor().mV[VX]);
*screen_y = llround((F32)gl_y / getScaleFactor().mV[VY]);
}
void LLFastTimerView::draw()
{
LLFastTimer t(LLFastTimer::FTM_RENDER_TIMER);
std::string tdesc;
F64 clock_freq = (F64)LLFastTimer::countsPerSecond();
F64 iclock_freq = 1000.0 / clock_freq;
S32 margin = 10;
S32 height = (S32) (gViewerWindow->getVirtualWindowRect().getHeight()*0.75f);
S32 width = (S32) (gViewerWindow->getVirtualWindowRect().getWidth() * 0.75f);
// HACK: casting away const. Should use setRect or some helper function instead.
const_cast<LLRect&>(getRect()).setLeftTopAndSize(getRect().mLeft, getRect().mTop, width, height);
S32 left, top, right, bottom;
S32 x, y, barw, barh, dx, dy;
S32 texth, textw;
LLPointer<LLUIImage> box_imagep = LLUI::getUIImage("rounded_square.tga");
// Make sure all timers are accounted for
// Set 'FTM_OTHER' to unaccounted ticks last frame
{
S32 display_timer[LLFastTimer::FTM_NUM_TYPES];
S32 hidx = LLFastTimer::sLastFrameIndex % LLFastTimer::FTM_HISTORY_NUM;
for (S32 i=0; i < LLFastTimer::FTM_NUM_TYPES; i++)
{
display_timer[i] = 0;
}
for (S32 i=0; i < FTV_DISPLAY_NUM; i++)
{
S32 tidx = ft_display_table[i].timer;
display_timer[tidx] = 1;
}
LLFastTimer::sCountHistory[hidx][LLFastTimer::FTM_OTHER] = 0;
LLFastTimer::sCallHistory[hidx][LLFastTimer::FTM_OTHER] = 0;
for (S32 tidx = 0; tidx < LLFastTimer::FTM_NUM_TYPES; tidx++)
{
U64 counts = LLFastTimer::sCountHistory[hidx][tidx];
if (counts > 0 && display_timer[tidx] == 0)
{
LLFastTimer::sCountHistory[hidx][LLFastTimer::FTM_OTHER] += counts;
LLFastTimer::sCallHistory[hidx][LLFastTimer::FTM_OTHER] += 1;
}
}
LLFastTimer::sCountAverage[LLFastTimer::FTM_OTHER] = 0;
LLFastTimer::sCallAverage[LLFastTimer::FTM_OTHER] = 0;
for (S32 h = 0; h < LLFastTimer::FTM_HISTORY_NUM; h++)
{
LLFastTimer::sCountAverage[LLFastTimer::FTM_OTHER] += LLFastTimer::sCountHistory[h][LLFastTimer::FTM_OTHER];
LLFastTimer::sCallAverage[LLFastTimer::FTM_OTHER] += LLFastTimer::sCallHistory[h][LLFastTimer::FTM_OTHER];
}
LLFastTimer::sCountAverage[LLFastTimer::FTM_OTHER] /= LLFastTimer::FTM_HISTORY_NUM;
LLFastTimer::sCallAverage[LLFastTimer::FTM_OTHER] /= LLFastTimer::FTM_HISTORY_NUM;
}
// Draw the window background
{
gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
gl_rect_2d(0, getRect().getHeight(), getRect().getWidth(), 0, LLColor4(0.f, 0.f, 0.f, 0.25f));
}
S32 xleft = margin;
S32 ytop = margin;
// Draw some help
{
x = xleft;
y = height - ytop;
texth = (S32)LLFontGL::sMonospace->getLineHeight();
char modedesc[][32] = {
"2 x Average ",
"Max ",
"Recent Max ",
"100 ms "
};
char centerdesc[][32] = {
"Left ",
"Centered ",
"Ordered "
};
tdesc = llformat("Full bar = %s [Click to pause/reset] [SHIFT-Click to toggle]",modedesc[mDisplayMode]);
LLFontGL::sMonospace->renderUTF8(tdesc, 0, x, y, LLColor4::white, LLFontGL::LEFT, LLFontGL::TOP);
textw = LLFontGL::sMonospace->getWidth(tdesc);
x = xleft, y -= (texth + 2);
tdesc = llformat("Justification = %s [CTRL-Click to toggle]",centerdesc[mDisplayCenter]);
LLFontGL::sMonospace->renderUTF8(tdesc, 0, x, y, LLColor4::white, LLFontGL::LEFT, LLFontGL::TOP);
y -= (texth + 2);
LLFontGL::sMonospace->renderUTF8(std::string("[Right-Click log selected] [ALT-Click toggle counts] [ALT-SHIFT-Click sub hidden]"),
0, x, y, LLColor4::white, LLFontGL::LEFT, LLFontGL::TOP);
y -= (texth + 2);
}
// Calc the total ticks
S32 histmax = llmin(LLFastTimer::sLastFrameIndex+1, MAX_VISIBLE_HISTORY);
U64 ticks_sum[LLFastTimer::FTM_HISTORY_NUM+1][FTV_DISPLAY_NUM];
for (S32 j=-1; j<LLFastTimer::FTM_HISTORY_NUM; j++)
{
S32 hidx;
if (j >= 0)
hidx = (LLFastTimer::sLastFrameIndex+j) % LLFastTimer::FTM_HISTORY_NUM;
else
hidx = -1;
// calculate tick info by adding child ticks to parents
for (S32 i=0; i < FTV_DISPLAY_NUM; i++)
{
if (mSubtractHidden && ft_display_table[i].disabled > 1)
{
continue;
}
// Get ticks
S32 tidx = ft_display_table[i].timer;
if (hidx >= 0)
ticks_sum[j+1][i] = LLFastTimer::sCountHistory[hidx][tidx];
else
ticks_sum[j+1][i] = LLFastTimer::sCountAverage[tidx];
S32 pidx = ft_display_table[i].parent;
// Add ticks to parents
while (pidx >= 0)
{
ticks_sum[j+1][pidx] += ticks_sum[j+1][i];
pidx = ft_display_table[pidx].parent;
}
}
}
// Draw the legend
S32 legendwidth = 0;
xleft = margin;
ytop = y;
y -= (texth + 2);
S32 cur_line = 0;
S32 display_line[FTV_DISPLAY_NUM];
for (S32 i=0; i<FTV_DISPLAY_NUM; i++)
{
S32 disabled = ft_display_table[i].disabled;
if (disabled == 3)
{
continue; // skip row
}
display_line[i] = cur_line;
ft_display_idx[cur_line] = i;
cur_line++;
S32 level = ft_display_table[i].level;
S32 parent = ft_display_table[i].parent;
x = xleft;
left = x; right = x + texth;
top = y; bottom = y - texth;
S32 scale_offset = 0;
if (i == mHoverIndex)
{
scale_offset = llfloor(sinf(mHighlightTimer.getElapsedTimeF32() * 6.f) * 2.f);
}
gl_rect_2d(left - scale_offset, top + scale_offset, right + scale_offset, bottom - scale_offset, *ft_display_table[i].color);
int tidx = ft_display_table[i].timer;
F32 ms = 0;
S32 calls = 0;
if (mHoverBarIndex > 0 && mHoverIndex >= 0)
{
S32 hidx = (LLFastTimer::sLastFrameIndex + (mHoverBarIndex - 1) - mScrollIndex) % LLFastTimer::FTM_HISTORY_NUM;
S32 bidx = LLFastTimer::FTM_HISTORY_NUM - mScrollIndex - mHoverBarIndex;
U64 ticks = ticks_sum[bidx+1][i]; // : LLFastTimer::sCountHistory[hidx][tidx];
ms = (F32)((F64)ticks * iclock_freq);
calls = (S32)LLFastTimer::sCallHistory[hidx][tidx];
}
else
{
U64 ticks = ticks_sum[0][i];
ms = (F32)((F64)ticks * iclock_freq);
calls = (S32)LLFastTimer::sCallAverage[tidx];
}
if (mDisplayCalls)
{
tdesc = llformat("%s (%d)",ft_display_table[i].desc,calls);
}
else
{
tdesc = llformat("%s [%.1f]",ft_display_table[i].desc,ms);
}
dx = (texth+4) + level*8;
LLColor4 color = disabled > 1 ? LLColor4::grey : LLColor4::white;
if (level > 0)
{
S32 line_start_y = (top + bottom) / 2;
S32 line_end_y = line_start_y + ((texth + 2) * (display_line[i] - display_line[parent])) - (texth / 2);
gl_line_2d(x + dx - 8, line_start_y, x + dx, line_start_y, color);
S32 line_x = x + (texth + 4) + ((level - 1) * 8);
gl_line_2d(line_x, line_start_y, line_x, line_end_y, color);
if (disabled == 1)
{
gl_line_2d(line_x+4, line_start_y-3, line_x+4, line_start_y+4, color);
}
}
x += dx;
BOOL is_child_of_hover_item = (i == mHoverIndex);
S32 next_parent = ft_display_table[i].parent;
while(!is_child_of_hover_item && next_parent >= 0)
{
is_child_of_hover_item = (mHoverIndex == next_parent);
next_parent = ft_display_table[next_parent].parent;
}
if (is_child_of_hover_item)
{
LLFontGL::sMonospace->renderUTF8(tdesc, 0, x, y, color, LLFontGL::LEFT, LLFontGL::TOP, LLFontGL::BOLD);
}
else
{
LLFontGL::sMonospace->renderUTF8(tdesc, 0, x, y, color, LLFontGL::LEFT, LLFontGL::TOP);
}
y -= (texth + 2);
textw = dx + LLFontGL::sMonospace->getWidth(std::string(ft_display_table[i].desc)) + 40;
if (textw > legendwidth)
legendwidth = textw;
}
for (S32 i=cur_line; i<FTV_DISPLAY_NUM; i++)
{
ft_display_idx[i] = -1;
}
xleft += legendwidth + 8;
// ytop = ytop;
// update rectangle that includes timer bars
mBarRect.mLeft = xleft;
mBarRect.mRight = getRect().mRight - xleft;
mBarRect.mTop = ytop - ((S32)LLFontGL::sMonospace->getLineHeight() + 4);
mBarRect.mBottom = margin + LINE_GRAPH_HEIGHT;
y = ytop;
barh = (ytop - margin - LINE_GRAPH_HEIGHT) / (MAX_VISIBLE_HISTORY + 2);
dy = barh>>2; // spacing between bars
if (dy < 1) dy = 1;
barh -= dy;
barw = width - xleft - margin;
// Draw the history bars
if (LLFastTimer::sLastFrameIndex >= 0)
{
U64 totalticks;
if (!LLFastTimer::sPauseHistory)
{
U64 ticks = 0;
int hidx = (LLFastTimer::sLastFrameIndex - mScrollIndex) % LLFastTimer::FTM_HISTORY_NUM;
for (S32 i=0; i<FTV_DISPLAY_NUM; i++)
{
if (mSubtractHidden && ft_display_table[i].disabled > 1)
{
continue;
}
int tidx = ft_display_table[i].timer;
ticks += LLFastTimer::sCountHistory[hidx][tidx];
}
if (LLFastTimer::sCurFrameIndex >= 10)
{
U64 framec = LLFastTimer::sCurFrameIndex;
U64 avg = (U64)mAvgCountTotal;
mAvgCountTotal = (avg*framec + ticks) / (framec + 1);
if (ticks > mMaxCountTotal)
{
mMaxCountTotal = ticks;
}
}
#if 1
if (ticks < mAvgCountTotal/100 || ticks > mAvgCountTotal*100)
LLFastTimer::sResetHistory = 1;
#endif
if (LLFastTimer::sCurFrameIndex < 10 || LLFastTimer::sResetHistory)
{
mAvgCountTotal = ticks;
mMaxCountTotal = ticks;
}
}
if (mDisplayMode == 0)
{
totalticks = mAvgCountTotal*2;
}
else if (mDisplayMode == 1)
{
totalticks = mMaxCountTotal;
}
else if (mDisplayMode == 2)
{
// Calculate the max total ticks for the current history
totalticks = 0;
for (S32 j=0; j<histmax; j++)
{
U64 ticks = 0;
for (S32 i=0; i<FTV_DISPLAY_NUM; i++)
{
if (mSubtractHidden && ft_display_table[i].disabled > 1)
{
continue;
}
int tidx = ft_display_table[i].timer;
ticks += LLFastTimer::sCountHistory[j][tidx];
}
if (ticks > totalticks)
totalticks = ticks;
}
}
else
{
totalticks = (U64)(clock_freq * .1); // 100 ms
}
// Draw MS ticks
{
U32 ms = (U32)((F64)totalticks * iclock_freq) ;
tdesc = llformat("%.1f ms |", (F32)ms*.25f);
x = xleft + barw/4 - LLFontGL::sMonospace->getWidth(tdesc);
LLFontGL::sMonospace->renderUTF8(tdesc, 0, x, y, LLColor4::white,
LLFontGL::LEFT, LLFontGL::TOP);
tdesc = llformat("%.1f ms |", (F32)ms*.50f);
x = xleft + barw/2 - LLFontGL::sMonospace->getWidth(tdesc);
LLFontGL::sMonospace->renderUTF8(tdesc, 0, x, y, LLColor4::white,
LLFontGL::LEFT, LLFontGL::TOP);
tdesc = llformat("%.1f ms |", (F32)ms*.75f);
x = xleft + (barw*3)/4 - LLFontGL::sMonospace->getWidth(tdesc);
LLFontGL::sMonospace->renderUTF8(tdesc, 0, x, y, LLColor4::white,
LLFontGL::LEFT, LLFontGL::TOP);
tdesc = llformat( "%d ms |", ms);
x = xleft + barw - LLFontGL::sMonospace->getWidth(tdesc);
LLFontGL::sMonospace->renderUTF8(tdesc, 0, x, y, LLColor4::white,
LLFontGL::LEFT, LLFontGL::TOP);
}
LLRect graph_rect;
// Draw borders
{
gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
gGL.color4f(0.5f,0.5f,0.5f,0.5f);
S32 by = y + 2;
y -= ((S32)LLFontGL::sMonospace->getLineHeight() + 4);
//heading
gl_rect_2d(xleft-5, by, getRect().getWidth()-5, y+5, FALSE);
//tree view
gl_rect_2d(5, by, xleft-10, 5, FALSE);
by = y + 5;
//average bar
gl_rect_2d(xleft-5, by, getRect().getWidth()-5, by-barh-dy-5, FALSE);
by -= barh*2+dy;
//current frame bar
gl_rect_2d(xleft-5, by, getRect().getWidth()-5, by-barh-dy-2, FALSE);
by -= barh+dy+1;
//history bars
gl_rect_2d(xleft-5, by, getRect().getWidth()-5, LINE_GRAPH_HEIGHT-barh-dy-2, FALSE);
by = LINE_GRAPH_HEIGHT-barh-dy-7;
//line graph
graph_rect = LLRect(xleft-5, by, getRect().getWidth()-5, 5);
gl_rect_2d(graph_rect, FALSE);
}
// Draw bars for each history entry
// Special: -1 = show running average
gGL.getTexUnit(0)->bind(box_imagep->getImage());
for (S32 j=-1; j<histmax && y > LINE_GRAPH_HEIGHT; j++)
{
int sublevel_dx[FTV_DISPLAY_NUM+1];
int sublevel_left[FTV_DISPLAY_NUM+1];
int sublevel_right[FTV_DISPLAY_NUM+1];
S32 tidx;
if (j >= 0)
{
tidx = LLFastTimer::FTM_HISTORY_NUM - j - 1 - mScrollIndex;
}
else
{
tidx = -1;
}
x = xleft;
// draw the bars for each stat
int xpos[FTV_DISPLAY_NUM+1];
int deltax[FTV_DISPLAY_NUM+1];
xpos[0] = xleft;
for (S32 i = 0; i < FTV_DISPLAY_NUM; i++)
{
if (ft_display_table[i].disabled > 1)
{
continue;
}
F32 frac = (F32)ticks_sum[tidx+1][i] / (F32)totalticks;
dx = llround(frac * (F32)barw);
deltax[i] = dx;
int level = ft_display_table[i].level;
int parent = ft_display_table[i].parent;
llassert(level < FTV_DISPLAY_NUM);
llassert(parent < FTV_DISPLAY_NUM);
left = xpos[level];
S32 prev_idx = i - 1;
while (prev_idx > 0)
{
if (ft_display_table[prev_idx].disabled <= 1)
{
break;
}
prev_idx--;
}
S32 next_idx = i + 1;
while (next_idx < FTV_DISPLAY_NUM)
{
if (ft_display_table[next_idx].disabled <= 1)
{
break;
}
next_idx++;
}
if (level == 0)
{
sublevel_left[level] = xleft;
sublevel_dx[level] = dx;
sublevel_right[level] = sublevel_left[level] + sublevel_dx[level];
}
else if (i==0 || ft_display_table[prev_idx].level < level)
{
// If we are the first entry at a new sublevel block, calc the
// total width of this sublevel and modify left to align block.
U64 sublevelticks = ticks_sum[tidx+1][i];
for (S32 k=i+1; k<FTV_DISPLAY_NUM; k++)
{
if (ft_display_table[k].level < level)
break;
if (ft_display_table[k].disabled <= 1 && ft_display_table[k].level == level)
sublevelticks += ticks_sum[tidx+1][k];
}
F32 subfrac = (F32)sublevelticks / (F32)totalticks;
sublevel_dx[level] = (int)(subfrac * (F32)barw + .5f);
if (mDisplayCenter == 1) // center aligned
{
left += (deltax[parent] - sublevel_dx[level])/2;
}
else if (mDisplayCenter == 2) // right aligned
{
left += (deltax[parent] - sublevel_dx[level]);
}
sublevel_left[level] = left;
sublevel_right[level] = sublevel_left[level] + sublevel_dx[level];
}
right = left + dx;
xpos[level] = right;
xpos[level+1] = left;
mBarStart[(j + 1) * FTV_DISPLAY_NUM + i] = left;
mBarEnd[(j + 1) * FTV_DISPLAY_NUM + i] = right;
top = y;
bottom = y - barh;
if (right > left)
{
//U32 rounded_edges = 0;
LLColor4 color = *ft_display_table[i].color;
S32 scale_offset = 0;
BOOL is_child_of_hover_item = (i == mHoverIndex);
S32 next_parent = ft_display_table[i].parent;
while(!is_child_of_hover_item && next_parent >= 0)
{
is_child_of_hover_item = (mHoverIndex == next_parent);
next_parent = ft_display_table[next_parent].parent;
}
if (i == mHoverIndex)
{
scale_offset = llfloor(sinf(mHighlightTimer.getElapsedTimeF32() * 6.f) * 3.f);
//color = lerp(color, LLColor4::black, -0.4f);
}
else if (mHoverIndex >= 0 && !is_child_of_hover_item)
{
color = lerp(color, LLColor4::grey, 0.8f);
}
gGL.color4fv(color.mV);
F32 start_fragment = llclamp((F32)(left - sublevel_left[level]) / (F32)sublevel_dx[level], 0.f, 1.f);
F32 end_fragment = llclamp((F32)(right - sublevel_left[level]) / (F32)sublevel_dx[level], 0.f, 1.f);
gl_segmented_rect_2d_fragment_tex(sublevel_left[level], top - level + scale_offset, sublevel_right[level], bottom + level - scale_offset, box_imagep->getTextureWidth(), box_imagep->getTextureHeight(), 16, start_fragment, end_fragment);
}
}
y -= (barh + dy);
if (j < 0)
y -= barh;
}
//draw line graph history
{
gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
LLLocalClipRect clip(graph_rect);
//normalize based on last frame's maximum
static U64 last_max = 0;
static F32 alpha_interp = 0.f;
U64 max_ticks = llmax(last_max, (U64) 1);
F32 ms = (F32)((F64)max_ticks * iclock_freq);
//display y-axis range
std::string tdesc;
if (mDisplayCalls)
tdesc = llformat("%d calls", (int)max_ticks);
else if (mDisplayHz)
tdesc = llformat("%d Hz", (int)max_ticks);
else
tdesc = llformat("%4.2f ms", ms);
x = graph_rect.mRight - LLFontGL::sMonospace->getWidth(tdesc)-5;
y = graph_rect.mTop - ((S32)LLFontGL::sMonospace->getLineHeight());
LLFontGL::sMonospace->renderUTF8(tdesc, 0, x, y, LLColor4::white,
LLFontGL::LEFT, LLFontGL::TOP);
//highlight visible range
{
S32 first_frame = LLFastTimer::FTM_HISTORY_NUM - mScrollIndex;
S32 last_frame = first_frame - MAX_VISIBLE_HISTORY;
F32 frame_delta = ((F32) (graph_rect.getWidth()))/(LLFastTimer::FTM_HISTORY_NUM-1);
F32 right = (F32) graph_rect.mLeft + frame_delta*first_frame;
F32 left = (F32) graph_rect.mLeft + frame_delta*last_frame;
gGL.color4f(0.5f,0.5f,0.5f,0.3f);
gl_rect_2d((S32) left, graph_rect.mTop, (S32) right, graph_rect.mBottom);
if (mHoverBarIndex >= 0)
{
S32 bar_frame = first_frame - mHoverBarIndex;
F32 bar = (F32) graph_rect.mLeft + frame_delta*bar_frame;
gGL.color4f(0.5f,0.5f,0.5f,1);
gGL.begin(LLRender::LINES);
gGL.vertex2i((S32)bar, graph_rect.mBottom);
gGL.vertex2i((S32)bar, graph_rect.mTop);
gGL.end();
}
}
U64 cur_max = 0;
for (S32 idx = 0; idx < FTV_DISPLAY_NUM; ++idx)
{
if (ft_display_table[idx].disabled > 1)
{ //skip disabled timers
continue;
}
//fatten highlighted timer
if (mHoverIndex == idx)
{
gGL.flush();
glLineWidth(3);
}
const F32 * col = ft_display_table[idx].color->mV;
F32 alpha = 1.f;
if (mHoverIndex >= 0 &&
idx != mHoverIndex)
{ //fade out non-hihglighted timers
if (ft_display_table[idx].parent != mHoverIndex)
{
alpha = alpha_interp;
}
}
gGL.color4f(col[0], col[1], col[2], alpha);
gGL.begin(LLRender::LINE_STRIP);
for (U32 j = 0; j < LLFastTimer::FTM_HISTORY_NUM; j++)
{
U64 ticks = ticks_sum[j+1][idx];
if (mDisplayHz)
{
F64 tc = (F64) (ticks+1) * iclock_freq;
tc = 1000.f/tc;
ticks = llmin((U64) tc, (U64) 1024);
}
else if (mDisplayCalls)
{
S32 tidx = ft_display_table[idx].timer;
S32 hidx = (LLFastTimer::sLastFrameIndex + j) % LLFastTimer::FTM_HISTORY_NUM;
ticks = (S32)LLFastTimer::sCallHistory[hidx][tidx];
}
if (alpha == 1.f)
{ //normalize to highlighted timer
cur_max = llmax(cur_max, ticks);
}
F32 x = graph_rect.mLeft + ((F32) (graph_rect.getWidth()))/(LLFastTimer::FTM_HISTORY_NUM-1)*j;
F32 y = graph_rect.mBottom + (F32) graph_rect.getHeight()/max_ticks*ticks;
gGL.vertex2f(x,y);
}
gGL.end();
if (mHoverIndex == idx)
{
gGL.flush();
glLineWidth(1);
}
}
//interpolate towards new maximum
F32 dt = gFrameIntervalSeconds*3.f;
last_max = (U64) ((F32) last_max + ((F32) cur_max- (F32) last_max) * dt);
F32 alpha_target = last_max > cur_max ?
llmin((F32) last_max/ (F32) cur_max - 1.f,1.f) :
llmin((F32) cur_max/ (F32) last_max - 1.f,1.f);
alpha_interp = alpha_interp + (alpha_target-alpha_interp) * dt;
if (mHoverIndex >= 0)
{
x = (graph_rect.mRight + graph_rect.mLeft)/2;
y = graph_rect.mBottom + 8;
LLFontGL::sMonospace->renderUTF8(std::string(ft_display_table[mHoverIndex].desc), 0, x, y, LLColor4::white,
LLFontGL::LEFT, LLFontGL::BOTTOM);
}
}
}
// Output stats for clicked bar to log
if (mPrintStats >= 0)
{
std::string legend_stat;
S32 stat_num;
S32 first = 1;
for (stat_num = 0; stat_num < FTV_DISPLAY_NUM; stat_num++)
{
if (ft_display_table[stat_num].disabled > 1)
continue;
if (!first)
legend_stat += ", ";
first=0;
legend_stat += ft_display_table[stat_num].desc;
}
llinfos << legend_stat << llendl;
std::string timer_stat;
first = 1;
for (stat_num = 0; stat_num < FTV_DISPLAY_NUM; stat_num++)
{
S32 disabled = ft_display_table[stat_num].disabled;
if (disabled > 1)
continue;
if (!first)
timer_stat += ", ";
first=0;
U64 ticks;
S32 tidx = ft_display_table[stat_num].timer;
if (mPrintStats > 0)
{
S32 hidx = (LLFastTimer::sLastFrameIndex+(mPrintStats-1)-mScrollIndex) % LLFastTimer::FTM_HISTORY_NUM;
ticks = disabled >= 1 ? ticks_sum[mPrintStats][stat_num] : LLFastTimer::sCountHistory[hidx][tidx];
}
else
{
ticks = disabled >= 1 ? ticks_sum[0][stat_num] : LLFastTimer::sCountAverage[tidx];
}
F32 ms = (F32)((F64)ticks * iclock_freq);
timer_stat += llformat("%.1f",ms);
}
llinfos << timer_stat << llendl;
mPrintStats = -1;
}
mHoverIndex = -1;
mHoverBarIndex = -1;
LLView::draw();
}
// virtual
void LLButton::draw()
{
BOOL flash = FALSE;
if( mFlashing )
{
F32 elapsed = mFlashingTimer.getElapsedTimeF32();
S32 flash_count = S32(elapsed * LLUI::sConfigGroup->getF32("ButtonFlashRate") * 2.f);
// flash on or off?
flash = (flash_count % 2 == 0) || flash_count > S32((F32)LLUI::sConfigGroup->getS32("ButtonFlashCount") * 2.f);
}
BOOL pressed_by_keyboard = FALSE;
if (hasFocus())
{
pressed_by_keyboard = gKeyboard->getKeyDown(' ') || (mCommitOnReturn && gKeyboard->getKeyDown(KEY_RETURN));
}
// Unselected image assignments
S32 local_mouse_x;
S32 local_mouse_y;
LLUI::getMousePositionLocal(this, &local_mouse_x, &local_mouse_y);
BOOL pressed = pressed_by_keyboard
|| (hasMouseCapture() && pointInView(local_mouse_x, local_mouse_y))
|| mToggleState;
BOOL use_glow_effect = FALSE;
LLColor4 glow_color = LLColor4::white;
LLRender::eBlendType glow_type = LLRender::BT_ADD_WITH_ALPHA;
if ( mNeedsHighlight )
{
if (pressed)
{
if (mImageHoverSelected)
{
mImagep = mImageHoverSelected;
}
else
{
mImagep = mImageSelected;
use_glow_effect = TRUE;
}
}
else
{
if (mImageHoverUnselected)
{
mImagep = mImageHoverUnselected;
}
else
{
mImagep = mImageUnselected;
use_glow_effect = TRUE;
}
}
}
else if ( pressed )
{
mImagep = mImageSelected;
}
else
{
mImagep = mImageUnselected;
}
if (mFlashing)
{
use_glow_effect = TRUE;
glow_type = LLRender::BT_ALPHA; // blend the glow
if (mNeedsHighlight) // highlighted AND flashing
glow_color = (glow_color*0.5f + mFlashBgColor*0.5f) % 2.0f; // average between flash and highlight colour, with sum of the opacity
else
glow_color = mFlashBgColor;
}
// Override if more data is available
// HACK: Use gray checked state to mean either:
// enabled and tentative
// or
// disabled but checked
if (!mImageDisabledSelected.isNull()
&&
( (getEnabled() && getTentative())
|| (!getEnabled() && pressed ) ) )
{
mImagep = mImageDisabledSelected;
}
else if (!mImageDisabled.isNull()
&& !getEnabled()
&& !pressed)
{
mImagep = mImageDisabled;
}
if (mNeedsHighlight && !mImagep)
{
use_glow_effect = TRUE;
}
// Figure out appropriate color for the text
LLColor4 label_color;
// label changes when button state changes, not when pressed
if ( getEnabled() )
{
if ( mToggleState )
{
label_color = mSelectedLabelColor;
}
else
{
label_color = mUnselectedLabelColor;
}
}
else
{
if ( mToggleState )
{
label_color = mDisabledSelectedLabelColor;
}
else
{
label_color = mDisabledLabelColor;
}
}
// Unselected label assignments
LLWString label;
if( mToggleState )
{
if( getEnabled() || mDisabledSelectedLabel.empty() )
{
label = mSelectedLabel;
}
else
{
label = mDisabledSelectedLabel;
}
}
else
{
if( getEnabled() || mDisabledLabel.empty() )
{
label = mUnselectedLabel;
}
else
{
label = mDisabledLabel;
}
}
// overlay with keyboard focus border
if (hasFocus())
{
F32 lerp_amt = gFocusMgr.getFocusFlashAmt();
drawBorder(gFocusMgr.getFocusColor(), llround(lerp(1.f, 3.f, lerp_amt)));
}
if (use_glow_effect)
{
mCurGlowStrength = lerp(mCurGlowStrength,
mFlashing ? (flash? 1.0 : 0.0)
: mHoverGlowStrength,
LLCriticalDamp::getInterpolant(0.05f));
}
else
{
mCurGlowStrength = lerp(mCurGlowStrength, 0.f, LLCriticalDamp::getInterpolant(0.05f));
}
// Draw button image, if available.
// Otherwise draw basic rectangular button.
if (mImagep.notNull())
{
if ( mScaleImage)
{
mImagep->draw(getLocalRect(), getEnabled() ? mImageColor : mDisabledImageColor );
if (mCurGlowStrength > 0.01f)
{
gGL.setSceneBlendType(glow_type);
mImagep->drawSolid(0, 0, getRect().getWidth(), getRect().getHeight(), glow_color % mCurGlowStrength);
gGL.setSceneBlendType(LLRender::BT_ALPHA);
}
}
else
{
mImagep->draw(0, 0, getEnabled() ? mImageColor : mDisabledImageColor );
if (mCurGlowStrength > 0.01f)
{
gGL.setSceneBlendType(glow_type);
mImagep->drawSolid(0, 0, glow_color % mCurGlowStrength);
gGL.setSceneBlendType(LLRender::BT_ALPHA);
}
}
}
else
{
// no image
llwarns << "No image for button " << getName() << llendl;
// draw it in pink so we can find it
gl_rect_2d(0, getRect().getHeight(), getRect().getWidth(), 0, LLColor4::pink1, FALSE);
}
// let overlay image and text play well together
S32 text_left = mLeftHPad;
S32 text_right = getRect().getWidth() - mRightHPad;
S32 text_width = getRect().getWidth() - mLeftHPad - mRightHPad;
S32 text_middle = text_left + text_width/2;
// draw overlay image
if (mImageOverlay.notNull() && mImageOverlay->getWidth() > 1)
{
// get max width and height (discard level 0)
S32 overlay_width = mImageOverlay->getWidth();
S32 overlay_height = mImageOverlay->getHeight();
F32 scale_factor = llmin((F32)getRect().getWidth() / (F32)overlay_width, (F32)getRect().getHeight() / (F32)overlay_height, 1.f);
overlay_width = llround((F32)overlay_width * scale_factor);
overlay_height = llround((F32)overlay_height * scale_factor);
S32 center_x = getLocalRect().getCenterX();
S32 center_y = getLocalRect().getCenterY();
//FUGLY HACK FOR "DEPRESSED" BUTTONS
if (pressed)
{
center_y--;
center_x++;
}
// fade out overlay images on disabled buttons
LLColor4 overlay_color = mImageOverlayColor;
if (!getEnabled())
{
overlay_color.mV[VALPHA] = 0.5f;
}
switch(mImageOverlayAlignment)
{
case LLFontGL::LEFT:
text_left += overlay_width + 1;
text_width -= overlay_width + 1;
text_middle += (overlay_width+1)/4;
mImageOverlay->draw(
mLeftHPad,
center_y - (overlay_height / 2),
overlay_width,
overlay_height,
overlay_color);
break;
case LLFontGL::HCENTER:
mImageOverlay->draw(
center_x - (overlay_width / 2),
center_y - (overlay_height / 2),
overlay_width,
overlay_height,
overlay_color);
break;
case LLFontGL::RIGHT:
text_right -= overlay_width + 1;
text_width -= overlay_width + 1;
text_middle += (overlay_width+1)/4;
mImageOverlay->draw(
getRect().getWidth() - mRightHPad - overlay_width,
center_y - (overlay_height / 2),
overlay_width,
overlay_height,
overlay_color);
break;
default:
// draw nothing
break;
}
}
// Draw label
if( !label.empty() )
{
LLWStringUtil::trim(label);
S32 x;
switch( mHAlign )
{
case LLFontGL::RIGHT:
x = text_right;
break;
case LLFontGL::HCENTER:
{
S32 actual_width = mGLFont->getWidth(label.c_str());
x = llmax(text_middle, text_left + actual_width/2);
}
break;
case LLFontGL::LEFT:
default:
x = text_left;
break;
}
S32 y_offset = 2 + (getRect().getHeight() - 20)/2;
if (pressed)
{
y_offset--;
x++;
}
mGLFont->render(label, 0,
(F32)x,
(F32)(LLBUTTON_V_PAD + y_offset),
label_color,
mHAlign, LLFontGL::BOTTOM,
LLFontGL::NORMAL,
mDropShadowedText ? LLFontGL::DROP_SHADOW_SOFT : LLFontGL::NO_SHADOW,
U32_MAX, text_width,
NULL, FALSE, FALSE);
}
if (sDebugRects
|| (LLView::sEditingUI && this == LLView::sEditingUIView))
{
drawDebugRect();
}
// reset hover status for next frame
mNeedsHighlight = FALSE;
}
BOOL LLThrottleGroup::dynamicAdjust()
{
const F32 DYNAMIC_ADJUST_TIME = 1.0f; // seconds
const F32 CURRENT_PERIOD_WEIGHT = .25f; // how much weight to give to last period while determining BPS utilization
const F32 BUSY_PERCENT = 0.75f; // if use more than this fraction of BPS, you are busy
const F32 IDLE_PERCENT = 0.70f; // if use less than this fraction, you are "idle"
const F32 TRANSFER_PERCENT = 0.90f; // how much unused bandwidth to take away each adjustment
const F32 RECOVER_PERCENT = 0.25f; // how much to give back during recovery phase
S32 i;
F64 mt_sec = LLMessageSystem::getMessageTimeSeconds();
// Only dynamically adjust every few seconds
if ((mt_sec - mDynamicAdjustTime) < DYNAMIC_ADJUST_TIME)
{
return FALSE;
}
mDynamicAdjustTime = mt_sec;
S32 total = 0;
// Update historical information
for (i = 0; i < TC_EOF; i++)
{
if (mBitsSentHistory[i] == 0)
{
// first run, just copy current period
mBitsSentHistory[i] = mBitsSentThisPeriod[i];
}
else
{
// have some history, so weight accordingly
mBitsSentHistory[i] = (1.f - CURRENT_PERIOD_WEIGHT) * mBitsSentHistory[i]
+ CURRENT_PERIOD_WEIGHT * mBitsSentThisPeriod[i];
}
mBitsSentThisPeriod[i] = 0;
total += llround(mBitsSentHistory[i]);
}
// Look for busy channels
// TODO: Fold into loop above.
BOOL channels_busy = FALSE;
F32 busy_nominal_sum = 0;
BOOL channel_busy[TC_EOF];
BOOL channel_idle[TC_EOF];
BOOL channel_over_nominal[TC_EOF];
for (i = 0; i < TC_EOF; i++)
{
// Is this a busy channel?
if (mBitsSentHistory[i] >= BUSY_PERCENT * DYNAMIC_ADJUST_TIME * mCurrentBPS[i])
{
// this channel is busy
channels_busy = TRUE;
busy_nominal_sum += mNominalBPS[i]; // use for allocation of pooled idle bandwidth
channel_busy[i] = TRUE;
}
else
{
channel_busy[i] = FALSE;
}
// Is this an idle channel?
if ((mBitsSentHistory[i] < IDLE_PERCENT * DYNAMIC_ADJUST_TIME * mCurrentBPS[i]) &&
(mBitsAvailable[i] > 0))
{
channel_idle[i] = TRUE;
}
else
{
channel_idle[i] = FALSE;
}
// Is this an overpumped channel?
if (mCurrentBPS[i] > mNominalBPS[i])
{
channel_over_nominal[i] = TRUE;
}
else
{
channel_over_nominal[i] = FALSE;
}
//if (total)
//{
// llinfos << i << ": B" << channel_busy[i] << " I" << channel_idle[i] << " N" << channel_over_nominal[i];
// llcont << " Nom: " << mNominalBPS[i] << " Cur: " << mCurrentBPS[i] << " BS: " << mBitsSentHistory[i] << llendl;
//}
}
if (channels_busy)
{
// Some channels are busy. Let's see if we can get them some bandwidth.
F32 used_bps;
F32 avail_bps;
F32 transfer_bps;
F32 pool_bps = 0;
for (i = 0; i < TC_EOF; i++)
{
if (channel_idle[i] || channel_over_nominal[i] )
{
// Either channel i is idle, or has been overpumped.
// Therefore it's a candidate to give up some bandwidth.
// Figure out how much bandwidth it has been using, and how
// much is available to steal.
used_bps = mBitsSentHistory[i] / DYNAMIC_ADJUST_TIME;
// CRO make sure to keep a minimum amount of throttle available
// CRO NB: channels set to < MINIMUM_BPS will never give up bps,
// which is correct I think
if (used_bps < gThrottleMinimumBPS[i])
{
used_bps = gThrottleMinimumBPS[i];
}
if (channel_over_nominal[i])
{
F32 unused_current = mCurrentBPS[i] - used_bps;
avail_bps = llmax(mCurrentBPS[i] - mNominalBPS[i], unused_current);
}
else
{
avail_bps = mCurrentBPS[i] - used_bps;
}
//llinfos << i << " avail " << avail_bps << llendl;
// Historically, a channel could have used more than its current share,
// even if it's idle right now.
// Make sure we don't steal too much.
if (avail_bps < 0)
{
continue;
}
// Transfer some bandwidth from this channel into the global pool.
transfer_bps = avail_bps * TRANSFER_PERCENT;
mCurrentBPS[i] -= transfer_bps;
pool_bps += transfer_bps;
}
}
//llinfos << "Pool BPS: " << pool_bps << llendl;
// Now redistribute the bandwidth to busy channels.
F32 unused_bps = 0.f;
for (i = 0; i < TC_EOF; i++)
{
if (channel_busy[i])
{
F32 add_amount = pool_bps * (mNominalBPS[i] / busy_nominal_sum);
//llinfos << "Busy " << i << " gets " << pool_bps << llendl;
mCurrentBPS[i] += add_amount;
// CRO: make sure this doesn't get too huge
// JC - Actually, need to let mCurrentBPS go less than nominal, otherwise
// you aren't allowing bandwidth to actually be moved from one channel
// to another.
// *TODO: If clamping high end, would be good to re-
// allocate to other channels in the above code.
const F32 MAX_BPS = 4 * mNominalBPS[i];
if (mCurrentBPS[i] > MAX_BPS)
{
F32 overage = mCurrentBPS[i] - MAX_BPS;
mCurrentBPS[i] -= overage;
unused_bps += overage;
}
// Paranoia
if (mCurrentBPS[i] < gThrottleMinimumBPS[i])
{
mCurrentBPS[i] = gThrottleMinimumBPS[i];
}
}
}
// For fun, add the overage back in to objects
if (unused_bps > 0.f)
{
mCurrentBPS[TC_TASK] += unused_bps;
}
}
else
{
// No one is busy.
// Make the channel allocations seek toward nominal.
// Look for overpumped channels
F32 starved_nominal_sum = 0;
F32 avail_bps = 0;
F32 transfer_bps = 0;
F32 pool_bps = 0;
for (i = 0; i < TC_EOF; i++)
{
if (mCurrentBPS[i] > mNominalBPS[i])
{
avail_bps = (mCurrentBPS[i] - mNominalBPS[i]);
transfer_bps = avail_bps * RECOVER_PERCENT;
mCurrentBPS[i] -= transfer_bps;
pool_bps += transfer_bps;
}
}
// Evenly distribute bandwidth to channels currently
// using less than nominal.
for (i = 0; i < TC_EOF; i++)
{
if (mCurrentBPS[i] < mNominalBPS[i])
{
// We're going to weight allocations by nominal BPS.
starved_nominal_sum += mNominalBPS[i];
}
}
for (i = 0; i < TC_EOF; i++)
{
if (mCurrentBPS[i] < mNominalBPS[i])
{
// Distribute bandwidth according to nominal allocation ratios.
mCurrentBPS[i] += pool_bps * (mNominalBPS[i] / starved_nominal_sum);
}
}
}
return TRUE;
}
void LLNetMap::renderPoint(const LLVector3 &pos_local, const LLColor4U &color,
S32 diameter, S32 relative_height)
{
if (diameter <= 0)
{
return;
}
const S32 image_width = (S32)mObjectImagep->getWidth();
const S32 image_height = (S32)mObjectImagep->getHeight();
S32 x_offset = llround(pos_local.mV[VX] * mObjectMapTPM + image_width / 2);
S32 y_offset = llround(pos_local.mV[VY] * mObjectMapTPM + image_height / 2);
if ((x_offset < 0) || (x_offset >= image_width))
{
return;
}
if ((y_offset < 0) || (y_offset >= image_height))
{
return;
}
U8 *datap = mObjectRawImagep->getData();
S32 neg_radius = diameter / 2;
S32 pos_radius = diameter - neg_radius;
S32 x, y;
if (relative_height > 0)
{
// ...point above agent
S32 px, py;
// vertical line
px = x_offset;
for (y = -neg_radius; y < pos_radius; y++)
{
py = y_offset + y;
if ((py < 0) || (py >= image_height))
{
continue;
}
S32 offset = px + py * image_width;
((U32*)datap)[offset] = color.mAll;
}
// top line
py = y_offset + pos_radius - 1;
for (x = -neg_radius; x < pos_radius; x++)
{
px = x_offset + x;
if ((px < 0) || (px >= image_width))
{
continue;
}
S32 offset = px + py * image_width;
((U32*)datap)[offset] = color.mAll;
}
}
else
{
// ...point level with agent
for (x = -neg_radius; x < pos_radius; x++)
{
S32 p_x = x_offset + x;
if ((p_x < 0) || (p_x >= image_width))
{
continue;
}
for (y = -neg_radius; y < pos_radius; y++)
{
S32 p_y = y_offset + y;
if ((p_y < 0) || (p_y >= image_height))
{
continue;
}
S32 offset = p_x + p_y * image_width;
((U32*)datap)[offset] = color.mAll;
}
}
}
}
unsigned long long
timespec_to_usec_ull(struct timespec *ts)
{
return llround((ts->tv_sec * 1E9 + ts->tv_nsec) / 1000.0);
}
