1101 lines
39 KiB
C++
1101 lines
39 KiB
C++
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
#include "EdMode.h"
|
|
#include "EditorModeTools.h"
|
|
#include "EditorViewportClient.h"
|
|
#include "Framework/Application/SlateApplication.h"
|
|
#include "CanvasItem.h"
|
|
#include "Engine/StaticMeshActor.h"
|
|
#include "Engine/Selection.h"
|
|
#include "EngineUtils.h"
|
|
#include "EditorModeManager.h"
|
|
#include "EditorModes.h"
|
|
#include "StaticMeshResources.h"
|
|
#include "Toolkits/BaseToolkit.h"
|
|
|
|
#include "CanvasTypes.h"
|
|
|
|
/** Hit proxy used for editable properties */
|
|
struct HPropertyWidgetProxy: public HHitProxy
|
|
{
|
|
DECLARE_HIT_PROXY();
|
|
|
|
/** Name of property this is the widget for */
|
|
FString PropertyName;
|
|
|
|
/** If the property is an array property, the index into that array that this widget is for */
|
|
int32 PropertyIndex;
|
|
|
|
/** This property is a transform */
|
|
bool bPropertyIsTransform;
|
|
|
|
HPropertyWidgetProxy(FString InPropertyName, int32 InPropertyIndex, bool bInPropertyIsTransform)
|
|
: HHitProxy(HPP_Foreground), PropertyName(InPropertyName), PropertyIndex(InPropertyIndex), bPropertyIsTransform(bInPropertyIsTransform)
|
|
{}
|
|
|
|
/** Show cursor as cross when over this handle */
|
|
virtual EMouseCursor::Type GetMouseCursor() override
|
|
{
|
|
return EMouseCursor::Crosshairs;
|
|
}
|
|
};
|
|
|
|
IMPLEMENT_HIT_PROXY(HPropertyWidgetProxy, HHitProxy);
|
|
|
|
namespace
|
|
{
|
|
/**
|
|
* Returns a reference to the named property value data in the given container.
|
|
*/
|
|
template <typename T>
|
|
T* GetPropertyValuePtrByName(const UStruct* InStruct, void* InContainer, FString PropertyName, int32 ArrayIndex, FProperty*& OutProperty)
|
|
{
|
|
T* ValuePtr = NULL;
|
|
|
|
// Extract the vector ptr recursively using the property name
|
|
int32 DelimPos = PropertyName.Find(TEXT("."));
|
|
if (DelimPos != INDEX_NONE)
|
|
{
|
|
// Parse the property name and (optional) array index
|
|
int32 SubArrayIndex = 0;
|
|
FString NameToken = PropertyName.Left(DelimPos);
|
|
int32 ArrayPos = NameToken.Find(TEXT("["));
|
|
if (ArrayPos != INDEX_NONE)
|
|
{
|
|
FString IndexToken = NameToken.RightChop(ArrayPos + 1).LeftChop(1);
|
|
SubArrayIndex = FCString::Atoi(*IndexToken);
|
|
|
|
NameToken = PropertyName.Left(ArrayPos);
|
|
}
|
|
|
|
// Obtain the property info from the given structure definition
|
|
FProperty* CurrentProp = FindFProperty<FProperty>(InStruct, FName(*NameToken));
|
|
|
|
// Check first to see if this is a simple structure (i.e. not an array of structures)
|
|
FStructProperty* StructProp = CastField<FStructProperty>(CurrentProp);
|
|
if (StructProp != NULL)
|
|
{
|
|
// Recursively call back into this function with the structure property and container value
|
|
ValuePtr = GetPropertyValuePtrByName<T>(StructProp->Struct, StructProp->ContainerPtrToValuePtr<void>(InContainer), PropertyName.RightChop(DelimPos + 1), ArrayIndex, OutProperty);
|
|
}
|
|
else
|
|
{
|
|
// Check to see if this is an array
|
|
FArrayProperty* ArrayProp = CastField<FArrayProperty>(CurrentProp);
|
|
if (ArrayProp != NULL)
|
|
{
|
|
// It is an array, now check to see if this is an array of structures
|
|
StructProp = CastField<FStructProperty>(ArrayProp->Inner);
|
|
if (StructProp != NULL)
|
|
{
|
|
FScriptArrayHelper_InContainer ArrayHelper(ArrayProp, InContainer);
|
|
if (ArrayHelper.IsValidIndex(SubArrayIndex))
|
|
{
|
|
// Recursively call back into this function with the array element and container value
|
|
ValuePtr = GetPropertyValuePtrByName<T>(StructProp->Struct, ArrayHelper.GetRawPtr(SubArrayIndex), PropertyName.RightChop(DelimPos + 1), ArrayIndex, OutProperty);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
FProperty* Prop = FindFProperty<FProperty>(InStruct, FName(*PropertyName));
|
|
if (Prop != NULL)
|
|
{
|
|
if (FArrayProperty* ArrayProp = CastField<FArrayProperty>(Prop))
|
|
{
|
|
check(ArrayIndex != INDEX_NONE);
|
|
|
|
// Property is an array property, so make sure we have a valid index specified
|
|
FScriptArrayHelper_InContainer ArrayHelper(ArrayProp, InContainer);
|
|
if (ArrayHelper.IsValidIndex(ArrayIndex))
|
|
{
|
|
ValuePtr = (T*)ArrayHelper.GetRawPtr(ArrayIndex);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Property is a vector property, so access directly
|
|
ValuePtr = Prop->ContainerPtrToValuePtr<T>(InContainer);
|
|
}
|
|
|
|
OutProperty = Prop;
|
|
}
|
|
}
|
|
|
|
return ValuePtr;
|
|
}
|
|
|
|
/**
|
|
* Returns the value of the property with the given name in the given Actor instance.
|
|
*/
|
|
template <typename T>
|
|
T GetPropertyValueByName(UObject* Object, FString PropertyName, int32 PropertyIndex)
|
|
{
|
|
T Value;
|
|
FProperty* DummyProperty = NULL;
|
|
if (T* ValuePtr = GetPropertyValuePtrByName<T>(Object->GetClass(), Object, PropertyName, PropertyIndex, DummyProperty))
|
|
{
|
|
Value = *ValuePtr;
|
|
}
|
|
return Value;
|
|
}
|
|
|
|
/**
|
|
* Sets the property with the given name in the given Actor instance to the given value.
|
|
*/
|
|
template <typename T>
|
|
void SetPropertyValueByName(UObject* Object, FString PropertyName, int32 PropertyIndex, const T& InValue, FProperty*& OutProperty)
|
|
{
|
|
if (T* ValuePtr = GetPropertyValuePtrByName<T>(Object->GetClass(), Object, PropertyName, PropertyIndex, OutProperty))
|
|
{
|
|
*ValuePtr = InValue;
|
|
}
|
|
}
|
|
} // namespace
|
|
|
|
//////////////////////////////////
|
|
// FEdMode
|
|
|
|
void FEdMode::FPropertyWidgetInfo::GetTransformAndColor(UObject* BestSelectedItem, bool bIsSelected, FTransform& OutLocalTransform, FString& OutValidationMessage, FColor& OutDrawColor) const
|
|
{
|
|
// Determine the desired position
|
|
if (bIsTransform)
|
|
{
|
|
OutLocalTransform = GetPropertyValueByName<FTransform>(BestSelectedItem, PropertyName, PropertyIndex);
|
|
}
|
|
else
|
|
{
|
|
OutLocalTransform = FTransform(GetPropertyValueByName<FVector>(BestSelectedItem, PropertyName, PropertyIndex));
|
|
}
|
|
|
|
// Determine the desired color
|
|
OutDrawColor = bIsSelected ? FColor::White : FColor(128, 128, 255);
|
|
if (PropertyValidationName != NAME_None)
|
|
{
|
|
if (UFunction* ValidateFunc = BestSelectedItem->FindFunction(PropertyValidationName))
|
|
{
|
|
BestSelectedItem->ProcessEvent(ValidateFunc, &OutValidationMessage);
|
|
|
|
// if we have a negative result, the widget color is red.
|
|
OutDrawColor = OutValidationMessage.IsEmpty() ? OutDrawColor : FColor::Red;
|
|
}
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////
|
|
// FEdMode
|
|
|
|
const FName FEdMode::MD_MakeEditWidget(TEXT("MakeEditWidget"));
|
|
const FName FEdMode::MD_ValidateWidgetUsing(TEXT("ValidateWidgetUsing"));
|
|
|
|
FEdMode::FEdMode()
|
|
: bPendingDeletion(false), CurrentWidgetAxis(EAxisList::None), CurrentTool(nullptr), Owner(nullptr), EditedPropertyIndex(INDEX_NONE), bEditedPropertyIsTransform(false)
|
|
{
|
|
bDrawKillZ = true;
|
|
}
|
|
|
|
FEdMode::~FEdMode()
|
|
{
|
|
}
|
|
|
|
void FEdMode::OnModeUnregistered(FEditorModeID ModeID)
|
|
{
|
|
if (ModeID == Info.ID)
|
|
{
|
|
// This should be synonymous with "delete this"
|
|
Owner->DestroyMode(ModeID);
|
|
}
|
|
}
|
|
|
|
bool FEdMode::MouseEnter(FEditorViewportClient* ViewportClient, FViewport* Viewport, int32 x, int32 y)
|
|
{
|
|
if (GetCurrentTool())
|
|
{
|
|
return GetCurrentTool()->MouseEnter(ViewportClient, Viewport, x, y);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool FEdMode::MouseLeave(FEditorViewportClient* ViewportClient, FViewport* Viewport)
|
|
{
|
|
if (GetCurrentTool())
|
|
{
|
|
return GetCurrentTool()->MouseLeave(ViewportClient, Viewport);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool FEdMode::MouseMove(FEditorViewportClient* ViewportClient, FViewport* Viewport, int32 x, int32 y)
|
|
{
|
|
if (GetCurrentTool())
|
|
{
|
|
return GetCurrentTool()->MouseMove(ViewportClient, Viewport, x, y);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool FEdMode::ReceivedFocus(FEditorViewportClient* ViewportClient, FViewport* Viewport)
|
|
{
|
|
if (GetCurrentTool())
|
|
{
|
|
return GetCurrentTool()->ReceivedFocus(ViewportClient, Viewport);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool FEdMode::LostFocus(FEditorViewportClient* ViewportClient, FViewport* Viewport)
|
|
{
|
|
if (GetCurrentTool())
|
|
{
|
|
return GetCurrentTool()->LostFocus(ViewportClient, Viewport);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool FEdMode::CapturedMouseMove(FEditorViewportClient* InViewportClient, FViewport* InViewport, int32 InMouseX, int32 InMouseY)
|
|
{
|
|
if (GetCurrentTool())
|
|
{
|
|
return GetCurrentTool()->CapturedMouseMove(InViewportClient, InViewport, InMouseX, InMouseY);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool FEdMode::InputKey(FEditorViewportClient* ViewportClient, FViewport* Viewport, FKey Key, EInputEvent Event)
|
|
{
|
|
// First try the currently selected tool
|
|
if ((GetCurrentTool() != nullptr) && GetCurrentTool()->InputKey(ViewportClient, Viewport, Key, Event))
|
|
{
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
// Next pass input to the mode toolkit
|
|
if (Toolkit.IsValid() && ((Event == IE_Pressed) || (Event == IE_Repeat)))
|
|
{
|
|
if (Toolkit->GetToolkitCommands()->ProcessCommandBindings(Key, FSlateApplication::Get().GetModifierKeys(), (Event == IE_Repeat)))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// Finally, pass input up to selected actors if not in a tool mode
|
|
TArray<AActor*> SelectedActors;
|
|
Owner->GetSelectedActors()->GetSelectedObjects<AActor>(SelectedActors);
|
|
|
|
for (TArray<AActor*>::TIterator It(SelectedActors); It; ++It)
|
|
{
|
|
// Tell the object we've had a key press
|
|
(*It)->EditorKeyPressed(Key, Event);
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool FEdMode::InputAxis(FEditorViewportClient* InViewportClient, FViewport* Viewport, int32 ControllerId, FKey Key, float Delta, float DeltaTime)
|
|
{
|
|
FModeTool* Tool = GetCurrentTool();
|
|
if (Tool)
|
|
{
|
|
return Tool->InputAxis(InViewportClient, Viewport, ControllerId, Key, Delta, DeltaTime);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool FEdMode::InputDelta(FEditorViewportClient* InViewportClient, FViewport* InViewport, FVector& InDrag, FRotator& InRot, FVector& InScale)
|
|
{
|
|
if (UsesPropertyWidgets())
|
|
{
|
|
FTransform DisplayWidgetToWorld;
|
|
UObject* BestSelectedItem = GetItemToTryDisplayingWidgetsFor(/*out*/ DisplayWidgetToWorld);
|
|
|
|
if ((BestSelectedItem != nullptr) && (InViewportClient->GetCurrentWidgetAxis() != EAxisList::None))
|
|
{
|
|
GEditor->NoteActorMovement();
|
|
|
|
if (!EditedPropertyName.IsEmpty())
|
|
{
|
|
FTransform LocalTM = FTransform::Identity;
|
|
|
|
if (bEditedPropertyIsTransform)
|
|
{
|
|
LocalTM = GetPropertyValueByName<FTransform>(BestSelectedItem, EditedPropertyName, EditedPropertyIndex);
|
|
}
|
|
else
|
|
{
|
|
FVector LocalPos = GetPropertyValueByName<FVector>(BestSelectedItem, EditedPropertyName, EditedPropertyIndex);
|
|
LocalTM = FTransform(LocalPos);
|
|
}
|
|
|
|
// Calculate world transform
|
|
FTransform WorldTM = LocalTM * DisplayWidgetToWorld;
|
|
// Calc delta specified by drag
|
|
// FTransform DeltaTM(InRot.Quaternion(), InDrag);
|
|
// Apply delta in world space
|
|
WorldTM.SetTranslation(WorldTM.GetTranslation() + InDrag);
|
|
WorldTM.SetRotation(InRot.Quaternion() * WorldTM.GetRotation());
|
|
// Convert new world transform back into local space
|
|
LocalTM = WorldTM.GetRelativeTransform(DisplayWidgetToWorld);
|
|
// Apply delta scale
|
|
LocalTM.SetScale3D(LocalTM.GetScale3D() + InScale);
|
|
|
|
BestSelectedItem->PreEditChange(NULL);
|
|
|
|
// Property that we actually change
|
|
FProperty* SetProperty = NULL;
|
|
|
|
if (bEditedPropertyIsTransform)
|
|
{
|
|
SetPropertyValueByName<FTransform>(BestSelectedItem, EditedPropertyName, EditedPropertyIndex, LocalTM, SetProperty);
|
|
}
|
|
else
|
|
{
|
|
SetPropertyValueByName<FVector>(BestSelectedItem, EditedPropertyName, EditedPropertyIndex, LocalTM.GetLocation(), SetProperty);
|
|
}
|
|
|
|
FPropertyChangedEvent PropertyChangeEvent(SetProperty);
|
|
BestSelectedItem->PostEditChangeProperty(PropertyChangeEvent);
|
|
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (GetCurrentTool())
|
|
{
|
|
return GetCurrentTool()->InputDelta(InViewportClient, InViewport, InDrag, InRot, InScale);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool FEdMode::UsesTransformWidget() const
|
|
{
|
|
if (GetCurrentTool())
|
|
{
|
|
return GetCurrentTool()->UseWidget();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool FEdMode::UsesTransformWidget(FWidget::EWidgetMode CheckMode) const
|
|
{
|
|
if (UsesPropertyWidgets())
|
|
{
|
|
FTransform DisplayWidgetToWorld;
|
|
UObject* BestSelectedItem = GetItemToTryDisplayingWidgetsFor(/*out*/ DisplayWidgetToWorld);
|
|
|
|
if (BestSelectedItem != nullptr)
|
|
{
|
|
// If editing a vector (not a transform)
|
|
if (!EditedPropertyName.IsEmpty() && !bEditedPropertyIsTransform)
|
|
{
|
|
return (CheckMode == FWidget::WM_Translate);
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
FVector FEdMode::GetWidgetLocation() const
|
|
{
|
|
if (UsesPropertyWidgets())
|
|
{
|
|
FTransform DisplayWidgetToWorld;
|
|
UObject* BestSelectedItem = GetItemToTryDisplayingWidgetsFor(/*out*/ DisplayWidgetToWorld);
|
|
if (BestSelectedItem)
|
|
{
|
|
if (!EditedPropertyName.IsEmpty())
|
|
{
|
|
FVector LocalPos = FVector::ZeroVector;
|
|
|
|
if (bEditedPropertyIsTransform)
|
|
{
|
|
FTransform LocalTM = GetPropertyValueByName<FTransform>(BestSelectedItem, EditedPropertyName, EditedPropertyIndex);
|
|
LocalPos = LocalTM.GetLocation();
|
|
}
|
|
else
|
|
{
|
|
LocalPos = GetPropertyValueByName<FVector>(BestSelectedItem, EditedPropertyName, EditedPropertyIndex);
|
|
}
|
|
|
|
const FVector WorldPos = DisplayWidgetToWorld.TransformPosition(LocalPos);
|
|
return WorldPos;
|
|
}
|
|
}
|
|
}
|
|
|
|
return Owner->PivotLocation;
|
|
}
|
|
|
|
bool FEdMode::GetCustomDrawingCoordinateSystem(FMatrix& InMatrix, void* InData)
|
|
{
|
|
if (UsesPropertyWidgets())
|
|
{
|
|
FTransform DisplayWidgetToWorld;
|
|
UObject* BestSelectedItem = GetItemToTryDisplayingWidgetsFor(/*out*/ DisplayWidgetToWorld);
|
|
if (BestSelectedItem)
|
|
{
|
|
if (EditedPropertyName != TEXT(""))
|
|
{
|
|
if (bEditedPropertyIsTransform)
|
|
{
|
|
FTransform LocalTM = GetPropertyValueByName<FTransform>(BestSelectedItem, EditedPropertyName, EditedPropertyIndex);
|
|
InMatrix = FRotationMatrix::Make((LocalTM * DisplayWidgetToWorld).GetRotation());
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
InMatrix = FRotationMatrix::Make(DisplayWidgetToWorld.GetRotation());
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool FEdMode::ShouldDrawWidget() const
|
|
{
|
|
bool bDrawWidget = false;
|
|
|
|
bool bHadSelectableComponents = false;
|
|
if (Owner->GetSelectedComponents()->Num() > 0)
|
|
{
|
|
// when components are selected, only show the widget when one or more are scene components
|
|
for (FSelectedEditableComponentIterator It(*Owner->GetSelectedComponents()); It; ++It)
|
|
{
|
|
bHadSelectableComponents = true;
|
|
if (It->IsA<USceneComponent>())
|
|
{
|
|
bDrawWidget = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!bHadSelectableComponents)
|
|
{
|
|
// when actors are selected, only show the widget when all selected actors have scene components
|
|
bDrawWidget = Owner->SelectionHasSceneComponent();
|
|
}
|
|
|
|
return bDrawWidget;
|
|
}
|
|
|
|
EAxisList::Type FEdMode::GetWidgetAxisToDraw(FWidget::EWidgetMode InWidgetMode) const
|
|
{
|
|
return EAxisList::All;
|
|
}
|
|
|
|
bool FEdMode::BoxSelect(FBox& InBox, bool InSelect)
|
|
{
|
|
bool bResult = false;
|
|
if (GetCurrentTool())
|
|
{
|
|
bResult = GetCurrentTool()->BoxSelect(InBox, InSelect);
|
|
}
|
|
return bResult;
|
|
}
|
|
|
|
bool FEdMode::FrustumSelect(const FConvexVolume& InFrustum, FEditorViewportClient* InViewportClient, bool InSelect)
|
|
{
|
|
bool bResult = false;
|
|
if (GetCurrentTool())
|
|
{
|
|
bResult = GetCurrentTool()->FrustumSelect(InFrustum, InViewportClient, InSelect);
|
|
}
|
|
return bResult;
|
|
}
|
|
|
|
void FEdMode::SelectNone()
|
|
{
|
|
if (GetCurrentTool())
|
|
{
|
|
GetCurrentTool()->SelectNone();
|
|
}
|
|
}
|
|
|
|
void FEdMode::Tick(FEditorViewportClient* ViewportClient, float DeltaTime)
|
|
{
|
|
if (GetCurrentTool())
|
|
{
|
|
GetCurrentTool()->Tick(ViewportClient, DeltaTime);
|
|
}
|
|
}
|
|
|
|
void FEdMode::ActorSelectionChangeNotify()
|
|
{
|
|
EditedPropertyName = TEXT("");
|
|
EditedPropertyIndex = INDEX_NONE;
|
|
bEditedPropertyIsTransform = false;
|
|
}
|
|
|
|
bool FEdMode::HandleClick(FEditorViewportClient* InViewportClient, HHitProxy* HitProxy, const FViewportClick& Click)
|
|
{
|
|
if (UsesPropertyWidgets() && (HitProxy != nullptr))
|
|
{
|
|
if (HitProxy->IsA(HPropertyWidgetProxy::StaticGetType()))
|
|
{
|
|
HPropertyWidgetProxy* PropertyProxy = (HPropertyWidgetProxy*)HitProxy;
|
|
EditedPropertyName = PropertyProxy->PropertyName;
|
|
EditedPropertyIndex = PropertyProxy->PropertyIndex;
|
|
bEditedPropertyIsTransform = PropertyProxy->bPropertyIsTransform;
|
|
return true;
|
|
}
|
|
// Left clicking on an actor, stop editing a property
|
|
else if (HitProxy->IsA(HActor::StaticGetType()))
|
|
{
|
|
EditedPropertyName = FString();
|
|
EditedPropertyIndex = INDEX_NONE;
|
|
bEditedPropertyIsTransform = false;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void FEdMode::Enter()
|
|
{
|
|
// Update components for selected actors, in case the mode we just exited
|
|
// was hijacking selection events selection and not updating components.
|
|
for (FSelectionIterator It(*Owner->GetSelectedActors()); It; ++It)
|
|
{
|
|
AActor* SelectedActor = CastChecked<AActor>(*It);
|
|
SelectedActor->MarkComponentsRenderStateDirty();
|
|
}
|
|
|
|
bPendingDeletion = false;
|
|
|
|
FEditorDelegates::EditorModeIDEnter.Broadcast(GetID());
|
|
}
|
|
|
|
void FEdMode::Exit()
|
|
{
|
|
FEditorDelegates::EditorModeIDExit.Broadcast(GetID());
|
|
}
|
|
|
|
UTexture2D* FEdMode::GetVertexTexture()
|
|
{
|
|
return GEngine->DefaultBSPVertexTexture;
|
|
}
|
|
|
|
void FEdMode::SetCurrentTool(EModeTools InID)
|
|
{
|
|
CurrentTool = FindTool(InID);
|
|
check(CurrentTool); // Tool not found! This can't happen.
|
|
|
|
CurrentToolChanged();
|
|
}
|
|
|
|
void FEdMode::SetCurrentTool(FModeTool* InModeTool)
|
|
{
|
|
CurrentTool = InModeTool;
|
|
check(CurrentTool);
|
|
|
|
CurrentToolChanged();
|
|
}
|
|
|
|
FModeTool* FEdMode::FindTool(EModeTools InID)
|
|
{
|
|
for (int32 x = 0; x < Tools.Num(); ++x)
|
|
{
|
|
if (Tools[x]->GetID() == InID)
|
|
{
|
|
return Tools[x];
|
|
}
|
|
}
|
|
|
|
UE_LOG(LogEditorModes, Fatal, TEXT("FEdMode::FindTool failed to find tool %d"), (int32)InID);
|
|
return NULL;
|
|
}
|
|
|
|
void FEdMode::Render(const FSceneView* View, FViewport* Viewport, FPrimitiveDrawInterface* PDI)
|
|
{
|
|
// Let the current mode tool render if it wants to
|
|
if (FModeTool* Tool = GetCurrentTool())
|
|
{
|
|
Tool->Render(View, Viewport, PDI);
|
|
}
|
|
|
|
if (UsesPropertyWidgets())
|
|
{
|
|
const bool bHitTesting = PDI->IsHitTesting();
|
|
|
|
FTransform DisplayWidgetToWorld;
|
|
UObject* BestSelectedItem = GetItemToTryDisplayingWidgetsFor(/*out*/ DisplayWidgetToWorld);
|
|
|
|
if (BestSelectedItem != nullptr)
|
|
{
|
|
UClass* Class = BestSelectedItem->GetClass();
|
|
TArray<FPropertyWidgetInfo> WidgetInfos;
|
|
GetPropertyWidgetInfos(Class, BestSelectedItem, WidgetInfos);
|
|
FEditorScriptExecutionGuard ScriptGuard;
|
|
for (const FPropertyWidgetInfo& WidgetInfo: WidgetInfos)
|
|
{
|
|
const bool bSelected = (WidgetInfo.PropertyName == EditedPropertyName) && (WidgetInfo.PropertyIndex == EditedPropertyIndex);
|
|
|
|
FTransform LocalWidgetTransform;
|
|
FString ValidationMessage;
|
|
FColor WidgetColor;
|
|
WidgetInfo.GetTransformAndColor(BestSelectedItem, bSelected, /*out*/ LocalWidgetTransform, /*out*/ ValidationMessage, /*out*/ WidgetColor);
|
|
|
|
const FTransform WorldWidgetTransform = LocalWidgetTransform * DisplayWidgetToWorld;
|
|
const FMatrix WidgetTM(WorldWidgetTransform.ToMatrixWithScale());
|
|
|
|
const float WidgetSize = 0.035f;
|
|
const float ZoomFactor = FMath::Min<float>(View->ViewMatrices.GetProjectionMatrix().M[0][0], View->ViewMatrices.GetProjectionMatrix().M[1][1]);
|
|
const float WidgetRadius = View->Project(WorldWidgetTransform.GetTranslation()).W * (WidgetSize / ZoomFactor);
|
|
|
|
if (bHitTesting)
|
|
PDI->SetHitProxy(new HPropertyWidgetProxy(WidgetInfo.PropertyName, WidgetInfo.PropertyIndex, WidgetInfo.bIsTransform));
|
|
DrawWireDiamond(PDI, WidgetTM, WidgetRadius, WidgetColor, SDPG_Foreground);
|
|
if (bHitTesting)
|
|
PDI->SetHitProxy(NULL);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void FEdMode::DrawHUD(FEditorViewportClient* ViewportClient, FViewport* Viewport, const FSceneView* View, FCanvas* Canvas)
|
|
{
|
|
// Render the drag tool.
|
|
ViewportClient->RenderDragTool(View, Canvas);
|
|
|
|
// Let the current mode tool draw a HUD if it wants to
|
|
FModeTool* tool = GetCurrentTool();
|
|
if (tool)
|
|
{
|
|
tool->DrawHUD(ViewportClient, Viewport, View, Canvas);
|
|
}
|
|
|
|
if (ViewportClient->IsPerspective() && GetDefault<ULevelEditorViewportSettings>()->bHighlightWithBrackets)
|
|
{
|
|
DrawBrackets(ViewportClient, Viewport, View, Canvas);
|
|
}
|
|
|
|
// If this viewport doesn't show mode widgets or the mode itself doesn't want them, leave.
|
|
if (!(ViewportClient->EngineShowFlags.ModeWidgets) || !ShowModeWidgets())
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Clear Hit proxies
|
|
const bool bIsHitTesting = Canvas->IsHitTesting();
|
|
if (!bIsHitTesting)
|
|
{
|
|
Canvas->SetHitProxy(NULL);
|
|
}
|
|
|
|
// Draw vertices for selected BSP brushes and static meshes if the large vertices show flag is set.
|
|
if (!ViewportClient->bDrawVertices)
|
|
{
|
|
return;
|
|
}
|
|
|
|
const bool bLargeVertices = View->Family->EngineShowFlags.LargeVertices;
|
|
const bool bShowBrushes = View->Family->EngineShowFlags.Brushes;
|
|
const bool bShowBSP = View->Family->EngineShowFlags.BSP;
|
|
const bool bShowBuilderBrush = View->Family->EngineShowFlags.BuilderBrush != 0;
|
|
|
|
UTexture2D* VertexTexture = GetVertexTexture();
|
|
const float TextureSizeX = VertexTexture->GetSizeX() * (bLargeVertices ? 1.0f : 0.5f);
|
|
const float TextureSizeY = VertexTexture->GetSizeY() * (bLargeVertices ? 1.0f : 0.5f);
|
|
|
|
// Temporaries.
|
|
TArray<FVector> Vertices;
|
|
|
|
for (FSelectionIterator It(*Owner->GetSelectedActors()); It; ++It)
|
|
{
|
|
AActor* SelectedActor = static_cast<AActor*>(*It);
|
|
checkSlow(SelectedActor->IsA(AActor::StaticClass()));
|
|
|
|
if (bLargeVertices)
|
|
{
|
|
FCanvasItemTestbed::bTestState = !FCanvasItemTestbed::bTestState;
|
|
|
|
// Static mesh vertices
|
|
AStaticMeshActor* Actor = Cast<AStaticMeshActor>(SelectedActor);
|
|
if (Actor && Actor->GetStaticMeshComponent() && Actor->GetStaticMeshComponent()->GetStaticMesh() && Actor->GetStaticMeshComponent()->GetStaticMesh()->GetRenderData())
|
|
{
|
|
FTransform ActorToWorld = Actor->ActorToWorld();
|
|
Vertices.Empty();
|
|
const FPositionVertexBuffer& VertexBuffer = Actor->GetStaticMeshComponent()->GetStaticMesh()->GetRenderData()->LODResources[0].VertexBuffers.PositionVertexBuffer;
|
|
for (uint32 i = 0; i < VertexBuffer.GetNumVertices(); i++)
|
|
{
|
|
Vertices.AddUnique(ActorToWorld.TransformPosition(VertexBuffer.VertexPosition(i)));
|
|
}
|
|
|
|
const float InvDpiScale = 1.0f / Canvas->GetDPIScale();
|
|
|
|
FCanvasTileItem TileItem(FVector2D(0.0f, 0.0f), FVector2D(0.0f, 0.0f), FLinearColor::White);
|
|
TileItem.BlendMode = SE_BLEND_Translucent;
|
|
for (int32 VertexIndex = 0; VertexIndex < Vertices.Num(); ++VertexIndex)
|
|
{
|
|
const FVector& Vertex = Vertices[VertexIndex];
|
|
FVector2D PixelLocation;
|
|
if (View->ScreenToPixel(View->WorldToScreen(Vertex), PixelLocation))
|
|
{
|
|
PixelLocation *= InvDpiScale;
|
|
|
|
const bool bOutside =
|
|
PixelLocation.X < 0.0f || PixelLocation.X > View->UnscaledViewRect.Width() * InvDpiScale ||
|
|
PixelLocation.Y < 0.0f || PixelLocation.Y > View->UnscaledViewRect.Height() * InvDpiScale;
|
|
if (!bOutside)
|
|
{
|
|
const float X = PixelLocation.X - (TextureSizeX / 2);
|
|
const float Y = PixelLocation.Y - (TextureSizeY / 2);
|
|
if (bIsHitTesting)
|
|
{
|
|
Canvas->SetHitProxy(new HStaticMeshVert(Actor, Vertex));
|
|
}
|
|
TileItem.Texture = VertexTexture->Resource;
|
|
|
|
TileItem.Size = FVector2D(TextureSizeX, TextureSizeY);
|
|
Canvas->DrawItem(TileItem, FVector2D(X, Y));
|
|
if (bIsHitTesting)
|
|
{
|
|
Canvas->SetHitProxy(NULL);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (UsesPropertyWidgets())
|
|
{
|
|
FTransform DisplayWidgetToWorld;
|
|
UObject* BestSelectedItem = GetItemToTryDisplayingWidgetsFor(/*out*/ DisplayWidgetToWorld);
|
|
if (BestSelectedItem != nullptr)
|
|
{
|
|
FEditorScriptExecutionGuard ScriptGuard;
|
|
|
|
FIntPoint SizeXYWithDPIScale = Viewport->GetSizeXY() / Canvas->GetDPIScale();
|
|
const int32 HalfX = 0.5f * SizeXYWithDPIScale.X;
|
|
const int32 HalfY = 0.5f * SizeXYWithDPIScale.Y;
|
|
|
|
UClass* Class = BestSelectedItem->GetClass();
|
|
TArray<FPropertyWidgetInfo> WidgetInfos;
|
|
GetPropertyWidgetInfos(Class, BestSelectedItem, WidgetInfos);
|
|
for (const FPropertyWidgetInfo& WidgetInfo: WidgetInfos)
|
|
{
|
|
FTransform LocalWidgetTransform;
|
|
FString ValidationMessage;
|
|
FColor IgnoredWidgetColor;
|
|
WidgetInfo.GetTransformAndColor(BestSelectedItem, /*bSelected=*/false, /*out*/ LocalWidgetTransform, /*out*/ ValidationMessage, /*out*/ IgnoredWidgetColor);
|
|
|
|
const FTransform WorldWidgetTransform = LocalWidgetTransform * DisplayWidgetToWorld;
|
|
|
|
const FPlane Proj = View->Project(WorldWidgetTransform.GetTranslation());
|
|
if (Proj.W > 0.f)
|
|
{
|
|
// do some string fixing
|
|
const uint32 VectorIndex = WidgetInfo.PropertyIndex;
|
|
const FString WidgetDisplayName = WidgetInfo.DisplayName + ((VectorIndex != INDEX_NONE) ? FString::Printf(TEXT("[%d]"), VectorIndex) : TEXT(""));
|
|
const FString DisplayString = ValidationMessage.IsEmpty() ? WidgetDisplayName : ValidationMessage;
|
|
|
|
const int32 XPos = HalfX + (HalfX * Proj.X);
|
|
const int32 YPos = HalfY + (HalfY * (Proj.Y * -1.f));
|
|
FCanvasTextItem TextItem(FVector2D(XPos + 5, YPos), FText::FromString(DisplayString), GEngine->GetSmallFont(), FLinearColor::White);
|
|
TextItem.EnableShadow(FLinearColor::Black);
|
|
Canvas->DrawItem(TextItem);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void FEdMode::DrawBrackets(FEditorViewportClient* ViewportClient, FViewport* Viewport, const FSceneView* View, FCanvas* Canvas)
|
|
{
|
|
USelection& SelectedActors = *Owner->GetSelectedActors();
|
|
for (int32 CurSelectedActorIndex = 0; CurSelectedActorIndex < SelectedActors.Num(); ++CurSelectedActorIndex)
|
|
{
|
|
AActor* SelectedActor = Cast<AActor>(SelectedActors.GetSelectedObject(CurSelectedActorIndex));
|
|
if (SelectedActor != NULL)
|
|
{
|
|
// Draw a bracket for selected "paintable" static mesh actors
|
|
const bool bIsValidActor = (Cast<AStaticMeshActor>(SelectedActor) != NULL);
|
|
|
|
const FLinearColor SelectedActorBoxColor(0.6f, 0.6f, 1.0f);
|
|
const bool bDrawBracket = bIsValidActor;
|
|
ViewportClient->DrawActorScreenSpaceBoundingBox(Canvas, View, Viewport, SelectedActor, SelectedActorBoxColor, bDrawBracket);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool FEdMode::UsesToolkits() const
|
|
{
|
|
return false;
|
|
}
|
|
|
|
UWorld* FEdMode::GetWorld() const
|
|
{
|
|
return Owner->GetWorld();
|
|
}
|
|
|
|
class FEditorModeTools* FEdMode::GetModeManager() const
|
|
{
|
|
return Owner;
|
|
}
|
|
|
|
bool FEdMode::StartTracking(FEditorViewportClient* InViewportClient, FViewport* InViewport)
|
|
{
|
|
bool bResult = false;
|
|
if (GetCurrentTool())
|
|
{
|
|
bResult = GetCurrentTool()->StartModify();
|
|
}
|
|
return bResult;
|
|
}
|
|
|
|
bool FEdMode::EndTracking(FEditorViewportClient* InViewportClient, FViewport* InViewport)
|
|
{
|
|
bool bResult = false;
|
|
if (GetCurrentTool())
|
|
{
|
|
bResult = GetCurrentTool()->EndModify();
|
|
}
|
|
return bResult;
|
|
}
|
|
|
|
FVector FEdMode::GetWidgetNormalFromCurrentAxis(void* InData)
|
|
{
|
|
// Figure out the proper coordinate system.
|
|
|
|
FMatrix matrix = FMatrix::Identity;
|
|
if (Owner->GetCoordSystem() == COORD_Local)
|
|
{
|
|
GetCustomDrawingCoordinateSystem(matrix, InData);
|
|
}
|
|
|
|
// Get a base normal from the current axis.
|
|
|
|
FVector BaseNormal(1, 0, 0); // Default to X axis
|
|
switch (CurrentWidgetAxis)
|
|
{
|
|
case EAxisList::Y: BaseNormal = FVector(0, 1, 0); break;
|
|
case EAxisList::Z: BaseNormal = FVector(0, 0, 1); break;
|
|
case EAxisList::XY: BaseNormal = FVector(1, 1, 0); break;
|
|
case EAxisList::XZ: BaseNormal = FVector(1, 0, 1); break;
|
|
case EAxisList::YZ: BaseNormal = FVector(0, 1, 1); break;
|
|
case EAxisList::XYZ: BaseNormal = FVector(1, 1, 1); break;
|
|
}
|
|
|
|
// Transform the base normal into the proper coordinate space.
|
|
return matrix.TransformPosition(BaseNormal);
|
|
}
|
|
|
|
AActor* FEdMode::GetFirstSelectedActorInstance() const
|
|
{
|
|
return Owner->GetSelectedActors()->GetTop<AActor>();
|
|
}
|
|
|
|
bool FEdMode::CanCreateWidgetForStructure(const UStruct* InPropStruct)
|
|
{
|
|
return InPropStruct && (InPropStruct->GetFName() == NAME_Vector || InPropStruct->GetFName() == NAME_Transform);
|
|
}
|
|
|
|
bool FEdMode::CanCreateWidgetForProperty(FProperty* InProp)
|
|
{
|
|
FStructProperty* TestProperty = CastField<FStructProperty>(InProp);
|
|
if (!TestProperty)
|
|
{
|
|
FArrayProperty* ArrayProperty = CastField<FArrayProperty>(InProp);
|
|
if (ArrayProperty)
|
|
{
|
|
TestProperty = CastField<FStructProperty>(ArrayProperty->Inner);
|
|
}
|
|
}
|
|
return (TestProperty != NULL) && CanCreateWidgetForStructure(TestProperty->Struct);
|
|
}
|
|
|
|
bool FEdMode::ShouldCreateWidgetForProperty(FProperty* InProp)
|
|
{
|
|
return CanCreateWidgetForProperty(InProp) && InProp->HasMetaData(MD_MakeEditWidget);
|
|
}
|
|
|
|
static bool IsTransformProperty(FProperty* InProp)
|
|
{
|
|
FStructProperty* StructProp = CastField<FStructProperty>(InProp);
|
|
return (StructProp != NULL && StructProp->Struct->GetFName() == NAME_Transform);
|
|
}
|
|
|
|
struct FPropertyWidgetInfoChainElement
|
|
{
|
|
FProperty* Property;
|
|
int32 Index;
|
|
|
|
FPropertyWidgetInfoChainElement(FProperty* InProperty = nullptr, int32 InIndex = INDEX_NONE)
|
|
: Property(InProperty), Index(InIndex)
|
|
{}
|
|
|
|
static bool ShouldCreateWidgetSomwhereInBranch(FProperty* InProp)
|
|
{
|
|
FStructProperty* StructProperty = CastField<FStructProperty>(InProp);
|
|
if (!StructProperty)
|
|
{
|
|
FArrayProperty* ArrayProperty = CastField<FArrayProperty>(InProp);
|
|
if (ArrayProperty)
|
|
{
|
|
StructProperty = CastField<FStructProperty>(ArrayProperty->Inner);
|
|
}
|
|
}
|
|
|
|
if (StructProperty)
|
|
{
|
|
if (FEdMode::CanCreateWidgetForStructure(StructProperty->Struct) && InProp->HasMetaData(FEdMode::MD_MakeEditWidget))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
for (TFieldIterator<FProperty> PropertyIt(StructProperty->Struct, EFieldIteratorFlags::IncludeSuper); PropertyIt; ++PropertyIt)
|
|
{
|
|
if (ShouldCreateWidgetSomwhereInBranch(*PropertyIt))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
static FEdMode::FPropertyWidgetInfo CreateWidgetInfo(const TArray<FPropertyWidgetInfoChainElement>& Chain, bool bIsTransform, FProperty* CurrentProp, int32 Index = INDEX_NONE)
|
|
{
|
|
check(CurrentProp);
|
|
FEdMode::FPropertyWidgetInfo WidgetInfo;
|
|
WidgetInfo.PropertyValidationName = FName(*CurrentProp->GetMetaData(FEdMode::MD_ValidateWidgetUsing));
|
|
WidgetInfo.bIsTransform = bIsTransform;
|
|
WidgetInfo.PropertyIndex = Index;
|
|
|
|
const FString SimplePostFix(TEXT("."));
|
|
for (int32 ChainIndex = 0; ChainIndex < Chain.Num(); ++ChainIndex)
|
|
{
|
|
const FPropertyWidgetInfoChainElement& Element = Chain[ChainIndex];
|
|
check(Element.Property);
|
|
const FString Postfix = (Element.Index != INDEX_NONE) ? FString::Printf(TEXT("[%d]."), Element.Index) : SimplePostFix;
|
|
const FString PropertyName = Element.Property->GetName() + Postfix;
|
|
const FString& DisplayName = Element.Property->GetMetaData(TEXT("DisplayName"));
|
|
|
|
WidgetInfo.PropertyName += PropertyName;
|
|
WidgetInfo.DisplayName += (!DisplayName.IsEmpty()) ? (DisplayName + Postfix) : PropertyName;
|
|
}
|
|
|
|
{
|
|
const FString PropertyName = CurrentProp->GetName();
|
|
const FString& DisplayName = CurrentProp->GetMetaData(TEXT("DisplayName"));
|
|
|
|
WidgetInfo.PropertyName += PropertyName;
|
|
WidgetInfo.DisplayName += (!DisplayName.IsEmpty()) ? DisplayName : PropertyName;
|
|
}
|
|
return WidgetInfo;
|
|
}
|
|
|
|
static void RecursiveGet(const FEdMode& EdMode, const UStruct* InStruct, const void* InContainer, TArray<FEdMode::FPropertyWidgetInfo>& OutInfos, TArray<FPropertyWidgetInfoChainElement>& Chain)
|
|
{
|
|
for (TFieldIterator<FProperty> PropertyIt(InStruct, EFieldIteratorFlags::IncludeSuper); PropertyIt; ++PropertyIt)
|
|
{
|
|
FProperty* CurrentProp = *PropertyIt;
|
|
check(CurrentProp);
|
|
|
|
if (EdMode.ShouldCreateWidgetForProperty(CurrentProp))
|
|
{
|
|
if (FArrayProperty* ArrayProp = CastField<FArrayProperty>(CurrentProp))
|
|
{
|
|
check(InContainer);
|
|
FScriptArrayHelper_InContainer ArrayHelper(ArrayProp, InContainer);
|
|
// See how many widgets we need to make for the array property
|
|
const uint32 ArrayDim = ArrayHelper.Num();
|
|
for (uint32 Index = 0; Index < ArrayDim; ++Index)
|
|
{
|
|
OutInfos.Add(FPropertyWidgetInfoChainElement::CreateWidgetInfo(Chain, IsTransformProperty(ArrayProp->Inner), CurrentProp, Index));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
OutInfos.Add(FPropertyWidgetInfoChainElement::CreateWidgetInfo(Chain, IsTransformProperty(CurrentProp), CurrentProp));
|
|
}
|
|
}
|
|
else if (FStructProperty* StructProp = CastField<FStructProperty>(CurrentProp))
|
|
{
|
|
// Recursively traverse into structures, looking for additional vector properties to expose
|
|
Chain.Push(FPropertyWidgetInfoChainElement(StructProp));
|
|
RecursiveGet(EdMode, StructProp->Struct, StructProp->ContainerPtrToValuePtr<void>(InContainer), OutInfos, Chain);
|
|
Chain.Pop(false);
|
|
}
|
|
else if (FArrayProperty* ArrayProp = CastField<FArrayProperty>(CurrentProp))
|
|
{
|
|
// Recursively traverse into arrays of structures, looking for additional vector properties to expose
|
|
FStructProperty* InnerStructProp = CastField<FStructProperty>(ArrayProp->Inner);
|
|
if (InnerStructProp)
|
|
{
|
|
FScriptArrayHelper_InContainer ArrayHelper(ArrayProp, InContainer);
|
|
|
|
// If the array is not empty the do additional check to tell if iteration is necessary
|
|
if (ArrayHelper.Num() && ShouldCreateWidgetSomwhereInBranch(InnerStructProp))
|
|
{
|
|
for (int32 ArrayIndex = 0; ArrayIndex < ArrayHelper.Num(); ++ArrayIndex)
|
|
{
|
|
Chain.Push(FPropertyWidgetInfoChainElement(ArrayProp, ArrayIndex));
|
|
RecursiveGet(EdMode, InnerStructProp->Struct, ArrayHelper.GetRawPtr(ArrayIndex), OutInfos, Chain);
|
|
Chain.Pop(false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
UObject* FEdMode::GetItemToTryDisplayingWidgetsFor(FTransform& OutLocalToWorld) const
|
|
{
|
|
// Determine what is selected, preferring a component over an actor
|
|
USceneComponent* SelectedComponent = Owner->GetSelectedComponents()->GetTop<USceneComponent>();
|
|
UObject* BestSelectedItem = SelectedComponent;
|
|
|
|
if (SelectedComponent == nullptr)
|
|
{
|
|
AActor* SelectedActor = GetFirstSelectedActorInstance();
|
|
if (SelectedActor != nullptr)
|
|
{
|
|
if (USceneComponent* RootComponent = SelectedActor->GetRootComponent())
|
|
{
|
|
BestSelectedItem = SelectedActor;
|
|
OutLocalToWorld = RootComponent->GetComponentToWorld();
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
OutLocalToWorld = SelectedComponent->GetComponentToWorld();
|
|
}
|
|
|
|
return BestSelectedItem;
|
|
}
|
|
|
|
void FEdMode::GetPropertyWidgetInfos(const UStruct* InStruct, const void* InContainer, TArray<FPropertyWidgetInfo>& OutInfos) const
|
|
{
|
|
TArray<FPropertyWidgetInfoChainElement> Chain;
|
|
FPropertyWidgetInfoChainElement::RecursiveGet(*this, InStruct, InContainer, OutInfos, Chain);
|
|
}
|
|
|
|
bool FEdMode::IsSnapRotationEnabled()
|
|
{
|
|
return GetDefault<ULevelEditorViewportSettings>()->RotGridEnabled;
|
|
}
|