Second Life viewer sources 1.13.2.12

1 files changed, 604 insertions, 0 deletions

diff --git a/linden/indra/newview/lltoolbrush.cpp b/linden/indra/newview/lltoolbrush.cpp
new file mode 100644
index 0000000..1822c63
--- /dev/null
+++ b/linden/indra/newview/lltoolbrush.cpp
@@ -0,0 +1,604 @@
+/** 
+ * @file lltoolbrush.cpp
+ * @brief Implementation of the toolbrushes
+ *
+ * Copyright (c) 2001-2007, Linden Research, Inc.
+ * 
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ */
+
+#include "llviewerprecompiledheaders.h"
+
+#include "lltoolbrush.h"
+#include "lltoolselectland.h"
+
+#include "llgl.h"
+
+#include "message.h"
+
+#include "llagent.h"
+#include "llcallbacklist.h"
+#include "llviewercontrol.h"
+#include "llfloatertools.h"
+#include "llregionposition.h"
+#include "llstatusbar.h"
+#include "llsurface.h"
+#include "llsurfacepatch.h"
+#include "lltoolmgr.h"
+#include "llui.h"
+#include "llviewerparcelmgr.h"
+#include "llviewerparceloverlay.h"
+#include "llviewerregion.h"
+#include "llviewerwindow.h"
+#include "llworld.h"
+#include "viewer.h"
+#include "llparcel.h"
+
+#include "llglheaders.h"
+
+const std::string REGION_BLOCKS_TERRAFORM_MSG = "This region does not allow terraforming.\n"
+                                "You will need to buy land in another part of the world to terraform it.";
+
+// Globals
+LLToolBrushLand *gToolLand = NULL;
+
+///============================================================================
+/// Local function declarations, constants, enums, and typedefs
+///============================================================================
+
+const S32 LAND_BRUSH_SIZE_COUNT = 3;
+const F32 LAND_BRUSH_SIZE[LAND_BRUSH_SIZE_COUNT] = {1.0f, 2.0f, 4.0f};
+const S32 LAND_STEPS = 3;
+const F32 LAND_METERS_PER_SECOND = 1.0f;
+enum
+{
+        E_LAND_LEVEL    = 0,
+        E_LAND_RAISE    = 1,
+        E_LAND_LOWER    = 2,
+        E_LAND_SMOOTH   = 3,
+        E_LAND_NOISE    = 4,
+        E_LAND_REVERT   = 5,
+        E_LAND_INVALID  = 6,
+};
+const LLColor4 OVERLAY_COLOR(1.0f, 1.0f, 1.0f, 1.0f);
+
+///============================================================================
+/// Class LLToolBrushLand
+///============================================================================
+
+// constructor
+LLToolBrushLand::LLToolBrushLand()
+:       LLTool("Land"),
+        mStartingZ( 0.0f ),
+        mMouseX( 0 ),
+        mMouseY(0),
+        mGotHover(FALSE),
+        mLastShowParcelOwners(FALSE),
+        mBrushSelected(FALSE)
+{
+        mBrushIndex = gSavedSettings.getS32("RadioLandBrushSize");
+}
+
+void LLToolBrushLand::modifyLandAtPointGlobal(const LLVector3d &pos_global,
+                                                                                          MASK mask)
+{
+        S32 radioAction = gSavedSettings.getS32("RadioLandBrushAction");
+
+        determineAffectedRegions(mLastAffectedRegions, pos_global);
+        for(LLViewerRegion* regionp = mLastAffectedRegions.getFirstData();
+                                regionp != NULL;
+                                regionp = mLastAffectedRegions.getNextData())
+        {
+                //BOOL is_changed = FALSE;
+                LLVector3 pos_region = regionp->getPosRegionFromGlobal(pos_global);
+                LLSurface &land = regionp->getLand();
+                char action = E_LAND_LEVEL;
+                switch (radioAction)
+                {
+                case 0:
+                //      // average toward mStartingZ
+                        action = E_LAND_LEVEL;
+                        break;
+                case 1:
+                        action = E_LAND_RAISE;
+                        break;
+                case 2:
+                        action = E_LAND_LOWER;
+                        break;
+                case 3:
+                        action = E_LAND_SMOOTH;
+                        break;
+                case 4:
+                        action = E_LAND_NOISE;
+                        break;
+                case 5:
+                        action = E_LAND_REVERT;
+                        break;
+                default:
+                        action = E_LAND_INVALID;
+                        break;
+                }
+
+                // Don't send a message to the region if nothing changed.
+                //if(!is_changed) continue;
+
+                // Now to update the patch information so it will redraw correctly.
+                LLSurfacePatch *patchp= land.resolvePatchRegion(pos_region);
+                if (patchp)
+                {
+                        patchp->dirtyZ();
+                }
+
+                // Also force the property lines to update, normals to recompute, etc.
+                regionp->forceUpdate();
+
+                // tell the simulator what we've done
+                F32 seconds = 1.0f / gFPSClamped;
+                F32 x_pos = (F32)pos_region.mV[VX];
+                F32 y_pos = (F32)pos_region.mV[VY];
+                U8 brush_size = (U8)mBrushIndex;
+                LLMessageSystem* msg = gMessageSystem;
+                msg->newMessageFast(_PREHASH_ModifyLand);
+                msg->nextBlockFast(_PREHASH_AgentData);
+                msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
+                msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
+                msg->nextBlockFast(_PREHASH_ModifyBlock);
+                msg->addU8Fast(_PREHASH_Action, (U8)action);
+                msg->addU8Fast(_PREHASH_BrushSize, brush_size);
+                msg->addF32Fast(_PREHASH_Seconds, seconds);
+                msg->addF32Fast(_PREHASH_Height, mStartingZ);
+                msg->nextBlockFast(_PREHASH_ParcelData);
+                msg->addS32Fast(_PREHASH_LocalID, -1);
+                msg->addF32Fast(_PREHASH_West, x_pos );
+                msg->addF32Fast(_PREHASH_South, y_pos );
+                msg->addF32Fast(_PREHASH_East, x_pos );
+                msg->addF32Fast(_PREHASH_North, y_pos );
+                msg->sendMessage(regionp->getHost());
+        }
+}
+
+void LLToolBrushLand::modifyLandInSelectionGlobal()
+{
+        if (gParcelMgr->selectionEmpty())
+        {
+                return;
+        }
+
+        if (gToolMgr->getCurrentTool(gKeyboard->currentMask(TRUE)) == gToolParcel)
+        {
+                // selecting land, don't do anything
+                return;
+        }
+
+        LLVector3d min;
+        LLVector3d max;
+
+        gParcelMgr->getSelection(min, max);
+
+        S32 radioAction = gSavedSettings.getS32("RadioLandBrushAction");
+
+        mLastAffectedRegions.removeAllNodes();
+
+        determineAffectedRegions(mLastAffectedRegions, LLVector3d(min.mdV[VX], min.mdV[VY], 0));
+        determineAffectedRegions(mLastAffectedRegions, LLVector3d(min.mdV[VX], max.mdV[VY], 0));
+        determineAffectedRegions(mLastAffectedRegions, LLVector3d(max.mdV[VX], min.mdV[VY], 0));
+        determineAffectedRegions(mLastAffectedRegions, LLVector3d(max.mdV[VX], max.mdV[VY], 0));
+
+        LLRegionPosition mid_point_region((min + max) * 0.5);
+        LLViewerRegion* center_region = mid_point_region.getRegion();
+        if (center_region)
+        {
+                LLVector3 pos_region = mid_point_region.getPositionRegion();
+                U32 grids = center_region->getLand().mGridsPerEdge;
+                S32 i = llclamp( (S32)pos_region.mV[VX], 0, (S32)grids );
+                S32 j = llclamp( (S32)pos_region.mV[VY], 0, (S32)grids );
+                mStartingZ = center_region->getLand().getZ(i+j*grids);
+        }
+        else
+        {
+                mStartingZ = 0.f;
+        }
+
+        // Stop if our selection include a no-terraform region
+        for(LLViewerRegion* regionp = mLastAffectedRegions.getFirstData();
+                                regionp != NULL;
+                                regionp = mLastAffectedRegions.getNextData())
+        {
+                if (!canTerraform(regionp))
+                {
+                        alertNoTerraform(regionp);
+                        return;
+                }
+        }
+
+        for(LLViewerRegion* regionp = mLastAffectedRegions.getFirstData();
+                                regionp != NULL;
+                                regionp = mLastAffectedRegions.getNextData())
+        {
+                //BOOL is_changed = FALSE;
+                LLVector3 min_region = regionp->getPosRegionFromGlobal(min);
+                LLVector3 max_region = regionp->getPosRegionFromGlobal(max);
+        
+                min_region.clamp(0.f, regionp->getWidth());
+                max_region.clamp(0.f, regionp->getWidth());
+                F32 seconds = 1.0f;
+
+                LLSurface &land = regionp->getLand();
+                char action = E_LAND_LEVEL;
+                switch (radioAction)
+                {
+                case 0:
+                //      // average toward mStartingZ
+                        action = E_LAND_LEVEL;
+                        seconds = 1.f;
+                        break;
+                case 1:
+                        action = E_LAND_RAISE;
+                        break;
+                case 2:
+                        action = E_LAND_LOWER;
+                        break;
+                case 3:
+                        action = E_LAND_SMOOTH;
+                        seconds = 10.f;
+                        break;
+                case 4:
+                        action = E_LAND_NOISE;
+                        seconds = 0.5f;
+                        break;
+                case 5:
+                        action = E_LAND_REVERT;
+                        seconds = 0.5f;
+                        break;
+                default:
+                        //action = E_LAND_INVALID;
+                        //seconds = 0.0f;
+                        return;
+                        break;
+                }
+
+                // Don't send a message to the region if nothing changed.
+                //if(!is_changed) continue;
+
+                // Now to update the patch information so it will redraw correctly.
+                LLSurfacePatch *patchp= land.resolvePatchRegion(min_region);
+                if (patchp)
+                {
+                        patchp->dirtyZ();
+                }
+
+                // Also force the property lines to update, normals to recompute, etc.
+                regionp->forceUpdate();
+
+                // tell the simulator what we've done
+                U8 brush_size = (U8)mBrushIndex;
+                LLMessageSystem* msg = gMessageSystem;
+                msg->newMessageFast(_PREHASH_ModifyLand);
+                msg->nextBlockFast(_PREHASH_AgentData);
+                msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
+                msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
+                msg->nextBlockFast(_PREHASH_ModifyBlock);
+                msg->addU8Fast(_PREHASH_Action, (U8)action);
+                msg->addU8Fast(_PREHASH_BrushSize, brush_size);
+                msg->addF32Fast(_PREHASH_Seconds, seconds);
+                msg->addF32Fast(_PREHASH_Height, mStartingZ);
+
+                BOOL parcel_selected = gParcelMgr->getWholeParcelSelected();
+                LLParcel* selected_parcel = gParcelMgr->getSelectedParcel();
+
+                if (parcel_selected && selected_parcel)
+                {
+                        msg->nextBlockFast(_PREHASH_ParcelData);
+                        msg->addS32Fast(_PREHASH_LocalID, selected_parcel->getLocalID());
+                        msg->addF32Fast(_PREHASH_West,  min_region.mV[VX] );
+                        msg->addF32Fast(_PREHASH_South, min_region.mV[VY] );
+                        msg->addF32Fast(_PREHASH_East,  max_region.mV[VX] );
+                        msg->addF32Fast(_PREHASH_North, max_region.mV[VY] );
+                }
+                else
+                {
+                        msg->nextBlockFast(_PREHASH_ParcelData);
+                        msg->addS32Fast(_PREHASH_LocalID, -1);
+                        msg->addF32Fast(_PREHASH_West,  min_region.mV[VX] );
+                        msg->addF32Fast(_PREHASH_South, min_region.mV[VY] );
+                        msg->addF32Fast(_PREHASH_East,  max_region.mV[VX] );
+                        msg->addF32Fast(_PREHASH_North, max_region.mV[VY] );
+                }
+
+                msg->sendMessage(regionp->getHost());
+        }
+}
+
+void LLToolBrushLand::brush( void )
+{
+        LLVector3d spot;
+        if( gViewerWindow->mousePointOnLandGlobal( mMouseX, mMouseY, &spot ) )
+        {
+                // Round to nearest X,Y grid
+                spot.mdV[VX] = floor( spot.mdV[VX] + 0.5 );
+                spot.mdV[VY] = floor( spot.mdV[VY] + 0.5 );
+
+                modifyLandAtPointGlobal(spot, gKeyboard->currentMask(TRUE));
+        }
+}
+
+BOOL LLToolBrushLand::handleMouseDown(S32 x, S32 y, MASK mask)
+{
+        BOOL handled = FALSE;
+
+        // Find the z value of the initial click. 
+        LLVector3d spot;
+        if( gViewerWindow->mousePointOnLandGlobal( x, y, &spot ) )
+        {
+                // Round to nearest X,Y grid
+                spot.mdV[VX] = floor( spot.mdV[VX] + 0.5 );
+                spot.mdV[VY] = floor( spot.mdV[VY] + 0.5 );
+
+                LLRegionPosition region_position( spot );
+                LLViewerRegion* regionp = region_position.getRegion();
+
+                if (!canTerraform(regionp))
+                {
+                        alertNoTerraform(regionp);
+                        return TRUE;
+                }
+
+                LLVector3 pos_region = region_position.getPositionRegion();
+                U32 grids = regionp->getLand().mGridsPerEdge;
+                S32 i = llclamp( (S32)pos_region.mV[VX], 0, (S32)grids );
+                S32 j = llclamp( (S32)pos_region.mV[VY], 0, (S32)grids );
+                mStartingZ = regionp->getLand().getZ(i+j*grids);
+                mMouseX = x;
+                mMouseY = y;
+                gIdleCallbacks.addFunction( &LLToolBrushLand::onIdle, (void*)this );
+                setMouseCapture( TRUE );
+
+                gParcelMgr->setSelectionVisible(FALSE);
+                handled = TRUE;
+        }
+
+        return handled;
+}
+
+BOOL LLToolBrushLand::handleHover( S32 x, S32 y, MASK mask )
+{
+        lldebugst(LLERR_USER_INPUT) << "hover handled by LLToolBrushLand ("
+                                                                << (hasMouseCapture() ? "active":"inactive")
+                                                                << ")" << llendl;
+        mMouseX = x;
+        mMouseY = y;
+        mGotHover = TRUE;
+        gViewerWindow->getWindow()->setCursor(UI_CURSOR_TOOLLAND);
+        return TRUE;
+}
+
+BOOL LLToolBrushLand::handleMouseUp(S32 x, S32 y, MASK mask)
+{
+        BOOL handled = FALSE;
+        mLastAffectedRegions.removeAllNodes();
+        if( hasMouseCapture() )
+        {
+                // Release the mouse
+                setMouseCapture( FALSE );
+
+                gParcelMgr->setSelectionVisible(TRUE);
+
+                gIdleCallbacks.deleteFunction( &LLToolBrushLand::onIdle, (void*)this );
+                handled = TRUE;
+        }
+
+        return handled;
+}
+
+void LLToolBrushLand::handleSelect()
+{
+        gEditMenuHandler = this;
+
+        gFloaterTools->setStatusText("Click and hold to modify land");
+//      if (!mBrushSelected)
+        {
+                mLastShowParcelOwners = gSavedSettings.getBOOL("ShowParcelOwners");
+                gSavedSettings.setBOOL("ShowParcelOwners", TRUE);
+                mBrushSelected = TRUE;
+        }
+}
+
+
+void LLToolBrushLand::handleDeselect()
+{
+        if( gEditMenuHandler == this )
+        {
+                gEditMenuHandler = NULL;
+        }
+        gFloaterTools->setStatusText("");
+        gSavedSettings.setBOOL("ShowParcelOwners", mLastShowParcelOwners);
+        gParcelMgr->setSelectionVisible(TRUE);
+        mBrushSelected = FALSE;
+}
+
+// Draw the area that will be affected.
+void LLToolBrushLand::render()
+{
+        if(mGotHover)
+        {
+                //llinfos << "LLToolBrushLand::render()" << llendl;
+                LLVector3d spot;
+                if(gViewerWindow->mousePointOnLandGlobal(mMouseX, mMouseY, &spot))
+                {
+                        spot.mdV[VX] = floor( spot.mdV[VX] + 0.5 );
+                        spot.mdV[VY] = floor( spot.mdV[VY] + 0.5 );
+
+                        mBrushIndex = gSavedSettings.getS32("RadioLandBrushSize");
+                        LLLinkedList<LLViewerRegion> regions;
+                        determineAffectedRegions(regions, spot);
+
+                        // Now, for each region, render the overlay
+                        LLVector3 pos_world = gAgent.getRegion()->getPosRegionFromGlobal(spot);
+                        for(LLViewerRegion* region = regions.getFirstData();
+                                region != NULL;
+                                region = regions.getNextData())
+                        {
+                                renderOverlay(region->getLand(), 
+                                                          region->getPosRegionFromGlobal(spot),
+                                                          pos_world);
+                        }
+                }
+                mGotHover = FALSE;
+        }
+}
+
+void LLToolBrushLand::renderOverlay(LLSurface& land, const LLVector3& pos_region,
+                                                                        const LLVector3& pos_world)
+{
+        glMatrixMode(GL_MODELVIEW);
+        LLGLSNoTexture gls_no_texture;
+        LLGLDepthTest mDepthTest(GL_TRUE);
+        glPushMatrix();
+        glColor4fv(OVERLAY_COLOR.mV);
+        glTranslatef(0.0f, 0.0f, 1.0f);
+        //glPushMatrix();
+        //glTranslatef(spot.mV[VX], spot.mV[VY], 100.0f);
+        //gl_rect_2d(0, 10, 10, 0);
+        //glPopMatrix();
+        S32 i = (S32) pos_region.mV[VX];
+        S32 j = (S32) pos_region.mV[VY];
+        S32 half_edge = llfloor(LAND_BRUSH_SIZE[mBrushIndex]);
+        //F32 dz = 0.0f;
+        //S32 dist = 0;
+        glBegin(GL_POINTS);
+        for(S32 di = -half_edge; di <= half_edge; di++)
+        {
+                if((i+di) < 0 || (i+di) >= (S32)land.mGridsPerEdge) continue;
+                for(S32 dj = -half_edge; dj <= half_edge; dj++)
+                {
+                        if( (j+dj) < 0 || (j+dj) >= (S32)land.mGridsPerEdge ) continue;
+                        glVertex3f(pos_world.mV[VX] + di, pos_world.mV[VY] + dj,
+                                           land.getZ((i+di)+(j+dj)*land.mGridsPerEdge));
+                }
+        }
+        glEnd();
+        glPopMatrix();
+}
+
+void LLToolBrushLand::determineAffectedRegions(LLLinkedList<LLViewerRegion>& regions,
+                                                                                           const LLVector3d& spot ) const
+{
+        LLVector3d corner(spot);
+        corner.mdV[VX] -= (LAND_BRUSH_SIZE[mBrushIndex] / 2);
+        corner.mdV[VY] -= (LAND_BRUSH_SIZE[mBrushIndex] / 2);
+        LLViewerRegion* region = NULL;
+        region = gWorldPointer->getRegionFromPosGlobal(corner);
+        if(region && !regions.checkData(region))
+        {
+                regions.addData(region);
+        }
+        corner.mdV[VY] += LAND_BRUSH_SIZE[mBrushIndex];
+        region = gWorldPointer->getRegionFromPosGlobal(corner);
+        if(region && !regions.checkData(region))
+        {
+                regions.addData(region);
+        }
+        corner.mdV[VX] += LAND_BRUSH_SIZE[mBrushIndex];
+        region = gWorldPointer->getRegionFromPosGlobal(corner);
+        if(region && !regions.checkData(region))
+        {
+                regions.addData(region);
+        }
+        corner.mdV[VY] -= LAND_BRUSH_SIZE[mBrushIndex];
+        region = gWorldPointer->getRegionFromPosGlobal(corner);
+        if(region && !regions.checkData(region))
+        {
+                regions.addData(region);
+        }
+}
+
+// static
+void LLToolBrushLand::onIdle( void* brush_tool )
+{
+        LLToolBrushLand* self = reinterpret_cast<LLToolBrushLand*>(brush_tool);
+
+        if( gToolMgr->getCurrentTool( gKeyboard->currentMask(TRUE) ) == self )
+        {
+                self->brush();
+        }
+        else
+        {
+                gIdleCallbacks.deleteFunction( &LLToolBrushLand::onIdle, self );
+        }
+}
+
+void LLToolBrushLand::onMouseCaptureLost()
+{
+        gIdleCallbacks.deleteFunction(&LLToolBrushLand::onIdle, this);
+}
+
+// static
+void LLToolBrushLand::undo()
+{
+        for(LLViewerRegion* regionp = mLastAffectedRegions.getFirstData();
+                        regionp != NULL;
+                        regionp = mLastAffectedRegions.getNextData())
+        {
+                gMessageSystem->newMessageFast(_PREHASH_UndoLand);
+                gMessageSystem->nextBlockFast(_PREHASH_AgentData);
+                gMessageSystem->addUUIDFast(_PREHASH_AgentID, gAgent.getID() );
+                gMessageSystem->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
+                gMessageSystem->sendMessage(regionp->getHost());
+        }
+}
+
+// static
+void LLToolBrushLand::redo()
+{
+        for(LLViewerRegion* regionp = mLastAffectedRegions.getFirstData();
+                        regionp != NULL;
+                        regionp = mLastAffectedRegions.getNextData())
+        {
+                gMessageSystem->newMessageFast(_PREHASH_RedoLand);
+                gMessageSystem->nextBlockFast(_PREHASH_AgentData);
+                gMessageSystem->addUUIDFast(_PREHASH_AgentID, gAgent.getID() );
+                gMessageSystem->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
+                gMessageSystem->sendMessage(regionp->getHost());
+        }
+}
+
+// static
+bool LLToolBrushLand::canTerraform(LLViewerRegion* regionp) const
+{
+        if (!regionp) return false;
+        if (regionp->canManageEstate()) return true;
+        return !(regionp->getRegionFlags() & REGION_FLAGS_BLOCK_TERRAFORM);
+}
+
+// static
+void LLToolBrushLand::alertNoTerraform(LLViewerRegion* regionp)
+{
+        if (!regionp) return;
+        
+        LLStringBase<char>::format_map_t args;
+        args["[REGION]"] = regionp->getName();
+        gViewerWindow->alertXml("RegionNoTerraforming", args);
+
+}
+
+///============================================================================
+/// Local function definitions
+///============================================================================