void GLBlitHelper::BlitFramebufferToTexture(GLuint srcFB, GLuint destTex, const gfxIntSize& srcSize, const gfxIntSize& destSize, GLenum destTarget) { MOZ_ASSERT(!srcFB || mGL->fIsFramebuffer(srcFB)); MOZ_ASSERT(mGL->fIsTexture(destTex)); if (mGL->IsSupported(GLFeature::framebuffer_blit)) { ScopedFramebufferForTexture destWrapper(mGL, destTex, destTarget); BlitFramebufferToFramebuffer(srcFB, destWrapper.FB(), srcSize, destSize); return; } ScopedBindTexture autoTex(mGL, destTex, destTarget); ScopedBindFramebuffer boundFB(mGL, srcFB); ScopedGLState scissor(mGL, LOCAL_GL_SCISSOR_TEST, false); mGL->fCopyTexSubImage2D(destTarget, 0, 0, 0, 0, 0, srcSize.width, srcSize.height); }
void GLScreenBuffer::AssureBlitted() { if (!mNeedsBlit) return; if (mDraw) { GLuint drawFB = DrawFB(); GLuint readFB = ReadFB(); MOZ_ASSERT(drawFB != 0); MOZ_ASSERT(drawFB != readFB); MOZ_ASSERT(mGL->IsSupported(GLFeature::framebuffer_blit)); MOZ_ASSERT(mDraw->Size() == mRead->Size()); ScopedBindFramebuffer boundFB(mGL); ScopedGLState scissor(mGL, LOCAL_GL_SCISSOR_TEST, false); BindReadFB_Internal(drawFB); BindDrawFB_Internal(readFB); const gfx::IntSize& srcSize = mDraw->Size(); const gfx::IntSize& destSize = mRead->Size(); mGL->raw_fBlitFramebuffer(0, 0, srcSize.width, srcSize.height, 0, 0, destSize.width, destSize.height, LOCAL_GL_COLOR_BUFFER_BIT, LOCAL_GL_NEAREST); // Done! } mNeedsBlit = false; }
void TerrainPreviewWindow::OnPaint(Canvas &canvas) { const GlueMapWindow *map = UIGlobals::GetMap(); if (map == nullptr) return; MapWindowProjection projection = map->VisibleProjection(); if (!projection.IsValid()) { /* TODO: initialise projection to middle of map instead of bailing out */ canvas.ClearWhite(); return; } projection.SetScreenSize(canvas.GetSize()); projection.SetScreenOrigin(canvas.GetWidth() / 2, canvas.GetHeight() / 2); Angle sun_azimuth(Angle::Degrees(-45)); if (renderer.GetSettings().slope_shading == SlopeShading::SUN && CommonInterface::Calculated().sun_data_available) sun_azimuth = CommonInterface::Calculated().sun_azimuth; renderer.Generate(projection, sun_azimuth); #ifdef ENABLE_OPENGL /* enable clipping because the OpenGL terrain renderer uses a large texture that exceeds the window dimensions */ GLCanvasScissor scissor(canvas); #endif renderer.Draw(canvas, projection); }
void Pipeline::OnRender(const App& app, const AppUpdateInfo&) { BeginRender(); GfxTestureEx_SwapChain& swapChainTexture = m_swapChain.GetTexture(); GfxGraphicsContext& context = m_contextManager.GetGraphicsContext(0); context.SetPipelineState(m_graphicsState); context.SetGraphicsRootSignature(m_rootSignature); context.SetRenderTarget(swapChainTexture); GfxViewport viewport(0.0f, 0.0f, (float)swapChainTexture.GetWidth(), (float)swapChainTexture.GetHeight()); GfxScissor scissor(0, 0, swapChainTexture.GetWidth(), swapChainTexture.GetHeight()); context.SetViewports(1, &viewport); context.SetScissors(1, &scissor); swapChainTexture.SetClearColor(GfxColorRGBA(0.0f, 0.2f, 0.4f, 1.0f)); context.ClearRenderTarget(swapChainTexture); context.SetPrimitiveTopology(GfxPrimitiveTopology::TriangleList); GfxVertexBufferView vbView(m_vertexBuffer, m_vertexBuffer.GetSize(), sizeof(PosColorVertex)); context.SetVertexBuffer( 0, vbView); context.DrawInstanced(3, 1, 0, 0); EndRender(); }
//----------------------------------------------------------------------------- // Constructor //----------------------------------------------------------------------------- C_BaseHLPlayer::C_BaseHLPlayer() { AddVar( &m_Local.m_vecPunchAngle, &m_Local.m_iv_vecPunchAngle, LATCH_SIMULATION_VAR ); AddVar( &m_Local.m_vecPunchAngleVel, &m_Local.m_iv_vecPunchAngleVel, LATCH_SIMULATION_VAR ); m_flZoomStart = 0.0f; m_flZoomEnd = 0.0f; m_flZoomRate = 0.0f; m_flZoomStartTime = 0.0f; m_flSpeedMod = cl_forwardspeed.GetFloat(); ConVarRef scissor("r_flashlightscissor"); scissor.SetValue("0"); }
void RenderState::debugOverdraw(bool enable, bool clear) { if (Properties::debugOverdraw && mFramebuffer == 0) { if (clear) { scissor().setEnabled(false); stencil().clear(); } if (enable) { stencil().enableDebugWrite(); } else { stencil().disable(); } } }
void RenderState::resumeFromFunctorInvoke() { glViewport(0, 0, mViewportWidth, mViewportHeight); glBindFramebuffer(GL_FRAMEBUFFER, mFramebuffer); debugOverdraw(false, false); glClearColor(0.0f, 0.0f, 0.0f, 0.0f); scissor().invalidate(); blend().invalidate(); mCaches->textureState().activateTexture(0); mCaches->textureState().resetBoundTextures(); }
void dlgTaskManager::OnTaskPaint(WndOwnerDrawFrame *Sender, Canvas &canvas) { #ifdef ENABLE_OPENGL /* enable clipping */ GLCanvasScissor scissor(canvas); #endif const Look &look = *CommonInterface::main_window.look; PaintTask(canvas, Sender->get_client_rect(), *active_task, XCSoarInterface::Basic().location, XCSoarInterface::SettingsMap(), look.task, look.airspace, terrain); }
void dlgTaskManager::OnTaskPaint(WndOwnerDrawFrame *Sender, Canvas &canvas) { #ifdef ENABLE_OPENGL /* enable clipping */ GLCanvasScissor scissor(canvas); #endif const MapLook &look = UIGlobals::GetMapLook(); const NMEAInfo &basic = CommonInterface::Basic(); PaintTask(canvas, Sender->get_client_rect(), *active_task, basic.location_available, basic.location, XCSoarInterface::GetMapSettings(), look.task, look.airspace, terrain, &airspace_database); }
void ListControl::DrawItems(Canvas &canvas, unsigned start, unsigned end) const { PixelRect rc = item_rect(start); canvas.SetBackgroundColor(look.list.background_color); canvas.SetBackgroundTransparent(); canvas.Select(*look.list.font); #ifdef ENABLE_OPENGL /* enable clipping */ GLScissor scissor(OpenGL::translate.x, OpenGL::screen_height - OpenGL::translate.y - canvas.GetHeight() - 1, scroll_bar.GetLeft(GetSize()), canvas.GetHeight()); #endif unsigned last_item = std::min(length, end); const bool focused = HasFocus(); for (unsigned i = start; i < last_item; i++) { const bool selected = i == cursor; const bool pressed = selected && drag_mode == DragMode::CURSOR; canvas.DrawFilledRectangle(rc, look.list.GetBackgroundColor(selected, focused, pressed)); canvas.SetTextColor(look.list.GetTextColor(selected, focused, pressed)); if (item_renderer != nullptr) item_renderer->OnPaintItem(canvas, rc, i); if (focused && selected) canvas.DrawFocusRectangle(rc); rc.Offset(0, rc.bottom - rc.top); } /* paint the bottom part below the last item */ rc.bottom = canvas.GetHeight(); if (rc.bottom > rc.top) canvas.DrawFilledRectangle(rc, look.list.background_color); }
void TargetMapWindow::OnPaintBuffer(Canvas &canvas) { #ifdef ENABLE_OPENGL /* enable clipping */ GLCanvasScissor scissor(canvas); #endif // Calculate screen position of the aircraft const auto aircraft_pos = projection.GeoToScreen(Basic().location); // reset label over-write preventer label_block.reset(); // Render terrain, groundline and topography RenderTerrain(canvas); RenderTopography(canvas); // Render airspace RenderAirspace(canvas); #ifdef ENABLE_OPENGL /* desaturate the map background, to focus on the task */ canvas.FadeToWhite(0x80); #endif // Render task, waypoints DrawTask(canvas); DrawWaypoints(canvas); // Render the snail trail RenderTrail(canvas); // Render topography on top of airspace, to keep the text readable RenderTopographyLabels(canvas); // Finally, draw you! if (Basic().alive) AircraftRenderer::Draw(canvas, GetMapSettings(), aircraft_look, Basic().attitude.heading - projection.GetScreenAngle(), aircraft_pos); RenderMapScale(canvas, projection, GetClientRect(), overlay_look); }
GLState &GLState::setScissor(Rectangleui const &newScissorRect) { Rectangleui cumulative; if(scissor()) { cumulative = scissorRect() & newScissorRect; } else { cumulative = newScissorRect; } d->props.set(Scissor, true); d->props.set(ScissorX, cumulative.left()); d->props.set(ScissorY, cumulative.top()); d->props.set(ScissorWidth, cumulative.width()); d->props.set(ScissorHeight, cumulative.height()); return *this; }
void TaskPointWidget::PaintMap(Canvas &canvas, const PixelRect &rc) { const OrderedTaskPoint &tp = ordered_task.GetPoint(active_index); #ifdef ENABLE_OPENGL /* enable clipping */ GLCanvasScissor scissor(canvas); #endif const MapLook &look = UIGlobals::GetMapLook(); const NMEAInfo &basic = CommonInterface::Basic(); PaintTaskPoint(canvas, rc, ordered_task, tp, basic.location_available ? basic.location : GeoPoint::Invalid(), CommonInterface::GetMapSettings(), look.task, look.airspace, terrain, &airspace_database); }
void LLRenderTarget::clear() { U32 mask = GL_COLOR_BUFFER_BIT; if (mUseDepth) { mask |= GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT; } if (mFBO) { glClear(mask); } else { LLGLEnable scissor(GL_SCISSOR_TEST); glScissor(0, 0, mResX, mResY); stop_glerror(); glClear(mask); } }
/** * Handles the drawing of the moving map and is called by the DrawThread */ void MapWindow::OnPaintBuffer(Canvas &canvas) { #ifndef ENABLE_OPENGL unsigned render_generation = ui_generation; #endif #ifdef ENABLE_OPENGL GLCanvasScissor scissor(canvas); #endif // Render the moving map Render(canvas, GetClientRect()); draw_sw.Finish(); #ifndef ENABLE_OPENGL /* save the generation number which was active when rendering had begun */ buffer_projection = render_projection; buffer_generation = render_generation; #endif }
void TaskListPanel::OnTaskPaint(WndOwnerDrawFrame *Sender, Canvas &canvas) { OrderedTask* ordered_task = get_task_to_display(); if (ordered_task == NULL) { canvas.ClearWhite(); return; } #ifdef ENABLE_OPENGL /* enable clipping */ GLCanvasScissor scissor(canvas); #endif const Look &look = CommonInterface::main_window.GetLook(); PaintTask(canvas, Sender->get_client_rect(), *ordered_task, XCSoarInterface::Basic().location, XCSoarInterface::GetMapSettings(), look.map.task, look.map.airspace, terrain); }
void TaskMapWindow::OnPaintBuffer(Canvas &canvas) { if (task == nullptr) { canvas.ClearWhite(); return; } #ifdef ENABLE_OPENGL /* enable clipping */ GLCanvasScissor scissor(canvas); #endif const NMEAInfo &basic = CommonInterface::Basic(); PaintTask(canvas, GetClientRect(), *task, basic.location_available ? basic.location : GeoPoint::Invalid(), CommonInterface::GetMapSettings(), look.task, look.airspace, terrain, &airspace_database, true); }
void TargetMapWindow::on_paint_buffer(Canvas &canvas) { #ifdef ENABLE_OPENGL /* enable clipping */ GLCanvasScissor scissor(canvas); #endif // Calculate screen position of the aircraft const RasterPoint aircraft_pos = projection.GeoToScreen(Basic().location); // reset label over-write preventer label_block.reset(); // Render terrain, groundline and topography RenderTerrain(canvas); RenderTopography(canvas); // Render airspace RenderAirspace(canvas); // Render task, waypoints DrawTask(canvas); DrawWaypoints(canvas); // Render the snail trail RenderTrail(canvas); // Render topography on top of airspace, to keep the text readable RenderTopographyLabels(canvas); // Finally, draw you! if (Basic().connected) AircraftRenderer::Draw(canvas, SettingsMap(), aircraft_look, Calculated().heading - projection.GetScreenAngle(), aircraft_pos); }
static void OnTaskPaint(WndOwnerDrawFrame *Sender, Canvas &canvas) { PixelRect rc = Sender->get_client_rect(); OrderedTaskPoint* tp = ordered_task->get_tp(active_index); if (!tp) { canvas.clear_white(); return; } #ifdef ENABLE_OPENGL /* enable clipping */ GLCanvasScissor scissor(canvas); #endif const Look &look = *CommonInterface::main_window.look; PaintTaskPoint(canvas, rc, *ordered_task, *tp, XCSoarInterface::Basic().location, XCSoarInterface::SettingsMap(), look.task, look.airspace, terrain); }
void RenderState::dump() { blend().dump(); meshState().dump(); scissor().dump(); stencil().dump(); }
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 ChartControl::OnPaint(Canvas &canvas) { assert(glide_computer != NULL); const ComputerSettings &settings_computer = blackboard->GetComputerSettings(); const MapSettings &settings_map = blackboard->GetMapSettings(); const MoreData &basic = blackboard->Basic(); const DerivedInfo &calculated = blackboard->Calculated(); #ifdef ENABLE_OPENGL /* enable clipping */ GLCanvasScissor scissor(canvas); #endif canvas.Clear(COLOR_WHITE); canvas.SetTextColor(COLOR_BLACK); PixelRect rcgfx = GetClientRect(); // background is painted in the base-class switch (page) { case AnalysisPage::BAROGRAPH: RenderBarograph(canvas, rcgfx, chart_look, look->cross_section, glide_computer->GetFlightStats(), basic, calculated, protected_task_manager); break; case AnalysisPage::CLIMB: RenderClimbChart(canvas, rcgfx, chart_look, glide_computer->GetFlightStats(), settings_computer.polar.glide_polar_task); break; case AnalysisPage::THERMAL_BAND: { OrderedTaskSettings otb; if (protected_task_manager != NULL) { otb = protected_task_manager->GetOrderedTaskSettings(); } ThermalBandRenderer renderer(thermal_band_look, chart_look); renderer.DrawThermalBand(basic, calculated, settings_computer, canvas, rcgfx, settings_computer.task, false, &otb); } break; case AnalysisPage::WIND: RenderWindChart(canvas, rcgfx, chart_look, glide_computer->GetFlightStats(), basic, glide_computer->GetWindStore()); break; case AnalysisPage::POLAR: RenderGlidePolar(canvas, rcgfx, look->chart, calculated.climb_history, settings_computer, settings_computer.polar.glide_polar_task); break; case AnalysisPage::TEMPTRACE: RenderTemperatureChart(canvas, rcgfx, chart_look, glide_computer->GetCuSonde()); break; case AnalysisPage::TASK: if (protected_task_manager != NULL) { const TraceComputer *trace_computer = glide_computer != NULL ? &glide_computer->GetTraceComputer() : NULL; const FlightStatisticsRenderer fs(chart_look, look->map); fs.RenderTask(canvas, rcgfx, basic, settings_computer, settings_map, *protected_task_manager, trace_computer); } break; case AnalysisPage::OLC: if (glide_computer != NULL) { const FlightStatisticsRenderer fs(chart_look, look->map); fs.RenderOLC(canvas, rcgfx, basic, settings_computer, settings_map, calculated.contest_stats, glide_computer->GetTraceComputer(), glide_computer->GetRetrospective()); } break; case AnalysisPage::TASK_SPEED: if (protected_task_manager != NULL) { ProtectedTaskManager::Lease task(*protected_task_manager); RenderSpeed(canvas, rcgfx, chart_look, glide_computer->GetFlightStats(), basic, calculated, task); } break; default: // should never get here! break; } }
void LLNetMap::draw() { static LLFrameTimer map_timer; if (mObjectImagep.isNull()) { createObjectImage(); } if (gSavedSettings.getS32( "MiniMapCenter") != MAP_CENTER_NONE) { 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 - gAgentCamera.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); } // Redraw object layer periodically if (mUpdateNow || (map_timer.getElapsedTimeF32() > 0.5f)) { mUpdateNow = FALSE; // Locate the centre of the object layer, accounting for panning LLVector3 new_center = globalPosToView(gAgentCamera.getCameraPositionGlobal(), rotate_map); new_center.mV[0] -= mCurPanX; new_center.mV[1] -= mCurPanY; new_center.mV[2] = 0.f; mObjectImageCenterGlobal = viewPosToGlobal(llround(new_center.mV[0]), llround(new_center.mV[1]), rotate_map); // 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 -= gAgentCamera.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 mapcolor = gAvatarMapColor; static const LLCachedControl<LLColor4> standard_color("MapAvatar",LLColor4(0.f,1.f,0.f,1.f),gColors); static const LLCachedControl<LLColor4> friend_color_stored("AscentFriendColor",LLColor4(1.f,1.f,0.f,1.f)); static const LLCachedControl<LLColor4> em_color("AscentEstateOwnerColor",LLColor4(1.f,0.6f,1.f,1.f)); static const LLCachedControl<LLColor4> linden_color("AscentLindenColor",LLColor4(0.f,0.f,1.f,1.f)); static const LLCachedControl<LLColor4> muted_color("AscentMutedColor",LLColor4(0.7f,0.7f,0.7f,1.f)); // Draw avatars // [RLVa:KB] - Version: 1.23.4 | Alternate: Snowglobe-1.2.4 | Checked: 2009-07-08 (RLVa-1.0.0e) | Modified: RLVa-0.2.0b LLColor4 friend_color = (!gRlvHandler.hasBehaviour(RLV_BHVR_SHOWNAMES)) ? friend_color_stored : standard_color; // [/RLVa:KB] std::vector<LLUUID> avatar_ids; std::vector<LLVector3d> positions; LLWorld::getInstance()->getAvatars(&avatar_ids, &positions); for(U32 i=0; i<avatar_ids.size(); i++) { LLColor4 avColor = standard_color; // 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); if (positions[i].mdV[VZ] == 0.f) { pos_map.mV[VZ] = 16000.f; } std::string avName; gCacheName->getFullName(avatar_ids[i], avName); if(LLMuteList::getInstance()->isMuted(avatar_ids[i])) { avColor = muted_color; } LLViewerRegion* avatar_region = LLWorld::getInstance()->getRegionFromPosGlobal(positions[i]); LLUUID estate_owner = avatar_region? avatar_region->getOwner() : LLUUID::null; //Lindens are always more Linden than your friend, make that take precedence if(LLMuteList::getInstance()->isLinden(avName)) { avColor = linden_color; } //check if they are an estate owner at their current position else if(estate_owner.notNull() && avatar_ids[i] == estate_owner) { avColor = em_color; } //without these dots, SL would suck. else if(is_agent_friend(avatar_ids[i])) { avColor = friend_color; } else { // MOYMOD Minimap custom av colors. boost::unordered_map<const LLUUID,LLColor4>::const_iterator it = mm_MarkerColors.find(avatar_ids[i]); if(it != mm_MarkerColors.end()) { avColor = it->second; } } LLWorldMapView::drawAvatar( pos_map.mV[VX], pos_map.mV[VY], avColor, 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]; mClosestAgentPosition = positions[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 ChartControl::on_paint(Canvas &canvas) { assert(glide_computer != NULL); const SETTINGS_COMPUTER &settings_computer = blackboard->SettingsComputer(); const SETTINGS_MAP &settings_map = blackboard->SettingsMap(); const MoreData &basic = blackboard->Basic(); const DerivedInfo &calculated = blackboard->Calculated(); #ifdef ENABLE_OPENGL /* enable clipping */ GLCanvasScissor scissor(canvas); #endif canvas.clear(COLOR_WHITE); canvas.set_text_color(COLOR_BLACK); canvas.select(Fonts::Map); PixelRect rcgfx = get_client_rect(); // background is painted in the base-class const FlightStatisticsRenderer fs(glide_computer->GetFlightStats(), chart_look, airspace_look, aircraft_look, task_look); switch (page) { case ANALYSIS_PAGE_BAROGRAPH: fs.RenderBarograph(canvas, rcgfx, basic, calculated, protected_task_manager); break; case ANALYSIS_PAGE_CLIMB: fs.RenderClimb(canvas, rcgfx, settings_computer.glide_polar_task); break; case ANALYSIS_PAGE_THERMAL_BAND: { OrderedTaskBehaviour otb; if (protected_task_manager != NULL) { otb = protected_task_manager->get_ordered_task_behaviour(); } ThermalBandRenderer renderer(thermal_band_look, chart_look); renderer.DrawThermalBand(basic, calculated, settings_computer, canvas, rcgfx, settings_computer.task, false, &otb); } break; case ANALYSIS_PAGE_WIND: fs.RenderWind(canvas, rcgfx, basic, glide_computer->GetWindStore()); break; case ANALYSIS_PAGE_POLAR: fs.RenderGlidePolar(canvas, rcgfx, calculated.climb_history, settings_computer, settings_computer.glide_polar_task); break; case ANALYSIS_PAGE_TEMPTRACE: fs.RenderTemperature(canvas, rcgfx); break; case ANALYSIS_PAGE_TASK: if (protected_task_manager != NULL) { const TraceComputer *trace_computer = glide_computer != NULL ? &glide_computer->GetTraceComputer() : NULL; fs.RenderTask(canvas, rcgfx, basic, calculated, settings_computer, settings_map, *protected_task_manager, trace_computer); } break; case ANALYSIS_PAGE_OLC: if (glide_computer != NULL) { TracePointVector trace; glide_computer->LockedCopyTraceTo(trace); fs.RenderOLC(canvas, rcgfx, basic, calculated, settings_computer, settings_map, calculated.contest_stats, trace); } break; case ANALYSIS_PAGE_TASK_SPEED: if (protected_task_manager != NULL) { ProtectedTaskManager::Lease task(*protected_task_manager); fs.RenderSpeed(canvas, rcgfx, basic, calculated, task); } break; default: // should never get here! break; } }
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)); // Prepare a scissor region F32 rotation = 0; { LLGLEnable scissor(GL_SCISSOR_TEST); { LLGLSNoTexture no_texture; LLLocalClipRect clip(getLocalRect()); glMatrixMode(GL_MODELVIEW); // Draw background rectangle gGL.color4fv( mBackgroundColor.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); if( LLNetMap::sRotateMap ) { // 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()); for (LLWorld::region_list_t::iterator iter = LLWorld::getInstance()->mActiveRegionList.begin(); iter != LLWorld::getInstance()->mActiveRegionList.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) * gMiniMapScale; F32 relative_y = (rel_region_pos.mV[1] / region_width) * gMiniMapScale; // background region rectangle F32 bottom = relative_y; F32 left = relative_x; F32 top = bottom + gMiniMapScale ; F32 right = left + gMiniMapScale ; if (regionp == gAgent.getRegion()) { gGL.color4f(1.f, 1.f, 1.f, 1.f); } else { gGL.color4f(0.8f, 0.8f, 0.8f, 1.f); } if (!regionp->isAlive()) { gGL.color4f(1.f, 0.5f, 0.5f, 1.f); } // Draw using texture. LLViewerImage::bindTexture(regionp->getLand().getSTexture()); gGL.begin(LLVertexBuffer::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()) { LLViewerImage::bindTexture(regionp->getLand().getWaterTexture()); gGL.begin(LLVertexBuffer::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] *= gMiniMapScale/region_width; map_center_agent.mV[VY] *= gMiniMapScale/region_width; LLViewerImage::bindTexture(mObjectImagep); F32 image_half_width = 0.5f*mObjectMapPixels; F32 image_half_height = 0.5f*mObjectMapPixels; gGL.begin(LLVertexBuffer::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; // Draw avatars for (LLWorld::region_list_t::iterator iter = LLWorld::getInstance()->mActiveRegionList.begin(); iter != LLWorld::getInstance()->mActiveRegionList.end(); ++iter) { LLViewerRegion* regionp = *iter; const LLVector3d& origin_global = regionp->getOriginGlobal(); S32 count = regionp->mMapAvatars.count(); S32 i; LLVector3 pos_local; U32 compact_local; U8 bits; // 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 for (i = 0; i < count; i++) { compact_local = regionp->mMapAvatars.get(i); bits = compact_local & 0xFF; pos_local.mV[VZ] = F32(bits) * 4.f; compact_local >>= 8; bits = compact_local & 0xFF; pos_local.mV[VY] = (F32)bits; compact_local >>= 8; bits = compact_local & 0xFF; pos_local.mV[VX] = (F32)bits; pos_global.setVec( pos_local ); pos_global += origin_global; pos_map = globalPosToView(pos_global); BOOL show_as_friend = FALSE; if( i < regionp->mMapAvatarIDs.count()) { show_as_friend = is_agent_friend(regionp->mMapAvatarIDs.get(i)); } LLWorldMapView::drawAvatar( pos_map.mV[VX], pos_map.mV[VY], show_as_friend ? gFriendMapColor : gAvatarMapColor, pos_map.mV[VZ]); } } // Draw dot for autopilot target if (gAgent.getAutoPilot()) { drawTracking( gAgent.getAutoPilotTargetGlobal(), gTrackColor ); } else { LLTracker::ETrackingStatus tracking_status = LLTracker::getTrackingStatus(); if ( LLTracker::TRACKING_AVATAR == tracking_status ) { drawTracking( LLAvatarTracker::instance().getGlobalPos(), gTrackColor ); } else if ( LLTracker::TRACKING_LANDMARK == tracking_status || LLTracker::TRACKING_LOCATION == tracking_status ) { drawTracking( LLTracker::getTrackedPositionGlobal(), gTrackColor ); } } // Draw dot for self avatar position pos_global = gAgent.getPositionGlobal(); pos_map = globalPosToView(pos_global); LLUIImagePtr you = LLWorldMapView::sAvatarYouSmallImage; you->draw( llround(pos_map.mV[VX]) - you->getWidth()/2, llround(pos_map.mV[VY]) - you->getHeight()/2); // Draw frustum F32 meters_to_pixels = gMiniMapScale/ 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; LLGLSNoTexture no_texture; if( LLNetMap::sRotateMap ) { gGL.color4fv(gFrustumMapColor.mV); gGL.begin( LLVertexBuffer::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(gRotatingFrustumMapColor.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( LLVertexBuffer::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( mTextBoxEast, rotation ); setDirectionPos( mTextBoxNorth, rotation + F_PI_BY_TWO ); setDirectionPos( mTextBoxWest, rotation + F_PI ); setDirectionPos( mTextBoxSouth, rotation + F_PI + F_PI_BY_TWO ); setDirectionPos( mTextBoxNorthEast, rotation + F_PI_BY_TWO / 2); setDirectionPos( mTextBoxNorthWest, rotation + F_PI_BY_TWO + F_PI_BY_TWO / 2); setDirectionPos( mTextBoxSouthWest, rotation + F_PI + F_PI_BY_TWO / 2); setDirectionPos( mTextBoxSouthEast, rotation + F_PI + F_PI_BY_TWO + F_PI_BY_TWO / 2); LLUICtrl::draw(); }