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); }