TorqueGameEngines/Torque3D
1
0
Fork 0
mirror of https://github.com/TorqueGameEngines/Torque3D.git synced 2026-02-13 03:33:48 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge branch 'development' into mipwip

Browse source
This commit is contained in:
AzaezelX 2025-08-04 11:04:49 -05:00
commit 65e92fc50c
220 changed files with 7290 additions and 8630 deletions
Download patch file Download diff file Expand all files Collapse all files

38
Engine/source/T3D/AI/AIController.cpp
View file

@ -168,11 +168,20 @@ bool AIController::getAIMove(Move* movePtr)
{
obj = getAIInfo()->mObj;
}
Point3F start = obj->getPosition();
Point3F end = start;
start.z = obj->getBoxCenter().z;
end.z -= mControllerData->mHeightTolerance;
obj->disableCollision();
// Only repath if not already adjusted and on risky ground
RayInfo info;
if (obj->getContainer()->castRay(obj->getPosition(), obj->getPosition() - Point3F(0, 0, mControllerData->mHeightTolerance), StaticShapeObjectType, &info))
if (obj->getContainer()->castRay(start, end, StaticShapeObjectType, &info))
{
getNav()->repath();
}
obj->enableCollision();
getGoal()->mInRange = false;
}
if (getGoal()->getDist() < mControllerData->mFollowTolerance )
@ -530,11 +539,15 @@ AIControllerData::AIControllerData()
mAttackRadius = 2.0f;
mMoveStuckTolerance = 0.01f;
mMoveStuckTestDelay = 30;
mHeightTolerance = 0.001f;
mHeightTolerance = 0.1f;
mFollowTolerance = 1.0f;
#ifdef TORQUE_NAVIGATION_ENABLED
mLinkTypes = LinkData(AllFlags);
mFilter.setIncludeFlags(mLinkTypes.getFlags());
mFilter.setExcludeFlags(0);
mAreaCosts.setSize(PolyAreas::NumAreas);
mAreaCosts.fill(1.0f);
mNavSize = AINavigation::Regular;
mFlocking.mChance = 90;
mFlocking.mMin = 1.0f;
@ -560,6 +573,8 @@ AIControllerData::AIControllerData(const AIControllerData& other, bool temp_clon
#ifdef TORQUE_NAVIGATION_ENABLED
mLinkTypes = other.mLinkTypes;
mFilter = other.mFilter;
mAreaCosts = other.mAreaCosts;
mNavSize = other.mNavSize;
mFlocking.mChance = other.mFlocking.mChance;
mFlocking.mMin = other.mFlocking.mMin;
@ -629,6 +644,8 @@ void AIControllerData::initPersistFields()
addFieldV("FlockSideStep", TypeRangedF32, Offset(mFlocking.mSideStep, AIControllerData), &CommonValidators::PositiveFloat,
"@brief Distance from destination before we stop moving out of the way.");
addField("areaCosts", TypeF32Vector, Offset(mAreaCosts, AIControllerData),
"Vector of costs for each PolyArea.");
addField("allowWalk", TypeBool, Offset(mLinkTypes.walk, AIControllerData),
"Allow the character to walk on dry land.");
addField("allowJump", TypeBool, Offset(mLinkTypes.jump, AIControllerData),
@ -662,6 +679,10 @@ void AIControllerData::packData(BitStream* stream)
#ifdef TORQUE_NAVIGATION_ENABLED
//enums
stream->write(mAreaCosts.size());
for (U32 i = 0; i < mAreaCosts.size(); i++) {
stream->write(mAreaCosts[i]);
}
stream->write(mLinkTypes.getFlags());
stream->write((U32)mNavSize);
// end enums
@ -684,10 +705,23 @@ void AIControllerData::unpackData(BitStream* stream)
stream->read(&mFollowTolerance);
#ifdef TORQUE_NAVIGATION_ENABLED
U32 num;
stream->read(&num);
mAreaCosts.setSize(num);
for (U32 i = 0; i < num; i++)
{
stream->read(&mAreaCosts[i]);
}
//enums
U16 linkFlags;
stream->read(&linkFlags);
mLinkTypes = LinkData(linkFlags);
mFilter.setIncludeFlags(mLinkTypes.getFlags());
mFilter.setExcludeFlags(mLinkTypes.getExcludeFlags());
for (U32 i = 0; i < PolyAreas::NumAreas; i++)
{
mFilter.setAreaCost((PolyAreas)i, mAreaCosts[i]);
}
U32 navSize;
stream->read(&navSize);
mNavSize = (AINavigation::NavSize)(navSize);

2
Engine/source/T3D/AI/AIController.h
View file

@ -168,6 +168,8 @@ public:
/// Types of link we can use.
LinkData mLinkTypes;
dtQueryFilter mFilter;
Vector<F32> mAreaCosts;
AINavigation::NavSize mNavSize;
#endif
Delegate<void(AIController* obj, Point3F location, Move* movePtr)> resolveYawPtr;

2
Engine/source/T3D/AI/AICover.cpp
View file

@ -80,7 +80,7 @@ bool AIController::findCover(const Point3F& from, F32 radius)
if (s.point)
{
// Calling setPathDestination clears cover...
bool foundPath = getNav()->setPathDestination(s.point->getPosition());
bool foundPath = getNav()->setPathDestination(s.point->getPosition(), true);
setCover(s.point);
s.point->setOccupied(true);
return foundPath;

123
Engine/source/T3D/AI/AINavigation.cpp
View file

@ -23,7 +23,7 @@
#include "AIController.h"
#include "T3D/shapeBase.h"
static U32 sAILoSMask = TerrainObjectType | StaticShapeObjectType | StaticObjectType | AIObjectType;
static U32 sAILoSMask = TerrainObjectType | StaticShapeObjectType | StaticObjectType;
AINavigation::AINavigation(AIController* controller)
{
@ -77,6 +77,7 @@ bool AINavigation::setPathDestination(const Point3F& pos, bool replace)
path->mAlwaysRender = true;
path->mLinkTypes = getCtrl()->mControllerData->mLinkTypes;
path->mXray = true;
path->mFilter = getCtrl()->mControllerData->mFilter;
// Paths plan automatically upon being registered.
if (!path->registerObject())
{
@ -338,7 +339,11 @@ void AINavigation::repath()
if (mPathData.path.isNull() || !mPathData.owned)
return;
if (mRandI(0, 100) < getCtrl()->mControllerData->mFlocking.mChance && flock())
if (avoidObstacles())
{
mPathData.path->mTo = mMoveDestination;
}
else if (mRandI(0, 100) < getCtrl()->mControllerData->mFlocking.mChance && flock())
{
mPathData.path->mTo = mMoveDestination;
}
@ -379,6 +384,60 @@ void AINavigation::clearPath()
mPathData = PathData();
}
bool AINavigation::avoidObstacles()
{
SimObjectPtr<SceneObject> obj = getCtrl()->getAIInfo()->mObj;
obj->disableCollision();
Point3F pos = obj->getBoxCenter();
VectorF forward = obj->getTransform().getForwardVector();
forward.normalizeSafe();
// Generate forward-left and forward-right by rotating forward vector
VectorF right = mCross(forward, Point3F(0, 0, 1));
VectorF leftDir = forward + right * -0.5f; // front-left
VectorF rightDir = forward + right * 0.5f; // front-right
leftDir.normalizeSafe();
rightDir.normalizeSafe();
F32 rayLength = obj->getVelocity().lenSquared() * TickSec * 2 + getCtrl()->getAIInfo()->mRadius;
Point3F directions[3] = {
forward,
leftDir,
rightDir
};
bool hit[3] = { false, false, false };
RayInfo info;
for (int i = 0; i < 3; ++i)
{
Point3F end = pos + directions[i] * rayLength;
if (obj->getContainer()->castRay(pos, end, sAILoSMask, &info))
{
hit[i] = true;
}
}
Point3F avoidance = Point3F::Zero;
if (hit[0]) avoidance += right * 1.0f;
if (hit[1]) avoidance += right * 1.5f;
if (hit[2]) avoidance -= right * 1.5f;
if (!avoidance.isZero())
{
avoidance.normalizeSafe();
F32 clearance = getCtrl()->getAIInfo()->mRadius * 1.5f;
Point3F newDest = info.point + avoidance * rayLength;
mMoveDestination = newDest;
obj->enableCollision();
return true;
}
obj->enableCollision();
return false;
}
bool AINavigation::flock()
{
AIControllerData::Flocking flockingData = getCtrl()->mControllerData->mFlocking;
@ -386,9 +445,10 @@ bool AINavigation::flock()
obj->disableCollision();
Point3F pos = obj->getBoxCenter();
Point3F searchArea = Point3F(flockingData.mMin / 2, flockingData.mMax / 2, getCtrl()->getAIInfo()->mObj->getObjBox().maxExtents.z / 2);
F32 maxFlocksq = flockingData.mMax * flockingData.mMax;
Point3F searchArea = Point3F(maxFlocksq, maxFlocksq, getCtrl()->getAIInfo()->mObj->getObjBox().maxExtents.z / 2);
bool flocking = false;
U32 found = 0;
if (getCtrl()->getGoal())
@ -412,41 +472,35 @@ bool AINavigation::flock()
sql.mList.remove(obj);
Point3F avoidanceOffset = Point3F::Zero;
F32 avoidanceAmtSq = 0;
//avoid objects in the way
RayInfo info;
if (obj->getContainer()->castRay(pos, dest + Point3F(0, 0, obj->getObjBox().len_z() / 2), sAILoSMask, &info))
{
Point3F blockerOffset = (info.point - dest);
blockerOffset.z = 0;
avoidanceOffset += blockerOffset;
}
//avoid bots that are too close
for (U32 i = 0; i < sql.mList.size(); i++)
{
ShapeBase* other = dynamic_cast<ShapeBase*>(sql.mList[i]);
Point3F objectCenter = other->getBoxCenter();
F32 sumRad = flockingData.mMin + other->getAIController()->mControllerData->mFlocking.mMin;
F32 sumMinRad = flockingData.mMin + other->getAIController()->mControllerData->mFlocking.mMin;
F32 separation = getCtrl()->getAIInfo()->mRadius + other->getAIController()->getAIInfo()->mRadius;
sumRad += separation;
separation += sumMinRad;
Point3F offset = (pos - objectCenter);
F32 offsetLensq = offset.lenSquared(); //square roots are expensive, so use squared val compares
if ((flockingData.mMin > 0) && (offsetLensq < (sumRad * sumRad)))
if ((flockingData.mMin > 0) && (offsetLensq < (sumMinRad * sumMinRad)))
{
other->disableCollision();
if (!obj->getContainer()->castRay(pos, other->getBoxCenter(), sAILoSMask, &info))
if (!obj->getContainer()->castRay(pos, other->getBoxCenter(), sAILoSMask | AIObjectType, &info))
{
found++;
offset.normalizeSafe();
offset *= sumRad + separation;
offset *= separation;
avoidanceOffset += offset; //accumulate total group, move away from that
avoidanceAmtSq += offsetLensq;
}
other->enableCollision();
}
}
//if we don't have to worry about bumping into one another (nothing found lower than minFLock), see about grouping up
if (found == 0)
{
@ -455,20 +509,20 @@ bool AINavigation::flock()
ShapeBase* other = static_cast<ShapeBase*>(sql.mList[i]);
Point3F objectCenter = other->getBoxCenter();
F32 sumRad = flockingData.mMin + other->getAIController()->mControllerData->mFlocking.mMin;
F32 sumMaxRad = flockingData.mMax + other->getAIController()->mControllerData->mFlocking.mMax;
F32 separation = getCtrl()->getAIInfo()->mRadius + other->getAIController()->getAIInfo()->mRadius;
sumRad += separation;
separation += sumMaxRad;
Point3F offset = (pos - objectCenter);
if ((flockingData.mMin > 0) && ((sumRad * sumRad) < (maxFlocksq)))
F32 offsetLensq = offset.lenSquared(); //square roots are expensive, so use squared val compares
if ((flockingData.mMax > 0) && (offsetLensq < (sumMaxRad * sumMaxRad)))
{
other->disableCollision();
if (!obj->getContainer()->castRay(pos, other->getBoxCenter(), sAILoSMask, &info))
if (!obj->getContainer()->castRay(pos, other->getBoxCenter(), sAILoSMask | AIObjectType, &info))
{
found++;
offset.normalizeSafe();
offset *= sumRad + separation;
avoidanceOffset -= offset; // subtract total group, move toward it
avoidanceAmtSq -= offsetLensq;
}
other->enableCollision();
}
@ -476,27 +530,36 @@ bool AINavigation::flock()
}
if (found > 0)
{
//ephasize the *side* portion of sidestep to better avoid clumps
if (avoidanceOffset.x < avoidanceOffset.y)
avoidanceOffset.x *= 2.0;
else
avoidanceOffset.y *= 2.0;
//add fuzz to sidestepping
avoidanceOffset.z = 0;
avoidanceOffset.x = (mRandF() * avoidanceOffset.x) * 0.5 + avoidanceOffset.x * 0.75;
avoidanceOffset.y = (mRandF() * avoidanceOffset.y) * 0.5 + avoidanceOffset.y * 0.75;
if (avoidanceOffset.lenSquared() < (maxFlocksq))
avoidanceOffset.normalizeSafe();
avoidanceOffset *= avoidanceAmtSq;
if ((avoidanceAmtSq) > flockingData.mMin * flockingData.mMin)
{
dest += avoidanceOffset;
dest = obj->getPosition()+avoidanceOffset;
}
//if we're not jumping...
if (mJump == None)
{
dest.z = obj->getPosition().z;
//make sure we don't run off a cliff
Point3F zlen(0, 0, getCtrl()->mControllerData->mHeightTolerance);
if (obj->getContainer()->castRay(dest + zlen, dest - zlen, TerrainObjectType | StaticShapeObjectType | StaticObjectType, &info))
{
if ((mMoveDestination - dest).len() > getCtrl()->mControllerData->mMoveTolerance)
{
mMoveDestination = dest;
flocking = true;
}
mMoveDestination = dest;
flocking = true;
}
}
}

1
Engine/source/T3D/AI/AINavigation.h
View file

@ -98,6 +98,7 @@ struct AINavigation
/// Move to the specified node in the current path.
void moveToNode(S32 node);
bool avoidObstacles();
bool flock();
#endif
};

19
Engine/source/T3D/aiPlayer.cpp
View file

@ -114,6 +114,10 @@ AIPlayer::AIPlayer()
mJump = None;
mNavSize = Regular;
mLinkTypes = LinkData(AllFlags);
mFilter.setIncludeFlags(mLinkTypes.getFlags());
mFilter.setExcludeFlags(0);
mAreaCosts.setSize(PolyAreas::NumAreas);
mAreaCosts.fill(1.0f);
#endif
mIsAiControlled = true;
@ -163,7 +167,8 @@ void AIPlayer::initPersistFields()
#ifdef TORQUE_NAVIGATION_ENABLED
addGroup("Pathfinding");
addField("areaCosts", TypeF32Vector, Offset(mAreaCosts, AIPlayer),
"Vector of costs for each PolyArea.");
addField("allowWalk", TypeBool, Offset(mLinkTypes.walk, AIPlayer),
"Allow the character to walk on dry land.");
addField("allowJump", TypeBool, Offset(mLinkTypes.jump, AIPlayer),
@ -785,6 +790,7 @@ void AIPlayer::moveToNode(S32 node)
bool AIPlayer::setPathDestination(const Point3F &pos)
{
#ifdef TORQUE_NAVIGATION_ENABLED
// Pathfinding only happens on the server.
if(!isServerObject())
return false;
@ -799,6 +805,13 @@ bool AIPlayer::setPathDestination(const Point3F &pos)
return false;
}
mFilter.setIncludeFlags(mLinkTypes.getFlags());
mFilter.setExcludeFlags(mLinkTypes.getExcludeFlags());
for (U32 i = 0; i < PolyAreas::NumAreas; i++)
{
mFilter.setAreaCost((PolyAreas)i, mAreaCosts[i]);
}
// Create a new path.
NavPath *path = new NavPath();
@ -808,6 +821,7 @@ bool AIPlayer::setPathDestination(const Point3F &pos)
path->mFromSet = path->mToSet = true;
path->mAlwaysRender = true;
path->mLinkTypes = mLinkTypes;
path->mFilter = mFilter;
path->mXray = true;
// Paths plan automatically upon being registered.
if(!path->registerObject())
@ -839,6 +853,9 @@ bool AIPlayer::setPathDestination(const Point3F &pos)
path->deleteObject();
return false;
}
#else
setMoveDestination(pos, false);
#endif
}
DefineEngineMethod(AIPlayer, setPathDestination, bool, (Point3F goal),,

2
Engine/source/T3D/aiPlayer.h
View file

@ -228,6 +228,8 @@ public:
/// Types of link we can use.
LinkData mLinkTypes;
dtQueryFilter mFilter;
Vector<F32> mAreaCosts;
/// @}
#endif // TORQUE_NAVIGATION_ENABLED

42
Engine/source/T3D/assets/ImageAsset.cpp
View file

@ -808,6 +808,8 @@ GuiControl* GuiInspectorTypeImageAssetPtr::constructEditControl()
if (Sim::findObject("ToolsGuiTextEditProfile", toolEditProfile))
editTextCtrl->setControlProfile(toolEditProfile);
editTextCtrl->setPlaceholderText("(None)");
GuiControlProfile* toolDefaultProfile = nullptr;
Sim::findObject("ToolsGuiDefaultProfile", toolDefaultProfile);
@ -836,21 +838,25 @@ GuiControl* GuiInspectorTypeImageAssetPtr::constructEditControl()
//
// Create "Open in Editor" button
/*mEditButton = new GuiBitmapButtonCtrl();
mEditButton = new GuiBitmapButtonCtrl();
if (mInspector->getInspectObject() != nullptr)
dSprintf(szBuffer, sizeof(szBuffer), "%d.apply(\"\");", getId());
else
dSprintf(szBuffer, sizeof(szBuffer), "%s = \"\";", mVariableName);
dSprintf(szBuffer, sizeof(szBuffer), "AssetBrowser.editAsset(%d.getText());", retCtrl->getId());
mEditButton->setField("Command", szBuffer);
mEditButton->setText("Edit");
mEditButton->setSizing(horizResizeLeft, vertResizeAspectTop);
mEditButton->setBitmap(StringTable->insert("ToolsModule:delete_n_image"));
mEditButton->setSizing(horizResizeRight, vertResizeAspectBottom);
mEditButton->setDataField(StringTable->insert("Profile"), NULL, "ToolsGuiButtonProfile");
mEditButton->setDataField(StringTable->insert("tooltipprofile"), NULL, "GuiToolTipProfile");
mEditButton->setDataField(StringTable->insert("hovertime"), NULL, "1000");
mEditButton->setDataField(StringTable->insert("tooltip"), NULL, "Open this asset in the Image Editor");
mEditButton->setDataField(StringTable->insert("tooltip"), NULL, "Clear this ImageAsset");
mEditButton->registerObject();
addObject(mEditButton);*/
addObject(mEditButton);
//
mUseHeightOverride = true;
@ -875,9 +881,9 @@ bool GuiInspectorTypeImageAssetPtr::updateRects()
mPreviewImage->resize(previewRect.point, previewRect.extent);
S32 editPos = previewRect.point.x + previewRect.extent.x + 10;
mEdit->resize(Point2I(editPos, rowSize * 1.5), Point2I(fieldExtent.x - editPos - 5, rowSize));
mEdit->resize(Point2I(editPos, rowSize * 1.5), Point2I(fieldExtent.x - editPos - 5 - rowSize, rowSize));
//mEditButton->resize(Point2I(fieldExtent.x - 105, previewRect.point.y + previewRect.extent.y - rowSize), Point2I(100, rowSize));
mEditButton->resize(Point2I(mEdit->getPosition().x + mEdit->getExtent().x, mEdit->getPosition().y), Point2I(rowSize, rowSize));
mBrowseButton->setHidden(true);
@ -975,7 +981,7 @@ void GuiInspectorTypeImageAssetPtr::updatePreviewImage()
//if what we're working with isn't even a valid asset, don't present like we found a good one
if (!AssetDatabase.isDeclaredAsset(previewImage))
{
mPreviewImage->_setBitmap(StringTable->EmptyString());
mPreviewImage->_setBitmap(StringTable->insert("ToolsModule:unknownImage_image"));
return;
}
@ -1003,7 +1009,7 @@ void GuiInspectorTypeImageAssetPtr::setPreviewImage(StringTableEntry assetId)
//if what we're working with isn't even a valid asset, don't present like we found a good one
if (!AssetDatabase.isDeclaredAsset(assetId))
{
mPreviewImage->_setBitmap(StringTable->EmptyString());
mPreviewImage->_setBitmap(StringTable->insert("ToolsModule:unknownImage_image"));
return;
}
@ -1025,4 +1031,20 @@ void GuiInspectorTypeImageAssetPtr::setPreviewImage(StringTableEntry assetId)
if (mPreviewImage->getBitmapAsset().isNull())
mPreviewImage->_setBitmap(StringTable->insert("ToolsModule:genericAssetIcon_image"));
}
void GuiInspectorTypeImageAssetPtr::setCaption(StringTableEntry caption)
{
mCaption = caption;
mLabel->setText(mCaption);
}
DefineEngineMethod(GuiInspectorTypeImageAssetPtr, setCaption, void, (String newCaption), , "() - Sets the caption of the field.")
{
object->setCaption(StringTable->insert(newCaption.c_str()));
}
DefineEngineMethod(GuiInspectorTypeImageAssetPtr, setIsDeleteBtnVisible, void, (bool isVisible), (false), "() - Sets if the delete/clear button is visible for the field")
{
object->setIsDeleteBtnVisible(isVisible);
}
#endif

14
Engine/source/T3D/assets/ImageAssetInspectors.h
View file

@ -16,7 +16,9 @@ public:
GuiTextCtrl* mLabel = NULL;
GuiBitmapButtonCtrl* mPreviewBorderButton = NULL;
GuiBitmapCtrl* mPreviewImage = NULL;
GuiButtonCtrl* mEditButton = NULL;
GuiBitmapButtonCtrl* mEditButton = NULL;
bool mIsDeleteButtonVisible;
DECLARE_CONOBJECT(GuiInspectorTypeImageAssetPtr);
static void consoleInit();
@ -29,6 +31,16 @@ public:
void updatePreviewImage();
void setPreviewImage(StringTableEntry assetId);
/// Sets this control's caption text, usually set within setInspectorField,
/// this is exposed in case someone wants to override the normal caption.
void setCaption(StringTableEntry caption) override;
void setIsDeleteBtnVisible(const bool& isVisible)
{
if (mEditButton)
mEditButton->setVisible(isVisible);
}
};
class GuiInspectorTypeImageAssetId : public GuiInspectorTypeImageAssetPtr

47
Engine/source/T3D/guiMaterialPreview.cpp
View file

@ -40,7 +40,8 @@
// GuiMaterialPreview
GuiMaterialPreview::GuiMaterialPreview()
: mMouseState(None),
mModel(NULL),
mModelInstance(NULL),
mMountedModelInstance(NULL),
runThread(0),
lastRenderTime(0),
mLastMousePoint(0, 0),
@ -64,13 +65,13 @@ GuiMaterialPreview::GuiMaterialPreview()
// By default don't do dynamic reflection
// updates for this viewport.
mReflectPriority = 0.0f;
mMountedModel = NULL;
mSkinTag = 0;
}
GuiMaterialPreview::~GuiMaterialPreview()
{
SAFE_DELETE(mModel);
SAFE_DELETE(mModelInstance);
SAFE_DELETE(mFakeSun);
}
@ -258,30 +259,34 @@ void GuiMaterialPreview::onMiddleMouseDragged(const GuiEvent &event)
}
// This is used to set the model we want to view in the control object.
void GuiMaterialPreview::setObjectModel(const char* modelName)
void GuiMaterialPreview::setObjectModel(StringTableEntry modelName)
{
deleteModel();
Resource<TSShape> model = ResourceManager::get().load(modelName);
if (! bool(model))
_setModel(modelName);
if (!getModel())
{
Con::warnf(avar("GuiMaterialPreview: Failed to load model %s. Please check your model name and load a valid model.", modelName));
Con::warnf("GuiMaterialPreview::setObjectModel - Failed to load model '%s'", modelName);
return;
}
mModel = new TSShapeInstance(model, true);
AssertFatal(mModel, avar("GuiMaterialPreview: Failed to load model %s. Please check your model name and load a valid model.", modelName));
mModelInstance = new TSShapeInstance(getModel(), true);
mModelInstance->resetMaterialList();
mModelInstance->cloneMaterialList();
AssertFatal(mModelInstance, avar("GuiMaterialPreview: Failed to load model %s. Please check your model name and load a valid model.", modelName));
// Initialize camera values:
mOrbitPos = mModel->getShape()->center;
mMinOrbitDist = mModel->getShape()->mRadius;
mOrbitPos = mModelInstance->getShape()->center;
mMinOrbitDist = mModelInstance->getShape()->mRadius;
lastRenderTime = Platform::getVirtualMilliseconds();
}
void GuiMaterialPreview::deleteModel()
{
SAFE_DELETE(mModel);
SAFE_DELETE(mModelInstance);
runThread = 0;
}
@ -358,7 +363,7 @@ void GuiMaterialPreview::onMouseLeave(const GuiEvent & event)
void GuiMaterialPreview::renderWorld(const RectI &updateRect)
{
// nothing to render, punt
if ( !mModel && !mMountedModel )
if ( !mModelInstance && !mMountedModelInstance )
return;
S32 time = Platform::getVirtualMilliseconds();
@ -408,10 +413,10 @@ void GuiMaterialPreview::renderWorld(const RectI &updateRect)
LIGHTMGR->unregisterAllLights();
LIGHTMGR->setSpecialLight( LightManager::slSunLightType, mFakeSun );
if ( mModel )
mModel->render( rdata );
if ( mModelInstance )
mModelInstance->render( rdata );
if ( mMountedModel )
if ( mMountedModelInstance )
{
// render a weapon
/*
@ -441,7 +446,7 @@ void GuiMaterialPreview::renderSunDirection() const
{
// Render four arrows aiming in the direction of the sun's light
ColorI color = LinearColorF(mFakeSun->getColor()).toColorI();
F32 length = mModel->getShape()->mBounds.len() * 0.8f;
F32 length = mModelInstance->getShape()->mBounds.len() * 0.8f;
// Get the sun's vectors
Point3F fwd = mFakeSun->getTransform().getForwardVector();
@ -449,8 +454,8 @@ void GuiMaterialPreview::renderSunDirection() const
Point3F right = mFakeSun->getTransform().getRightVector() * length / 8;
// Calculate the start and end points of the first arrow (bottom left)
Point3F start = mModel->getShape()->center - fwd * length - up / 2 - right / 2;
Point3F end = mModel->getShape()->center - fwd * length / 3 - up / 2 - right / 2;
Point3F start = mModelInstance->getShape()->center - fwd * length - up / 2 - right / 2;
Point3F end = mModelInstance->getShape()->center - fwd * length / 3 - up / 2 - right / 2;
GFXStateBlockDesc desc;
desc.setZReadWrite(true, true);
@ -476,7 +481,7 @@ void GuiMaterialPreview::resetViewport()
mCameraRot.set( mDegToRad(30.0f), 0, mDegToRad(-30.0f) );
mCameraPos.set(0.0f, 1.75f, 1.25f);
mOrbitDist = 5.0f;
mOrbitPos = mModel->getShape()->center;
mOrbitPos = mModelInstance->getShape()->center;
// Reset the viewport's lighting.
GuiMaterialPreview::mFakeSun->setColor( LinearColorF( 1.0f, 1.0f, 1.0f ) );
@ -498,7 +503,7 @@ DefineEngineMethod(GuiMaterialPreview, setModel, void, ( const char* shapeName )
"Sets the model to be displayed in this control\n\n"
"@param shapeName Name of the model to display.\n")
{
object->setObjectModel(shapeName);
object->setObjectModel(StringTable->insert(shapeName));
}
DefineEngineMethod(GuiMaterialPreview, deleteModel, void, (),,

9
Engine/source/T3D/guiMaterialPreview.h
View file

@ -28,6 +28,8 @@
#ifndef _GUIMATERIALPREVIEW_H_
#define _GUIMATERIALPREVIEW_H_
#include "assets/ShapeAsset.h"
#include "gui/3d/guiTSControl.h"
#include "ts/tsShapeInstance.h"
@ -50,8 +52,11 @@ protected:
MouseState mMouseState;
TSShapeInstance* mModel;
TSShapeInstance* mMountedModel;
DECLARE_SHAPEASSET_REFACTOR(GuiMaterialPreview, Model)
DECLARE_SHAPEASSET_REFACTOR(GuiMaterialPreview, MountedModel)
TSShapeInstance* mModelInstance;
TSShapeInstance* mMountedModelInstance;
U32 mSkinTag;
// For Camera Panning.

10
Engine/source/T3D/turret/turretShape.cpp
View file

@ -141,7 +141,7 @@ void TurretShapeData::initPersistFields()
"@brief Should the turret allow only z rotations.\n\n"
"True indicates that the turret may only be rotated on its z axis, just like the Item class. "
"This keeps the turret always upright regardless of the surface it lands on.\n");
addFieldV("maxHeading", TypeRangedF32, Offset(maxHeading, TurretShapeData), &CommonValidators::PosDegreeRangeQuarter,
addFieldV("maxHeading", TypeRangedF32, Offset(maxHeading, TurretShapeData), &CommonValidators::PosDegreeRangeHalf,
"@brief Maximum number of degrees to rotate from center.\n\n"
"A value of 180 or more degrees indicates the turret may rotate completely around.\n");
addFieldV("minPitch", TypeRangedF32, Offset(minPitch, TurretShapeData), &CommonValidators::PosDegreeRangeQuarter,
@ -1047,8 +1047,8 @@ void TurretShape::writePacketData(GameConnection *connection, BitStream *stream)
// Update client regardless of status flags.
Parent::writePacketData(connection, stream);
stream->writeSignedFloat(mRot.x / M_2PI_F, 7);
stream->writeSignedFloat(mRot.z / M_2PI_F, 7);
stream->writeSignedFloat(mRot.x / M_2PI_F, 11);
stream->writeSignedFloat(mRot.z / M_2PI_F, 11);
}
void TurretShape::readPacketData(GameConnection *connection, BitStream *stream)
@ -1056,8 +1056,8 @@ void TurretShape::readPacketData(GameConnection *connection, BitStream *stream)
Parent::readPacketData(connection, stream);
Point3F rot(0.0f, 0.0f, 0.0f);
rot.x = stream->readSignedFloat(7) * M_2PI_F;
rot.z = stream->readSignedFloat(7) * M_2PI_F;
rot.x = stream->readSignedFloat(11) * M_2PI_F;
rot.z = stream->readSignedFloat(11) * M_2PI_F;
_setRotation(rot);
mTurretDelta.rot = rot;

7
Engine/source/environment/waterBlock.cpp
View file

@ -531,12 +531,9 @@ void WaterBlock::initPersistFields()
docsURL;
addGroup( "WaterBlock" );
addProtectedFieldV("gridSize", TypeRangedS32, Offset(mGridElementSize, WaterBlock), &setGridSizeProperty, &defaultProtectedGetFn, &CommonValidators::NaturalNumber,
addProtectedFieldV("gridSize", TypeRangedF32, Offset(mGridElementSize, WaterBlock), &setGridSizeProperty, &defaultProtectedGetFn, &CommonValidators::PositiveFloat,
"Spacing between vertices in the WaterBlock mesh");
addProtectedFieldV("gridElementSize", TypeRangedS32, Offset(mGridElementSize, WaterBlock), &setGridSizeProperty, &defaultProtectedGetFn, &CommonValidators::NaturalNumber,
"Duplicate of gridElementSize for backwards compatility");
addProtectedFieldV("gridElementSize", TypeRangedF32, Offset(mGridElementSize, WaterBlock), &setGridSizeProperty, &defaultProtectedGetFn, &CommonValidators::PositiveFloat, "Duplicate of gridElementSize for backwards compatility");
Parent::initPersistFields();
}

2
Engine/source/environment/waterBlock.h
View file

@ -82,7 +82,7 @@ private:
GFXPrimitiveBufferHandle mRadialPrimBuff;
// misc
U32 mGridElementSize;
F32 mGridElementSize;
U32 mWidth;
U32 mHeight;
F32 mElapsedTime;

3
Engine/source/environment/waterObject.cpp
View file

@ -45,6 +45,7 @@
#include "T3D/sfx/sfx3DWorld.h"
#include "sfx/sfxTypes.h"
#include "console/typeValidators.h"
#include "gfx/gfxTransformSaver.h"
GFXImplementVertexFormat( GFXWaterVertex )
{
@ -699,6 +700,8 @@ void WaterObject::prepRenderImage( SceneRenderState *state )
if( !state->isDiffusePass() )
return;
GFXTransformSaver saver;
// Setup scene transforms
mMatrixSet->setSceneView(GFX->getWorldMatrix());
mMatrixSet->setSceneProjection(GFX->getProjectionMatrix());

6
Engine/source/environment/waterPlane.cpp
View file

@ -124,9 +124,7 @@ void WaterPlane::initPersistFields()
addProtectedFieldV( "gridSize", TypeRangedS32, Offset( mGridSize, WaterPlane ), &protectedSetGridSize, &defaultProtectedGetFn, &CommonValidators::NaturalNumber,
"Spacing between vertices in the WaterBlock mesh" );
addProtectedFieldV( "gridElementSize", TypeRangedS32, Offset( mGridElementSize, WaterPlane ), &protectedSetGridElementSize, &defaultProtectedGetFn, &CommonValidators::NaturalNumber,
"Duplicate of gridElementSize for backwards compatility");
addProtectedFieldV("gridElementSize", TypeRangedF32, Offset(mGridElementSize, WaterPlane), &protectedSetGridElementSize, &defaultProtectedGetFn, &CommonValidators::PositiveFloat, "Duplicate of gridElementSize for backwards compatility");
endGroup( "WaterPlane" );
@ -699,6 +697,8 @@ void WaterPlane::prepRenderImage( SceneRenderState *state )
if( !state->isDiffusePass() )
return;
GFXTransformSaver saver;
mBasicLighting = dStricmp( LIGHTMGR->getId(), "BLM" ) == 0;
mUnderwater = isUnderwater( state->getCameraPosition() );

202
Engine/source/gfx/gfxDrawUtil.cpp
View file

@ -1486,69 +1486,73 @@ void GFXDrawUtil::_drawWireCapsule( const GFXStateBlockDesc &desc, const Point3F
void GFXDrawUtil::drawCone( const GFXStateBlockDesc &desc, const Point3F &basePnt, const Point3F &tipPnt, F32 baseRadius, const ColorI &color )
{
VectorF uvec = tipPnt - basePnt;
F32 height = uvec.len();
uvec.normalize();
MatrixF mat( true );
MathUtils::getMatrixFromUpVector( uvec, &mat );
mat.setPosition(basePnt);
VectorF dir = tipPnt - basePnt;
F32 height = dir.len();
dir.normalize();
Point3F scale( baseRadius, baseRadius, height );
mat.scale(scale);
MatrixF mat(true);
MathUtils::getMatrixFromUpVector(dir, &mat);
mat.setPosition(basePnt);
mat.scale(Point3F(baseRadius, baseRadius, height));
GFXTransformSaver saver;
mDevice->pushWorldMatrix();
mDevice->multWorld(mat);
S32 numPoints = sizeof(circlePoints)/sizeof(Point2F);
GFXVertexBufferHandle<GFXVertexPCT> verts(mDevice, numPoints * 3 + 2, GFXBufferTypeVolatile);
const S32 numPoints = sizeof(circlePoints) / sizeof(Point2F);
// Vertex index layout
const S32 baseCenterIdx = 0;
const S32 baseStartIdx = 1;
const S32 tipIdx = baseStartIdx + numPoints;
const S32 sideStartIdx = tipIdx + 1;
const S32 totalVerts = sideStartIdx + numPoints * 3;
GFXVertexBufferHandle<GFXVertexPCT> verts(mDevice, totalVerts, GFXBufferTypeVolatile);
verts.lock();
F32 sign = -1.f;
S32 indexDown = 0; //counting down from numPoints
S32 indexUp = 0; //counting up from 0
S32 index = 0; //circlePoints index for cap
for (S32 i = 0; i < numPoints + 1; i++)
// Base center vertex (at origin in local space)
verts[baseCenterIdx].point = Point3F(0, 0, 0);
verts[baseCenterIdx].color = color;
// Base circle vertices
for (S32 i = 0; i < numPoints; i++)
{
//Top cap
if (i != numPoints)
{
if (sign < 0)
index = indexDown;
else
index = indexUp;
verts[baseStartIdx + i].point = Point3F(circlePoints[i].x, circlePoints[i].y, 0);
verts[baseStartIdx + i].color = color;
}
verts[i].point = Point3F(circlePoints[index].x, circlePoints[index].y, 0);
verts[i].color = color;
// Tip vertex (pointing "up" in local Z)
verts[tipIdx].point = Point3F(0, 0, 1);
verts[tipIdx].color = color;
if (sign < 0)
indexUp += 1;
else
indexDown = numPoints - indexUp;
// Side triangles: one triangle per segment
for (S32 i = 0; i < numPoints; i++)
{
S32 triBase = sideStartIdx + i * 3;
// invert sign
sign *= -1.0f;
}
// Each triangle is (tip, base[i], base[(i+1)%numPoints])
verts[triBase + 0].point = verts[tipIdx].point;
verts[triBase + 1].point = verts[baseStartIdx + i].point;
verts[triBase + 2].point = verts[baseStartIdx + ((i + 1) % numPoints)].point;
//cone
S32 imod = i % numPoints;
S32 vertindex = 2 * i + numPoints;
verts[vertindex].point = Point3F(circlePoints[imod].x, circlePoints[imod].y, 0);
verts[vertindex].color = color;
verts[vertindex + 1].point = Point3F(0.0f, 0.0f, 1.0f);
verts[vertindex + 1].color = color;
verts[triBase + 0].color = color;
verts[triBase + 1].color = color;
verts[triBase + 2].color = color;
}
verts.unlock();
mDevice->setStateBlockByDesc( desc );
mDevice->setVertexBuffer( verts );
mDevice->setStateBlockByDesc(desc);
mDevice->setVertexBuffer(verts);
mDevice->setupGenericShaders();
mDevice->drawPrimitive(GFXTriangleStrip, 0, numPoints - 2);
mDevice->drawPrimitive(GFXTriangleStrip, numPoints, numPoints * 2);
// Draw base cap using triangle fan
mDevice->drawPrimitive(GFXTriangleList, baseCenterIdx, numPoints - 2);
// Draw sides using triangle list
mDevice->drawPrimitive(GFXTriangleList, sideStartIdx, numPoints);
mDevice->popWorldMatrix();
@ -1556,71 +1560,89 @@ void GFXDrawUtil::drawCone( const GFXStateBlockDesc &desc, const Point3F &basePn
void GFXDrawUtil::drawCylinder( const GFXStateBlockDesc &desc, const Point3F &basePnt, const Point3F &tipPnt, F32 radius, const ColorI &color )
{
VectorF uvec = tipPnt - basePnt;
F32 height = uvec.len();
uvec.normalize();
MatrixF mat( true );
MathUtils::getMatrixFromUpVector( uvec, &mat );
VectorF dir = tipPnt - basePnt;
F32 height = dir.len();
dir.normalize();
MatrixF mat(true);
MathUtils::getMatrixFromUpVector(dir, &mat);
mat.setPosition(basePnt);
mat.scale(Point3F(radius, radius, height));
Point3F scale( radius, radius, height * 2 );
mat.scale(scale);
GFXTransformSaver saver;
mDevice->pushWorldMatrix();
mDevice->multWorld(mat);
S32 numPoints = sizeof(circlePoints) / sizeof(Point2F);
GFXVertexBufferHandle<GFXVertexPCT> verts(mDevice, numPoints *4 + 2, GFXBufferTypeVolatile);
const S32 numPoints = sizeof(circlePoints) / sizeof(Point2F);
// Vertex index layout
const S32 baseCenterIdx = 0;
const S32 topCenterIdx = 1;
const S32 baseStartIdx = 2;
const S32 topStartIdx = baseStartIdx + numPoints;
const S32 sideStartIdx = topStartIdx + numPoints;
const S32 totalVerts = sideStartIdx + numPoints * 6;
GFXVertexBufferHandle<GFXVertexPCT> verts(mDevice, totalVerts, GFXBufferTypeVolatile);
verts.lock();
F32 sign = -1.f;
S32 indexDown = 0; //counting down from numPoints
S32 indexUp = 0; //counting up from 0
S32 index = 0; //circlePoints index for caps
for (S32 i = 0; i < numPoints + 1; i++)
// Base center
verts[baseCenterIdx].point = Point3F(0, 0, 0);
verts[baseCenterIdx].color = color;
// Top center
verts[topCenterIdx].point = Point3F(0, 0, 1);
verts[topCenterIdx].color = color;
// Base circle
for (S32 i = 0; i < numPoints; ++i)
{
//Top/Bottom cap
if (i != numPoints)
{
if (sign < 0)
index = indexDown;
else
index = indexUp;
verts[baseStartIdx + i].point = Point3F(circlePoints[i].x, circlePoints[i].y, 0);
verts[baseStartIdx + i].color = color;
}
verts[i].point = Point3F(circlePoints[index].x, circlePoints[index].y, 0);
verts[i].color = color;
verts[i + numPoints].point = Point3F(circlePoints[index].x, circlePoints[index].y, 0.5f);
verts[i + numPoints].color = color;
// Top circle
for (S32 i = 0; i < numPoints; ++i)
{
verts[topStartIdx + i].point = Point3F(circlePoints[i].x, circlePoints[i].y, 1.0f);
verts[topStartIdx + i].color = color;
}
if (sign < 0)
indexUp += 1;
else
indexDown = numPoints - indexUp;
// Side triangles
for (S32 i = 0; i < numPoints; ++i)
{
S32 next = (i + 1) % numPoints;
S32 idx = sideStartIdx + i * 6;
// invert sign
sign *= -1.0f;
}
// First triangle (base[i], base[next], top[i])
verts[idx + 0].point = verts[baseStartIdx + i].point;
verts[idx + 1].point = verts[baseStartIdx + next].point;
verts[idx + 2].point = verts[topStartIdx + i].point;
//cylinder
S32 imod = i % numPoints;
S32 vertindex = 2 * i + (numPoints * 2);
verts[vertindex].point = Point3F(circlePoints[imod].x, circlePoints[imod].y, 0);
verts[vertindex].color = color;
verts[vertindex + 1].point = Point3F(circlePoints[imod].x, circlePoints[imod].y, 0.5f);
verts[vertindex + 1].color = color;
// Second triangle (top[i], base[next], top[next])
verts[idx + 3].point = verts[topStartIdx + i].point;
verts[idx + 4].point = verts[baseStartIdx + next].point;
verts[idx + 5].point = verts[topStartIdx + next].point;
for (int j = 0; j < 6; ++j)
verts[idx + j].color = color;
}
verts.unlock();
mDevice->setStateBlockByDesc( desc );
mDevice->setVertexBuffer( verts );
mDevice->setStateBlockByDesc(desc);
mDevice->setVertexBuffer(verts);
mDevice->setupGenericShaders();
mDevice->drawPrimitive( GFXTriangleStrip, 0, numPoints-2 );
mDevice->drawPrimitive( GFXTriangleStrip, numPoints, numPoints - 2);
mDevice->drawPrimitive( GFXTriangleStrip, numPoints*2, numPoints * 2);
// Draw base cap
mDevice->drawPrimitive(GFXTriangleList, baseCenterIdx, numPoints - 2);
// Draw top cap
mDevice->drawPrimitive(GFXTriangleList, topCenterIdx, numPoints - 2);
// Draw sides (2 triangles per segment)
mDevice->drawPrimitive(GFXTriangleList, sideStartIdx, numPoints * 2);
mDevice->popWorldMatrix();
}

67
Engine/source/gfx/gl/gfxGLCircularVolatileBuffer.h
View file

@ -178,39 +178,59 @@ public:
U32 mSize = 0;
}_getBufferData;
void lock(const U32 size, U32 offsetAlign, U32 &outOffset, void* &outPtr)
void lock(const U32 size, U32 offsetAlign, U32& outOffset, void*& outPtr)
{
if( !size )
if (!size)
{
AssertFatal(0, "");
AssertFatal(0, "GLCircularVolatileBuffer::lock - size must be > 0");
outOffset = 0;
outPtr = NULL;
outPtr = nullptr;
return;
}
mLockManager.waitFirstRange( mBufferFreePos, (mBufferFreePos + size)-1 );
// Align free pos first (before wraparound check)
if (offsetAlign)
{
mBufferFreePos = ((mBufferFreePos + offsetAlign - 1) / offsetAlign) * offsetAlign;
}
if( mBufferFreePos + size > mBufferSize )
{
mUsedRanges.push_back( UsedRange( mBufferFreePos, mBufferSize-1 ) );
// If the size won't fit from current pos to end, wrap around
if (mBufferFreePos + size > mBufferSize)
{
// Protect the remaining space
if (mBufferFreePos < mBufferSize)
mUsedRanges.push_back(UsedRange(mBufferFreePos, mBufferSize - 1));
// Reset free pos
mBufferFreePos = 0;
}
// force offset buffer align
if( offsetAlign )
mBufferFreePos = ( (mBufferFreePos/offsetAlign) + 1 ) * offsetAlign;
// Realign after wrap
if (offsetAlign)
{
mBufferFreePos = ((mBufferFreePos + offsetAlign - 1) / offsetAlign) * offsetAlign;
}
// Now check for overlaps *after* wrapping
mLockManager.waitOverlapRanges(mBufferFreePos, mBufferFreePos + size - 1);
}
else
{
// Normal range wait
mLockManager.waitOverlapRanges(mBufferFreePos, mBufferFreePos + size - 1);
}
outOffset = mBufferFreePos;
if( GFXGL->mCapabilities.bufferStorage )
{
outPtr = (U8*)(mBufferPtr) + mBufferFreePos;
}
else if( GFXGL->glUseMap() )
if (GFXGL->mCapabilities.bufferStorage)
{
PRESERVE_BUFFER( mBinding );
outPtr = static_cast<U8*>(mBufferPtr) + mBufferFreePos;
}
else if (GFXGL->glUseMap())
{
PRESERVE_BUFFER(mBinding);
glBindBuffer(mBinding, mBufferName);
const GLbitfield access = GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_RANGE_BIT | GL_MAP_UNSYNCHRONIZED_BIT;
const GLbitfield access = GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT;
outPtr = glMapBufferRange(mBinding, outOffset, size, access);
}
else
@ -218,14 +238,13 @@ public:
_getBufferData.mOffset = outOffset;
_getBufferData.mSize = size;
outPtr = mFrameAllocator.lock( size );
}
outPtr = mFrameAllocator.lock(size);
}
//set new buffer pos
mBufferFreePos = mBufferFreePos + size;
mBufferFreePos += size;
//align 4bytes
mBufferFreePos = ( (mBufferFreePos/4) + 1 ) * 4;
mBufferFreePos = ((mBufferFreePos + 4 - 1) / 4) * 4;
}
void unlock()

9
Engine/source/gui/editor/inspector/field.cpp
View file

@ -1050,6 +1050,15 @@ DefineEngineMethod(GuiInspectorField, setCaption, void, (String newCaption),, "(
object->setCaption(StringTable->insert(newCaption.c_str()));
}
DefineEngineMethod(GuiInspectorField, getFieldName, const char*, (), , "() - Gets the fieldName of the field.")
{
constexpr U32 bufSize = 128;
char* retBuffer = Con::getReturnBuffer(bufSize);
dSprintf(retBuffer, bufSize, "%s", object->getFieldName());
return retBuffer;
}
DefineEngineMethod(GuiInspectorField, setSpecialEditVariableName, void, (String newCaption), , "() - Sets the variable name for special edit fields.")
{
object->setSpecialEditVariableName(StringTable->insert(newCaption.c_str()));

2
Engine/source/gui/editor/inspector/field.h
View file

@ -132,6 +132,8 @@ class GuiInspectorField : public GuiControl
/// this is exposed in case someone wants to override the normal caption.
virtual void setCaption( StringTableEntry caption ) { mCaption = caption; }
virtual StringTableEntry getCaption() { return mCaption; }
void setEditControl(GuiControl* editCtrl);
void setHeightOverride(bool useOverride, U32 heightOverride);

25
Engine/source/gui/editor/inspector/group.cpp
View file

@ -211,7 +211,7 @@ GuiInspectorField *GuiInspectorGroup::findField( const char *fieldName )
for( ; i != mChildren.end(); i++ )
{
if( (*i)->getFieldName() != NULL && dStricmp( (*i)->getFieldName(), fieldName ) == 0 )
if( ((*i)->getFieldName() != NULL && dStricmp( (*i)->getFieldName(), fieldName ) == 0) || ((*i)->getCaption() != StringTable->EmptyString() && dStricmp((*i)->getCaption(), fieldName) == 0) )
return (*i);
}
@ -834,3 +834,26 @@ DefineEngineMethod(GuiInspectorGroup, setForcedArrayIndex, void, (S32 arrayIndex
{
object->setForcedArrayIndex(arrayIndex);
}
DefineEngineMethod(GuiInspectorGroup, findField, S32, (const char* fieldName),,
"Finds an Inspector field in this group of a given name.\n"
"@param fieldName The name of the field to be found.\n"
"@return Field SimObjectId")
{
if (dStrEqual(fieldName, ""))
return 0;
GuiInspectorField* field = object->findField(StringTable->insert(fieldName));
if (field == nullptr)
return 0;
return field->getId();
}
DefineEngineMethod(GuiInspectorGroup, refresh, void, (), ,
"Finds an Inspector field in this group of a given name.\n"
"@param fieldName The name of the field to be found.\n"
"@return Field SimObjectId")
{
object->inspectGroup();
}

34
Engine/source/materials/materialDefinition.cpp
View file

@ -101,6 +101,15 @@ ImplementEnumType(MaterialWaveType,
{ Material::Square, "Square", "Warps the material along a wave which transitions between two oppposite states. As a Square Wave, the transition is quick and sudden." },
EndImplementEnumType;
ImplementEnumType(MaterialSourceChannelType,
"When sampling from ORM Texture maps, dictates what channel to sample from for a given AO, Roughness or Metalness texture.\n"
"@ingroup GFX\n")
{ Material::RedChannel, "Red", "Red Channel" },
{ Material::GreenChannel, "Green", "Green Channel" },
{ Material::BlueChannel, "Blue", "Blue Channel" },
{ Material::AlphaChannel, "Alpha", "Alpha Channel" },
EndImplementEnumType;
bool Material::sAllowTextureTargetAssignment = false;
GFXCubemap* Material::GetNormalizeCube()
@ -254,6 +263,11 @@ void Material::initPersistFields()
addGroup("Light Influence Maps");
addFieldV("roughness", TypeRangedF32, Offset(mRoughness, Material), &CommonValidators::F32_8BitPercent, MAX_STAGES,
"The degree of roughness when not using a ORMConfigMap.");
addFieldV("metalness", TypeRangedF32, Offset(mMetalness, Material), &CommonValidators::F32_8BitPercent, MAX_STAGES,
"The degree of Metalness when not using a ORMConfigMap.");
INITPERSISTFIELD_IMAGEASSET_ARRAY(ORMConfigMap, MAX_STAGES, Material, "AO|Roughness|metalness map");
addField("isSRGb", TypeBool, Offset(mIsSRGb, Material), MAX_STAGES,
"Substance Designer Workaround.");
@ -261,21 +275,19 @@ void Material::initPersistFields()
"Treat Roughness as Roughness");
INITPERSISTFIELD_IMAGEASSET_ARRAY(AOMap, MAX_STAGES, Material, "AOMap");
INITPERSISTFIELD_IMAGEASSET_ARRAY(RoughMap, MAX_STAGES, Material, "RoughMap (also needs MetalMap)");
INITPERSISTFIELD_IMAGEASSET_ARRAY(MetalMap, MAX_STAGES, Material, "MetalMap (also needs RoughMap)");
INITPERSISTFIELD_IMAGEASSET_ARRAY(GlowMap, MAX_STAGES, Material, "GlowMap (needs Albedo)");
addFieldV("AOChan", TypeRangedS32, Offset(mAOChan, Material), &bmpChanRange, MAX_STAGES,
addField("AOChan", TYPEID< SourceChannelType >(), Offset(mAOChan, Material), MAX_STAGES,
"The input channel AO maps use.");
addFieldV("roughness", TypeRangedF32, Offset(mRoughness, Material), &CommonValidators::F32_8BitPercent,MAX_STAGES,
"The degree of roughness when not using a ORMConfigMap.");
addFieldV("roughnessChan", TypeRangedS32, Offset(mRoughnessChan, Material), &bmpChanRange, MAX_STAGES,
INITPERSISTFIELD_IMAGEASSET_ARRAY(RoughMap, MAX_STAGES, Material, "RoughMap (also needs MetalMap)");
addField("roughnessChan", TYPEID< SourceChannelType >(), Offset(mRoughnessChan, Material), MAX_STAGES,
"The input channel roughness maps use.");
addFieldV("metalness", TypeRangedF32, Offset(mMetalness, Material), &CommonValidators::F32_8BitPercent, MAX_STAGES,
"The degree of Metalness when not using a ORMConfigMap.");
addFieldV("metalChan", TypeRangedS32, Offset(mMetalChan, Material), &bmpChanRange, MAX_STAGES,
INITPERSISTFIELD_IMAGEASSET_ARRAY(MetalMap, MAX_STAGES, Material, "MetalMap (also needs RoughMap)");
addField("metalChan", TYPEID< SourceChannelType >(), Offset(mMetalChan, Material), MAX_STAGES,
"The input channel metalness maps use.");
INITPERSISTFIELD_IMAGEASSET_ARRAY(GlowMap, MAX_STAGES, Material, "GlowMap (needs Albedo)");
addFieldV("glowMul", TypeRangedF32, Offset(mGlowMul, Material),&glowMulRange, MAX_STAGES,
"glow mask multiplier");
endGroup("Light Influence Maps");

10
Engine/source/materials/materialDefinition.h
View file

@ -129,6 +129,14 @@ public:
Square,
};
enum SourceChannelType
{
RedChannel = 0,
GreenChannel,
BlueChannel,
AlphaChannel
};
class StageData
{
protected:
@ -425,9 +433,11 @@ private:
typedef Material::AnimType MaterialAnimType;
typedef Material::BlendOp MaterialBlendOp;
typedef Material::WaveType MaterialWaveType;
typedef Material::SourceChannelType MaterialSourceChannelType;
DefineBitfieldType(MaterialAnimType);
DefineEnumType(MaterialBlendOp);
DefineEnumType(MaterialWaveType);
DefineEnumType(MaterialSourceChannelType);
#endif // _MATERIALDEFINITION_H_

315
Engine/source/navigation/ChunkyTriMesh.cpp Normal file
View file

@ -0,0 +1,315 @@
//
// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it
// freely, subject to the following restrictions:
// 1. The origin of this software must not be misrepresented; you must not
// claim that you wrote the original software. If you use this software
// in a product, an acknowledgment in the product documentation would be
// appreciated but is not required.
// 2. Altered source versions must be plainly marked as such, and must not be
// misrepresented as being the original software.
// 3. This notice may not be removed or altered from any source distribution.
//
#include "ChunkyTriMesh.h"
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
struct BoundsItem
{
float bmin[2];
float bmax[2];
int i;
};
static int compareItemX(const void* va, const void* vb)
{
const BoundsItem* a = (const BoundsItem*)va;
const BoundsItem* b = (const BoundsItem*)vb;
if (a->bmin[0] < b->bmin[0])
return -1;
if (a->bmin[0] > b->bmin[0])
return 1;
return 0;
}
static int compareItemY(const void* va, const void* vb)
{
const BoundsItem* a = (const BoundsItem*)va;
const BoundsItem* b = (const BoundsItem*)vb;
if (a->bmin[1] < b->bmin[1])
return -1;
if (a->bmin[1] > b->bmin[1])
return 1;
return 0;
}
static void calcExtends(const BoundsItem* items, const int /*nitems*/,
const int imin, const int imax,
float* bmin, float* bmax)
{
bmin[0] = items[imin].bmin[0];
bmin[1] = items[imin].bmin[1];
bmax[0] = items[imin].bmax[0];
bmax[1] = items[imin].bmax[1];
for (int i = imin+1; i < imax; ++i)
{
const BoundsItem& it = items[i];
if (it.bmin[0] < bmin[0]) bmin[0] = it.bmin[0];
if (it.bmin[1] < bmin[1]) bmin[1] = it.bmin[1];
if (it.bmax[0] > bmax[0]) bmax[0] = it.bmax[0];
if (it.bmax[1] > bmax[1]) bmax[1] = it.bmax[1];
}
}
inline int longestAxis(float x, float y)
{
return y > x ? 1 : 0;
}
static void subdivide(BoundsItem* items, int nitems, int imin, int imax, int trisPerChunk,
int& curNode, rcChunkyTriMeshNode* nodes, const int maxNodes,
int& curTri, int* outTris, const int* inTris)
{
int inum = imax - imin;
int icur = curNode;
if (curNode >= maxNodes)
return;
rcChunkyTriMeshNode& node = nodes[curNode++];
if (inum <= trisPerChunk)
{
// Leaf
calcExtends(items, nitems, imin, imax, node.bmin, node.bmax);
// Copy triangles.
node.i = curTri;
node.n = inum;
for (int i = imin; i < imax; ++i)
{
const int* src = &inTris[items[i].i*3];
int* dst = &outTris[curTri*3];
curTri++;
dst[0] = src[0];
dst[1] = src[1];
dst[2] = src[2];
}
}
else
{
// Split
calcExtends(items, nitems, imin, imax, node.bmin, node.bmax);
int axis = longestAxis(node.bmax[0] - node.bmin[0],
node.bmax[1] - node.bmin[1]);
if (axis == 0)
{
// Sort along x-axis
qsort(items+imin, static_cast<size_t>(inum), sizeof(BoundsItem), compareItemX);
}
else if (axis == 1)
{
// Sort along y-axis
qsort(items+imin, static_cast<size_t>(inum), sizeof(BoundsItem), compareItemY);
}
int isplit = imin+inum/2;
// Left
subdivide(items, nitems, imin, isplit, trisPerChunk, curNode, nodes, maxNodes, curTri, outTris, inTris);
// Right
subdivide(items, nitems, isplit, imax, trisPerChunk, curNode, nodes, maxNodes, curTri, outTris, inTris);
int iescape = curNode - icur;
// Negative index means escape.
node.i = -iescape;
}
}
bool rcCreateChunkyTriMesh(const float* verts, const int* tris, int ntris,
int trisPerChunk, rcChunkyTriMesh* cm)
{
int nchunks = (ntris + trisPerChunk-1) / trisPerChunk;
cm->nodes = new rcChunkyTriMeshNode[nchunks*4];
if (!cm->nodes)
return false;
cm->tris = new int[ntris*3];
if (!cm->tris)
return false;
cm->ntris = ntris;
// Build tree
BoundsItem* items = new BoundsItem[ntris];
if (!items)
return false;
for (int i = 0; i < ntris; i++)
{
const int* t = &tris[i*3];
BoundsItem& it = items[i];
it.i = i;
// Calc triangle XZ bounds.
it.bmin[0] = it.bmax[0] = verts[t[0]*3+0];
it.bmin[1] = it.bmax[1] = verts[t[0]*3+2];
for (int j = 1; j < 3; ++j)
{
const float* v = &verts[t[j]*3];
if (v[0] < it.bmin[0]) it.bmin[0] = v[0];
if (v[2] < it.bmin[1]) it.bmin[1] = v[2];
if (v[0] > it.bmax[0]) it.bmax[0] = v[0];
if (v[2] > it.bmax[1]) it.bmax[1] = v[2];
}
}
int curTri = 0;
int curNode = 0;
subdivide(items, ntris, 0, ntris, trisPerChunk, curNode, cm->nodes, nchunks*4, curTri, cm->tris, tris);
delete [] items;
cm->nnodes = curNode;
// Calc max tris per node.
cm->maxTrisPerChunk = 0;
for (int i = 0; i < cm->nnodes; ++i)
{
rcChunkyTriMeshNode& node = cm->nodes[i];
const bool isLeaf = node.i >= 0;
if (!isLeaf) continue;
if (node.n > cm->maxTrisPerChunk)
cm->maxTrisPerChunk = node.n;
}
return true;
}
inline bool checkOverlapRect(const float amin[2], const float amax[2],
const float bmin[2], const float bmax[2])
{
bool overlap = true;
overlap = (amin[0] > bmax[0] || amax[0] < bmin[0]) ? false : overlap;
overlap = (amin[1] > bmax[1] || amax[1] < bmin[1]) ? false : overlap;
return overlap;
}
int rcGetChunksOverlappingRect(const rcChunkyTriMesh* cm,
float bmin[2], float bmax[2],
int* ids, const int maxIds)
{
// Traverse tree
int i = 0;
int n = 0;
while (i < cm->nnodes)
{
const rcChunkyTriMeshNode* node = &cm->nodes[i];
const bool overlap = checkOverlapRect(bmin, bmax, node->bmin, node->bmax);
const bool isLeafNode = node->i >= 0;
if (isLeafNode && overlap)
{
if (n < maxIds)
{
ids[n] = i;
n++;
}
}
if (overlap || isLeafNode)
i++;
else
{
const int escapeIndex = -node->i;
i += escapeIndex;
}
}
return n;
}
static bool checkOverlapSegment(const float p[2], const float q[2],
const float bmin[2], const float bmax[2])
{
static const float EPSILON = 1e-6f;
float tmin = 0;
float tmax = 1;
float d[2];
d[0] = q[0] - p[0];
d[1] = q[1] - p[1];
for (int i = 0; i < 2; i++)
{
if (fabsf(d[i]) < EPSILON)
{
// Ray is parallel to slab. No hit if origin not within slab
if (p[i] < bmin[i] || p[i] > bmax[i])
return false;
}
else
{
// Compute intersection t value of ray with near and far plane of slab
float ood = 1.0f / d[i];
float t1 = (bmin[i] - p[i]) * ood;
float t2 = (bmax[i] - p[i]) * ood;
if (t1 > t2) { float tmp = t1; t1 = t2; t2 = tmp; }
if (t1 > tmin) tmin = t1;
if (t2 < tmax) tmax = t2;
if (tmin > tmax) return false;
}
}
return true;
}
int rcGetChunksOverlappingSegment(const rcChunkyTriMesh* cm,
float p[2], float q[2],
int* ids, const int maxIds)
{
// Traverse tree
int i = 0;
int n = 0;
while (i < cm->nnodes)
{
const rcChunkyTriMeshNode* node = &cm->nodes[i];
const bool overlap = checkOverlapSegment(p, q, node->bmin, node->bmax);
const bool isLeafNode = node->i >= 0;
if (isLeafNode && overlap)
{
if (n < maxIds)
{
ids[n] = i;
n++;
}
}
if (overlap || isLeafNode)
i++;
else
{
const int escapeIndex = -node->i;
i += escapeIndex;
}
}
return n;
}

59
Engine/source/navigation/ChunkyTriMesh.h Normal file
View file

@ -0,0 +1,59 @@
//
// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it
// freely, subject to the following restrictions:
// 1. The origin of this software must not be misrepresented; you must not
// claim that you wrote the original software. If you use this software
// in a product, an acknowledgment in the product documentation would be
// appreciated but is not required.
// 2. Altered source versions must be plainly marked as such, and must not be
// misrepresented as being the original software.
// 3. This notice may not be removed or altered from any source distribution.
//
#ifndef CHUNKYTRIMESH_H
#define CHUNKYTRIMESH_H
struct rcChunkyTriMeshNode
{
float bmin[2];
float bmax[2];
int i;
int n;
};
struct rcChunkyTriMesh
{
inline rcChunkyTriMesh() : nodes(0), nnodes(0), tris(0), ntris(0), maxTrisPerChunk(0) {}
inline ~rcChunkyTriMesh() { delete [] nodes; delete [] tris; }
rcChunkyTriMeshNode* nodes;
int nnodes;
int* tris;
int ntris;
int maxTrisPerChunk;
private:
// Explicitly disabled copy constructor and copy assignment operator.
rcChunkyTriMesh(const rcChunkyTriMesh&);
rcChunkyTriMesh& operator=(const rcChunkyTriMesh&);
};
/// Creates partitioned triangle mesh (AABB tree),
/// where each node contains at max trisPerChunk triangles.
bool rcCreateChunkyTriMesh(const float* verts, const int* tris, int ntris,
int trisPerChunk, rcChunkyTriMesh* cm);
/// Returns the chunk indices which overlap the input rectable.
int rcGetChunksOverlappingRect(const rcChunkyTriMesh* cm, float bmin[2], float bmax[2], int* ids, const int maxIds);
/// Returns the chunk indices which overlap the input segment.
int rcGetChunksOverlappingSegment(const rcChunkyTriMesh* cm, float p[2], float q[2], int* ids, const int maxIds);
#endif // CHUNKYTRIMESH_H

15
Engine/source/navigation/coverPoint.cpp
View file

@ -31,6 +31,7 @@
#include "gfx/gfxDrawUtil.h"
#include "renderInstance/renderPassManager.h"
#include "console/engineAPI.h"
#include "T3D/gameBase/gameConnection.h"
extern bool gEditingMission;
@ -285,14 +286,22 @@ void CoverPoint::prepRenderImage(SceneRenderState *state)
void CoverPoint::render(ObjectRenderInst *ri, SceneRenderState *state, BaseMatInstance *overrideMat)
{
initGFXResources();
if (!state->isDiffusePass()) return;
if(overrideMat)
GameConnection* conn = GameConnection::getConnectionToServer();
MatrixF camTrans;
conn->getControlCameraTransform(0, &camTrans);
if ((getPosition() - camTrans.getPosition()).lenSquared() > 2500) return; //50 unit clamp
if (overrideMat)
return;
initGFXResources();
if(smVertexBuffer[mSize].isNull())
return;
PROFILE_SCOPE(CoverPoint_Render);
// Set up a GFX debug event (this helps with debugging rendering events in external tools)

484
Engine/source/navigation/duDebugDrawTorque.cpp
View file

@ -38,28 +38,64 @@
duDebugDrawTorque::duDebugDrawTorque()
{
VECTOR_SET_ASSOCIATION(mVertList);
VECTOR_SET_ASSOCIATION(mDrawCache);
mPrimType = 0;
mQuadsMode = false;
mVertCount = 0;
mGroup = 0;
mCurrColor = 0;
mOverrideColor = 0;
mOverride = false;
dMemset(&mStore, 0, sizeof(mStore));
mOverrideState = false;
}
duDebugDrawTorque::~duDebugDrawTorque()
{
clear();
}
void duDebugDrawTorque::depthMask(bool state)
{
mDesc.setZReadWrite(state, state);
if (mOverrideState)
return;
mDesc.setZReadWrite(state);
if (!state)
{
mDesc.setCullMode(GFXCullNone);
mDesc.setBlend(true);
}
else
{
mDesc.setCullMode(GFXCullCW);
mDesc.setBlend(false);
}
}
void duDebugDrawTorque::depthMask(bool state, bool isOverride)
{
depthMask(state);
mOverrideState = isOverride;
}
void duDebugDrawTorque::blend(bool blend)
{
mDesc.setBlend(true);
}
void duDebugDrawTorque::texture(bool state)
{
// need a checker texture?...... if(state is true) then set first slot to that texture.
}
unsigned int duDebugDrawTorque::areaToCol(unsigned int area)
{
switch (area)
{
// Ground (1) : light blue
case GroundArea: return duRGBA(0, 192, 255, 255);
// Water : blue
case WaterArea: return duRGBA(0, 0, 255, 255);
// Road : brown
case OffMeshArea: return duRGBA(50, 20, 12, 255);
// Unexpected : red
default: return duRGBA(255, 0, 0, 255);
}
}
/// Begin drawing primitives.
@ -67,27 +103,20 @@ void duDebugDrawTorque::texture(bool state)
/// @param size [in] size of a primitive, applies to point size and line width only.
void duDebugDrawTorque::begin(duDebugDrawPrimitives prim, float size)
{
mCurrColor = -1;
mQuadsMode = false;
if (!mVertList.empty())
mVertList.clear();
mVertCount = 0;
mPrimType = 0;
switch(prim)
{
case DU_DRAW_POINTS: mPrimType = GFXPointList; break;
case DU_DRAW_LINES: mPrimType = GFXLineList; break;
case DU_DRAW_TRIS: mPrimType = GFXTriangleList; break;
case DU_DRAW_QUADS: mPrimType = GFXTriangleList;
mQuadsMode = true; break;
}
mBuffers.push_back(Buffer(mPrimType));
mBuffers.last().group = mGroup;
mDesc.setCullMode(GFXCullNone);
mDesc.setBlend(true);
}
void duDebugDrawTorque::beginGroup(U32 group)
{
mGroup = group;
switch (prim)
{
case DU_DRAW_POINTS: mPrimType = DU_DRAW_POINTS; break;
case DU_DRAW_LINES: mPrimType = DU_DRAW_LINES; break;
case DU_DRAW_TRIS: mPrimType = DU_DRAW_TRIS; break;
case DU_DRAW_QUADS: mPrimType = DU_DRAW_QUADS; break;
}
}
/// Submit a vertex
@ -103,30 +132,7 @@ void duDebugDrawTorque::vertex(const float* pos, unsigned int color)
/// @param color [in] color of the verts.
void duDebugDrawTorque::vertex(const float x, const float y, const float z, unsigned int color)
{
if(mQuadsMode)
{
if(mVertCount == 3)
{
_vertex(x, -z, y, color);
_vertex(mStore[0][0], mStore[0][1], mStore[0][2], color);
_vertex(mStore[1][0], mStore[1][1], mStore[1][2], color);
_vertex(mStore[1][0], mStore[1][1], mStore[1][2], color);
_vertex(mStore[2][0], mStore[2][1], mStore[2][2], color);
_vertex(x, -z, y, color);
mVertCount = 0;
}
else
{
mStore[mVertCount][0] = x;
mStore[mVertCount][1] = -z;
mStore[mVertCount][2] = y;
mVertCount++;
}
}
else
{
_vertex(x, -z, y, color);
}
_vertex(x, -z, y, color);
}
/// Submit a vertex
@ -148,105 +154,325 @@ void duDebugDrawTorque::vertex(const float x, const float y, const float z, unsi
/// Push a vertex onto the buffer.
void duDebugDrawTorque::_vertex(const float x, const float y, const float z, unsigned int color)
{
// Use override color if we must.
//if(mOverride)
//color = mOverrideColor;
if(mCurrColor != color || !mBuffers.last().buffer.size())
{
U8 r, g, b, a;
// Convert color integer to components.
rcCol(color, r, g, b, a);
mBuffers.last().buffer.push_back(Instruction(r, g, b, a));
mCurrColor = color;
}
// Construct vertex data.
mBuffers.last().buffer.push_back(Instruction(x, y, z));
GFXVertexPCT vert;
vert.point.set(x, y, z);
U8 r, g, b, a;
// Convert color integer to components.
rcCol(color, r, g, b, a);
vert.color.set(r, g, b, a);
mVertList.push_back(vert);
}
/// End drawing primitives.
void duDebugDrawTorque::end()
{
}
if (mVertList.empty())
return;
void duDebugDrawTorque::overrideColor(unsigned int col)
{
mOverride = true;
mOverrideColor = col;
}
void duDebugDrawTorque::cancelOverride()
{
mOverride = false;
}
void duDebugDrawTorque::renderBuffer(Buffer &b)
{
PrimBuild::begin(b.primType, b.buffer.size());
Vector<Instruction> &buf = b.buffer;
for(U32 i = 0; i < buf.size(); i++)
const U32 maxVertsPerDraw = GFX_MAX_DYNAMIC_VERTS;
switch (mPrimType)
{
switch(buf[i].type)
case DU_DRAW_POINTS:
{
const U32 totalPoints = mVertList.size();
for (U32 p = 0; p < totalPoints;)
{
case Instruction::POINT:
PrimBuild::vertex3f(buf[i].data.point.x,
buf[i].data.point.y,
buf[i].data.point.z);
break;
const U32 pointsThisBatch = getMin(maxVertsPerDraw, totalPoints - p);
const U32 batchVerts = pointsThisBatch;
Box3F box;
box.minExtents.set(F32_MAX, F32_MAX, F32_MAX);
box.maxExtents.set(-F32_MAX, -F32_MAX, -F32_MAX);
case Instruction::COLOR:
if(mOverride)
break;
PrimBuild::color4i(buf[i].data.color.r,
buf[i].data.color.g,
buf[i].data.color.b,
buf[i].data.color.a);
break;
default:
break;
GFXVertexBufferHandle<GFXVertexPCT> buffer;
buffer.set(GFX, batchVerts, GFXBufferTypeStatic);
GFXVertexPCT* verts = buffer.lock();
for (U32 i = 0; i < pointsThisBatch; ++i)
{
verts[i] = mVertList[p + i];
box.minExtents.setMin(verts[i].point);
box.maxExtents.setMax(verts[i].point);
}
buffer.unlock();
// --- Build index buffer
GFXPrimitiveBufferHandle pb;
pb.set(GFX, pointsThisBatch, pointsThisBatch, GFXBufferTypeStatic);
U16* indices = nullptr;
pb.lock(&indices);
for (U32 i = 0; i < pointsThisBatch; ++i)
{
indices[i] = i;
}
pb.unlock();
CachedDraw batch;
batch.primType = GFXPointList;
batch.buffer = buffer;
batch.vertexCount = batchVerts;
batch.primitiveBuffer = pb;
batch.primitiveCount = pointsThisBatch;
batch.state = mDesc;
batch.bounds = box;
mDrawCache.push_back(batch);
p += pointsThisBatch;
}
break;
}
PrimBuild::end();
case DU_DRAW_LINES:
{
AssertFatal(mVertList.size() % 2 == 0, "DU_DRAW_LINES given invalid vertex count.");
const U32 vertsPerLine = 2;
const U32 totalLines = mVertList.size() / vertsPerLine;
for (U32 l = 0; l < totalLines;)
{
const U32 linesThisBatch = getMin(maxVertsPerDraw / vertsPerLine, totalLines - l);
const U32 batchVerts = linesThisBatch * vertsPerLine;
Box3F box;
box.minExtents.set(F32_MAX, F32_MAX, F32_MAX);
box.maxExtents.set(-F32_MAX, -F32_MAX, -F32_MAX);
GFXVertexBufferHandle<GFXVertexPCT> buffer;
buffer.set(GFX, batchVerts, GFXBufferTypeStatic);
GFXVertexPCT* verts = buffer.lock();
for (U32 i = 0; i < linesThisBatch * vertsPerLine; ++i)
{
verts[i] = mVertList[l * vertsPerLine + i];
box.minExtents.setMin(verts[i].point);
box.maxExtents.setMax(verts[i].point);
}
buffer.unlock();
// --- Build index buffer
GFXPrimitiveBufferHandle pb;
pb.set(GFX, linesThisBatch * 2, linesThisBatch, GFXBufferTypeStatic);
U16* indices = nullptr;
pb.lock(&indices);
for (U32 i = 0; i < linesThisBatch; ++i)
{
indices[i * 2 + 0] = i * 2;
indices[i * 2 + 1] = i * 2 + 1;
}
pb.unlock();
CachedDraw batch;
batch.primType = GFXLineList;
batch.buffer = buffer;
batch.vertexCount = batchVerts;
batch.primitiveBuffer = pb;
batch.primitiveCount = linesThisBatch;
batch.state = mDesc;
batch.bounds = box;
mDrawCache.push_back(batch);
l += linesThisBatch;
}
break;
}
case DU_DRAW_TRIS:
{
AssertFatal(mVertList.size() % 3 == 0, "DU_DRAW_TRIS given invalid vertex count.");
const U32 vertsPerTri = 3;
const U32 totalTris = mVertList.size() / vertsPerTri;
for (U32 t = 0; t < totalTris;)
{
const U32 trisThisBatch = getMin(maxVertsPerDraw / vertsPerTri, totalTris - t);
const U32 batchVerts = trisThisBatch * vertsPerTri;
Box3F box;
box.minExtents.set(F32_MAX, F32_MAX, F32_MAX);
box.maxExtents.set(-F32_MAX, -F32_MAX, -F32_MAX);
GFXVertexBufferHandle<GFXVertexPCT> buffer;
buffer.set(GFX, batchVerts, GFXBufferTypeStatic);
GFXVertexPCT* verts = buffer.lock();
for (U32 i = 0; i < trisThisBatch * vertsPerTri; ++i)
{
verts[i] = mVertList[t * vertsPerTri + i];
box.minExtents.setMin(verts[i].point);
box.maxExtents.setMax(verts[i].point);
}
buffer.unlock();
// --- Build index buffer
GFXPrimitiveBufferHandle pb;
pb.set(GFX, trisThisBatch*3, trisThisBatch, GFXBufferTypeStatic);
U16* indices = nullptr;
pb.lock(&indices);
for (U32 i = 0; i < trisThisBatch; ++i)
{
indices[i * 3 + 0] = i * 3 + 0;
indices[i * 3 + 1] = i * 3 + 1;
indices[i * 3 + 2] = i * 3 + 2;
}
pb.unlock();
CachedDraw batch;
batch.primType = GFXTriangleList;
batch.buffer = buffer;
batch.vertexCount = batchVerts;
batch.primitiveBuffer = pb;
batch.primitiveCount = trisThisBatch;
batch.state = mDesc;
batch.bounds = box;
mDrawCache.push_back(batch);
t += trisThisBatch;
}
break;
}
case DU_DRAW_QUADS:
{
AssertFatal(mVertList.size() % 4 == 0, "DU_DRAW_QUADS given wrong number of vertices.");
const U32 vertsPerQuad = 4;
const U32 totalQuads = mVertList.size() / 4;
for (U32 q = 0; q < totalQuads;)
{
const U32 quadsThisBatch = getMin(maxVertsPerDraw / vertsPerQuad, totalQuads - q);
const U32 batchVerts = quadsThisBatch * vertsPerQuad;
const U32 batchIndices = quadsThisBatch * 6;
Box3F box;
box.minExtents.set(F32_MAX, F32_MAX, F32_MAX);
box.maxExtents.set(-F32_MAX, -F32_MAX, -F32_MAX);
GFXVertexBufferHandle<GFXVertexPCT> buffer;
buffer.set(GFX, batchVerts, GFXBufferTypeStatic);
GFXVertexPCT* verts = buffer.lock();
U32 outIdx = 0;
for (U32 i = 0; i < quadsThisBatch; ++i)
{
const GFXVertexPCT& v0 = mVertList[(q + i) * 4 + 0];
const GFXVertexPCT& v1 = mVertList[(q + i) * 4 + 1];
const GFXVertexPCT& v2 = mVertList[(q + i) * 4 + 2];
const GFXVertexPCT& v3 = mVertList[(q + i) * 4 + 3];
verts[outIdx++] = v0;
verts[outIdx++] = v1;
verts[outIdx++] = v2;
verts[outIdx++] = v3;
}
buffer.unlock();
GFXPrimitiveBufferHandle pb;
pb.set(GFX, batchIndices, quadsThisBatch*2, GFXBufferTypeStatic);
U16* indices = nullptr;
pb.lock(&indices);
for (U32 i = 0; i < quadsThisBatch; ++i)
{
const U16 base = i * 4;
indices[i * 6 + 0] = base + 0;
indices[i * 6 + 1] = base + 1;
indices[i * 6 + 2] = base + 2;
indices[i * 6 + 3] = base + 0;
indices[i * 6 + 4] = base + 2;
indices[i * 6 + 5] = base + 3;
}
pb.unlock();
CachedDraw batch;
batch.primType = GFXTriangleList;
batch.buffer = buffer;
batch.vertexCount = batchVerts;
batch.primitiveBuffer = pb;
batch.primitiveCount = quadsThisBatch*2;
batch.state = mDesc;
mDrawCache.push_back(batch);
q += quadsThisBatch;
}
break;
}
}
mVertList.clear();
}
void duDebugDrawTorque::render()
void duDebugDrawTorque::clearCache()
{
GFXStateBlockRef sb = GFX->createStateBlock(mDesc);
GFX->setStateBlock(sb);
// Use override color for all rendering.
if(mOverride)
mDrawCache.clear();
}
void duDebugDrawTorque::render(SceneRenderState* state)
{
if (!state->isDiffusePass()) return;
const Frustum& frustum = state->getCameraFrustum();
for (U32 i = 0; i < mDrawCache.size(); ++i)
{
U8 r, g, b, a;
rcCol(mOverrideColor, r, g, b, a);
PrimBuild::color4i(r, g, b, a);
}
for(U32 b = 0; b < mBuffers.size(); b++)
{
renderBuffer(mBuffers[b]);
const CachedDraw& draw = mDrawCache[i];
if (!frustum.getBounds().isOverlapped(draw.bounds))
continue;
GFX->setPrimitiveBuffer(draw.primitiveBuffer);
GFX->setStateBlockByDesc(draw.state);
GFX->setupGenericShaders(GFXDevice::GSColor);
GFX->setVertexBuffer(draw.buffer);
GFX->drawIndexedPrimitive(
draw.primType,
0, // start vertex
0, // min vertex index
draw.vertexCount, // vertex count
0, // start index
draw.primitiveCount // primitive count
);
}
}
void duDebugDrawTorque::renderGroup(U32 group)
void duDebugDrawTorque::immediateRender()
{
GFXStateBlockRef sb = GFX->createStateBlock(mDesc);
GFX->setStateBlock(sb);
// Use override color for all rendering.
if(mOverride)
for (U32 i = 0; i < mDrawCache.size(); ++i)
{
U8 r, g, b, a;
rcCol(mOverrideColor, r, g, b, a);
PrimBuild::color4i(r, g, b, a);
}
for(U32 b = 0; b < mBuffers.size(); b++)
{
if(mBuffers[b].group == group)
renderBuffer(mBuffers[b]);
const CachedDraw& draw = mDrawCache[i];
GFX->setPrimitiveBuffer(draw.primitiveBuffer);
GFX->setStateBlockByDesc(draw.state);
GFX->setupGenericShaders(GFXDevice::GSColor);
GFX->setVertexBuffer(draw.buffer);
GFX->drawIndexedPrimitive(
draw.primType,
0, // start vertex
0, // min vertex index
draw.vertexCount, // vertex count
0, // start index
draw.primitiveCount // primitive count
);
}
}
void duDebugDrawTorque::clear()
{
for(U32 b = 0; b < mBuffers.size(); b++)
mBuffers[b].buffer.clear();
mBuffers.clear();
}

149
Engine/source/navigation/duDebugDrawTorque.h
View file

@ -23,12 +23,37 @@
#ifndef _DU_DEBUG_DRAW_TORQUE_H_
#define _DU_DEBUG_DRAW_TORQUE_H_
#ifndef _TVECTOR_H_
#include "core/util/tVector.h"
#endif
#include <DebugDraw.h>
#include "gfx/gfxStateBlock.h"
/// @brief Implements the duDebugDraw interface in Torque.
class duDebugDrawTorque: public duDebugDraw {
#ifndef _GFXSTATEBLOCK_H_
#include "gfx/gfxStateBlock.h"
#endif
#ifndef _GFXVERTEXTYPES_H_
#include "gfx/gfxVertexTypes.h"
#endif
#ifndef _GFXVERTEXBUFFER_H_
#include "gfx/gfxVertexBuffer.h"
#endif
#ifndef _SCENERENDERSTATE_H_
#include "scene/sceneRenderState.h"
#endif
/**
* @class duDebugDrawTorque
* @brief Implements the duDebugDraw interface in Torque.
*
* Every debug draw from recast goes through a process of begin, add vertex and then end
* just like our primbuilder class, but we need to catch these vertices
* and add them to a GFXVertexBuffer as recast supports GL_QUADS which is now
* deprecated.
*/
class duDebugDrawTorque : public duDebugDraw {
public:
duDebugDrawTorque();
~duDebugDrawTorque();
@ -36,23 +61,20 @@ public:
/// Enable/disable Z read.
void depthMask(bool state) override;
/// Enable/disable texturing. Not used.
void texture(bool state) override;
/// <summary>
/// Enable/disable Z read and overrides any setting that will come from detour.
/// </summary>
/// <param name="state">Z read state.</param>
/// <param name="isOverride">Set to true to override any future changes.</param>
void depthMask(bool state, bool isOverride);
/// Special colour overwrite for when I get picky about the colours Mikko chose.
void overrideColor(unsigned int col);
/// Stop the colour override.
void cancelOverride();
void blend(bool blend);
/// Begin drawing primitives.
/// @param prim [in] primitive type to draw, one of rcDebugDrawPrimitives.
/// @param size [in] size of a primitive, applies to point size and line width only.
void begin(duDebugDrawPrimitives prim, float size = 1.0f) override;
/// All new buffers go into this group.
void beginGroup(U32 group);
/// Submit a vertex
/// @param pos [in] position of the verts.
/// @param color [in] color of the verts.
@ -66,92 +88,57 @@ public:
/// Submit a vertex
/// @param pos [in] position of the verts.
/// @param color [in] color of the verts.
/// @param uv [in] the uv coordinates.
void vertex(const float* pos, unsigned int color, const float* uv) override;
/// Submit a vertex
/// @param x,y,z [in] position of the verts.
/// @param color [in] color of the verts.
/// @param u [in] the u coordinate.
/// @param v [in] the v coordinate.
void vertex(const float x, const float y, const float z, unsigned int color, const float u, const float v) override;
/// Set a texture
/// @param state, use a texture in this draw, usually a checker texture.
void texture(bool state) override;
/// <summary>
/// Assigns a colour to an area type.
/// </summary>
/// <param name="area">The area type.</param>
/// <returns>The colour in recast format for the area.</returns>
unsigned int areaToCol(unsigned int area) override;
/// End drawing primitives.
void end() override;
/// Render buffered primitive.
void render();
void clearCache();
void render(SceneRenderState* state);
void immediateRender();
/// Render buffered primitives in a group.
void renderGroup(U32 group);
/// Delete buffered primitive.
void clear();
private:
struct CachedDraw {
GFXPrimitiveType primType;
GFXVertexBufferHandle<GFXVertexPCT> buffer;
GFXPrimitiveBufferHandle primitiveBuffer;
U32 vertexCount;
U32 primitiveCount;
GFXStateBlockDesc state;
Box3F bounds;
};
Vector<CachedDraw> mDrawCache;
GFXStateBlockDesc mDesc;
Vector<GFXVertexPCT> mVertList; // Our vertex list for setting up vertexBuffer in the End function.
GFXVertexBufferHandle<GFXVertexPCT> mVertexBuffer; // our vertex buffer for drawing.
U32 mPrimType;
bool mQuadsMode;
U32 mVertCount;
F32 mStore[3][3];
U32 mGroup;
struct Instruction {
// Contain either a point or a color command.
union {
struct {
U8 r, g, b, a;
} color;
struct {
float x, y, z;
} point;
U32 primType;
} data;
// Which type of data do we store?
enum {
COLOR,
POINT,
PRIMTYPE,
} type;
// Construct as color instruction.
Instruction(U8 r, U8 g, U8 b, U8 a) {
type = COLOR;
data.color.r = r;
data.color.g = g;
data.color.b = b;
data.color.a = a;
}
// Construct as point.
Instruction(float x, float y, float z) {
type = POINT;
data.point.x = x;
data.point.y = y;
data.point.z = z;
}
Instruction(U32 t = 0) {
type = PRIMTYPE;
data.primType = t;
}
};
struct Buffer {
U32 group;
Vector<Instruction> buffer;
GFXPrimitiveType primType;
Buffer(U32 type = 0) {
primType = (GFXPrimitiveType)type;
group = 0;
}
};
Vector<Buffer> mBuffers;
U32 mCurrColor;
U32 mOverrideColor;
bool mOverride;
bool mOverrideState;
void _vertex(const float x, const float y, const float z, unsigned int color);
void renderBuffer(Buffer &b);
};
#endif

451
Engine/source/navigation/guiNavEditorCtrl.cpp
View file

@ -38,6 +38,7 @@
#include "gui/worldEditor/undoActions.h"
#include "T3D/gameBase/gameConnection.h"
#include "T3D/AI/AIController.h"
#include "navigation/navMeshTool.h"
IMPLEMENT_CONOBJECT(GuiNavEditorCtrl);
@ -47,24 +48,11 @@ ConsoleDocClass(GuiNavEditorCtrl,
"@internal"
);
// Each of the mode names directly correlates with the Nav Editor's tool palette.
const String GuiNavEditorCtrl::mSelectMode = "SelectMode";
const String GuiNavEditorCtrl::mLinkMode = "LinkMode";
const String GuiNavEditorCtrl::mCoverMode = "CoverMode";
const String GuiNavEditorCtrl::mTileMode = "TileMode";
const String GuiNavEditorCtrl::mTestMode = "TestMode";
GuiNavEditorCtrl::GuiNavEditorCtrl()
{
mMode = mSelectMode;
mIsDirty = false;
mStartDragMousePoint = InvalidMousePoint;
mMesh = NULL;
mCurTile = mTile = -1;
mPlayer = mCurPlayer = NULL;
mSpawnClass = mSpawnDatablock = "";
mLinkStart = Point3F::Max;
mLink = mCurLink = -1;
}
GuiNavEditorCtrl::~GuiNavEditorCtrl()
@ -101,25 +89,21 @@ void GuiNavEditorCtrl::initPersistFields()
docsURL;
addField("isDirty", TypeBool, Offset(mIsDirty, GuiNavEditorCtrl));
addField("spawnClass", TypeRealString, Offset(mSpawnClass, GuiNavEditorCtrl),
"Class of object to spawn in test mode.");
addField("spawnDatablock", TypeRealString, Offset(mSpawnDatablock, GuiNavEditorCtrl),
"Datablock to give new objects in test mode.");
Parent::initPersistFields();
}
void GuiNavEditorCtrl::onSleep()
{
Parent::onSleep();
//mMode = mSelectMode;
}
void GuiNavEditorCtrl::selectMesh(NavMesh *mesh)
{
mesh->setSelected(true);
mMesh = mesh;
if (mTool)
mTool->setActiveNavMesh(mMesh);
}
DefineEngineMethod(GuiNavEditorCtrl, selectMesh, void, (S32 id),,
@ -141,125 +125,6 @@ DefineEngineMethod(GuiNavEditorCtrl, getMesh, S32, (),,
return object->getMeshId();
}
S32 GuiNavEditorCtrl::getPlayerId()
{
return mPlayer.isNull() ? 0 : mPlayer->getId();
}
DefineEngineMethod(GuiNavEditorCtrl, getPlayer, S32, (),,
"@brief Select a NavMesh object.")
{
return object->getPlayerId();
}
void GuiNavEditorCtrl::deselect()
{
if(!mMesh.isNull())
mMesh->setSelected(false);
mMesh = NULL;
mPlayer = mCurPlayer = NULL;
mCurTile = mTile = -1;
mLinkStart = Point3F::Max;
mLink = mCurLink = -1;
}
DefineEngineMethod(GuiNavEditorCtrl, deselect, void, (),,
"@brief Deselect whatever is currently selected in the editor.")
{
object->deselect();
}
void GuiNavEditorCtrl::deleteLink()
{
if(!mMesh.isNull() && mLink != -1)
{
mMesh->selectLink(mLink, false);
mMesh->deleteLink(mLink);
mLink = -1;
Con::executef(this, "onLinkDeselected");
}
}
DefineEngineMethod(GuiNavEditorCtrl, deleteLink, void, (),,
"@brief Delete the currently selected link.")
{
object->deleteLink();
}
void GuiNavEditorCtrl::setLinkFlags(const LinkData &d)
{
if(mMode == mLinkMode && !mMesh.isNull() && mLink != -1)
{
mMesh->setLinkFlags(mLink, d);
}
}
DefineEngineMethod(GuiNavEditorCtrl, setLinkFlags, void, (U32 flags),,
"@Brief Set jump and drop properties of the selected link.")
{
object->setLinkFlags(LinkData(flags));
}
void GuiNavEditorCtrl::buildTile()
{
if(!mMesh.isNull() && mTile != -1)
mMesh->buildTile(mTile);
}
DefineEngineMethod(GuiNavEditorCtrl, buildTile, void, (),,
"@brief Build the currently selected tile.")
{
object->buildTile();
}
void GuiNavEditorCtrl::spawnPlayer(const Point3F &pos)
{
SceneObject *obj = (SceneObject*)Sim::spawnObject(mSpawnClass, mSpawnDatablock);
if(obj)
{
MatrixF mat(true);
mat.setPosition(pos);
obj->setTransform(mat);
SimObject* cleanup = Sim::findObject("MissionCleanup");
if(cleanup)
{
SimGroup* missionCleanup = dynamic_cast<SimGroup*>(cleanup);
missionCleanup->addObject(obj);
}
mPlayer = obj;
#ifdef TORQUE_NAVIGATION_ENABLED
AIPlayer* asAIPlayer = dynamic_cast<AIPlayer*>(obj);
if (asAIPlayer) //try direct
{
Con::executef(this, "onPlayerSelected", Con::getIntArg(asAIPlayer->mLinkTypes.getFlags()));
}
else
{
ShapeBase* sbo = dynamic_cast<ShapeBase*>(obj);
if (sbo->getAIController())
{
if (sbo->getAIController()->mControllerData)
Con::executef(this, "onPlayerSelected", Con::getIntArg(sbo->getAIController()->mControllerData->mLinkTypes.getFlags()));
}
else
{
#endif
Con::executef(this, "onPlayerSelected");
#ifdef TORQUE_NAVIGATION_ENABLED
}
}
#endif
}
}
DefineEngineMethod(GuiNavEditorCtrl, spawnPlayer, void, (),,
"@brief Spawn an AIPlayer at the centre of the screen.")
{
Point3F c;
if(object->get3DCentre(c))
object->spawnPlayer(c);
}
void GuiNavEditorCtrl::get3DCursor(GuiCursor *&cursor,
bool &visible,
const Gui3DMouseEvent &event_)
@ -315,148 +180,12 @@ void GuiNavEditorCtrl::on3DMouseDown(const Gui3DMouseEvent & event)
{
mGizmo->on3DMouseDown(event);
if(!isFirstResponder())
setFirstResponder();
if (mTool)
mTool->on3DMouseDown(event);
mouseLock();
// Construct a LineSegment from the camera position to 1000 meters away in
// the direction clicked.
// If that segment hits the terrain, truncate the ray to only be that length.
Point3F startPnt = event.pos;
Point3F endPnt = event.pos + event.vec * 1000.0f;
RayInfo ri;
U8 keys = Input::getModifierKeys();
bool shift = keys & SI_LSHIFT;
bool ctrl = keys & SI_LCTRL;
if(mMode == mLinkMode && !mMesh.isNull())
{
if(gServerContainer.castRay(startPnt, endPnt, StaticObjectType, &ri))
{
U32 link = mMesh->getLink(ri.point);
if(link != -1)
{
if(mLink != -1)
mMesh->selectLink(mLink, false);
mMesh->selectLink(link, true, false);
mLink = link;
LinkData d = mMesh->getLinkFlags(mLink);
Con::executef(this, "onLinkSelected", Con::getIntArg(d.getFlags()));
}
else
{
if(mLink != -1)
{
mMesh->selectLink(mLink, false);
mLink = -1;
Con::executef(this, "onLinkDeselected");
}
else
{
if(mLinkStart != Point3F::Max)
{
mMesh->addLink(mLinkStart, ri.point);
if(!shift)
mLinkStart = Point3F::Max;
}
else
{
mLinkStart = ri.point;
}
}
}
}
else
{
mMesh->selectLink(mLink, false);
mLink = -1;
Con::executef(this, "onLinkDeselected");
}
}
if(mMode == mTileMode && !mMesh.isNull())
{
if(gServerContainer.castRay(startPnt, endPnt, StaticShapeObjectType, &ri))
{
mTile = mMesh->getTile(ri.point);
dd.clear();
mMesh->renderTileData(dd, mTile);
}
}
if(mMode == mTestMode)
{
// Spawn new character
if(ctrl)
{
if(gServerContainer.castRay(startPnt, endPnt, StaticObjectType, &ri))
spawnPlayer(ri.point);
}
// Deselect character
else if(shift)
{
mPlayer = NULL;
Con::executef(this, "onPlayerDeselected");
}
// Select/move character
else
{
if(gServerContainer.castRay(startPnt, endPnt, PlayerObjectType | VehicleObjectType, &ri))
{
if(ri.object)
{
mPlayer = ri.object;
#ifdef TORQUE_NAVIGATION_ENABLED
AIPlayer* asAIPlayer = dynamic_cast<AIPlayer*>(mPlayer.getPointer());
if (asAIPlayer) //try direct
{
Con::executef(this, "onPlayerSelected", Con::getIntArg(asAIPlayer->mLinkTypes.getFlags()));
}
else
{
ShapeBase* sbo = dynamic_cast<ShapeBase*>(mPlayer.getPointer());
if (sbo->getAIController())
{
if (sbo->getAIController()->mControllerData)
Con::executef(this, "onPlayerSelected", Con::getIntArg(sbo->getAIController()->mControllerData->mLinkTypes.getFlags()));
}
else
{
#endif
Con::executef(this, "onPlayerSelected");
}
#ifdef TORQUE_NAVIGATION_ENABLED
}
}
#endif
}
else if (!mPlayer.isNull() && gServerContainer.castRay(startPnt, endPnt, StaticObjectType, &ri))
{
AIPlayer* asAIPlayer = dynamic_cast<AIPlayer*>(mPlayer.getPointer());
if (asAIPlayer) //try direct
{
#ifdef TORQUE_NAVIGATION_ENABLED
asAIPlayer->setPathDestination(ri.point);
#else
asAIPlayer->setMoveDestination(ri.point,false);
#endif
}
else
{
ShapeBase* sbo = dynamic_cast<ShapeBase*>(mPlayer.getPointer());
if (sbo->getAIController())
{
if (sbo->getAIController()->mControllerData)
sbo->getAIController()->getNav()->setPathDestination(ri.point, true);
}
}
}
}
}
return;
}
void GuiNavEditorCtrl::on3DMouseUp(const Gui3DMouseEvent & event)
@ -464,64 +193,18 @@ void GuiNavEditorCtrl::on3DMouseUp(const Gui3DMouseEvent & event)
// Keep the Gizmo up to date.
mGizmo->on3DMouseUp(event);
if (mTool)
mTool->on3DMouseUp(event);
mouseUnlock();
}
void GuiNavEditorCtrl::on3DMouseMove(const Gui3DMouseEvent & event)
{
//if(mSelRiver != NULL && mSelNode != -1)
//mGizmo->on3DMouseMove(event);
if (mTool)
mTool->on3DMouseMove(event);
Point3F startPnt = event.pos;
Point3F endPnt = event.pos + event.vec * 1000.0f;
RayInfo ri;
if(mMode == mLinkMode && !mMesh.isNull())
{
if(gServerContainer.castRay(startPnt, endPnt, StaticObjectType, &ri))
{
U32 link = mMesh->getLink(ri.point);
if(link != -1)
{
if(link != mLink)
{
if(mCurLink != -1)
mMesh->selectLink(mCurLink, false);
mMesh->selectLink(link, true, true);
}
mCurLink = link;
}
else
{
if(mCurLink != mLink)
mMesh->selectLink(mCurLink, false);
mCurLink = -1;
}
}
else
{
mMesh->selectLink(mCurLink, false);
mCurLink = -1;
}
}
// Select a tile from our current NavMesh.
if(mMode == mTileMode && !mMesh.isNull())
{
if(gServerContainer.castRay(startPnt, endPnt, StaticObjectType, &ri))
mCurTile = mMesh->getTile(ri.point);
else
mCurTile = -1;
}
if(mMode == mTestMode)
{
if(gServerContainer.castRay(startPnt, endPnt, PlayerObjectType | VehicleObjectType, &ri))
mCurPlayer = ri.object;
else
mCurPlayer = NULL;
}
return;
}
void GuiNavEditorCtrl::on3DMouseDragged(const Gui3DMouseEvent & event)
@ -549,6 +232,11 @@ void GuiNavEditorCtrl::on3DMouseLeave(const Gui3DMouseEvent & event)
void GuiNavEditorCtrl::updateGuiInfo()
{
if (mTool)
{
if (mTool->updateGuiInfo())
return;
}
}
void GuiNavEditorCtrl::onRender(Point2I offset, const RectI &updateRect)
@ -559,22 +247,6 @@ void GuiNavEditorCtrl::onRender(Point2I offset, const RectI &updateRect)
return;
}
static void renderBoxOutline(const Box3F &box, const ColorI &col)
{
if(box != Box3F::Invalid)
{
GFXStateBlockDesc desc;
desc.setCullMode(GFXCullNone);
desc.setFillModeSolid();
desc.setZReadWrite(true, false);
desc.setBlend(true);
GFX->getDrawUtil()->drawCube(desc, box, ColorI(col, 20));
desc.setFillModeWireframe();
desc.setBlend(false);
GFX->getDrawUtil()->drawCube(desc, box, ColorI(col, 255));
}
}
void GuiNavEditorCtrl::renderScene(const RectI & updateRect)
{
GFX->setStateBlock(mZDisableSB);
@ -592,45 +264,15 @@ void GuiNavEditorCtrl::renderScene(const RectI & updateRect)
Point3F camPos;
mat.getColumn(3,&camPos);
if(mMode == mLinkMode)
{
if(mLinkStart != Point3F::Max)
{
GFXStateBlockDesc desc;
desc.setBlend(false);
desc.setZReadWrite(true ,true);
MatrixF linkMat(true);
linkMat.setPosition(mLinkStart);
Point3F scale(0.8f, 0.8f, 0.8f);
GFX->getDrawUtil()->drawTransform(desc, linkMat, &scale);
}
}
if(mMode == mTileMode && !mMesh.isNull())
{
renderBoxOutline(mMesh->getTileBox(mCurTile), ColorI::BLUE);
renderBoxOutline(mMesh->getTileBox(mTile), ColorI::GREEN);
if(Con::getBoolVariable("$Nav::Editor::renderVoxels", false)) dd.renderGroup(0);
if(Con::getBoolVariable("$Nav::Editor::renderInput", false))
{
dd.depthMask(false);
dd.renderGroup(1);
dd.depthMask(true);
}
}
if(mMode == mTestMode)
{
if(!mCurPlayer.isNull())
renderBoxOutline(mCurPlayer->getWorldBox(), ColorI::BLUE);
if(!mPlayer.isNull())
renderBoxOutline(mPlayer->getWorldBox(), ColorI::GREEN);
}
if (mTool)
mTool->onRender3D();
duDebugDrawTorque d;
if(!mMesh.isNull())
if (!mMesh.isNull())
{
mMesh->renderLinks(d);
d.render();
d.immediateRender();
}
// Now draw all the 2d stuff!
GFX->setClipRect(updateRect);
@ -652,15 +294,6 @@ bool GuiNavEditorCtrl::getStaticPos(const Gui3DMouseEvent & event, Point3F &tpos
return hit;
}
void GuiNavEditorCtrl::setMode(String mode, bool sourceShortcut = false)
{
mMode = mode;
Con::executef(this, "onModeSet", mode);
if(sourceShortcut)
Con::executef(this, "paletteSync", mode);
}
void GuiNavEditorCtrl::submitUndo(const UTF8 *name)
{
// Grab the mission editor undo manager.
@ -691,13 +324,41 @@ void GuiNavEditorCtrl::_prepRenderImage(SceneManager* sceneGraph, const SceneRen
}*/
}
DefineEngineMethod(GuiNavEditorCtrl, getMode, const char*, (), , "")
void GuiNavEditorCtrl::setActiveTool(NavMeshTool* tool)
{
return object->getMode();
if (mTool)
{
mTool->onDeactivated();
}
mTool = tool;
if (mTool)
{
mTool->setActiveEditor(this);
mTool->setActiveNavMesh(mMesh);
mTool->onActivated(mLastEvent);
}
}
DefineEngineMethod(GuiNavEditorCtrl, setMode, void, (String mode),, "setMode(String mode)")
void GuiNavEditorCtrl::setDrawMode(S32 id)
{
object->setMode(mode);
if (mMesh.isNull())
return;
mMesh->setDrawMode((NavMesh::DrawMode)id);
}
DefineEngineMethod(GuiNavEditorCtrl, setDrawMode, void, (S32 id), ,
"@brief Deselect whatever is currently selected in the editor.")
{
object->setDrawMode(id);
}
DefineEngineMethod(GuiNavEditorCtrl, setActiveTool, void, (const char* toolName), , "( NavMeshTool tool )")
{
NavMeshTool* tool = dynamic_cast<NavMeshTool*>(Sim::findObject(toolName));
object->setActiveTool(tool);
}
#endif

45
Engine/source/navigation/guiNavEditorCtrl.h
View file

@ -34,6 +34,10 @@
#include "gui/worldEditor/gizmo.h"
#endif
//#ifndef _NAVMESH_TOOL_H_
//#include "navigation/navMeshTool.h"
//#endif
#include "navMesh.h"
#include "T3D/aiPlayer.h"
@ -41,6 +45,7 @@ struct ObjectRenderInst;
class SceneManager;
class SceneRenderState;
class BaseMatInstance;
class NavMeshTool;
class GuiNavEditorCtrl : public EditTSCtrl
{
@ -51,7 +56,6 @@ public:
static const String mSelectMode;
static const String mLinkMode;
static const String mCoverMode;
static const String mTileMode;
static const String mTestMode;
GuiNavEditorCtrl();
@ -96,26 +100,14 @@ public:
bool getStaticPos(const Gui3DMouseEvent & event, Point3F &tpos);
void setMode(String mode, bool sourceShortcut);
String getMode() { return mMode; }
void selectMesh(NavMesh *mesh);
void deselect();
S32 getMeshId();
S32 getPlayerId();
String mSpawnClass;
String mSpawnDatablock;
void deleteLink();
void setLinkFlags(const LinkData &d);
void buildTile();
void spawnPlayer(const Point3F &pos);
/// @}
void setActiveTool(NavMeshTool* tool);
void setDrawMode(S32 id);
protected:
@ -128,38 +120,21 @@ protected:
bool mIsDirty;
String mMode;
/// Currently-selected NavMesh.
SimObjectPtr<NavMesh> mMesh;
/// @name Link mode
/// @{
Point3F mLinkStart;
S32 mCurLink;
S32 mLink;
/// The active tool in used by the editor.
SimObjectPtr<NavMeshTool> mTool;
/// @}
/// @name Tile mode
/// @{
S32 mCurTile;
S32 mTile;
duDebugDrawTorque dd;
/// @}
/// @name Test mode
/// @{
SimObjectPtr<SceneObject> mPlayer;
SimObjectPtr<SceneObject> mCurPlayer;
/// @}
Gui3DMouseEvent mLastMouseEvent;
#define InvalidMousePoint Point2I(-100,-100)

869
Engine/source/navigation/navMesh.cpp
View file

File diff suppressed because it is too large Load diff

131
Engine/source/navigation/navMesh.h
View file

@ -102,6 +102,7 @@ public:
U32 mMergeRegionArea;
F32 mTileSize;
U32 mMaxPolysPerTile;
duDebugDrawTorque mDbgDraw;
/// @}
/// @name Water
@ -112,6 +113,29 @@ public:
Impassable
};
enum DrawMode
{
DRAWMODE_NAVMESH,
DRAWMODE_NAVMESH_TRANS,
DRAWMODE_NAVMESH_BVTREE,
DRAWMODE_NAVMESH_NODES,
DRAWMODE_NAVMESH_PORTALS,
DRAWMODE_NAVMESH_INVIS,
DRAWMODE_MESH,
DRAWMODE_VOXELS,
DRAWMODE_VOXELS_WALKABLE,
DRAWMODE_COMPACT,
DRAWMODE_COMPACT_DISTANCE,
DRAWMODE_COMPACT_REGIONS,
DRAWMODE_REGION_CONNECTIONS,
DRAWMODE_RAW_CONTOURS,
DRAWMODE_BOTH_CONTOURS,
DRAWMODE_CONTOURS,
DRAWMODE_POLYMESH,
DRAWMODE_POLYMESH_DETAIL,
MAX_DRAWMODE
};
WaterMethod mWaterMethod;
/// @}
@ -127,7 +151,7 @@ public:
/// @{
/// Add an off-mesh link.
S32 addLink(const Point3F &from, const Point3F &to, U32 flags = 0);
S32 addLink(const Point3F &from, const Point3F &to, bool biDir, F32 rad, U32 flags = 0);
/// Get the ID of the off-mesh link near the point.
S32 getLink(const Point3F &pos);
@ -144,15 +168,27 @@ public:
/// Get the flags used by a link.
LinkData getLinkFlags(U32 idx);
bool getLinkDir(U32 idx);
F32 getLinkRadius(U32 idx);
void setLinkDir(U32 idx, bool biDir);
void setLinkRadius(U32 idx, F32 rad);
/// Set flags used by a link.
void setLinkFlags(U32 idx, const LinkData &d);
void setDrawMode(DrawMode mode) { m_drawMode = mode; setMaskBits(LoadFlag); }
/// Set the selected state of a link.
void selectLink(U32 idx, bool select, bool hover = true);
/// Delete the selected link.
void deleteLink(U32 idx);
dtNavMeshQuery* getNavMeshQuery() { return mQuery; }
/// @}
/// Should small characters use this mesh?
@ -230,6 +266,7 @@ public:
void prepRenderImage(SceneRenderState *state) override;
void render(ObjectRenderInst *ri, SceneRenderState *state, BaseMatInstance *overrideMat);
void renderLinks(duDebugDraw &dd);
void renderSearch(duDebugDraw& dd);
void renderTileData(duDebugDrawTorque &dd, U32 tile);
bool mAlwaysRender;
@ -249,15 +286,13 @@ public:
void inspectPostApply() override;
void createNewFile();
protected:
dtNavMesh const* getNavMesh() { return nm; }
private:
/// Generates a navigation mesh for the collection of objects in this
/// mesh. Returns true if successful. Stores the created mesh in tnm.
bool generateMesh();
/// Builds the next tile in the dirty list.
void buildNextTile();
@ -275,56 +310,45 @@ private:
/// Recast min and max points.
F32 bmin[3], bmax[3];
/// Default constructor.
Tile() : box(Box3F::Invalid), x(0), y(0)
Tile() : box(Box3F::Invalid), x(0), y(0), chf(0), solid(0), cset(0), pmesh(0), dmesh(0), triareas(nullptr)
{
bmin[0] = bmin[1] = bmin[2] = bmax[0] = bmax[1] = bmax[2] = 0.0f;
}
/// Value constructor.
Tile(const Box3F &b, U32 _x, U32 _y, const F32 *min, const F32 *max)
: box(b), x(_x), y(_y)
: box(b), x(_x), y(_y), chf(0), solid(0), cset(0), pmesh(0), dmesh(0), triareas(nullptr)
{
rcVcopy(bmin, min);
rcVcopy(bmax, max);
}
};
/// Intermediate data for tile creation.
struct TileData {
RecastPolyList geom;
rcHeightfield *hf;
rcCompactHeightfield *chf;
rcContourSet *cs;
rcPolyMesh *pm;
rcPolyMeshDetail *pmd;
TileData()
~Tile()
{
hf = NULL;
chf = NULL;
cs = NULL;
pm = NULL;
pmd = NULL;
}
void freeAll()
{
geom.clear();
rcFreeHeightField(hf);
rcFreeCompactHeightfield(chf);
rcFreeContourSet(cs);
rcFreePolyMesh(pm);
rcFreePolyMeshDetail(pmd);
}
~TileData()
{
freeAll();
if (chf)
delete chf;
if (cset)
delete cset;
if (solid)
delete solid;
if (pmesh)
delete pmesh;
if (dmesh)
delete dmesh;
if (triareas)
delete[] triareas;
}
unsigned char* triareas;
rcCompactHeightfield* chf;
rcHeightfield* solid;
rcContourSet* cset;
rcPolyMesh* pmesh;
rcPolyMeshDetail* dmesh;
};
/// List of tiles.
Vector<Tile> mTiles;
/// List of tile intermediate data.
Vector<TileData> mTileData;
/// List of indices to the tile array which are dirty.
Vector<U32> mDirtyTiles;
@ -332,7 +356,7 @@ private:
void updateTiles(bool dirty = false);
/// Generates navmesh data for a single tile.
unsigned char *buildTileData(const Tile &tile, TileData &data, U32 &dataSize);
unsigned char *buildTileData(const Tile &tile, U32 &dataSize);
/// @}
@ -363,19 +387,9 @@ private:
/// @}
/// @name Intermediate data
/// @{
/// Config struct.
rcConfig cfg;
/// Updates our config from console members.
void updateConfig();
dtNavMesh *nm;
rcContext *ctx;
/// @}
dtNavMeshQuery* mQuery;
/// @name Cover
/// @{
@ -408,8 +422,6 @@ private:
/// @name Rendering
/// @{
duDebugDrawTorque mDbgDraw;
void renderToDrawer();
/// @}
@ -419,6 +431,21 @@ private:
/// Use this object to manage update events.
static SimObjectPtr<EventManager> smEventManager;
protected:
RecastPolyList* m_geo;
unsigned char* m_triareas;
rcHeightfield* m_solid;
rcCompactHeightfield* m_chf;
rcContourSet* m_cset;
rcPolyMesh* m_pmesh;
rcPolyMeshDetail* m_dmesh;
rcConfig m_cfg;
DrawMode m_drawMode;
U32 mWaterVertStart;
U32 mWaterTriStart;
void cleanup();
};
typedef NavMesh::WaterMethod NavMeshWaterMethod;

40
Engine/source/navigation/navMeshTool.cpp Normal file
View file

@ -0,0 +1,40 @@
#include "platform/platform.h"
#include "navigation/navMeshTool.h"
#ifdef TORQUE_TOOLS
#include "util/undo.h"
#include "math/mMath.h"
#include "math/mathUtils.h"
IMPLEMENT_CONOBJECT(NavMeshTool);
ConsoleDocClass(NavMeshTool,
"@brief Base class for NavMesh Editor specific tools\n\n"
"Editor use only.\n\n"
"@internal"
);
void NavMeshTool::_submitUndo(UndoAction* action)
{
AssertFatal(action, "NavMeshTool::_submitUndo() - No undo action!");
// Grab the mission editor undo manager.
UndoManager* undoMan = NULL;
if (!Sim::findObject("EUndoManager", undoMan))
{
Con::errorf("NavMeshTool::_submitUndo() - EUndoManager not found!");
return;
}
undoMan->addAction(action);
}
NavMeshTool::NavMeshTool()
: mNavMesh(NULL)
{
}
NavMeshTool::~NavMeshTool()
{
}
#endif

58
Engine/source/navigation/navMeshTool.h Normal file
View file

@ -0,0 +1,58 @@
#pragma once
#ifndef _NAVMESH_TOOL_H_
#define _NAVMESH_TOOL_H_
#ifdef TORQUE_TOOLS
#ifndef _SIMBASE_H_
#include "console/simBase.h"
#endif
#ifndef _GUITYPES_H_
#include "gui/core/guiTypes.h"
#endif
#ifndef _NAVMESH_H_
#include "navigation/navMesh.h"
#endif
#ifndef _GUINAVEDITORCTRL_H_
#include "navigation/guiNavEditorCtrl.h"
#endif
class UndoAction;
class NavMeshTool : public SimObject
{
typedef SimObject Parent;
protected:
SimObjectPtr<NavMesh> mNavMesh;
SimObjectPtr<GuiNavEditorCtrl> mCurEditor;
void _submitUndo(UndoAction* action);
public:
NavMeshTool();
virtual ~NavMeshTool();
DECLARE_CONOBJECT(NavMeshTool);
virtual void setActiveNavMesh(NavMesh* nav_mesh) { mNavMesh = nav_mesh; }
virtual void setActiveEditor(GuiNavEditorCtrl* nav_editor) { mCurEditor = nav_editor; }
virtual void onActivated(const Gui3DMouseEvent& lastEvent) {}
virtual void onDeactivated() {}
virtual void on3DMouseDown(const Gui3DMouseEvent& evt) {}
virtual void on3DMouseUp(const Gui3DMouseEvent& evt) {}
virtual void on3DMouseMove(const Gui3DMouseEvent& evt) {}
virtual void on3DMouseDragged(const Gui3DMouseEvent& evt) {}
virtual void on3DMouseEnter(const Gui3DMouseEvent& evt) {}
virtual void on3DMouseLeave(const Gui3DMouseEvent& evt) {}
virtual bool onMouseWheel(const GuiEvent& evt) { return false; }
virtual void onRender3D() {}
virtual void onRender2D() {}
virtual void updateGizmo() {}
virtual bool updateGuiInfo() { return false; }
virtual void onUndoAction() {}
};
#endif
#endif // !_NAVMESH_TOOL_H_

40
Engine/source/navigation/navMeshTools/coverTool.cpp Normal file
View file

@ -0,0 +1,40 @@
#include "coverTool.h"
IMPLEMENT_CONOBJECT(CoverTool);
CoverTool::CoverTool()
{
}
void CoverTool::onActivated(const Gui3DMouseEvent& evt)
{
Con::executef(this, "onActivated");
}
void CoverTool::onDeactivated()
{
Con::executef(this, "onDeactivated");
}
void CoverTool::on3DMouseDown(const Gui3DMouseEvent& evt)
{
if (mNavMesh.isNull())
return;
}
void CoverTool::on3DMouseMove(const Gui3DMouseEvent& evt)
{
if (mNavMesh.isNull())
return;
}
void CoverTool::onRender3D()
{
if (mNavMesh.isNull())
return;
}
bool CoverTool::updateGuiInfo()
{
return false;
}

33
Engine/source/navigation/navMeshTools/coverTool.h Normal file
View file

@ -0,0 +1,33 @@
#ifndef _COVERTOOL_H_
#define _COVERTOOL_H_
#ifndef _NAVMESH_TOOL_H_
#include "navigation/navMeshTool.h"
#endif
#ifndef _NAVPATH_H_
#include "navigation/navPath.h"
#endif
class CoverTool : public NavMeshTool
{
typedef NavMeshTool Parent;
public:
DECLARE_CONOBJECT(CoverTool);
CoverTool();
virtual ~CoverTool() {}
void onActivated(const Gui3DMouseEvent& evt) override;
void onDeactivated() override;
void on3DMouseDown(const Gui3DMouseEvent& evt) override;
void on3DMouseMove(const Gui3DMouseEvent& evt) override;
void onRender3D() override;
bool updateGuiInfo() override;
};
#endif // !_COVERTOOL_H_

121
Engine/source/navigation/navMeshTools/navMeshSelectTool.cpp Normal file
View file

@ -0,0 +1,121 @@
#include "navMeshSelectTool.h"
#include "console/consoleTypes.h"
#include "gfx/gfxDrawUtil.h"
IMPLEMENT_CONOBJECT(NavMeshSelectTool);
static void renderBoxOutline(const Box3F& box, const ColorI& col)
{
if (box != Box3F::Invalid)
{
GFXStateBlockDesc desc;
desc.setCullMode(GFXCullNone);
desc.setFillModeSolid();
desc.setZReadWrite(true, false);
desc.setBlend(true);
GFX->getDrawUtil()->drawCube(desc, box, ColorI(col, 20));
desc.setFillModeWireframe();
desc.setBlend(false);
GFX->getDrawUtil()->drawCube(desc, box, ColorI(col, 255));
}
}
NavMeshSelectTool::NavMeshSelectTool()
{
mCurMesh = NULL;
}
void NavMeshSelectTool::onActivated(const Gui3DMouseEvent& evt)
{
Con::executef(this, "onActivated");
}
void NavMeshSelectTool::onDeactivated()
{
Con::executef(this, "onDeactivated");
}
void NavMeshSelectTool::on3DMouseDown(const Gui3DMouseEvent& evt)
{
if (mCurEditor.isNull())
return;
Point3F startPnt = evt.pos;
Point3F endPnt = evt.pos + evt.vec * 1000.0f;
RayInfo ri;
if (gServerContainer.collideBox(startPnt, endPnt, MarkerObjectType, &ri))
{
if (!ri.object)
return;
NavMesh* selNavMesh = dynamic_cast<NavMesh*>(ri.object);
if (selNavMesh)
{
mCurEditor->selectMesh(selNavMesh);
mSelMesh = selNavMesh;
Con::executef(this, "onNavMeshSelected");
return;
}
}
}
void NavMeshSelectTool::on3DMouseMove(const Gui3DMouseEvent& evt)
{
if (mCurEditor.isNull())
return;
Point3F startPnt = evt.pos;
Point3F endPnt = evt.pos + evt.vec * 1000.0f;
RayInfo ri;
if (gServerContainer.collideBox(startPnt, endPnt, MarkerObjectType, &ri))
{
NavMesh* selNavMesh = dynamic_cast<NavMesh*>(ri.object);
if (selNavMesh)
{
mCurMesh = selNavMesh;
}
else
{
mCurMesh = NULL;
}
}
else
{
mCurMesh = NULL;
}
}
void NavMeshSelectTool::onRender3D()
{
if (!mCurMesh.isNull())
renderBoxOutline(mCurMesh->getWorldBox(), ColorI::LIGHT);
if (!mSelMesh.isNull())
renderBoxOutline(mSelMesh->getWorldBox(), ColorI::LIGHT);
}
bool NavMeshSelectTool::updateGuiInfo()
{
SimObject* statusbar;
Sim::findObject("EditorGuiStatusBar", statusbar);
GuiTextCtrl* selectionBar;
Sim::findObject("EWorldEditorStatusBarSelection", selectionBar);
String text;
text = "LMB To select a NavMesh.";
if (statusbar)
Con::executef(statusbar, "setInfo", text.c_str());
text = "";
if(mSelMesh)
text = String::ToString("NavMesh Selected: %d", mSelMesh->getId());
if (selectionBar)
selectionBar->setText(text);
return true;
}

32
Engine/source/navigation/navMeshTools/navMeshSelectTool.h Normal file
View file

@ -0,0 +1,32 @@
#ifndef _NAVMESHSELECTTOOL_H_
#define _NAVMESHSELECTTOOL_H_
#ifndef _NAVMESH_TOOL_H_
#include "navigation/navMeshTool.h"
#endif
class NavMeshSelectTool : public NavMeshTool
{
typedef NavMeshTool Parent;
protected:
SimObjectPtr<NavMesh> mCurMesh;
SimObjectPtr<NavMesh> mSelMesh;
public:
DECLARE_CONOBJECT(NavMeshSelectTool);
NavMeshSelectTool();
virtual ~NavMeshSelectTool() {}
void setActiveNavMesh(NavMesh* nav_mesh) { mNavMesh = nav_mesh; mSelMesh = nav_mesh; }
void onActivated(const Gui3DMouseEvent& evt) override;
void onDeactivated() override;
void on3DMouseDown(const Gui3DMouseEvent& evt) override;
void on3DMouseMove(const Gui3DMouseEvent& evt) override;
void onRender3D() override;
bool updateGuiInfo() override;
};
#endif

426
Engine/source/navigation/navMeshTools/navMeshTestTool.cpp Normal file
View file

@ -0,0 +1,426 @@
#include "navMeshTestTool.h"
#include "navigation/guiNavEditorCtrl.h"
#include "console/consoleTypes.h"
#include "gfx/gfxDrawUtil.h"
#include "scene/sceneManager.h"
#include "math/mathUtils.h"
#include "T3D/gameBase/gameConnection.h"
#include "T3D/AI/AIController.h"
IMPLEMENT_CONOBJECT(NavMeshTestTool);
//// take control
// GameConnection* conn = GameConnection::getConnectionToServer();
// if (conn)
// conn->setControlObject(static_cast<GameBase*>(obj));
//}
static void renderBoxOutline(const Box3F& box, const ColorI& col)
{
if (box != Box3F::Invalid)
{
GFXStateBlockDesc desc;
desc.setCullMode(GFXCullNone);
desc.setFillModeSolid();
desc.setZReadWrite(true, false);
desc.setBlend(true);
GFX->getDrawUtil()->drawCube(desc, box, ColorI(col, 20));
desc.setFillModeWireframe();
desc.setBlend(false);
GFX->getDrawUtil()->drawCube(desc, box, ColorI(col, 255));
}
}
void NavMeshTestTool::spawnPlayer(const Point3F& position)
{
if (mSpawnClass.isEmpty() || mSpawnDatablock.isEmpty())
{
Con::warnf("NavMeshTestTool::spawnPlayer - spawn class/datablock not set!");
return;
}
SimObject* spawned = Sim::spawnObject(mSpawnClass, mSpawnDatablock);
SceneObject* obj = dynamic_cast<SceneObject*>(spawned);
if (!obj)
{
Con::warnf("NavMeshTestTool::spawnPlayer - spawn failed or not a SceneObject");
if (spawned)
spawned->deleteObject();
return;
}
obj->setPosition(position);
SimObject* cleanup = Sim::findObject("MissionCleanup");
if (cleanup)
{
SimGroup* missionCleanup = dynamic_cast<SimGroup*>(cleanup);
missionCleanup->addObject(obj);
}
mPlayer = obj;
Con::executef(this, "onPlayerSpawned", obj->getIdString());
#ifdef TORQUE_NAVIGATION_ENABLED
AIPlayer* asAIPlayer = dynamic_cast<AIPlayer*>(mPlayer.getPointer());
if (asAIPlayer)
{
Con::executef(this, "onPlayerSelected");
}
else
{
ShapeBase* sbo = dynamic_cast<ShapeBase*>(mPlayer.getPointer());
if (sbo && sbo->getAIController() && sbo->getAIController()->mControllerData)
{
Con::executef(this, "onPlayerSelected");
}
else
{
Con::executef(this, "onPlayerSelected");
}
}
#else
Con::executef(this, "onPlayerSelected");
#endif
}
void NavMeshTestTool::drawAgent(duDebugDrawTorque& dd, const F32* pos, F32 r, F32 h, F32 c, const U32 col)
{
dd.depthMask(false);
// Agent dimensions.
duDebugDrawCylinderWire(&dd, pos[0] - r, pos[1] + 0.02f, pos[2] - r, pos[0] + r, pos[1] + h, pos[2] + r, col, 2.0f);
duDebugDrawCircle(&dd, pos[0], pos[1] + c, pos[2], r, duRGBA(0, 0, 0, 64), 1.0f);
U32 colb = duRGBA(0, 0, 0, 196);
dd.begin(DU_DRAW_LINES);
dd.vertex(pos[0], pos[1] - c, pos[2], colb);
dd.vertex(pos[0], pos[1] + c, pos[2], colb);
dd.vertex(pos[0] - r / 2, pos[1] + 0.02f, pos[2], colb);
dd.vertex(pos[0] + r / 2, pos[1] + 0.02f, pos[2], colb);
dd.vertex(pos[0], pos[1] + 0.02f, pos[2] - r / 2, colb);
dd.vertex(pos[0], pos[1] + 0.02f, pos[2] + r / 2, colb);
dd.end();
dd.depthMask(true);
}
NavMeshTestTool::NavMeshTestTool()
{
mSpawnClass = String::EmptyString;
mSpawnDatablock = String::EmptyString;
mPlayer = NULL;
mCurPlayer = NULL;
mFollowObject = NULL;
mCurFollowObject = NULL;
mPathStart = Point3F::Max;
mPathEnd = Point3F::Max;
mTestPath = NULL;
mLinkTypes = LinkData(AllFlags);
mFilter.setIncludeFlags(mLinkTypes.getFlags());
mFilter.setExcludeFlags(0);
mSelectFollow = false;
}
void NavMeshTestTool::onActivated(const Gui3DMouseEvent& evt)
{
mSelectFollow = false;
Con::executef(this, "onActivated");
}
void NavMeshTestTool::onDeactivated()
{
if (mTestPath != NULL) {
mTestPath->deleteObject();
mTestPath = NULL;
}
if (mPlayer != NULL)
{
mPlayer = NULL;
Con::executef(this, "onPlayerDeselected");
}
mSelectFollow = false;
Con::executef(this, "onDeactivated");
}
void NavMeshTestTool::on3DMouseDown(const Gui3DMouseEvent& evt)
{
if (mNavMesh.isNull())
return;
Point3F startPnt = evt.pos;
Point3F endPnt = evt.pos + evt.vec * 1000.0f;
RayInfo ri;
bool shift = evt.modifier & SI_LSHIFT;
bool ctrl = evt.modifier & SI_LCTRL;
if (ctrl)
{
if (gServerContainer.castRay(startPnt, endPnt, StaticObjectType, &ri))
{
spawnPlayer(ri.point);
}
return;
}
if (shift)
{
mPlayer = NULL;
Con::executef(this, "onPlayerDeselected");
return;
}
if (gServerContainer.castRay(startPnt, endPnt, PlayerObjectType | VehicleObjectType, &ri))
{
if (!ri.object)
return;
if (mSelectFollow)
{
mFollowObject = ri.object;
Con::executef(this, "onFollowSelected");
mSelectFollow = false;
return;
}
else
{
mPlayer = ri.object;
}
#ifdef TORQUE_NAVIGATION_ENABLED
AIPlayer* asAIPlayer = dynamic_cast<AIPlayer*>(mPlayer.getPointer());
if (asAIPlayer)
{
Con::executef(this, "onPlayerSelected");
}
else
{
ShapeBase* sbo = dynamic_cast<ShapeBase*>(mPlayer.getPointer());
if (sbo && sbo->getAIController() && sbo->getAIController()->mControllerData)
{
Con::executef(this, "onPlayerSelected");
}
else
{
Con::executef(this, "onPlayerSelected");
}
}
#else
Con::executef(this, "onPlayerSelected");
#endif
}
else if (gServerContainer.castRay(startPnt, endPnt, StaticObjectType, &ri))
{
if (mPlayer.isNull())
{
if (mPathStart != Point3F::Max && mPathEnd != Point3F::Max) // start a new path.
{
mPathStart = Point3F::Max;
mPathEnd = Point3F::Max;
}
if (mPathStart != Point3F::Max)
{
mPathEnd = ri.point;
mTestPath = new NavPath();
mTestPath->mMesh = mNavMesh;
mTestPath->mFrom = mPathStart;
mTestPath->mTo = mPathEnd;
mTestPath->mFromSet = mTestPath->mToSet = true;
mTestPath->mAlwaysRender = true;
mTestPath->mLinkTypes = mLinkTypes;
mTestPath->mFilter = mFilter;
mTestPath->mXray = true;
// Paths plan automatically upon being registered.
if (!mTestPath->registerObject())
{
delete mTestPath;
return;
}
}
else
{
mPathStart = ri.point;
if (mTestPath != NULL) {
mTestPath->deleteObject();
mTestPath = NULL;
}
}
}
else
{
AIPlayer* asAIPlayer = dynamic_cast<AIPlayer*>(mPlayer.getPointer());
if (asAIPlayer) //try direct
{
asAIPlayer->setPathDestination(ri.point);
mPathStart = mPlayer->getPosition();
mPathEnd = ri.point;
}
else
{
ShapeBase* sbo = dynamic_cast<ShapeBase*>(mPlayer.getPointer());
if (sbo->getAIController())
{
if (sbo->getAIController()->mControllerData)
{
sbo->getAIController()->getNav()->setPathDestination(ri.point, true);
mPathStart = mPlayer->getPosition();
mPathEnd = ri.point;
}
}
}
}
}
}
void NavMeshTestTool::on3DMouseMove(const Gui3DMouseEvent& evt)
{
if (mNavMesh.isNull())
return;
Point3F startPnt = evt.pos;
Point3F endPnt = evt.pos + evt.vec * 1000.0f;
RayInfo ri;
if (gServerContainer.castRay(startPnt, endPnt, PlayerObjectType | VehicleObjectType, &ri))
{
if (mSelectFollow)
mCurFollowObject = ri.object;
else
mCurPlayer = ri.object;
}
else
{
mCurFollowObject = NULL;
mCurPlayer = NULL;
}
}
void NavMeshTestTool::onRender3D()
{
if (mNavMesh.isNull())
return;
static const U32 startCol = duRGBA(128, 25, 0, 192);
static const U32 endCol = duRGBA(51, 102, 0, 129);
const F32 agentRadius = mNavMesh->mWalkableRadius;
const F32 agentHeight = mNavMesh->mWalkableHeight;
const F32 agentClimb = mNavMesh->mWalkableClimb;
duDebugDrawTorque dd;
dd.depthMask(false);
if (mPathStart != Point3F::Max)
{
drawAgent(dd, DTStoRC(mPathStart), agentRadius, agentHeight, agentClimb, startCol);
}
if (mPathEnd != Point3F::Max)
{
drawAgent(dd, DTStoRC(mPathEnd), agentRadius, agentHeight, agentClimb, endCol);
}
dd.depthMask(true);
mNavMesh->renderSearch(dd);
dd.immediateRender();
if (!mCurFollowObject.isNull())
renderBoxOutline(mCurFollowObject->getWorldBox(), ColorI::LIGHT);
if (!mCurPlayer.isNull())
renderBoxOutline(mCurPlayer->getWorldBox(), ColorI::BLUE);
if (!mPlayer.isNull())
renderBoxOutline(mPlayer->getWorldBox(), ColorI::GREEN);
if (!mFollowObject.isNull())
renderBoxOutline(mFollowObject->getWorldBox(), ColorI::WHITE);
}
bool NavMeshTestTool::updateGuiInfo()
{
SimObject* statusbar;
Sim::findObject("EditorGuiStatusBar", statusbar);
GuiTextCtrl* selectionBar;
Sim::findObject("EWorldEditorStatusBarSelection", selectionBar);
String text;
if (mPlayer)
text = "LMB To Select move Destination. LSHIFT+LMB To Deselect Current Bot.";
if (mCurPlayer != NULL && mCurPlayer != mPlayer)
text = "LMB To select Bot.";
if (mPlayer == NULL)
{
text = "LMB To place start/end for test path.";
}
if (mSpawnClass != String::EmptyString && mSpawnDatablock != String::EmptyString)
text += " CTRL+LMB To spawn a new Bot.";
if (mSelectFollow)
text = "LMB To select Follow Target.";
if (statusbar)
Con::executef(statusbar, "setInfo", text.c_str());
text = "";
if (mPlayer)
text = String::ToString("Bot Selected: %d", mPlayer->getId());
if (selectionBar)
selectionBar->setText(text);
return true;
}
S32 NavMeshTestTool::getPlayerId()
{
return mPlayer.isNull() ? 0 : mPlayer->getId();
}
S32 NavMeshTestTool::getFollowObjectId()
{
return mFollowObject.isNull() ? 0 : mFollowObject->getId();
}
DefineEngineMethod(NavMeshTestTool, getPlayer, S32, (), ,
"@brief Return the current player id.")
{
return object->getPlayerId();
}
DefineEngineMethod(NavMeshTestTool, getFollowObject, S32, (), ,
"@brief Return the current follow object id.")
{
return object->getFollowObjectId();
}
DefineEngineMethod(NavMeshTestTool, setSpawnClass, void, (String className), , "")
{
object->setSpawnClass(className);
}
DefineEngineMethod(NavMeshTestTool, setSpawnDatablock, void, (String dbName), , "")
{
object->setSpawnDatablock(dbName);
}
DefineEngineMethod(NavMeshTestTool, followSelectMode, void, (), ,
"@brief Set NavMeshTool to select a follow object.")
{
return object->followSelectMode();
}

60
Engine/source/navigation/navMeshTools/navMeshTestTool.h Normal file
View file

@ -0,0 +1,60 @@
#ifndef _NAVMESHTESTTOOL_H_
#define _NAVMESHTESTTOOL_H_
#ifndef _NAVMESH_TOOL_H_
#include "navigation/navMeshTool.h"
#endif
#ifndef _NAVPATH_H_
#include "navigation/navPath.h"
#endif
class NavMeshTestTool : public NavMeshTool
{
typedef NavMeshTool Parent;
protected:
String mSpawnClass;
String mSpawnDatablock;
SimObjectPtr<SceneObject> mPlayer;
SimObjectPtr<SceneObject> mCurPlayer;
SimObjectPtr<SceneObject> mFollowObject;
SimObjectPtr<SceneObject> mCurFollowObject;
Point3F mPathStart;
Point3F mPathEnd;
NavPath* mTestPath;
LinkData mLinkTypes;
dtQueryFilter mFilter;
bool mSelectFollow;
public:
DECLARE_CONOBJECT(NavMeshTestTool);
void spawnPlayer(const Point3F& position);
void drawAgent(duDebugDrawTorque& dd, const F32* pos, F32 r, F32 h, F32 c, const U32 col);
NavMeshTestTool();
virtual ~NavMeshTestTool() {}
void onActivated(const Gui3DMouseEvent& evt) override;
void onDeactivated() override;
void on3DMouseDown(const Gui3DMouseEvent& evt) override;
void on3DMouseMove(const Gui3DMouseEvent& evt) override;
void onRender3D() override;
bool updateGuiInfo() override;
S32 getPlayerId();
S32 getFollowObjectId();
void setSpawnClass(String className) { mSpawnClass = className; }
void setSpawnDatablock(String dbName) { mSpawnDatablock = dbName; }
void followSelectMode() { mSelectFollow = true; }
};
#endif // !_NAVMESHTESTTOOL_H_

200
Engine/source/navigation/navMeshTools/offMeshConnTool.cpp Normal file
View file

@ -0,0 +1,200 @@
#include "offMeshConnTool.h"
#include "navigation/guiNavEditorCtrl.h"
#include "console/consoleTypes.h"
#include "gfx/gfxDrawUtil.h"
#include "scene/sceneManager.h"
#include "math/mathUtils.h"
IMPLEMENT_CONOBJECT(OffMeshConnectionTool);
void OffMeshConnectionTool::onActivated(const Gui3DMouseEvent& evt)
{
Con::executef(this, "onActivated");
}
void OffMeshConnectionTool::onDeactivated()
{
Con::executef(this, "onDeactivated");
}
void OffMeshConnectionTool::on3DMouseDown(const Gui3DMouseEvent& evt)
{
if (mNavMesh.isNull())
return;
Point3F startPnt = evt.pos;
Point3F endPnt = evt.pos + evt.vec * 1000.0f;
RayInfo ri;
bool shift = evt.modifier & SI_LSHIFT;
bool ctrl = evt.modifier & SI_LCTRL;
if (gServerContainer.castRay(startPnt, endPnt, StaticObjectType, &ri))
{
U32 link = mNavMesh->getLink(ri.point);
if (link != -1)
{
if (mLink != -1)
mNavMesh->selectLink(mLink, false);
mNavMesh->selectLink(link, true, false);
mLink = link;
if (ctrl)
{
mNavMesh->selectLink(mLink, false);
mNavMesh->deleteLink(mLink);
mLink = -1;
Con::executef(this, "onLinkDeselected");
return;
}
else
{
LinkData d = mNavMesh->getLinkFlags(mLink);
bool biDir = mNavMesh->getLinkDir(mLink);
F32 linkRad = mNavMesh->getLinkRadius(mLink);
Con::executef(this, "onLinkSelected", Con::getIntArg(d.getFlags()), Con::getBoolArg(biDir), Con::getFloatArg(linkRad));
}
}
else
{
if (mLink != -1)
{
mNavMesh->selectLink(mLink, false);
mLink = -1;
Con::executef(this, "onLinkDeselected");
}
if (mLinkStart != Point3F::Max)
{
mLink = mNavMesh->addLink(mLinkStart, ri.point, mBiDir, mLinkRadius);
mNavMesh->selectLink(mLink, true, false);
if (shift)
mLinkStart = ri.point;
else
mLinkStart = Point3F::Max;
Con::executef(this, "onLinkSelected", Con::getIntArg(mLinkCache.getFlags()), Con::getBoolArg(mBiDir), Con::getFloatArg(mLinkRadius));
}
else
{
mLinkStart = ri.point;
}
}
}
else
{
if (mLink != -1)
{
mNavMesh->selectLink(mLink, false);
mLink = -1;
Con::executef(this, "onLinkDeselected");
}
}
}
void OffMeshConnectionTool::on3DMouseMove(const Gui3DMouseEvent& evt)
{
if (mNavMesh.isNull())
return;
Point3F startPnt = evt.pos;
Point3F endPnt = evt.pos + evt.vec * 1000.0f;
RayInfo ri;
if (gServerContainer.castRay(startPnt, endPnt, StaticObjectType, &ri))
{
U32 link = mNavMesh->getLink(ri.point);
if (link != -1)
{
if (link != mLink)
{
if (mCurLink != -1)
mNavMesh->selectLink(mCurLink, false);
mNavMesh->selectLink(link, true, true);
}
mCurLink = link;
}
else
{
if (mCurLink != mLink)
mNavMesh->selectLink(mCurLink, false);
mCurLink = -1;
}
}
else
{
mNavMesh->selectLink(mCurLink, false);
mCurLink = -1;
}
}
void OffMeshConnectionTool::onRender3D()
{
if (mNavMesh.isNull())
return;
duDebugDrawTorque dd;
if (mLinkStart != Point3F::Max)
{
Point3F rcFrom = DTStoRC(mLinkStart);
dd.begin(DU_DRAW_LINES);
dd.depthMask(false);
duAppendCircle(&dd, rcFrom.x, rcFrom.y, rcFrom.z, mLinkRadius, duRGBA(0, 255, 0, 255));
dd.end();
}
//mNavMesh->renderLinks(dd);
dd.immediateRender();
}
bool OffMeshConnectionTool::updateGuiInfo()
{
SimObject* statusbar;
Sim::findObject("EditorGuiStatusBar", statusbar);
GuiTextCtrl* selectionBar;
Sim::findObject("EWorldEditorStatusBarSelection", selectionBar);
String text;
text = "LMB To Select Link. CTRL+LMB To Delete Link";
if (mLinkStart != Point3F::Max)
text = "LinkStarted: LMB To place End Point. Hold Left Shift to start a new Link from the end point.";
if (statusbar)
Con::executef(statusbar, "setInfo", text.c_str());
if (mLink != -1)
text = String::ToString("Selected Link: %d", mLink);
else
text = "";
if (selectionBar)
selectionBar->setText(text);
return true;
}
void OffMeshConnectionTool::setLinkProperties(const LinkData& d, bool biDir, F32 rad)
{
if (!mNavMesh.isNull() && mLink != -1)
{
mNavMesh->setLinkFlags(mLink, d);
mNavMesh->setLinkDir(mLink, biDir);
mNavMesh->setLinkRadius(mLink, rad);
}
mLinkCache = d;
mBiDir = biDir;
mLinkRadius = rad;
}
DefineEngineMethod(OffMeshConnectionTool, setLinkProperties, void, (U32 flags, bool biDir, F32 rad), ,
"@Brief Set properties of the selected link.")
{
object->setLinkProperties(LinkData(flags), biDir, rad);
}

53
Engine/source/navigation/navMeshTools/offMeshConnTool.h Normal file
View file

@ -0,0 +1,53 @@
#ifndef _OFFMESHCONNTOOL_H_
#define _OFFMESHCONNTOOL_H_
#ifndef _NAVMESH_TOOL_H_
#include "navigation/navMeshTool.h"
#endif
class OffMeshConnectionTool : public NavMeshTool
{
typedef NavMeshTool Parent;
bool mStartPosSet;
bool mBiDir;
S32 mLink;
S32 mCurLink;
Point3F mLinkStart;
LinkData mLinkCache;
F32 mLinkRadius;
public:
DECLARE_CONOBJECT(OffMeshConnectionTool);
OffMeshConnectionTool() {
mStartPosSet = false;
mBiDir = false;
mLink = -1;
mCurLink = -1;
mLinkStart = Point3F::Max;
mLinkCache = LinkData(0);
mLinkRadius = 1.0;
}
virtual ~OffMeshConnectionTool() {}
void setActiveNavMesh(NavMesh* nav_mesh) override {
mNavMesh = nav_mesh;
if (!mNavMesh.isNull())
mLinkRadius = mNavMesh->mWalkableRadius;
}
void onActivated(const Gui3DMouseEvent& evt) override;
void onDeactivated() override;
void on3DMouseDown(const Gui3DMouseEvent& evt) override;
void on3DMouseMove(const Gui3DMouseEvent& evt) override;
void onRender3D() override;
bool updateGuiInfo() override;
void setLinkProperties(const LinkData& d, bool biDir, F32 rad);
};
#endif

115
Engine/source/navigation/navMeshTools/tileTool.cpp Normal file
View file

@ -0,0 +1,115 @@
#include "tileTool.h"
#include "navigation/guiNavEditorCtrl.h"
#include "console/consoleTypes.h"
#include "gfx/gfxDrawUtil.h"
#include "scene/sceneManager.h"
#include "math/mathUtils.h"
IMPLEMENT_CONOBJECT(TileTool);
static void renderBoxOutline(const Box3F& box, const ColorI& col)
{
if (box != Box3F::Invalid)
{
GFXStateBlockDesc desc;
desc.setCullMode(GFXCullNone);
desc.setFillModeSolid();
desc.setZReadWrite(true, false);
desc.setBlend(true);
GFX->getDrawUtil()->drawCube(desc, box, ColorI(col, 20));
desc.setFillModeWireframe();
desc.setBlend(false);
GFX->getDrawUtil()->drawCube(desc, box, ColorI(col, 255));
}
}
void TileTool::onActivated(const Gui3DMouseEvent& lastEvent)
{
Con::executef(this, "onActivated");
}
void TileTool::onDeactivated()
{
Con::executef(this, "onDeactivated");
}
void TileTool::on3DMouseDown(const Gui3DMouseEvent& evt)
{
if (mNavMesh.isNull())
return;
Point3F start = evt.pos;
Point3F end = evt.pos + evt.vec * 1000.0f;
RayInfo ri;
if (gServerContainer.castRay(start, end, StaticObjectType, &ri))
{
mSelTile = mNavMesh->getTile(ri.point);
}
}
void TileTool::on3DMouseMove(const Gui3DMouseEvent& evt)
{
if (mNavMesh.isNull())
return;
Point3F startPnt = evt.pos;
Point3F endPnt = evt.pos + evt.vec * 1000.0f;
RayInfo ri;
if (gServerContainer.castRay(startPnt, endPnt, StaticObjectType, &ri))
mCurTile = mNavMesh->getTile(ri.point);
else
mCurTile = -1;
}
void TileTool::onRender3D()
{
if (mNavMesh.isNull())
return;
if(mCurTile != -1)
renderBoxOutline(mNavMesh->getTileBox(mCurTile), ColorI::BLUE);
if(mSelTile != -1)
renderBoxOutline(mNavMesh->getTileBox(mSelTile), ColorI::GREEN);
}
void TileTool::buildTile()
{
if (!mNavMesh.isNull() && mSelTile != -1)
mNavMesh->buildTile(mSelTile);
}
bool TileTool::updateGuiInfo()
{
SimObject* statusbar;
Sim::findObject("EditorGuiStatusBar", statusbar);
GuiTextCtrl* selectionBar;
Sim::findObject("EWorldEditorStatusBarSelection", selectionBar);
String text;
text = "LMB To select NavMesh Tile";
if (statusbar)
Con::executef(statusbar, "setInfo", text.c_str());
if (mSelTile != -1)
text = String::ToString("Selected Tile: %d", mSelTile);
else
text = "";
if (selectionBar)
selectionBar->setText(text);
return true;
}
DefineEngineMethod(TileTool, buildTile, void, (), ,
"@brief Build the currently selected tile.")
{
return object->buildTile();
}

31
Engine/source/navigation/navMeshTools/tileTool.h Normal file
View file

@ -0,0 +1,31 @@
#ifndef _TILETOOL_H_
#define _TILETOOL_H_
#ifndef _NAVMESH_TOOL_H_
#include "navigation/navMeshTool.h"
#endif
class TileTool : public NavMeshTool
{
typedef NavMeshTool Parent;
S32 mCurTile;
S32 mSelTile;
public:
DECLARE_CONOBJECT(TileTool);
TileTool() { mCurTile = -1; mSelTile = -1; }
virtual ~TileTool() {}
void onActivated(const Gui3DMouseEvent& evt) override;
void onDeactivated() override;
void on3DMouseDown(const Gui3DMouseEvent& evt) override;
void on3DMouseMove(const Gui3DMouseEvent& evt) override;
void onRender3D() override;
void buildTile();
bool updateGuiInfo() override;
};
#endif

15
Engine/source/navigation/navPath.cpp
View file

@ -69,14 +69,11 @@ NavPath::NavPath() :
mXray = false;
mRenderSearch = false;
mQuery = NULL;
mStatus = DT_FAILURE;
}
NavPath::~NavPath()
{
dtFreeNavMeshQuery(mQuery);
mQuery = NULL;
}
void NavPath::checkAutoUpdate()
@ -264,9 +261,6 @@ bool NavPath::onAdd()
if(isServerObject())
{
mQuery = dtAllocNavMeshQuery();
if(!mQuery)
return false;
checkAutoUpdate();
if(!plan())
setProcessTick(true);
@ -293,7 +287,8 @@ bool NavPath::init()
return false;
// Initialise our query.
if(dtStatusFailed(mQuery->init(mMesh->getNavMesh(), MaxPathLen)))
mQuery = mMesh->getNavMeshQuery();
if(!mQuery)
return false;
mPoints.clear();
@ -372,9 +367,6 @@ void NavPath::resize()
bool NavPath::plan()
{
PROFILE_SCOPE(NavPath_plan);
// Initialise filter.
mFilter.setIncludeFlags(mLinkTypes.getFlags());
// Initialise query and visit locations.
if(!init())
return false;
@ -640,9 +632,8 @@ void NavPath::renderSimple(ObjectRenderInst *ri, SceneRenderState *state, BaseMa
if(np->mQuery && !dtStatusSucceed(np->mStatus))
{
duDebugDrawTorque dd;
dd.overrideColor(duRGBA(250, 20, 20, 255));
duDebugDrawNavMeshNodes(&dd, *np->mQuery);
dd.render();
dd.immediateRender();
}
}
}

3
Engine/source/navigation/navPath.h
View file

@ -57,7 +57,7 @@ public:
/// What sort of link types are we allowed to move on?
LinkData mLinkTypes;
dtQueryFilter mFilter;
/// Plan the path.
bool plan();
@ -152,7 +152,6 @@ private:
dtNavMeshQuery *mQuery;
dtStatus mStatus;
dtQueryFilter mFilter;
S32 mCurIndex;
Vector<Point3F> mPoints;
Vector<U16> mFlags;

71
Engine/source/navigation/recastPolyList.cpp
View file

@ -27,12 +27,16 @@
#include "gfx/primBuilder.h"
#include "gfx/gfxStateBlock.h"
RecastPolyList::RecastPolyList()
RecastPolyList::RecastPolyList() : mChunkyMesh(0)
{
nverts = 0;
verts = NULL;
vertcap = 0;
nnormals = 0;
normals = NULL;
normalcap = 0;
ntris = 0;
tris = NULL;
tricap = 0;
@ -44,6 +48,28 @@ RecastPolyList::~RecastPolyList()
clear();
}
rcChunkyTriMesh* RecastPolyList::getChunkyMesh()
{
if (!mChunkyMesh)
{
mChunkyMesh = new rcChunkyTriMesh;
if (!mChunkyMesh)
{
Con::errorf("Build tile navigation: out of memory");
return NULL;
}
if (!rcCreateChunkyTriMesh(getVerts(), getTris(), getTriCount(), 256, mChunkyMesh))
{
Con::errorf("Build tile navigation: out of memory");
return NULL;
}
}
return mChunkyMesh;
}
void RecastPolyList::clear()
{
nverts = 0;
@ -51,6 +77,11 @@ void RecastPolyList::clear()
verts = NULL;
vertcap = 0;
nnormals = 0;
delete[] normals;
normals = NULL;
normalcap = 0;
ntris = 0;
delete[] tris;
tris = NULL;
@ -134,6 +165,39 @@ void RecastPolyList::vertex(U32 vi)
void RecastPolyList::end()
{
// Fetch current triangle indices
const U32 i0 = tris[ntris * 3 + 0];
const U32 i1 = tris[ntris * 3 + 1];
const U32 i2 = tris[ntris * 3 + 2];
// Rebuild vertices
Point3F v0(verts[i0 * 3 + 0], verts[i0 * 3 + 1], verts[i0 * 3 + 2]);
Point3F v1(verts[i1 * 3 + 0], verts[i1 * 3 + 1], verts[i1 * 3 + 2]);
Point3F v2(verts[i2 * 3 + 0], verts[i2 * 3 + 1], verts[i2 * 3 + 2]);
// Compute normal
Point3F edge1 = v1 - v0;
Point3F edge2 = v2 - v0;
Point3F normal = mCross(edge1, edge2);
normal.normalizeSafe();
// Allocate/resize normal buffer if needed
if (nnormals == normalcap)
{
normalcap = (normalcap == 0) ? 16 : normalcap * 2;
F32* newNormals = new F32[normalcap * 3];
if (normals)
dMemcpy(newNormals, normals, nnormals * 3 * sizeof(F32));
delete[] normals;
normals = newNormals;
}
// Store normal
normals[nnormals * 3 + 0] = normal.x;
normals[nnormals * 3 + 1] = normal.y;
normals[nnormals * 3 + 2] = normal.z;
nnormals++;
ntris++;
}
@ -147,6 +211,11 @@ const F32 *RecastPolyList::getVerts() const
return verts;
}
const F32* RecastPolyList::getNormals() const
{
return normals;
}
U32 RecastPolyList::getTriCount() const
{
return ntris;

18
Engine/source/navigation/recastPolyList.h
View file

@ -26,6 +26,10 @@
#include "collision/abstractPolyList.h"
#include "core/util/tVector.h"
#ifndef CHUNKYTRIMESH_H
#include "ChunkyTriMesh.h"
#endif
/// Represents polygons in the same manner as the .obj file format. Handy for
/// padding data to Recast, since it expects this data format. At the moment,
/// this class only accepts triangles.
@ -57,6 +61,8 @@ public:
U32 getVertCount() const;
const F32 *getVerts() const;
const F32* getNormals() const;
U32 getTriCount() const;
const S32 *getTris() const;
@ -70,6 +76,9 @@ public:
/// Default destructor.
~RecastPolyList();
rcChunkyTriMesh* getChunkyMesh();
protected:
/// Number of vertices defined.
U32 nverts;
@ -78,6 +87,13 @@ protected:
/// Size of vertex array.
U32 vertcap;
// Number of normals defined.
U32 nnormals;
// Array of normals (xyz in float array)
F32* normals;
// Size of normal array (matches verts)
U32 normalcap;
/// Number of triangles defined.
U32 ntris;
/// Array of triangle vertex indices. Size ntris*3
@ -93,6 +109,8 @@ protected:
/// Another inherited utility function.
const PlaneF& getIndexedPlane(const U32 index) override { return planes[index]; }
rcChunkyTriMesh* mChunkyMesh;
private:
};

5
Engine/source/navigation/torqueRecast.h
View file

@ -52,6 +52,7 @@ inline void rcCol(unsigned int col, U8 &r, U8 &g, U8 &b, U8 &a)
}
enum PolyAreas {
NullArea = 0,
GroundArea,
WaterArea,
OffMeshArea,
@ -99,6 +100,10 @@ struct LinkData {
(climb ? ClimbFlag : 0) |
(teleport ? TeleportFlag : 0);
}
U16 getExcludeFlags() const
{
return AllFlags & ~getFlags();
}
};
#endif