/** * @file llviewerparceloverlay.cpp * @brief LLViewerParcelOverlay class implementation * * $LicenseInfo:firstyear=2002&license=viewerlgpl$ * Second Life Viewer Source Code * Copyright (C) 2010, Linden Research, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; * version 2.1 of the License only. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA * $/LicenseInfo$ */ #include "llviewerprecompiledheaders.h" #include "llviewerparceloverlay.h" // indra includes #include "llparcel.h" #include "llfloaterreg.h" #include "llgl.h" #include "llrender.h" #include "lluicolor.h" #include "v4color.h" #include "v2math.h" // newview includes #include "llagentcamera.h" #include "llviewertexture.h" #include "llviewercontrol.h" #include "llsurface.h" #include "llviewerregion.h" #include "llviewercamera.h" #include "llviewertexturelist.h" #include "llselectmgr.h" #include "llfloatertools.h" #include "llglheaders.h" #include "pipeline.h" static constexpr U8 OVERLAY_IMG_COMPONENTS = 4; static constexpr F32 LINE_WIDTH = 0.0625f; bool LLViewerParcelOverlay::sColorSetInitialized = false; LLUIColor LLViewerParcelOverlay::sAvailColor; LLUIColor LLViewerParcelOverlay::sOwnedColor; LLUIColor LLViewerParcelOverlay::sGroupColor; LLUIColor LLViewerParcelOverlay::sSelfColor; LLUIColor LLViewerParcelOverlay::sForSaleColor; LLUIColor LLViewerParcelOverlay::sAuctionColor; LLViewerParcelOverlay::LLViewerParcelOverlay(LLViewerRegion* region, F32 region_width_meters) : mRegion(region), mParcelGridsPerEdge(S32(region_width_meters / PARCEL_GRID_STEP_METERS)), mDirty(false), mTimeSinceLastUpdate(), mOverlayTextureIdx(-1) { if (!sColorSetInitialized) { sColorSetInitialized = true; sAvailColor = LLUIColorTable::instance().getColor("PropertyColorAvail").get(); sOwnedColor = LLUIColorTable::instance().getColor("PropertyColorOther").get(); sGroupColor = LLUIColorTable::instance().getColor("PropertyColorGroup").get(); sSelfColor = LLUIColorTable::instance().getColor("PropertyColorSelf").get(); sForSaleColor = LLUIColorTable::instance().getColor("PropertyColorForSale").get(); sAuctionColor = LLUIColorTable::instance().getColor("PropertyColorAuction").get(); } // Create a texture to hold color information. // 4 components // Use mipmaps = false, clamped, NEAREST filter, for sharp edges mImageRaw = new LLImageRaw(mParcelGridsPerEdge, mParcelGridsPerEdge, OVERLAY_IMG_COMPONENTS); mTexture = LLViewerTextureManager::getLocalTexture(mImageRaw.get(), false); mTexture->setAddressMode(LLTexUnit::TAM_CLAMP); mTexture->setFilteringOption(LLTexUnit::TFO_POINT); // // Initialize the GL texture with empty data. // // Create the base texture. U8* raw = mImageRaw->getData(); const S32 COUNT = mParcelGridsPerEdge * mParcelGridsPerEdge * OVERLAY_IMG_COMPONENTS; for (S32 i = 0; i < COUNT; i++) { raw[i] = 0; } //mTexture->setSubImage(mImageRaw, 0, 0, mParcelGridsPerEdge, mParcelGridsPerEdge); // Create storage for ownership information from simulator // and initialize it. mOwnership = new U8[ mParcelGridsPerEdge * mParcelGridsPerEdge ]; for (S32 i = 0; i < mParcelGridsPerEdge * mParcelGridsPerEdge; i++) { mOwnership[i] = PARCEL_PUBLIC; } gPipeline.markGLRebuild(this); } LLViewerParcelOverlay::~LLViewerParcelOverlay() { delete[] mOwnership; mOwnership = NULL; mImageRaw = NULL; } //--------------------------------------------------------------------------- // ACCESSORS //--------------------------------------------------------------------------- bool LLViewerParcelOverlay::isOwned(const LLVector3& pos) const { S32 row = S32(pos.mV[VY] / PARCEL_GRID_STEP_METERS); S32 column = S32(pos.mV[VX] / PARCEL_GRID_STEP_METERS); return (PARCEL_PUBLIC != ownership(row, column)); } bool LLViewerParcelOverlay::isOwnedSelf(const LLVector3& pos) const { S32 row = S32(pos.mV[VY] / PARCEL_GRID_STEP_METERS); S32 column = S32(pos.mV[VX] / PARCEL_GRID_STEP_METERS); return (PARCEL_SELF == ownership(row, column)); } bool LLViewerParcelOverlay::isOwnedGroup(const LLVector3& pos) const { S32 row = S32(pos.mV[VY] / PARCEL_GRID_STEP_METERS); S32 column = S32(pos.mV[VX] / PARCEL_GRID_STEP_METERS); return (PARCEL_GROUP == ownership(row, column)); } bool LLViewerParcelOverlay::isOwnedOther(const LLVector3& pos) const { S32 row = S32(pos.mV[VY] / PARCEL_GRID_STEP_METERS); S32 column = S32(pos.mV[VX] / PARCEL_GRID_STEP_METERS); U8 overlay = ownership(row, column); return (PARCEL_OWNED == overlay || PARCEL_FOR_SALE == overlay); } bool LLViewerParcelOverlay::encroachesOwned(const std::vector& boxes) const { // boxes are expected to already be axis aligned for (U32 i = 0; i < boxes.size(); ++i) { LLVector3 min = boxes[i].getMinAgent(); LLVector3 max = boxes[i].getMaxAgent(); S32 left = S32(llclamp((min.mV[VX] / PARCEL_GRID_STEP_METERS), 0.f, REGION_WIDTH_METERS - 1.f)); S32 right = S32(llclamp((max.mV[VX] / PARCEL_GRID_STEP_METERS), 0.f, REGION_WIDTH_METERS - 1.f)); S32 top = S32(llclamp((min.mV[VY] / PARCEL_GRID_STEP_METERS), 0.f, REGION_WIDTH_METERS - 1.f)); S32 bottom = S32(llclamp((max.mV[VY] / PARCEL_GRID_STEP_METERS), 0.f, REGION_WIDTH_METERS - 1.f)); for (S32 row = top; row <= bottom; row++) { for (S32 column = left; column <= right; column++) { U8 type = ownership(row, column); if ((PARCEL_SELF == type) || (PARCEL_GROUP == type)) { return true; } } } } return false; } bool LLViewerParcelOverlay::encroachesOnUnowned(const std::vector& boxes) const { // boxes are expected to already be axis aligned for (U32 i = 0; i < boxes.size(); ++i) { LLVector3 min = boxes[i].getMinAgent(); LLVector3 max = boxes[i].getMaxAgent(); S32 left = S32(llclamp((min.mV[VX] / PARCEL_GRID_STEP_METERS), 0.f, REGION_WIDTH_METERS - 1.f)); S32 right = S32(llclamp((max.mV[VX] / PARCEL_GRID_STEP_METERS), 0.f, REGION_WIDTH_METERS - 1.f)); S32 top = S32(llclamp((min.mV[VY] / PARCEL_GRID_STEP_METERS), 0.f, REGION_WIDTH_METERS - 1.f)); S32 bottom = S32(llclamp((max.mV[VY] / PARCEL_GRID_STEP_METERS), 0.f, REGION_WIDTH_METERS - 1.f)); for (S32 row = top; row <= bottom; row++) { for (S32 column = left; column <= right; column++) { U8 type = ownership(row, column); if ((PARCEL_SELF != type)) { return true; } } } } return false; } bool LLViewerParcelOverlay::encroachesOnNearbyParcel(const std::vector& boxes) const { // boxes are expected to already be axis aligned for (U32 i = 0; i < boxes.size(); ++i) { LLVector3 min = boxes[i].getMinAgent(); LLVector3 max = boxes[i].getMaxAgent(); // If an object crosses region borders it crosses a parcel if ( min.mV[VX] < 0 || min.mV[VY] < 0 || max.mV[VX] > REGION_WIDTH_METERS || max.mV[VY] > REGION_WIDTH_METERS) { return true; } S32 left = S32(llclamp((min.mV[VX] / PARCEL_GRID_STEP_METERS), 0.f, REGION_WIDTH_METERS - 1.f)); S32 right = S32(llclamp((max.mV[VX] / PARCEL_GRID_STEP_METERS), 0.f, REGION_WIDTH_METERS - 1.f)); S32 bottom = S32(llclamp((min.mV[VY] / PARCEL_GRID_STEP_METERS), 0.f, REGION_WIDTH_METERS - 1.f)); S32 top = S32(llclamp((max.mV[VY] / PARCEL_GRID_STEP_METERS), 0.f, REGION_WIDTH_METERS - 1.f)); const S32 GRIDS_PER_EDGE = mParcelGridsPerEdge; for (S32 row = bottom; row <= top; row++) { for (S32 col = left; col <= right; col++) { // This is not the rightmost column if (col < GRIDS_PER_EDGE-1) { U8 east_overlay = mOwnership[row*GRIDS_PER_EDGE+col+1]; // If the column to the east of the current one marks // the other parcel's west edge and the box extends // to the west it crosses the parcel border. if ((east_overlay & PARCEL_WEST_LINE) && col < right) { return true; } } // This is not the topmost column if (row < GRIDS_PER_EDGE-1) { U8 north_overlay = mOwnership[(row+1)*GRIDS_PER_EDGE+col]; // If the row to the north of the current one marks // the other parcel's south edge and the box extends // to the south it crosses the parcel border. if ((north_overlay & PARCEL_SOUTH_LINE) && row < top) { return true; } } } } } return false; } bool LLViewerParcelOverlay::isSoundLocal(const LLVector3& pos) const { S32 row = S32(pos.mV[VY] / PARCEL_GRID_STEP_METERS); S32 column = S32(pos.mV[VX] / PARCEL_GRID_STEP_METERS); return parcelFlags(row, column, PARCEL_SOUND_LOCAL); } U8 LLViewerParcelOverlay::ownership( const LLVector3& pos) const { S32 row = S32(pos.mV[VY] / PARCEL_GRID_STEP_METERS); S32 column = S32(pos.mV[VX] / PARCEL_GRID_STEP_METERS); return ownership(row, column); } U8 LLViewerParcelOverlay::parcelLineFlags(const LLVector3& pos) const { S32 row = S32(pos.mV[VY] / PARCEL_GRID_STEP_METERS); S32 column = S32(pos.mV[VX] / PARCEL_GRID_STEP_METERS); return parcelFlags(row, column, PARCEL_WEST_LINE | PARCEL_SOUTH_LINE); } U8 LLViewerParcelOverlay::parcelLineFlags(S32 row, S32 col) const { return parcelFlags(row, col, PARCEL_WEST_LINE | PARCEL_SOUTH_LINE); } U8 LLViewerParcelOverlay::parcelFlags(S32 row, S32 col, U8 flags) const { if (row >= mParcelGridsPerEdge || col >= mParcelGridsPerEdge || row < 0 || col < 0) { LL_WARNS() << "Attempted to get ownership out of region's overlay, row: " << row << " col: " << col << LL_ENDL; return flags; } return mOwnership[row * mParcelGridsPerEdge + col] & flags; } F32 LLViewerParcelOverlay::getOwnedRatio() const { S32 size = mParcelGridsPerEdge * mParcelGridsPerEdge; S32 total = 0; for (S32 i = 0; i < size; i++) { if ((mOwnership[i] & PARCEL_COLOR_MASK) != PARCEL_PUBLIC) { total++; } } return (F32)total / (F32)size; } //--------------------------------------------------------------------------- // MANIPULATORS //--------------------------------------------------------------------------- // Color tables for owned land // Available = index 0 // Other = index 1 // Group = index 2 // Self = index 3 // Make sure the texture colors match the ownership data. // Note: Assumes that the ownership array and void LLViewerParcelOverlay::updateOverlayTexture() { if (mOverlayTextureIdx < 0) { if (!mDirty) return; mOverlayTextureIdx = 0; } const LLColor4U avail = sAvailColor.get(); const LLColor4U owned = sOwnedColor.get(); const LLColor4U group = sGroupColor.get(); const LLColor4U self = sSelfColor.get(); const LLColor4U for_sale = sForSaleColor.get(); const LLColor4U auction = sAuctionColor.get(); // Create the base texture. U8* raw = mImageRaw->getData(); const S32 COUNT = mParcelGridsPerEdge * mParcelGridsPerEdge; S32 max = mOverlayTextureIdx + mParcelGridsPerEdge; if (max > COUNT) max = COUNT; S32 pixel_index = mOverlayTextureIdx * OVERLAY_IMG_COMPONENTS; S32 i; for (i = mOverlayTextureIdx; i < max; i++) { U8 ownership = mOwnership[i]; U8 r,g,b,a; // Color stored in low three bits switch (ownership & 0x7) { case PARCEL_PUBLIC: r = avail.mV[VRED]; g = avail.mV[VGREEN]; b = avail.mV[VBLUE]; a = avail.mV[VALPHA]; break; case PARCEL_OWNED: r = owned.mV[VRED]; g = owned.mV[VGREEN]; b = owned.mV[VBLUE]; a = owned.mV[VALPHA]; break; case PARCEL_GROUP: r = group.mV[VRED]; g = group.mV[VGREEN]; b = group.mV[VBLUE]; a = group.mV[VALPHA]; break; case PARCEL_SELF: r = self.mV[VRED]; g = self.mV[VGREEN]; b = self.mV[VBLUE]; a = self.mV[VALPHA]; break; case PARCEL_FOR_SALE: r = for_sale.mV[VRED]; g = for_sale.mV[VGREEN]; b = for_sale.mV[VBLUE]; a = for_sale.mV[VALPHA]; break; case PARCEL_AUCTION: r = auction.mV[VRED]; g = auction.mV[VGREEN]; b = auction.mV[VBLUE]; a = auction.mV[VALPHA]; break; default: r = self.mV[VRED]; g = self.mV[VGREEN]; b = self.mV[VBLUE]; a = self.mV[VALPHA]; break; } raw[pixel_index + VRED] = (U8)r; raw[pixel_index + VGREEN] = (U8)g; raw[pixel_index + VBLUE] = (U8)b; raw[pixel_index + VALPHA] = (U8)a; pixel_index += OVERLAY_IMG_COMPONENTS; } // Copy data into GL texture from raw data if (i >= COUNT) { if (!mTexture->hasGLTexture()) { mTexture->createGLTexture(0, mImageRaw); } mTexture->setSubImage(mImageRaw, 0, 0, mParcelGridsPerEdge, mParcelGridsPerEdge); mOverlayTextureIdx = -1; } else { mOverlayTextureIdx = i; } } void LLViewerParcelOverlay::uncompressLandOverlay(S32 chunk, U8* packed_overlay) { // Unpack the message data into the ownership array S32 size = mParcelGridsPerEdge * mParcelGridsPerEdge; S32 chunk_size = size / PARCEL_OVERLAY_CHUNKS; memcpy(mOwnership + chunk*chunk_size, packed_overlay, chunk_size); /*Flawfinder: ignore*/ // Force property lines and overlay texture to update setDirty(); } void LLViewerParcelOverlay::updatePropertyLines() { static LLCachedControl show(gSavedSettings, "ShowPropertyLines"); if (!show) return; LLColor4U colors[PARCEL_COLOR_MASK + 1]; colors[PARCEL_SELF] = sSelfColor.get(); colors[PARCEL_OWNED] = sOwnedColor.get(); colors[PARCEL_GROUP] = sGroupColor.get(); colors[PARCEL_FOR_SALE] = sForSaleColor.get(); colors[PARCEL_AUCTION] = sAuctionColor.get(); mEdges.clear(); constexpr F32 GRID_STEP = PARCEL_GRID_STEP_METERS; const S32 GRIDS_PER_EDGE = mParcelGridsPerEdge; for (S32 row = 0; row < GRIDS_PER_EDGE; row++) { for (S32 col = 0; col < GRIDS_PER_EDGE; col++) { U8 overlay = mOwnership[row * GRIDS_PER_EDGE + col]; S32 colorIndex = overlay & PARCEL_COLOR_MASK; switch (colorIndex) { case PARCEL_SELF: case PARCEL_GROUP: case PARCEL_OWNED: case PARCEL_FOR_SALE: case PARCEL_AUCTION: break; default: continue; } const LLColor4U& color = colors[colorIndex]; F32 left = col * GRID_STEP; F32 right = left + GRID_STEP; F32 bottom = row * GRID_STEP; F32 top = bottom + GRID_STEP; // West edge if (overlay & PARCEL_WEST_LINE) { addPropertyLine(left, bottom, 0, 1, LINE_WIDTH, 0, color); } // East edge if (col == GRIDS_PER_EDGE - 1 || mOwnership[row * GRIDS_PER_EDGE + col + 1] & PARCEL_WEST_LINE) { addPropertyLine(right, bottom, 0, 1, -LINE_WIDTH, 0, color); } // South edge if (overlay & PARCEL_SOUTH_LINE) { addPropertyLine(left, bottom, 1, 0, 0, LINE_WIDTH, color); } // North edge if (row == GRIDS_PER_EDGE - 1 || mOwnership[(row + 1) * GRIDS_PER_EDGE + col] & PARCEL_SOUTH_LINE) { addPropertyLine(left, top, 1, 0, 0, -LINE_WIDTH, color); } } } // Everything's clean now mDirty = false; } void LLViewerParcelOverlay::addPropertyLine(F32 start_x, F32 start_y, F32 dx, F32 dy, F32 tick_dx, F32 tick_dy, const LLColor4U& color) { LLSurface& land = mRegion->getLand(); F32 water_z = land.getWaterHeight(); mEdges.resize(mEdges.size() + 1); Edge& edge = mEdges.back(); edge.color = color; // Detailized rendering vertices: // A B C D E F G // *-*------*--------*--------*------*-* : 'outside' vertices are placed right on the border // *------*--------*--------*------* : 'inside' vertices are shifted on LINE_WIDTH inside // Simplified rendering vertices: // A G // *-----------------------------------* // *-----------------------------------* F32 outside_x = start_x; F32 outside_y = start_y; F32 outside_z = land.resolveHeightRegion(outside_x, outside_y); F32 inside_x = start_x + tick_dx; F32 inside_y = start_y + tick_dy; F32 inside_z = land.resolveHeightRegion(inside_x, inside_y); auto move = [&](F32 distance) { outside_x += dx * distance; outside_y += dy * distance; outside_z = land.resolveHeightRegion(outside_x, outside_y); inside_x += dx * distance; inside_y += dy * distance; inside_z = land.resolveHeightRegion(inside_x, inside_y); }; auto split = [&](U32 lod, const LLVector4a& start, F32 x, F32 y, F32 z, F32 part) { F32 new_x = start[VX] + (x - start[VX]) * part; F32 new_y = start[VY] + (y - start[VY]) * part; F32 new_z = start[VZ] + (z - start[VZ]) * part; edge.pushVertex(lod, new_x, new_y, new_z, water_z); }; auto checkForSplit = [&](U32 lod) { const std::vector& vertices = edge.verticesUnderWater[lod]; const LLVector4a& last_outside = vertices.back(); F32 z0 = last_outside[VZ]; F32 z1 = outside_z; if ((z0 >= water_z && z1 >= water_z) || (z0 < water_z && z1 < water_z)) return; F32 part = (water_z - z0) / (z1 - z0); const LLVector4a& last_inside = vertices[vertices.size() - 2]; split(lod, last_inside, inside_x, inside_y, inside_z, part); split(lod, last_outside, outside_x, outside_y, outside_z, part); }; auto pushTwoVertices = [&](U32 lod) { LLVector3 out(outside_x, outside_y, outside_z); LLVector3 in(inside_x, inside_y, inside_z); if (fabs(inside_z - outside_z) < LINE_WIDTH / 5) { edge.pushVertex(lod, inside_x, inside_y, inside_z, water_z); } else { // Make the line thinner if heights differ too much LLVector3 dist(in - out); F32 coef = dist.length() / LINE_WIDTH; LLVector3 new_in(out + dist / coef); edge.pushVertex(lod, new_in[VX], new_in[VY], new_in[VZ], water_z); } edge.pushVertex(lod, outside_x, outside_y, outside_z, water_z); }; // Point A simplified (first two vertices) pushTwoVertices(1); // Point A detailized (only one vertex) edge.pushVertex(0, outside_x, outside_y, outside_z, water_z); // Point B (two vertices) move(LINE_WIDTH); pushTwoVertices(0); // Points C, D, E F32 distance = 1.f - LINE_WIDTH; constexpr U32 GRID_STEP = (U32)PARCEL_GRID_STEP_METERS; for (U32 i = 1; i < GRID_STEP; ++i) { move(distance); checkForSplit(0); pushTwoVertices(0); distance = 1.f; } // Point F (two vertices) move(1.f - LINE_WIDTH); checkForSplit(0); pushTwoVertices(0); // Point G simplified (last two vertices) move(LINE_WIDTH); checkForSplit(1); pushTwoVertices(1); // Point G detailized (only one vertex) edge.pushVertex(0, outside_x, outside_y, outside_z, water_z); } void LLViewerParcelOverlay::Edge::pushVertex(U32 lod, F32 x, F32 y, F32 z, F32 water_z) { verticesUnderWater[lod].emplace_back(x, y, z); gGL.transform(verticesUnderWater[lod].back()); if (z >= water_z) { verticesAboveWater[lod].push_back(verticesUnderWater[lod].back()); } else { verticesAboveWater[lod].emplace_back(x, y, water_z); gGL.transform(verticesAboveWater[lod].back()); } } void LLViewerParcelOverlay::setDirty() { mDirty = true; } void LLViewerParcelOverlay::updateGL() { LL_PROFILE_ZONE_SCOPED; updateOverlayTexture(); } void LLViewerParcelOverlay::idleUpdate(bool force_update) { if (gGLManager.mIsDisabled) { return; } if (mOverlayTextureIdx >= 0 && (!(mDirty && force_update))) { // We are in the middle of updating the overlay texture gPipeline.markGLRebuild(this); return; } // Only if we're dirty and it's been a while since the last update. if (mDirty) { if (force_update || mTimeSinceLastUpdate.getElapsedTimeF32() > 4.0f) { updateOverlayTexture(); updatePropertyLines(); mTimeSinceLastUpdate.reset(); } } } void LLViewerParcelOverlay::renderPropertyLines() { static LLCachedControl show(gSavedSettings, "ShowPropertyLines"); if (!show) return; LLSurface& land = mRegion->getLand(); F32 water_z = land.getWaterHeight() + 0.01f; LLGLSUIDefault gls_ui; // called from pipeline gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE); LLGLDepthTest mDepthTest(GL_TRUE); // Find camera height off the ground (not from zero) F32 ground_height_at_camera = land.resolveHeightGlobal( gAgentCamera.getCameraPositionGlobal() ); F32 camera_z = LLViewerCamera::getInstance()->getOrigin().mV[VZ]; F32 camera_height = camera_z - ground_height_at_camera; camera_height = llclamp(camera_height, 0.f, 100.f); // Pull lines toward camera by 1 cm per meter off the ground. const LLVector3& CAMERA_AT = LLViewerCamera::getInstance()->getAtAxis(); F32 pull_toward_camera_scale = 0.01f * camera_height; LLVector3 pull_toward_camera = CAMERA_AT; pull_toward_camera *= -pull_toward_camera_scale; // Always fudge a little vertically. pull_toward_camera.mV[VZ] += 0.01f; gGL.matrixMode(LLRender::MM_MODELVIEW); gGL.pushMatrix(); // Move to appropriate region coords LLVector3 origin = mRegion->getOriginAgent(); gGL.translatef(origin.mV[VX], origin.mV[VY], origin.mV[VZ]); gGL.translatef(pull_toward_camera.mV[VX], pull_toward_camera.mV[VY], pull_toward_camera.mV[VZ]); // Stomp the camera into two dimensions LLVector3 camera_region = mRegion->getPosRegionFromGlobal( gAgentCamera.getCameraPositionGlobal() ); bool draw_underwater = camera_region.mV[VZ] < water_z || !gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_WATER); // Set up a cull plane 2 * PARCEL_GRID_STEP_METERS behind // the camera. The cull plane normal is the camera's at axis. LLVector3 cull_plane_point = LLViewerCamera::getInstance()->getAtAxis(); cull_plane_point *= -2.f * PARCEL_GRID_STEP_METERS; cull_plane_point += camera_region; bool render_hidden = !draw_underwater && LLSelectMgr::sRenderHiddenSelections && LLFloaterReg::instanceVisible("build"); constexpr F32 PROPERTY_LINE_CLIP_DIST_SQUARED = 256.f * 256.f; constexpr F32 PROPERTY_LINE_LOD0_DIST_SQUARED = PROPERTY_LINE_CLIP_DIST_SQUARED / 25.f; for (const Edge& edge : mEdges) { const std::vector& vertices0 = edge.verticesAboveWater[0]; const F32* first = vertices0.front().getF32ptr(); const F32* last = vertices0.back().getF32ptr(); LLVector3 center((first[VX] + last[VX]) / 2, (first[VY] + last[VY]) / 2, (first[VZ] + last[VZ]) / 2); gGL.untransform(center); F32 dist_squared = dist_vec_squared(center, camera_region); if (dist_squared > PROPERTY_LINE_CLIP_DIST_SQUARED) { continue; } // Destroy vertex, transform to plane-local. center -= cull_plane_point; // Negative dot product means it is in back of the plane if (center * CAMERA_AT < 0.f) { continue; } U32 lod = dist_squared < PROPERTY_LINE_LOD0_DIST_SQUARED ? 0 : 1; gGL.begin(LLRender::TRIANGLE_STRIP); gGL.color4ubv(edge.color.mV); if (draw_underwater) { gGL.vertexBatchPreTransformed(edge.verticesUnderWater[lod]); } else { gGL.vertexBatchPreTransformed(edge.verticesAboveWater[lod]); if (render_hidden) { LLGLDepthTest depth(GL_TRUE, GL_FALSE, GL_GREATER); LLColor4U color = edge.color; color.mV[VALPHA] /= 4; gGL.color4ubv(color.mV); gGL.vertexBatchPreTransformed(edge.verticesUnderWater[lod]); } } gGL.end(); } gGL.popMatrix(); } // Draw half of a single cell (no fill) in a grid drawn from left to right and from bottom to top void grid_2d_part_lines(const F32 left, const F32 top, const F32 right, const F32 bottom, bool has_left, bool has_bottom) { gGL.begin(LLRender::LINES); if (has_left) { gGL.vertex2f(left, bottom); gGL.vertex2f(left, top); } if (has_bottom) { gGL.vertex2f(left, bottom); gGL.vertex2f(right, bottom); } gGL.end(); } void LLViewerParcelOverlay::renderPropertyLinesOnMinimap(F32 scale_pixels_per_meter, const F32* parcel_outline_color) { static LLCachedControl show(gSavedSettings, "MiniMapShowPropertyLines"); if (!mOwnership || !show) { return; } LLVector3 origin_agent = mRegion->getOriginAgent(); LLVector3 rel_region_pos = origin_agent - gAgentCamera.getCameraPositionAgent(); F32 region_left = rel_region_pos.mV[VX] * scale_pixels_per_meter; F32 region_bottom = rel_region_pos.mV[VY] * scale_pixels_per_meter; F32 map_parcel_width = PARCEL_GRID_STEP_METERS * scale_pixels_per_meter; const S32 GRIDS_PER_EDGE = mParcelGridsPerEdge; gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE); glLineWidth(1.0f); gGL.color4fv(parcel_outline_color); for (S32 i = 0; i <= GRIDS_PER_EDGE; i++) { const F32 bottom = region_bottom + (i * map_parcel_width); const F32 top = bottom + map_parcel_width; for (S32 j = 0; j <= GRIDS_PER_EDGE; j++) { const F32 left = region_left + (j * map_parcel_width); const F32 right = left + map_parcel_width; const bool is_region_boundary = i == GRIDS_PER_EDGE || j == GRIDS_PER_EDGE; const U8 overlay = is_region_boundary ? 0 : mOwnership[(i * GRIDS_PER_EDGE) + j]; // The property line vertices are three-dimensional, but here we only care about the x and y coordinates, as we are drawing on a // 2D map const bool has_left = i != GRIDS_PER_EDGE && (j == GRIDS_PER_EDGE || (overlay & PARCEL_WEST_LINE)); const bool has_bottom = j != GRIDS_PER_EDGE && (i == GRIDS_PER_EDGE || (overlay & PARCEL_SOUTH_LINE)); grid_2d_part_lines(left, top, right, bottom, has_left, has_bottom); } } }