1225 lines
39 KiB
C++
1225 lines
39 KiB
C++
/**
|
|
* @file llfloaterpathfindingconsole.cpp
|
|
* @author William Todd Stinson
|
|
* @brief "Pathfinding console" floater, allowing manipulation of the Havok AI pathfinding settings.
|
|
*
|
|
* $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 "llfloaterpathfindingconsole.h"
|
|
#include "llfloaterpathfindinglinksets.h"
|
|
#include "llfloaterpathfindingcharacters.h"
|
|
|
|
#include "llsd.h"
|
|
#include "llhandle.h"
|
|
#include "llcontrol.h"
|
|
#include "llpanel.h"
|
|
#include "llbutton.h"
|
|
#include "llcheckboxctrl.h"
|
|
#include "llsliderctrl.h"
|
|
#include "lllineeditor.h"
|
|
#include "lltextbase.h"
|
|
#include "lltabcontainer.h"
|
|
#include "llcombobox.h"
|
|
#include "llfloaterreg.h"
|
|
#include "llpathfindingnavmeshzone.h"
|
|
#include "llpathfindingmanager.h"
|
|
#include "llenvmanager.h"
|
|
#include "llpathfindingpathtool.h"
|
|
#include "lltoolmgr.h"
|
|
#include "lltoolfocus.h"
|
|
#include "pipeline.h"
|
|
#include "llpathinglib.h"
|
|
#include "llviewerparcelmgr.h"
|
|
|
|
#define XUI_RENDER_HEATMAP_NONE 0
|
|
#define XUI_RENDER_HEATMAP_A 1
|
|
#define XUI_RENDER_HEATMAP_B 2
|
|
#define XUI_RENDER_HEATMAP_C 3
|
|
#define XUI_RENDER_HEATMAP_D 4
|
|
|
|
#define XUI_CHARACTER_TYPE_NONE 0
|
|
#define XUI_CHARACTER_TYPE_A 1
|
|
#define XUI_CHARACTER_TYPE_B 2
|
|
#define XUI_CHARACTER_TYPE_C 3
|
|
#define XUI_CHARACTER_TYPE_D 4
|
|
|
|
#define SET_SHAPE_RENDER_FLAG(_flag,_type) _flag |= (1U << _type)
|
|
|
|
#define CONTROL_NAME_RETRIEVE_NEIGHBOR "RetrieveNeighboringRegion"
|
|
#define CONTROL_NAME_WALKABLE_OBJECTS "PathfindingWalkable"
|
|
#define CONTROL_NAME_STATIC_OBSTACLE_OBJECTS "PathfindingObstacle"
|
|
#define CONTROL_NAME_MATERIAL_VOLUMES "PathfindingMaterial"
|
|
#define CONTROL_NAME_EXCLUSION_VOLUMES "PathfindingExclusion"
|
|
#define CONTROL_NAME_INTERIOR_EDGE "PathfindingConnectedEdge"
|
|
#define CONTROL_NAME_EXTERIOR_EDGE "PathfindingBoundaryEdge"
|
|
#define CONTROL_NAME_HEATMAP_MIN "PathfindingHeatColorBase"
|
|
#define CONTROL_NAME_HEATMAP_MAX "PathfindingHeatColorMax"
|
|
#define CONTROL_NAME_NAVMESH_FACE "PathfindingFaceColor"
|
|
#define CONTROL_NAME_TEST_PATH_VALID_END "PathfindingStarValidColor"
|
|
#define CONTROL_NAME_TEST_PATH_INVALID_END "PathfindingStarInvalidColor"
|
|
#define CONTROL_NAME_TEST_PATH "PathfindingTestPathColor"
|
|
#define CONTROL_NAME_WATER "PathfindingWaterColor"
|
|
|
|
LLHandle<LLFloaterPathfindingConsole> LLFloaterPathfindingConsole::sInstanceHandle;
|
|
|
|
extern LLPipeline gPipeline;
|
|
|
|
//---------------------------------------------------------------------------
|
|
// LLFloaterPathfindingConsole
|
|
//---------------------------------------------------------------------------
|
|
|
|
BOOL LLFloaterPathfindingConsole::postBuild()
|
|
{
|
|
mShowLabel = findChild<LLTextBase>("show_label");
|
|
llassert(mShowLabel != NULL);
|
|
|
|
mShowWorldCheckBox = findChild<LLCheckBoxCtrl>("show_world");
|
|
llassert(mShowWorldCheckBox != NULL);
|
|
mShowWorldCheckBox->setCommitCallback(boost::bind(&LLFloaterPathfindingConsole::onShowWorldSet, this));
|
|
|
|
mShowWorldMovablesOnlyCheckBox = findChild<LLCheckBoxCtrl>("show_world_movables_only");
|
|
llassert(mShowWorldMovablesOnlyCheckBox != NULL);
|
|
mShowWorldMovablesOnlyCheckBox->setCommitCallback(boost::bind(&LLFloaterPathfindingConsole::onShowWorldMovablesOnlySet, this));
|
|
|
|
mShowNavMeshCheckBox = findChild<LLCheckBoxCtrl>("show_navmesh");
|
|
llassert(mShowNavMeshCheckBox != NULL);
|
|
mShowNavMeshCheckBox->setCommitCallback(boost::bind(&LLFloaterPathfindingConsole::onShowNavMeshSet, this));
|
|
|
|
mShowNavMeshWalkabilityLabel = findChild<LLTextBase>("show_walkability_label");
|
|
llassert(mShowNavMeshWalkabilityLabel != NULL);
|
|
|
|
mShowNavMeshWalkabilityComboBox = findChild<LLComboBox>("show_heatmap_mode");
|
|
llassert(mShowNavMeshWalkabilityComboBox != NULL);
|
|
mShowNavMeshWalkabilityComboBox->setCommitCallback(boost::bind(&LLFloaterPathfindingConsole::onShowWalkabilitySet, this));
|
|
|
|
mShowWalkablesCheckBox = findChild<LLCheckBoxCtrl>("show_walkables");
|
|
llassert(mShowWalkablesCheckBox != NULL);
|
|
|
|
mShowStaticObstaclesCheckBox = findChild<LLCheckBoxCtrl>("show_static_obstacles");
|
|
llassert(mShowStaticObstaclesCheckBox != NULL);
|
|
|
|
mShowMaterialVolumesCheckBox = findChild<LLCheckBoxCtrl>("show_material_volumes");
|
|
llassert(mShowMaterialVolumesCheckBox != NULL);
|
|
|
|
mShowExclusionVolumesCheckBox = findChild<LLCheckBoxCtrl>("show_exclusion_volumes");
|
|
llassert(mShowExclusionVolumesCheckBox != NULL);
|
|
|
|
mShowRenderWaterPlaneCheckBox = findChild<LLCheckBoxCtrl>("show_water_plane");
|
|
llassert(mShowRenderWaterPlaneCheckBox != NULL);
|
|
|
|
mShowXRayCheckBox = findChild<LLCheckBoxCtrl>("show_xray");
|
|
llassert(mShowXRayCheckBox != NULL);
|
|
|
|
mViewCharactersButton = findChild<LLButton>("view_characters_floater");
|
|
llassert(mViewCharactersButton != NULL);
|
|
mViewCharactersButton->setCommitCallback(boost::bind(&LLFloaterPathfindingConsole::onViewCharactersClicked, this));
|
|
|
|
mTestTab = findChild<LLPanel>("test_panel");
|
|
llassert(mTestTab != NULL);
|
|
|
|
mPathfindingViewerStatus = findChild<LLTextBase>("pathfinding_viewer_status");
|
|
llassert(mPathfindingViewerStatus != NULL);
|
|
|
|
mPathfindingSimulatorStatus = findChild<LLTextBase>("pathfinding_simulator_status");
|
|
llassert(mPathfindingSimulatorStatus != NULL);
|
|
|
|
mCtrlClickLabel = findChild<LLTextBase>("ctrl_click_label");
|
|
llassert(mCtrlClickLabel != NULL);
|
|
|
|
mShiftClickLabel = findChild<LLTextBase>("shift_click_label");
|
|
llassert(mShiftClickLabel != NULL);
|
|
|
|
mCharacterWidthLabel = findChild<LLTextBase>("character_width_label");
|
|
llassert(mCharacterWidthLabel != NULL);
|
|
|
|
mCharacterWidthSlider = findChild<LLSliderCtrl>("character_width");
|
|
llassert(mCharacterWidthSlider != NULL);
|
|
mCharacterWidthSlider->setCommitCallback(boost::bind(&LLFloaterPathfindingConsole::onCharacterWidthSet, this));
|
|
|
|
mCharacterWidthUnitLabel = findChild<LLTextBase>("character_width_unit_label");
|
|
llassert(mCharacterWidthUnitLabel != NULL);
|
|
|
|
mCharacterTypeLabel = findChild<LLTextBase>("character_type_label");
|
|
llassert(mCharacterTypeLabel != NULL);
|
|
|
|
mCharacterTypeComboBox = findChild<LLComboBox>("path_character_type");
|
|
llassert(mCharacterTypeComboBox != NULL);
|
|
mCharacterTypeComboBox->setCommitCallback(boost::bind(&LLFloaterPathfindingConsole::onCharacterTypeSwitch, this));
|
|
|
|
mPathTestingStatus = findChild<LLTextBase>("path_test_status");
|
|
llassert(mPathTestingStatus != NULL);
|
|
|
|
mClearPathButton = findChild<LLButton>("clear_path");
|
|
llassert(mClearPathButton != NULL);
|
|
mClearPathButton->setCommitCallback(boost::bind(&LLFloaterPathfindingConsole::onClearPathClicked, this));
|
|
|
|
if (LLPathingLib::getInstance() != NULL)
|
|
{
|
|
mPathfindingToolset = new LLToolset();
|
|
mPathfindingToolset->addTool(LLPathfindingPathTool::getInstance());
|
|
mPathfindingToolset->addTool(LLToolCamera::getInstance());
|
|
mPathfindingToolset->setShowFloaterTools(false);
|
|
}
|
|
|
|
updateCharacterWidth();
|
|
updateCharacterType();
|
|
|
|
return LLFloater::postBuild();
|
|
}
|
|
|
|
void LLFloaterPathfindingConsole::onOpen(const LLSD& pKey)
|
|
{
|
|
LLFloater::onOpen(pKey);
|
|
//make sure we have a pathing system
|
|
if ( LLPathingLib::getInstance() == NULL )
|
|
{
|
|
setConsoleState(kConsoleStateLibraryNotImplemented);
|
|
llwarns <<"Errror: cannot find pathing library implementation."<<llendl;
|
|
}
|
|
else
|
|
{
|
|
if (!mNavMeshZoneSlot.connected())
|
|
{
|
|
mNavMeshZoneSlot = mNavMeshZone.registerNavMeshZoneListener(boost::bind(&LLFloaterPathfindingConsole::onNavMeshZoneCB, this, _1));
|
|
}
|
|
|
|
mIsNavMeshUpdating = false;
|
|
initializeNavMeshZoneForCurrentRegion();
|
|
registerSavedSettingsListeners();
|
|
fillInColorsForNavMeshVisualization();
|
|
}
|
|
|
|
if (!mRegionBoundarySlot.connected())
|
|
{
|
|
mRegionBoundarySlot = LLEnvManagerNew::instance().setRegionChangeCallback(boost::bind(&LLFloaterPathfindingConsole::onRegionBoundaryCross, this));
|
|
}
|
|
|
|
if (!mTeleportFailedSlot.connected())
|
|
{
|
|
mTeleportFailedSlot = LLViewerParcelMgr::getInstance()->setTeleportFailedCallback(boost::bind(&LLFloaterPathfindingConsole::onRegionBoundaryCross, this));
|
|
}
|
|
|
|
if (!mPathEventSlot.connected())
|
|
{
|
|
mPathEventSlot = LLPathfindingPathTool::getInstance()->registerPathEventListener(boost::bind(&LLFloaterPathfindingConsole::onPathEvent, this));
|
|
}
|
|
|
|
setDefaultInputs();
|
|
updatePathTestStatus();
|
|
|
|
switchIntoTestPathMode();
|
|
}
|
|
|
|
void LLFloaterPathfindingConsole::onClose(bool pIsAppQuitting)
|
|
{
|
|
switchOutOfTestPathMode();
|
|
|
|
if (mPathEventSlot.connected())
|
|
{
|
|
mPathEventSlot.disconnect();
|
|
}
|
|
|
|
if (mTeleportFailedSlot.connected())
|
|
{
|
|
mTeleportFailedSlot.disconnect();
|
|
}
|
|
|
|
if (mRegionBoundarySlot.connected())
|
|
{
|
|
mRegionBoundarySlot.disconnect();
|
|
}
|
|
|
|
if (mNavMeshZoneSlot.connected())
|
|
{
|
|
mNavMeshZoneSlot.disconnect();
|
|
}
|
|
|
|
if (LLPathingLib::getInstance() != NULL)
|
|
{
|
|
mNavMeshZone.disable();
|
|
}
|
|
deregisterSavedSettingsListeners();
|
|
|
|
setDefaultInputs();
|
|
setConsoleState(kConsoleStateUnknown);
|
|
cleanupRenderableRestoreItems();
|
|
LLFloater::onClose(pIsAppQuitting);
|
|
}
|
|
|
|
LLHandle<LLFloaterPathfindingConsole> LLFloaterPathfindingConsole::getInstanceHandle()
|
|
{
|
|
if (sInstanceHandle.isDead())
|
|
{
|
|
LLFloaterPathfindingConsole *floaterInstance = LLFloaterReg::getTypedInstance<LLFloaterPathfindingConsole>("pathfinding_console");
|
|
if (floaterInstance != NULL)
|
|
{
|
|
sInstanceHandle = floaterInstance->mSelfHandle;
|
|
}
|
|
}
|
|
|
|
return sInstanceHandle;
|
|
}
|
|
|
|
BOOL LLFloaterPathfindingConsole::isRenderNavMesh() const
|
|
{
|
|
return mShowNavMeshCheckBox->get();
|
|
}
|
|
|
|
void LLFloaterPathfindingConsole::setRenderNavMesh(BOOL pIsRenderNavMesh)
|
|
{
|
|
mShowNavMeshCheckBox->set(pIsRenderNavMesh);
|
|
setNavMeshRenderState();
|
|
}
|
|
|
|
BOOL LLFloaterPathfindingConsole::isRenderWalkables() const
|
|
{
|
|
return mShowWalkablesCheckBox->get();
|
|
}
|
|
|
|
void LLFloaterPathfindingConsole::setRenderWalkables(BOOL pIsRenderWalkables)
|
|
{
|
|
mShowWalkablesCheckBox->set(pIsRenderWalkables);
|
|
}
|
|
|
|
BOOL LLFloaterPathfindingConsole::isRenderStaticObstacles() const
|
|
{
|
|
return mShowStaticObstaclesCheckBox->get();
|
|
}
|
|
|
|
void LLFloaterPathfindingConsole::setRenderStaticObstacles(BOOL pIsRenderStaticObstacles)
|
|
{
|
|
mShowStaticObstaclesCheckBox->set(pIsRenderStaticObstacles);
|
|
}
|
|
|
|
BOOL LLFloaterPathfindingConsole::isRenderMaterialVolumes() const
|
|
{
|
|
return mShowMaterialVolumesCheckBox->get();
|
|
}
|
|
|
|
void LLFloaterPathfindingConsole::setRenderMaterialVolumes(BOOL pIsRenderMaterialVolumes)
|
|
{
|
|
mShowMaterialVolumesCheckBox->set(pIsRenderMaterialVolumes);
|
|
}
|
|
|
|
BOOL LLFloaterPathfindingConsole::isRenderExclusionVolumes() const
|
|
{
|
|
return mShowExclusionVolumesCheckBox->get();
|
|
}
|
|
|
|
void LLFloaterPathfindingConsole::setRenderExclusionVolumes(BOOL pIsRenderExclusionVolumes)
|
|
{
|
|
mShowExclusionVolumesCheckBox->set(pIsRenderExclusionVolumes);
|
|
}
|
|
|
|
BOOL LLFloaterPathfindingConsole::isRenderWorld() const
|
|
{
|
|
return mShowWorldCheckBox->get();
|
|
}
|
|
|
|
void LLFloaterPathfindingConsole::setRenderWorld(BOOL pIsRenderWorld)
|
|
{
|
|
mShowWorldCheckBox->set(pIsRenderWorld);
|
|
setWorldRenderState();
|
|
}
|
|
|
|
BOOL LLFloaterPathfindingConsole::isRenderWorldMovablesOnly() const
|
|
{
|
|
return (mShowWorldCheckBox->get() && mShowWorldMovablesOnlyCheckBox->get());
|
|
}
|
|
|
|
void LLFloaterPathfindingConsole::setRenderWorldMovablesOnly(BOOL pIsRenderWorldMovablesOnly)
|
|
{
|
|
mShowWorldMovablesOnlyCheckBox->set(pIsRenderWorldMovablesOnly);
|
|
}
|
|
|
|
BOOL LLFloaterPathfindingConsole::isRenderWaterPlane() const
|
|
{
|
|
return mShowRenderWaterPlaneCheckBox->get();
|
|
}
|
|
|
|
void LLFloaterPathfindingConsole::setRenderWaterPlane(BOOL pIsRenderWaterPlane)
|
|
{
|
|
mShowRenderWaterPlaneCheckBox->set(pIsRenderWaterPlane);
|
|
}
|
|
|
|
BOOL LLFloaterPathfindingConsole::isRenderXRay() const
|
|
{
|
|
return mShowXRayCheckBox->get();
|
|
}
|
|
|
|
void LLFloaterPathfindingConsole::setRenderXRay(BOOL pIsRenderXRay)
|
|
{
|
|
mShowXRayCheckBox->set(pIsRenderXRay);
|
|
}
|
|
|
|
LLPathingLib::LLPLCharacterType LLFloaterPathfindingConsole::getRenderHeatmapType() const
|
|
{
|
|
LLPathingLib::LLPLCharacterType renderHeatmapType;
|
|
|
|
switch (mShowNavMeshWalkabilityComboBox->getValue().asInteger())
|
|
{
|
|
case XUI_RENDER_HEATMAP_NONE :
|
|
renderHeatmapType = LLPathingLib::LLPL_CHARACTER_TYPE_NONE;
|
|
break;
|
|
case XUI_RENDER_HEATMAP_A :
|
|
renderHeatmapType = LLPathingLib::LLPL_CHARACTER_TYPE_A;
|
|
break;
|
|
case XUI_RENDER_HEATMAP_B :
|
|
renderHeatmapType = LLPathingLib::LLPL_CHARACTER_TYPE_B;
|
|
break;
|
|
case XUI_RENDER_HEATMAP_C :
|
|
renderHeatmapType = LLPathingLib::LLPL_CHARACTER_TYPE_C;
|
|
break;
|
|
case XUI_RENDER_HEATMAP_D :
|
|
renderHeatmapType = LLPathingLib::LLPL_CHARACTER_TYPE_D;
|
|
break;
|
|
default :
|
|
renderHeatmapType = LLPathingLib::LLPL_CHARACTER_TYPE_NONE;
|
|
llassert(0);
|
|
break;
|
|
}
|
|
|
|
return renderHeatmapType;
|
|
}
|
|
|
|
void LLFloaterPathfindingConsole::setRenderHeatmapType(LLPathingLib::LLPLCharacterType pRenderHeatmapType)
|
|
{
|
|
LLSD comboBoxValue;
|
|
|
|
switch (pRenderHeatmapType)
|
|
{
|
|
case LLPathingLib::LLPL_CHARACTER_TYPE_NONE :
|
|
comboBoxValue = XUI_RENDER_HEATMAP_NONE;
|
|
break;
|
|
case LLPathingLib::LLPL_CHARACTER_TYPE_A :
|
|
comboBoxValue = XUI_RENDER_HEATMAP_A;
|
|
break;
|
|
case LLPathingLib::LLPL_CHARACTER_TYPE_B :
|
|
comboBoxValue = XUI_RENDER_HEATMAP_B;
|
|
break;
|
|
case LLPathingLib::LLPL_CHARACTER_TYPE_C :
|
|
comboBoxValue = XUI_RENDER_HEATMAP_C;
|
|
break;
|
|
case LLPathingLib::LLPL_CHARACTER_TYPE_D :
|
|
comboBoxValue = XUI_RENDER_HEATMAP_D;
|
|
break;
|
|
default :
|
|
comboBoxValue = XUI_RENDER_HEATMAP_NONE;
|
|
llassert(0);
|
|
break;
|
|
}
|
|
|
|
mShowNavMeshWalkabilityComboBox->setValue(comboBoxValue);
|
|
}
|
|
|
|
LLFloaterPathfindingConsole::LLFloaterPathfindingConsole(const LLSD& pSeed)
|
|
: LLFloater(pSeed),
|
|
mSelfHandle(),
|
|
mShowLabel(),
|
|
mShowWorldCheckBox(NULL),
|
|
mShowWorldMovablesOnlyCheckBox(NULL),
|
|
mShowNavMeshCheckBox(NULL),
|
|
mShowNavMeshWalkabilityLabel(),
|
|
mShowNavMeshWalkabilityComboBox(NULL),
|
|
mShowWalkablesCheckBox(NULL),
|
|
mShowStaticObstaclesCheckBox(NULL),
|
|
mShowMaterialVolumesCheckBox(NULL),
|
|
mShowExclusionVolumesCheckBox(NULL),
|
|
mShowRenderWaterPlaneCheckBox(NULL),
|
|
mShowXRayCheckBox(NULL),
|
|
mPathfindingViewerStatus(NULL),
|
|
mPathfindingSimulatorStatus(NULL),
|
|
mViewCharactersButton(NULL),
|
|
mTestTab(NULL),
|
|
mCtrlClickLabel(),
|
|
mShiftClickLabel(),
|
|
mCharacterWidthLabel(),
|
|
mCharacterWidthUnitLabel(),
|
|
mCharacterWidthSlider(NULL),
|
|
mCharacterTypeLabel(),
|
|
mCharacterTypeComboBox(NULL),
|
|
mPathTestingStatus(NULL),
|
|
mClearPathButton(NULL),
|
|
mNavMeshZoneSlot(),
|
|
mNavMeshZone(),
|
|
mIsNavMeshUpdating(false),
|
|
mRegionBoundarySlot(),
|
|
mTeleportFailedSlot(),
|
|
mPathEventSlot(),
|
|
mPathfindingToolset(NULL),
|
|
mSavedToolset(NULL),
|
|
mSavedSettingRetrieveNeighborSlot(),
|
|
mSavedSettingWalkableSlot(),
|
|
mSavedSettingStaticObstacleSlot(),
|
|
mSavedSettingMaterialVolumeSlot(),
|
|
mSavedSettingExclusionVolumeSlot(),
|
|
mSavedSettingInteriorEdgeSlot(),
|
|
mSavedSettingExteriorEdgeSlot(),
|
|
mSavedSettingHeatmapMinSlot(),
|
|
mSavedSettingHeatmapMaxSlot(),
|
|
mSavedSettingNavMeshFaceSlot(),
|
|
mSavedSettingTestPathValidEndSlot(),
|
|
mSavedSettingTestPathInvalidEndSlot(),
|
|
mSavedSettingWaterSlot(),
|
|
mSavedSettingTestPathSlot(),
|
|
mConsoleState(kConsoleStateUnknown)
|
|
{
|
|
mSelfHandle.bind(this);
|
|
}
|
|
|
|
LLFloaterPathfindingConsole::~LLFloaterPathfindingConsole()
|
|
{
|
|
}
|
|
|
|
void LLFloaterPathfindingConsole::onShowWorldSet()
|
|
{
|
|
setWorldRenderState();
|
|
updateRenderablesObjects();
|
|
}
|
|
|
|
void LLFloaterPathfindingConsole::onShowWorldMovablesOnlySet()
|
|
{
|
|
updateRenderablesObjects();
|
|
}
|
|
|
|
void LLFloaterPathfindingConsole::onShowNavMeshSet()
|
|
{
|
|
setNavMeshRenderState();
|
|
}
|
|
|
|
void LLFloaterPathfindingConsole::onShowWalkabilitySet()
|
|
{
|
|
LLPathingLib::getInstance()->setNavMeshMaterialType(getRenderHeatmapType());
|
|
}
|
|
|
|
void LLFloaterPathfindingConsole::onViewCharactersClicked()
|
|
{
|
|
LLFloaterPathfindingCharacters::openCharactersViewer();
|
|
}
|
|
|
|
void LLFloaterPathfindingConsole::onCharacterWidthSet()
|
|
{
|
|
updateCharacterWidth();
|
|
}
|
|
|
|
void LLFloaterPathfindingConsole::onCharacterTypeSwitch()
|
|
{
|
|
updateCharacterType();
|
|
}
|
|
|
|
void LLFloaterPathfindingConsole::onClearPathClicked()
|
|
{
|
|
clearPath();
|
|
}
|
|
|
|
void LLFloaterPathfindingConsole::onNavMeshZoneCB(LLPathfindingNavMeshZone::ENavMeshZoneRequestStatus pNavMeshZoneRequestStatus)
|
|
{
|
|
switch (pNavMeshZoneRequestStatus)
|
|
{
|
|
case LLPathfindingNavMeshZone::kNavMeshZoneRequestUnknown :
|
|
setConsoleState(kConsoleStateUnknown);
|
|
break;
|
|
case LLPathfindingNavMeshZone::kNavMeshZoneRequestWaiting :
|
|
setConsoleState(kConsoleStateRegionLoading);
|
|
break;
|
|
case LLPathfindingNavMeshZone::kNavMeshZoneRequestChecking :
|
|
setConsoleState(kConsoleStateCheckingVersion);
|
|
break;
|
|
case LLPathfindingNavMeshZone::kNavMeshZoneRequestNeedsUpdate :
|
|
mIsNavMeshUpdating = true;
|
|
mNavMeshZone.refresh();
|
|
break;
|
|
case LLPathfindingNavMeshZone::kNavMeshZoneRequestStarted :
|
|
setConsoleState(kConsoleStateDownloading);
|
|
break;
|
|
case LLPathfindingNavMeshZone::kNavMeshZoneRequestCompleted :
|
|
mIsNavMeshUpdating = false;
|
|
setConsoleState(kConsoleStateHasNavMesh);
|
|
break;
|
|
case LLPathfindingNavMeshZone::kNavMeshZoneRequestNotEnabled :
|
|
setConsoleState(kConsoleStateRegionNotEnabled);
|
|
break;
|
|
case LLPathfindingNavMeshZone::kNavMeshZoneRequestError :
|
|
setConsoleState(kConsoleStateError);
|
|
break;
|
|
default:
|
|
setConsoleState(kConsoleStateUnknown);
|
|
llassert(0);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void LLFloaterPathfindingConsole::onRegionBoundaryCross()
|
|
{
|
|
initializeNavMeshZoneForCurrentRegion();
|
|
setRenderWorld(TRUE);
|
|
setRenderWorldMovablesOnly(FALSE);
|
|
}
|
|
|
|
void LLFloaterPathfindingConsole::onPathEvent()
|
|
{
|
|
const LLPathfindingPathTool *pathToolInstance = LLPathfindingPathTool::getInstance();
|
|
|
|
mCharacterWidthSlider->setValue(LLSD(pathToolInstance->getCharacterWidth()));
|
|
|
|
LLSD characterType;
|
|
switch (pathToolInstance->getCharacterType())
|
|
{
|
|
case LLPathfindingPathTool::kCharacterTypeNone :
|
|
characterType = XUI_CHARACTER_TYPE_NONE;
|
|
break;
|
|
case LLPathfindingPathTool::kCharacterTypeA :
|
|
characterType = XUI_CHARACTER_TYPE_A;
|
|
break;
|
|
case LLPathfindingPathTool::kCharacterTypeB :
|
|
characterType = XUI_CHARACTER_TYPE_B;
|
|
break;
|
|
case LLPathfindingPathTool::kCharacterTypeC :
|
|
characterType = XUI_CHARACTER_TYPE_C;
|
|
break;
|
|
case LLPathfindingPathTool::kCharacterTypeD :
|
|
characterType = XUI_CHARACTER_TYPE_D;
|
|
break;
|
|
default :
|
|
characterType = XUI_CHARACTER_TYPE_NONE;
|
|
llassert(0);
|
|
break;
|
|
}
|
|
mCharacterTypeComboBox->setValue(characterType);
|
|
|
|
updatePathTestStatus();
|
|
}
|
|
|
|
void LLFloaterPathfindingConsole::setDefaultInputs()
|
|
{
|
|
setRenderWorld(TRUE);
|
|
setRenderNavMesh(FALSE);
|
|
setRenderWalkables(FALSE);
|
|
setRenderMaterialVolumes(FALSE);
|
|
setRenderStaticObstacles(FALSE);
|
|
setRenderExclusionVolumes(FALSE);
|
|
setRenderWaterPlane(FALSE);
|
|
setRenderXRay(FALSE);
|
|
setRenderWorldMovablesOnly(FALSE);
|
|
}
|
|
|
|
void LLFloaterPathfindingConsole::setConsoleState(EConsoleState pConsoleState)
|
|
{
|
|
mConsoleState = pConsoleState;
|
|
updateControlsOnConsoleState();
|
|
updateStatusOnConsoleState();
|
|
}
|
|
|
|
void LLFloaterPathfindingConsole::setWorldRenderState()
|
|
{
|
|
BOOL renderWorld = isRenderWorld();
|
|
|
|
mShowWorldMovablesOnlyCheckBox->setEnabled(renderWorld);
|
|
if (!renderWorld)
|
|
{
|
|
mShowWorldMovablesOnlyCheckBox->set(FALSE);
|
|
}
|
|
}
|
|
|
|
void LLFloaterPathfindingConsole::setNavMeshRenderState()
|
|
{
|
|
BOOL renderNavMesh = isRenderNavMesh();
|
|
|
|
mShowNavMeshWalkabilityLabel->setEnabled(renderNavMesh);
|
|
mShowNavMeshWalkabilityComboBox->setEnabled(renderNavMesh);
|
|
}
|
|
|
|
void LLFloaterPathfindingConsole::updateRenderablesObjects()
|
|
{
|
|
if ( isRenderWorldMovablesOnly() )
|
|
{
|
|
gPipeline.hidePermanentObjects( mRenderableRestoreList );
|
|
}
|
|
else
|
|
{
|
|
cleanupRenderableRestoreItems();
|
|
}
|
|
}
|
|
|
|
void LLFloaterPathfindingConsole::updateControlsOnConsoleState()
|
|
{
|
|
switch (mConsoleState)
|
|
{
|
|
case kConsoleStateUnknown :
|
|
case kConsoleStateRegionNotEnabled :
|
|
case kConsoleStateRegionLoading :
|
|
mShowLabel->setEnabled(FALSE);
|
|
mShowWorldCheckBox->setEnabled(FALSE);
|
|
mShowWorldMovablesOnlyCheckBox->setEnabled(FALSE);
|
|
mShowNavMeshCheckBox->setEnabled(FALSE);
|
|
mShowNavMeshWalkabilityLabel->setEnabled(FALSE);
|
|
mShowNavMeshWalkabilityComboBox->setEnabled(FALSE);
|
|
mShowWalkablesCheckBox->setEnabled(FALSE);
|
|
mShowStaticObstaclesCheckBox->setEnabled(FALSE);
|
|
mShowMaterialVolumesCheckBox->setEnabled(FALSE);
|
|
mShowExclusionVolumesCheckBox->setEnabled(FALSE);
|
|
mShowRenderWaterPlaneCheckBox->setEnabled(FALSE);
|
|
mShowXRayCheckBox->setEnabled(FALSE);
|
|
mViewCharactersButton->setEnabled(FALSE);
|
|
mTestTab->setEnabled(FALSE);
|
|
mCtrlClickLabel->setEnabled(FALSE);
|
|
mShiftClickLabel->setEnabled(FALSE);
|
|
mCharacterWidthLabel->setEnabled(FALSE);
|
|
mCharacterWidthUnitLabel->setEnabled(FALSE);
|
|
mCharacterWidthSlider->setEnabled(FALSE);
|
|
mCharacterTypeLabel->setEnabled(FALSE);
|
|
mCharacterTypeComboBox->setEnabled(FALSE);
|
|
mClearPathButton->setEnabled(FALSE);
|
|
clearPath();
|
|
break;
|
|
case kConsoleStateLibraryNotImplemented :
|
|
mShowLabel->setEnabled(FALSE);
|
|
mShowWorldCheckBox->setEnabled(FALSE);
|
|
mShowWorldMovablesOnlyCheckBox->setEnabled(FALSE);
|
|
mShowNavMeshCheckBox->setEnabled(FALSE);
|
|
mShowNavMeshWalkabilityLabel->setEnabled(FALSE);
|
|
mShowNavMeshWalkabilityComboBox->setEnabled(FALSE);
|
|
mShowWalkablesCheckBox->setEnabled(FALSE);
|
|
mShowStaticObstaclesCheckBox->setEnabled(FALSE);
|
|
mShowMaterialVolumesCheckBox->setEnabled(FALSE);
|
|
mShowExclusionVolumesCheckBox->setEnabled(FALSE);
|
|
mShowRenderWaterPlaneCheckBox->setEnabled(FALSE);
|
|
mShowXRayCheckBox->setEnabled(FALSE);
|
|
mViewCharactersButton->setEnabled(TRUE);
|
|
mTestTab->setEnabled(FALSE);
|
|
mCtrlClickLabel->setEnabled(FALSE);
|
|
mShiftClickLabel->setEnabled(FALSE);
|
|
mCharacterWidthLabel->setEnabled(FALSE);
|
|
mCharacterWidthUnitLabel->setEnabled(FALSE);
|
|
mCharacterWidthSlider->setEnabled(FALSE);
|
|
mCharacterTypeLabel->setEnabled(FALSE);
|
|
mCharacterTypeComboBox->setEnabled(FALSE);
|
|
mClearPathButton->setEnabled(FALSE);
|
|
clearPath();
|
|
break;
|
|
case kConsoleStateCheckingVersion :
|
|
case kConsoleStateDownloading :
|
|
case kConsoleStateError :
|
|
mShowLabel->setEnabled(FALSE);
|
|
mShowWorldCheckBox->setEnabled(FALSE);
|
|
mShowWorldMovablesOnlyCheckBox->setEnabled(FALSE);
|
|
mShowNavMeshCheckBox->setEnabled(FALSE);
|
|
mShowNavMeshWalkabilityLabel->setEnabled(FALSE);
|
|
mShowNavMeshWalkabilityComboBox->setEnabled(FALSE);
|
|
mShowWalkablesCheckBox->setEnabled(FALSE);
|
|
mShowStaticObstaclesCheckBox->setEnabled(FALSE);
|
|
mShowMaterialVolumesCheckBox->setEnabled(FALSE);
|
|
mShowExclusionVolumesCheckBox->setEnabled(FALSE);
|
|
mShowRenderWaterPlaneCheckBox->setEnabled(FALSE);
|
|
mShowXRayCheckBox->setEnabled(FALSE);
|
|
mViewCharactersButton->setEnabled(TRUE);
|
|
mTestTab->setEnabled(FALSE);
|
|
mCtrlClickLabel->setEnabled(FALSE);
|
|
mShiftClickLabel->setEnabled(FALSE);
|
|
mCharacterWidthLabel->setEnabled(FALSE);
|
|
mCharacterWidthUnitLabel->setEnabled(FALSE);
|
|
mCharacterWidthSlider->setEnabled(FALSE);
|
|
mCharacterTypeLabel->setEnabled(FALSE);
|
|
mCharacterTypeComboBox->setEnabled(FALSE);
|
|
mClearPathButton->setEnabled(FALSE);
|
|
clearPath();
|
|
break;
|
|
case kConsoleStateHasNavMesh :
|
|
mShowLabel->setEnabled(TRUE);
|
|
mShowWorldCheckBox->setEnabled(TRUE);
|
|
setWorldRenderState();
|
|
mShowNavMeshCheckBox->setEnabled(TRUE);
|
|
setNavMeshRenderState();
|
|
mShowWalkablesCheckBox->setEnabled(TRUE);
|
|
mShowStaticObstaclesCheckBox->setEnabled(TRUE);
|
|
mShowMaterialVolumesCheckBox->setEnabled(TRUE);
|
|
mShowExclusionVolumesCheckBox->setEnabled(TRUE);
|
|
mShowRenderWaterPlaneCheckBox->setEnabled(TRUE);
|
|
mShowXRayCheckBox->setEnabled(TRUE);
|
|
mViewCharactersButton->setEnabled(TRUE);
|
|
mTestTab->setEnabled(TRUE);
|
|
mCtrlClickLabel->setEnabled(TRUE);
|
|
mShiftClickLabel->setEnabled(TRUE);
|
|
mCharacterWidthLabel->setEnabled(TRUE);
|
|
mCharacterWidthUnitLabel->setEnabled(TRUE);
|
|
mCharacterWidthSlider->setEnabled(TRUE);
|
|
mCharacterTypeLabel->setEnabled(TRUE);
|
|
mCharacterTypeComboBox->setEnabled(TRUE);
|
|
mClearPathButton->setEnabled(TRUE);
|
|
break;
|
|
default :
|
|
llassert(0);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void LLFloaterPathfindingConsole::updateStatusOnConsoleState()
|
|
{
|
|
static const LLColor4 errorColor = LLUIColorTable::instance().getColor("PathfindingErrorColor");
|
|
static const LLColor4 warningColor = LLUIColorTable::instance().getColor("PathfindingWarningColor");
|
|
|
|
std::string simulatorStatusText("");
|
|
std::string viewerStatusText("");
|
|
LLStyle::Params viewerStyleParams;
|
|
|
|
switch (mConsoleState)
|
|
{
|
|
case kConsoleStateUnknown :
|
|
simulatorStatusText = getString("navmesh_simulator_status_unknown");
|
|
viewerStatusText = getString("navmesh_viewer_status_unknown");
|
|
viewerStyleParams.color = errorColor;
|
|
break;
|
|
case kConsoleStateLibraryNotImplemented :
|
|
simulatorStatusText = getString("navmesh_simulator_status_unknown");
|
|
viewerStatusText = getString("navmesh_viewer_status_library_not_implemented");
|
|
viewerStyleParams.color = errorColor;
|
|
break;
|
|
case kConsoleStateRegionNotEnabled :
|
|
simulatorStatusText = getString("navmesh_simulator_status_unknown");
|
|
viewerStatusText = getString("navmesh_viewer_status_region_not_enabled");
|
|
viewerStyleParams.color = errorColor;
|
|
break;
|
|
case kConsoleStateRegionLoading :
|
|
simulatorStatusText = getString("navmesh_simulator_status_unknown");
|
|
viewerStatusText = getString("navmesh_viewer_status_region_loading");
|
|
viewerStyleParams.color = warningColor;
|
|
break;
|
|
case kConsoleStateCheckingVersion :
|
|
simulatorStatusText = getString("navmesh_simulator_status_unknown");
|
|
viewerStatusText = getString("navmesh_viewer_status_checking_version");
|
|
viewerStyleParams.color = warningColor;
|
|
break;
|
|
case kConsoleStateDownloading :
|
|
simulatorStatusText = getSimulatorStatusText();
|
|
if (mIsNavMeshUpdating)
|
|
{
|
|
viewerStatusText = getString("navmesh_viewer_status_updating");
|
|
}
|
|
else
|
|
{
|
|
viewerStatusText = getString("navmesh_viewer_status_downloading");
|
|
}
|
|
viewerStyleParams.color = warningColor;
|
|
break;
|
|
case kConsoleStateHasNavMesh :
|
|
simulatorStatusText = getSimulatorStatusText();
|
|
viewerStatusText = getString("navmesh_viewer_status_has_navmesh");
|
|
break;
|
|
case kConsoleStateError :
|
|
simulatorStatusText = getString("navmesh_simulator_status_unknown");
|
|
viewerStatusText = getString("navmesh_viewer_status_error");
|
|
viewerStyleParams.color = errorColor;
|
|
break;
|
|
default :
|
|
simulatorStatusText = getString("navmesh_simulator_status_unknown");
|
|
viewerStatusText = getString("navmesh_viewer_status_unknown");
|
|
viewerStyleParams.color = errorColor;
|
|
llassert(0);
|
|
break;
|
|
}
|
|
|
|
mPathfindingViewerStatus->setText((LLStringExplicit)viewerStatusText, viewerStyleParams);
|
|
mPathfindingSimulatorStatus->setText((LLStringExplicit)simulatorStatusText);
|
|
}
|
|
|
|
std::string LLFloaterPathfindingConsole::getSimulatorStatusText() const
|
|
{
|
|
std::string simulatorStatusText("");
|
|
|
|
switch (mNavMeshZone.getNavMeshZoneStatus())
|
|
{
|
|
case LLPathfindingNavMeshZone::kNavMeshZonePending :
|
|
simulatorStatusText = getString("navmesh_simulator_status_pending");
|
|
break;
|
|
case LLPathfindingNavMeshZone::kNavMeshZoneBuilding :
|
|
simulatorStatusText = getString("navmesh_simulator_status_building");
|
|
break;
|
|
case LLPathfindingNavMeshZone::kNavMeshZoneSomePending :
|
|
simulatorStatusText = getString("navmesh_simulator_status_some_pending");
|
|
break;
|
|
case LLPathfindingNavMeshZone::kNavMeshZoneSomeBuilding :
|
|
simulatorStatusText = getString("navmesh_simulator_status_some_building");
|
|
break;
|
|
case LLPathfindingNavMeshZone::kNavMeshZonePendingAndBuilding :
|
|
simulatorStatusText = getString("navmesh_simulator_status_pending_and_building");
|
|
break;
|
|
case LLPathfindingNavMeshZone::kNavMeshZoneComplete :
|
|
simulatorStatusText = getString("navmesh_simulator_status_complete");
|
|
break;
|
|
default :
|
|
simulatorStatusText = getString("navmesh_simulator_status_unknown");
|
|
break;
|
|
}
|
|
|
|
return simulatorStatusText;
|
|
}
|
|
|
|
void LLFloaterPathfindingConsole::initializeNavMeshZoneForCurrentRegion()
|
|
{
|
|
mNavMeshZone.disable();
|
|
mNavMeshZone.initialize();
|
|
mNavMeshZone.enable();
|
|
mNavMeshZone.refresh();
|
|
cleanupRenderableRestoreItems();
|
|
}
|
|
|
|
void LLFloaterPathfindingConsole::cleanupRenderableRestoreItems()
|
|
{
|
|
if ( !mRenderableRestoreList.empty() )
|
|
{
|
|
gPipeline.restorePermanentObjects( mRenderableRestoreList );
|
|
mRenderableRestoreList.clear();
|
|
}
|
|
else
|
|
{
|
|
gPipeline.skipRenderingOfTerrain( false );
|
|
}
|
|
}
|
|
|
|
void LLFloaterPathfindingConsole::switchIntoTestPathMode()
|
|
{
|
|
if (LLPathingLib::getInstance() != NULL)
|
|
{
|
|
llassert(mPathfindingToolset != NULL);
|
|
LLToolMgr *toolMgrInstance = LLToolMgr::getInstance();
|
|
if (toolMgrInstance->getCurrentToolset() != mPathfindingToolset)
|
|
{
|
|
mSavedToolset = toolMgrInstance->getCurrentToolset();
|
|
toolMgrInstance->setCurrentToolset(mPathfindingToolset);
|
|
}
|
|
}
|
|
}
|
|
|
|
void LLFloaterPathfindingConsole::switchOutOfTestPathMode()
|
|
{
|
|
if (LLPathingLib::getInstance() != NULL)
|
|
{
|
|
llassert(mPathfindingToolset != NULL);
|
|
LLToolMgr *toolMgrInstance = LLToolMgr::getInstance();
|
|
if (toolMgrInstance->getCurrentToolset() == mPathfindingToolset)
|
|
{
|
|
toolMgrInstance->setCurrentToolset(mSavedToolset);
|
|
mSavedToolset = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
void LLFloaterPathfindingConsole::updateCharacterWidth()
|
|
{
|
|
LLPathfindingPathTool::getInstance()->setCharacterWidth(mCharacterWidthSlider->getValueF32());
|
|
}
|
|
|
|
void LLFloaterPathfindingConsole::updateCharacterType()
|
|
{
|
|
LLPathfindingPathTool::ECharacterType characterType;
|
|
|
|
switch (mCharacterTypeComboBox->getValue().asInteger())
|
|
{
|
|
case XUI_CHARACTER_TYPE_NONE :
|
|
characterType = LLPathfindingPathTool::kCharacterTypeNone;
|
|
break;
|
|
case XUI_CHARACTER_TYPE_A :
|
|
characterType = LLPathfindingPathTool::kCharacterTypeA;
|
|
break;
|
|
case XUI_CHARACTER_TYPE_B :
|
|
characterType = LLPathfindingPathTool::kCharacterTypeB;
|
|
break;
|
|
case XUI_CHARACTER_TYPE_C :
|
|
characterType = LLPathfindingPathTool::kCharacterTypeC;
|
|
break;
|
|
case XUI_CHARACTER_TYPE_D :
|
|
characterType = LLPathfindingPathTool::kCharacterTypeD;
|
|
break;
|
|
default :
|
|
characterType = LLPathfindingPathTool::kCharacterTypeNone;
|
|
llassert(0);
|
|
break;
|
|
}
|
|
|
|
LLPathfindingPathTool::getInstance()->setCharacterType(characterType);
|
|
}
|
|
|
|
void LLFloaterPathfindingConsole::clearPath()
|
|
{
|
|
LLPathfindingPathTool::getInstance()->clearPath();
|
|
}
|
|
|
|
void LLFloaterPathfindingConsole::updatePathTestStatus()
|
|
{
|
|
static const LLColor4 errorColor = LLUIColorTable::instance().getColor("PathfindingErrorColor");
|
|
static const LLColor4 warningColor = LLUIColorTable::instance().getColor("PathfindingWarningColor");
|
|
|
|
std::string statusText("");
|
|
LLStyle::Params styleParams;
|
|
|
|
switch (LLPathfindingPathTool::getInstance()->getPathStatus())
|
|
{
|
|
case LLPathfindingPathTool::kPathStatusUnknown :
|
|
statusText = getString("pathing_unknown");
|
|
styleParams.color = errorColor;
|
|
break;
|
|
case LLPathfindingPathTool::kPathStatusChooseStartAndEndPoints :
|
|
statusText = getString("pathing_choose_start_and_end_points");
|
|
styleParams.color = warningColor;
|
|
break;
|
|
case LLPathfindingPathTool::kPathStatusChooseStartPoint :
|
|
statusText = getString("pathing_choose_start_point");
|
|
styleParams.color = warningColor;
|
|
break;
|
|
case LLPathfindingPathTool::kPathStatusChooseEndPoint :
|
|
statusText = getString("pathing_choose_end_point");
|
|
styleParams.color = warningColor;
|
|
break;
|
|
case LLPathfindingPathTool::kPathStatusHasValidPath :
|
|
statusText = getString("pathing_path_valid");
|
|
break;
|
|
case LLPathfindingPathTool::kPathStatusHasInvalidPath :
|
|
statusText = getString("pathing_path_invalid");
|
|
styleParams.color = errorColor;
|
|
break;
|
|
case LLPathfindingPathTool::kPathStatusNotEnabled :
|
|
statusText = getString("pathing_region_not_enabled");
|
|
styleParams.color = errorColor;
|
|
break;
|
|
case LLPathfindingPathTool::kPathStatusNotImplemented :
|
|
statusText = getString("pathing_library_not_implemented");
|
|
styleParams.color = errorColor;
|
|
break;
|
|
case LLPathfindingPathTool::kPathStatusError :
|
|
statusText = getString("pathing_error");
|
|
styleParams.color = errorColor;
|
|
break;
|
|
default :
|
|
statusText = getString("pathing_unknown");
|
|
styleParams.color = errorColor;
|
|
break;
|
|
}
|
|
|
|
mPathTestingStatus->setText((LLStringExplicit)statusText, styleParams);
|
|
}
|
|
|
|
|
|
BOOL LLFloaterPathfindingConsole::isRenderAnyShapes() const
|
|
{
|
|
return (isRenderWalkables() || isRenderStaticObstacles() ||
|
|
isRenderMaterialVolumes() || isRenderExclusionVolumes());
|
|
}
|
|
|
|
U32 LLFloaterPathfindingConsole::getRenderShapeFlags()
|
|
{
|
|
U32 shapeRenderFlag = 0U;
|
|
|
|
if (isRenderWalkables())
|
|
{
|
|
SET_SHAPE_RENDER_FLAG(shapeRenderFlag, LLPathingLib::LLST_WalkableObjects);
|
|
}
|
|
if (isRenderStaticObstacles())
|
|
{
|
|
SET_SHAPE_RENDER_FLAG(shapeRenderFlag, LLPathingLib::LLST_ObstacleObjects);
|
|
}
|
|
if (isRenderMaterialVolumes())
|
|
{
|
|
SET_SHAPE_RENDER_FLAG(shapeRenderFlag, LLPathingLib::LLST_MaterialPhantoms);
|
|
}
|
|
if (isRenderExclusionVolumes())
|
|
{
|
|
SET_SHAPE_RENDER_FLAG(shapeRenderFlag, LLPathingLib::LLST_ExclusionPhantoms);
|
|
}
|
|
|
|
return shapeRenderFlag;
|
|
}
|
|
|
|
void LLFloaterPathfindingConsole::registerSavedSettingsListeners()
|
|
{
|
|
if (!mSavedSettingRetrieveNeighborSlot.connected())
|
|
{
|
|
mSavedSettingRetrieveNeighborSlot = gSavedSettings.getControl(CONTROL_NAME_RETRIEVE_NEIGHBOR)->getSignal()->connect(boost::bind(&LLFloaterPathfindingConsole::handleRetrieveNeighborChange, this, _1, _2));
|
|
}
|
|
if (!mSavedSettingWalkableSlot.connected())
|
|
{
|
|
mSavedSettingWalkableSlot = gSavedSettings.getControl(CONTROL_NAME_WALKABLE_OBJECTS)->getSignal()->connect(boost::bind(&LLFloaterPathfindingConsole::handleNavMeshColorChange, this, _1, _2));
|
|
}
|
|
if (!mSavedSettingStaticObstacleSlot.connected())
|
|
{
|
|
mSavedSettingStaticObstacleSlot = gSavedSettings.getControl(CONTROL_NAME_STATIC_OBSTACLE_OBJECTS)->getSignal()->connect(boost::bind(&LLFloaterPathfindingConsole::handleNavMeshColorChange, this, _1, _2));
|
|
}
|
|
if (!mSavedSettingMaterialVolumeSlot.connected())
|
|
{
|
|
mSavedSettingMaterialVolumeSlot = gSavedSettings.getControl(CONTROL_NAME_MATERIAL_VOLUMES)->getSignal()->connect(boost::bind(&LLFloaterPathfindingConsole::handleNavMeshColorChange, this, _1, _2));
|
|
}
|
|
if (!mSavedSettingExclusionVolumeSlot.connected())
|
|
{
|
|
mSavedSettingExclusionVolumeSlot = gSavedSettings.getControl(CONTROL_NAME_EXCLUSION_VOLUMES)->getSignal()->connect(boost::bind(&LLFloaterPathfindingConsole::handleNavMeshColorChange, this, _1, _2));
|
|
}
|
|
if (!mSavedSettingInteriorEdgeSlot.connected())
|
|
{
|
|
mSavedSettingInteriorEdgeSlot = gSavedSettings.getControl(CONTROL_NAME_INTERIOR_EDGE)->getSignal()->connect(boost::bind(&LLFloaterPathfindingConsole::handleNavMeshColorChange, this, _1, _2));
|
|
}
|
|
if (!mSavedSettingExteriorEdgeSlot.connected())
|
|
{
|
|
mSavedSettingExteriorEdgeSlot = gSavedSettings.getControl(CONTROL_NAME_EXTERIOR_EDGE)->getSignal()->connect(boost::bind(&LLFloaterPathfindingConsole::handleNavMeshColorChange, this, _1, _2));
|
|
}
|
|
if (!mSavedSettingHeatmapMinSlot.connected())
|
|
{
|
|
mSavedSettingHeatmapMinSlot = gSavedSettings.getControl(CONTROL_NAME_HEATMAP_MIN)->getSignal()->connect(boost::bind(&LLFloaterPathfindingConsole::handleNavMeshColorChange, this, _1, _2));
|
|
}
|
|
if (!mSavedSettingHeatmapMaxSlot.connected())
|
|
{
|
|
mSavedSettingHeatmapMaxSlot = gSavedSettings.getControl(CONTROL_NAME_HEATMAP_MAX)->getSignal()->connect(boost::bind(&LLFloaterPathfindingConsole::handleNavMeshColorChange, this, _1, _2));
|
|
}
|
|
if (!mSavedSettingNavMeshFaceSlot.connected())
|
|
{
|
|
mSavedSettingNavMeshFaceSlot = gSavedSettings.getControl(CONTROL_NAME_NAVMESH_FACE)->getSignal()->connect(boost::bind(&LLFloaterPathfindingConsole::handleNavMeshColorChange, this, _1, _2));
|
|
}
|
|
if (!mSavedSettingTestPathValidEndSlot.connected())
|
|
{
|
|
mSavedSettingTestPathValidEndSlot = gSavedSettings.getControl(CONTROL_NAME_TEST_PATH_VALID_END)->getSignal()->connect(boost::bind(&LLFloaterPathfindingConsole::handleNavMeshColorChange, this, _1, _2));
|
|
}
|
|
if (!mSavedSettingTestPathInvalidEndSlot.connected())
|
|
{
|
|
mSavedSettingTestPathInvalidEndSlot = gSavedSettings.getControl(CONTROL_NAME_TEST_PATH_INVALID_END)->getSignal()->connect(boost::bind(&LLFloaterPathfindingConsole::handleNavMeshColorChange, this, _1, _2));
|
|
}
|
|
if (!mSavedSettingTestPathSlot.connected())
|
|
{
|
|
mSavedSettingTestPathSlot = gSavedSettings.getControl(CONTROL_NAME_TEST_PATH)->getSignal()->connect(boost::bind(&LLFloaterPathfindingConsole::handleNavMeshColorChange, this, _1, _2));
|
|
}
|
|
if (!mSavedSettingWaterSlot.connected())
|
|
{
|
|
mSavedSettingWaterSlot = gSavedSettings.getControl(CONTROL_NAME_WATER)->getSignal()->connect(boost::bind(&LLFloaterPathfindingConsole::handleNavMeshColorChange, this, _1, _2));
|
|
}
|
|
}
|
|
|
|
void LLFloaterPathfindingConsole::deregisterSavedSettingsListeners()
|
|
{
|
|
if (mSavedSettingRetrieveNeighborSlot.connected())
|
|
{
|
|
mSavedSettingRetrieveNeighborSlot.disconnect();
|
|
}
|
|
if (mSavedSettingWalkableSlot.connected())
|
|
{
|
|
mSavedSettingWalkableSlot.disconnect();
|
|
}
|
|
if (mSavedSettingStaticObstacleSlot.connected())
|
|
{
|
|
mSavedSettingStaticObstacleSlot.disconnect();
|
|
}
|
|
if (mSavedSettingMaterialVolumeSlot.connected())
|
|
{
|
|
mSavedSettingMaterialVolumeSlot.disconnect();
|
|
}
|
|
if (mSavedSettingExclusionVolumeSlot.connected())
|
|
{
|
|
mSavedSettingExclusionVolumeSlot.disconnect();
|
|
}
|
|
if (mSavedSettingInteriorEdgeSlot.connected())
|
|
{
|
|
mSavedSettingInteriorEdgeSlot.disconnect();
|
|
}
|
|
if (mSavedSettingExteriorEdgeSlot.connected())
|
|
{
|
|
mSavedSettingExteriorEdgeSlot.disconnect();
|
|
}
|
|
if (mSavedSettingHeatmapMinSlot.connected())
|
|
{
|
|
mSavedSettingHeatmapMinSlot.disconnect();
|
|
}
|
|
if (mSavedSettingHeatmapMaxSlot.connected())
|
|
{
|
|
mSavedSettingHeatmapMaxSlot.disconnect();
|
|
}
|
|
if (mSavedSettingNavMeshFaceSlot.connected())
|
|
{
|
|
mSavedSettingNavMeshFaceSlot.disconnect();
|
|
}
|
|
if (mSavedSettingTestPathValidEndSlot.connected())
|
|
{
|
|
mSavedSettingTestPathValidEndSlot.disconnect();
|
|
}
|
|
if (mSavedSettingTestPathInvalidEndSlot.connected())
|
|
{
|
|
mSavedSettingTestPathInvalidEndSlot.disconnect();
|
|
}
|
|
if (mSavedSettingTestPathSlot.connected())
|
|
{
|
|
mSavedSettingTestPathSlot.disconnect();
|
|
}
|
|
}
|
|
|
|
void LLFloaterPathfindingConsole::handleRetrieveNeighborChange(LLControlVariable *pControl, const LLSD &pNewValue)
|
|
{
|
|
initializeNavMeshZoneForCurrentRegion();
|
|
}
|
|
|
|
void LLFloaterPathfindingConsole::handleNavMeshColorChange(LLControlVariable *pControl, const LLSD &pNewValue)
|
|
{
|
|
fillInColorsForNavMeshVisualization();
|
|
}
|
|
|
|
void LLFloaterPathfindingConsole::fillInColorsForNavMeshVisualization()
|
|
{
|
|
if (LLPathingLib::getInstance() != NULL)
|
|
{
|
|
LLPathingLib::NavMeshColors navMeshColors;
|
|
|
|
LLColor4 in = gSavedSettings.getColor4(CONTROL_NAME_WALKABLE_OBJECTS);
|
|
navMeshColors.mWalkable= LLColor4U(in);
|
|
|
|
in = gSavedSettings.getColor4(CONTROL_NAME_STATIC_OBSTACLE_OBJECTS);
|
|
navMeshColors.mObstacle= LLColor4U(in);
|
|
|
|
in = gSavedSettings.getColor4(CONTROL_NAME_MATERIAL_VOLUMES);
|
|
navMeshColors.mMaterial= LLColor4U(in);
|
|
|
|
in = gSavedSettings.getColor4(CONTROL_NAME_EXCLUSION_VOLUMES);
|
|
navMeshColors.mExclusion= LLColor4U(in);
|
|
|
|
in = gSavedSettings.getColor4(CONTROL_NAME_INTERIOR_EDGE);
|
|
navMeshColors.mConnectedEdge= LLColor4U(in);
|
|
|
|
in = gSavedSettings.getColor4(CONTROL_NAME_EXTERIOR_EDGE);
|
|
navMeshColors.mBoundaryEdge= LLColor4U(in);
|
|
|
|
navMeshColors.mHeatColorBase = gSavedSettings.getColor4(CONTROL_NAME_HEATMAP_MIN);
|
|
|
|
navMeshColors.mHeatColorMax = gSavedSettings.getColor4(CONTROL_NAME_HEATMAP_MAX);
|
|
|
|
in = gSavedSettings.getColor4(CONTROL_NAME_NAVMESH_FACE);
|
|
navMeshColors.mFaceColor= LLColor4U(in);
|
|
|
|
in = gSavedSettings.getColor4(CONTROL_NAME_TEST_PATH_VALID_END);
|
|
navMeshColors.mStarValid= LLColor4U(in);
|
|
|
|
in = gSavedSettings.getColor4(CONTROL_NAME_TEST_PATH_INVALID_END);
|
|
navMeshColors.mStarInvalid= LLColor4U(in);
|
|
|
|
in = gSavedSettings.getColor4(CONTROL_NAME_TEST_PATH);
|
|
navMeshColors.mTestPath= LLColor4U(in);
|
|
|
|
in = gSavedSettings.getColor4(CONTROL_NAME_WATER);
|
|
navMeshColors.mWaterColor= LLColor4U(in);
|
|
|
|
LLPathingLib::getInstance()->setNavMeshColors(navMeshColors);
|
|
}
|
|
}
|