TSharedRef< FSlateTextHighlightRunRenderer > FSlateTextHighlightRunRenderer::Create() { return MakeShareable( new FSlateTextHighlightRunRenderer() ); }
void SSizeMap::FinalizeNodesRecursively( TSharedPtr<FTreeMapNodeData>& Node, const TSharedPtr<FTreeMapNodeData>& SharedRootNode, int32& TotalAssetCount, SIZE_T& TotalSize, bool& bAnyUnknownSizes ) { // Process children first, so we can get the totals for the root node and shared nodes int32 SubtreeAssetCount = 0; SIZE_T SubtreeSize = 0; bool bAnyUnknownSizesInSubtree = false; { for( TSharedPtr<FTreeMapNodeData> ChildNode : Node->Children ) { FinalizeNodesRecursively( ChildNode, SharedRootNode, SubtreeAssetCount, SubtreeSize, bAnyUnknownSizesInSubtree ); } TotalAssetCount += SubtreeAssetCount; TotalSize += SubtreeSize; if( bAnyUnknownSizesInSubtree ) { bAnyUnknownSizes = true; } } if( Node == SharedRootNode ) { // @todo sizemap: Should we indicate in a non-shared parent node how many if its dependents ended up being in the "shared" bucket? Probably // not that important, because the user can choose to view that asset in isolation to see the full tree. Node->Name = FString::Printf( TEXT( "%s (%s)" ), *LOCTEXT( "SharedGroupName", "*SHARED*" ).ToString(), *SizeMapInternals::MakeBestSizeString( SubtreeSize, !bAnyUnknownSizes ) ); // Container nodes are always auto-sized Node->Size = 0.0f; } else if( Node->Parent == nullptr ) { // Tree root is always auto-sized Node->Size = 0.0f; } else { const FNodeSizeMapData& NodeSizeMapData = NodeSizeMapDataMap.FindChecked( Node.ToSharedRef() ); ++TotalAssetCount; TotalSize += NodeSizeMapData.AssetSize; if( !NodeSizeMapData.bHasKnownSize ) { bAnyUnknownSizes = true; } // Setup a thumbnail const FSlateBrush* DefaultThumbnailSlateBrush; { // For non-class types, use the default based upon the actual asset class // This has the side effect of not showing a class icon for assets that don't have a proper thumbnail image available bool bIsClassType = false; const UClass* ThumbnailClass = FClassIconFinder::GetIconClassForAssetData( NodeSizeMapData.AssetData, &bIsClassType ); const FName DefaultThumbnail = (bIsClassType) ? NAME_None : FName(*FString::Printf(TEXT("ClassThumbnail.%s"), *NodeSizeMapData.AssetData.AssetClass.ToString())); DefaultThumbnailSlateBrush = FClassIconFinder::FindThumbnailForClass(ThumbnailClass, DefaultThumbnail); // @todo sizemap urgent: Actually implement rendered thumbnail support, not just class-based background images // const int32 ThumbnailSize = 128; // @todo sizemap: Hard-coded thumbnail size. Move this elsewhere // TSharedRef<FAssetThumbnail> AssetThumbnail( new FAssetThumbnail( NodeSizeMapData.AssetData, ThumbnailSize, ThumbnailSize, AssetThumbnailPool ) ); // ChildTreeMapNode->AssetThumbnail = AssetThumbnail->MakeThumbnailImage(); } if( Node->IsLeafNode() ) { Node->CenterText = SizeMapInternals::MakeBestSizeString( NodeSizeMapData.AssetSize, NodeSizeMapData.bHasKnownSize ); Node->Size = NodeSizeMapData.AssetSize; // The STreeMap widget is not expecting zero-sized leaf nodes. So we make them very small instead. if( Node->Size == 0 ) { Node->Size = 1; } // Leaf nodes get a background picture Node->BackgroundBrush = DefaultThumbnailSlateBrush; // "Asset name" // "Asset type" Node->Name = NodeSizeMapData.AssetData.AssetName.ToString(); Node->Name2 = NodeSizeMapData.AssetData.AssetClass.ToString(); } else { // Container nodes are always auto-sized Node->Size = 0.0f; // "Asset name (asset type, size)" Node->Name = FString::Printf( TEXT( "%s (%s, %s)" ), *NodeSizeMapData.AssetData.AssetName.ToString(), *NodeSizeMapData.AssetData.AssetClass.ToString(), *SizeMapInternals::MakeBestSizeString( SubtreeSize + NodeSizeMapData.AssetSize, !bAnyUnknownSizesInSubtree && NodeSizeMapData.bHasKnownSize ) ); const bool bNeedsSelfNode = NodeSizeMapData.AssetSize > 0; if( bNeedsSelfNode ) { // We have children, so make some space for our own asset's size within our box FTreeMapNodeDataRef ChildSelfTreeMapNode = MakeShareable( new FTreeMapNodeData() ); Node->Children.Add( ChildSelfTreeMapNode ); ChildSelfTreeMapNode->Parent = Node.Get(); // Keep back-pointer to parent node // Map the "self" node to the same node data as its parent NodeSizeMapDataMap.Add( ChildSelfTreeMapNode, NodeSizeMapData ); // "*SELF*" // "Asset type" ChildSelfTreeMapNode->Name = LOCTEXT( "SelfNodeLabel", "*SELF*" ).ToString(); ChildSelfTreeMapNode->Name2 = NodeSizeMapData.AssetData.AssetClass.ToString(); ChildSelfTreeMapNode->CenterText = SizeMapInternals::MakeBestSizeString( NodeSizeMapData.AssetSize, NodeSizeMapData.bHasKnownSize ); ChildSelfTreeMapNode->Size = NodeSizeMapData.AssetSize; // Leaf nodes get a background picture ChildSelfTreeMapNode->BackgroundBrush = DefaultThumbnailSlateBrush; } } } // Sort all of my child nodes alphabetically. This is just so that we get deterministic results when viewing the // same sets of assets. Node->Children.StableSort( []( const FTreeMapNodeDataPtr& A, const FTreeMapNodeDataPtr& B ) { return A->Name < B->Name; } ); }
// Create Objects void TestScene::SetupObjects() { spObject sun(new Object); sun->SetVO(MakeShareable(new PrimitiveUVSphere(256, 128))); sun->GetTransform().SetScale(Vector3(2.f, 2.f, 2.f)); Texture sunTexture; LoadTexture(sunTexture, "textures/texture_sun.png"); sun->GetVO()->GetTexture() = sunTexture; sun->SetGLMode(GL_TRIANGLES); sun->EnableTexture(); sun->SetName(L"Sun"); objects.push_back(sun); objectMap.insert(std::make_pair(sun->GetName(), sun)); spObject world(new Object); world->SetVO(MakeShareable(new PrimitiveUVSphere(256, 128))); world->GetTransform().SetPosition(Vector3(5.f, 0.f, 0.f)); Texture worldTexture; LoadTexture(worldTexture, "textures/4kworld.png"); world->GetVO()->GetTexture() = worldTexture; world->SetGLMode(GL_TRIANGLES); world->EnableTexture(); world->SetName(L"Earth"); world->SetParent(sun.Get(), TransformInheritance(true, false, true, false)); objects.push_back(world); objectMap.insert(std::make_pair(world->GetName(), world)); spObject clouds(new Object); clouds->SetVO(MakeShareable(new PrimitiveUVSphere(256, 128))); clouds->GetTransform().SetScale(Vector3(1.01f, 1.01f, 1.01f)); Texture cloudTexture; LoadTexture(cloudTexture, "textures/clouds.png"); clouds->GetVO()->GetTexture() = cloudTexture; clouds->SetGLMode(GL_TRIANGLES); clouds->EnableTexture(); clouds->EnableTransparency(); clouds->SetName(L"Clouds"); clouds->SetParent(world.Get(), TransformInheritance(true, false, true, false)); objects.push_back(clouds); objectMap.insert(std::make_pair(clouds->GetName(), clouds)); //spObject disc(new Object); //disc->SetVO(new PrimitiveDisc(64)); //Texture discTexture; //LoadTexture(discTexture, "crate.png"); //disc->GetVO()->GetTexture() = discTexture; //disc->SetGLMode(GL_TRIANGLE_FAN); //disc->GetTransform().SetPosition(Vector3(2.5f, 0.0f, 0.0f)); //disc->EnableTexture(); //disc->SetName(L"Disc"); //objects.push_back(disc); spObject moon(new Object); moon->SetVO(MakeShareable(new PrimitiveUVSphere(256, 128))); moon->GetTransform().SetScale(Vector3(0.27f, 0.27f, 0.27f)); moon->GetTransform().SetPosition(Vector3(0.f, 0.f, -2.2f)); Texture moonTexture; LoadTexture(moonTexture, "textures/moonmap1k.png"); moon->GetVO()->GetTexture() = moonTexture; moon->SetGLMode(GL_TRIANGLES); moon->EnableTexture(); moon->SetName(L"Moon"); moon->SetParent(world.Get(), TransformInheritance(true, false, true, false)); objects.push_back(moon); objectMap.insert(std::make_pair(moon->GetName(), moon)); spObject hst(new Object); hst->SetVO(MakeShareable(new Model)); static_cast<Model*>(hst->GetVO().Get())->Load("models/hst.obj", "textures/hst.png"); hst->GetTransform().SetScale(Vector3(0.0001f, 0.0001f, 0.0001f)); // This thing is yuge! hst->GetTransform().SetPosition(Vector3(-1.1f, 0.f, 0.f)); hst->GetTransform().SetPreRotation(Rotation(0.f, Vector3(0.25f, 0.25f, -0.25f))); hst->GetTransform().SetRotation(Rotation(0.f, Vector3(-0.2f, 0.8f, -0.2f))); hst->SetGLMode(GL_TRIANGLES); hst->SetName(L"HST"); hst->EnableTexture(); hst->SetParent(world.Get(), TransformInheritance(true, false, true, false)); objects.push_back(hst); objectMap.insert(std::make_pair(hst->GetName(), hst)); spObject iss(new Object); iss->SetVO(MakeShareable(new Model)); static_cast<Model*>(iss->GetVO().Get())->Load("models/iss.obj", "textures/iss.png"); iss->GetTransform().SetScale(Vector3(0.01f, 0.01f, 0.01f)); iss->GetTransform().SetPreRotation(Rotation(0.f, Vector3(0.f, 0.5f, 0.f))); iss->GetTransform().SetRotation(Rotation(0.f, Vector3(0.25f, 0.5f, 0.25f))); iss->GetTransform().SetPosition(Vector3(0.f, 0.f, 1.2f)); iss->SetGLMode(GL_TRIANGLES); iss->SetName(L"ISS"); iss->EnableTexture(); iss->SetParent(world.Get(), TransformInheritance(true, false, true, false)); objects.push_back(iss); objectMap.insert(std::make_pair(iss->GetName(), iss)); spObject teapot(new Object); teapot->SetVO(MakeShareable(new Model)); static_cast<Model*>(teapot->GetVO().Get())->Load("Models/teapot.obj", "textures/teapot.png"); teapot->GetTransform().SetPosition(Vector3(5.f, 5.f, -3.f)); teapot->GetTransform().SetPreRotation(Rotation(0.f, Vector3(1.f, 0.f, 0.f))); teapot->GetTransform().SetRotation(Rotation(0.f, Vector3(0.f, 0.f, 1.f))); teapot->GetTransform().SetScale(Vector3(0.05f, 0.05f, 0.05f)); teapot->SetGLMode(GL_TRIANGLES); teapot->SetName(L"Teapot"); teapot->EnableTexture(); teapot->SetParent(iss.Get(), TransformInheritance(true, true, true, false)); objects.push_back(teapot); objectMap.insert(std::make_pair(teapot->GetName(), teapot)); }
TSharedPtr<IMovieSceneTrackInstance> UMovieSceneDirectorTrack::CreateInstance() { return MakeShareable( new FMovieSceneDirectorTrackInstance( *this ) ); }
bool FCreateLandscapeCommand::Update() { //Switch to the Landscape tool GLevelEditorModeTools().ActivateMode(FBuiltinEditorModes::EM_Landscape); FEdModeLandscape* LandscapeEdMode = (FEdModeLandscape*)GLevelEditorModeTools().GetActiveMode(FBuiltinEditorModes::EM_Landscape); //Modify the "Section size" LandscapeEdMode->UISettings->NewLandscape_QuadsPerSection = 7; LandscapeEdMode->UISettings->NewLandscape_ClampSize(); //Create the landscape TSharedPtr<FLandscapeEditorDetailCustomization_NewLandscape> Customization_NewLandscape = MakeShareable(new FLandscapeEditorDetailCustomization_NewLandscape); Customization_NewLandscape->OnCreateButtonClicked(); if (LandscapeEdMode->CurrentToolTarget.LandscapeInfo.IsValid()) { UE_LOG(LogLandscapeAutomationTests, Display, TEXT("Created a new landscape")); } else { UE_LOG(LogLandscapeAutomationTests, Error, TEXT("Failed to create a new landscape")); } return true; }
TSharedRef<IStructCustomization> FMathStructCustomization::MakeInstance() { return MakeShareable( new FMathStructCustomization ); }
TSharedRef< FEdModeGeometry > FEdModeGeometry::Create() { TSharedRef< FEdModeGeometry > GeometryMode = MakeShareable( new FEdModeGeometry() ); return GeometryMode; }
void SBlueprintEditorSelectedDebugObjectWidget::GenerateDebugWorldNames(bool bRestoreSelection) { TSharedPtr<FString> OldSelection; // Store off the old selection if (bRestoreSelection && DebugWorldsComboBox.IsValid()) { OldSelection = DebugWorldsComboBox->GetSelectedItem(); } DebugWorldNames.Empty(); DebugWorlds.Empty(); DebugWorlds.Add(NULL); DebugWorldNames.Add(MakeShareable(new FString(GetDebugAllWorldsString()))); UWorld* PreviewWorld = NULL; TSharedPtr<SSCSEditorViewport> PreviewViewportPtr = BlueprintEditor.Pin()->GetSCSViewport(); if (PreviewViewportPtr.IsValid()) { PreviewWorld = PreviewViewportPtr->GetPreviewScene().GetWorld(); } for (TObjectIterator<UWorld> It; It; ++It) { UWorld *TestWorld = *It; if (!TestWorld || TestWorld->WorldType != EWorldType::PIE) { continue; } DebugWorlds.Add(TestWorld); ENetMode NetMode = TestWorld->GetNetMode(); FString WorldName; switch (NetMode) { case NM_Standalone: WorldName = NSLOCTEXT("BlueprintEditor", "DebugWorldStandalone", "Standalone").ToString(); break; case NM_ListenServer: WorldName = NSLOCTEXT("BlueprintEditor", "DebugWorldListenServer", "Listen Server").ToString(); break; case NM_DedicatedServer: WorldName = NSLOCTEXT("BlueprintEditor", "DebugWorldDedicatedServer", "Dedicated Server").ToString(); break; case NM_Client: FWorldContext &PieContext = GEngine->WorldContextFromWorld(TestWorld); WorldName = FString::Printf(TEXT("%s %d"), *NSLOCTEXT("BlueprintEditor", "DebugWorldClient", "Client").ToString(), PieContext.PIEInstance - 1); break; }; DebugWorldNames.Add(MakeShareable(new FString(WorldName))); } // Attempt to restore the old selection if (bRestoreSelection && DebugWorldsComboBox.IsValid()) { bool bMatchFound = false; for (int32 WorldIdx = 0; WorldIdx < DebugWorldNames.Num(); ++WorldIdx) { if (*DebugWorldNames[WorldIdx] == *OldSelection) { DebugWorldsComboBox->SetSelectedItem(DebugWorldNames[WorldIdx]); bMatchFound = true; break; } } // No match found, use the default option if (!bMatchFound) { DebugWorldsComboBox->SetSelectedItem(DebugWorldNames[0]); } } // Finally ensure we have a valid selection if (DebugWorldsComboBox.IsValid()) { TSharedPtr<FString> CurrentSelection = DebugWorldsComboBox->GetSelectedItem(); if (DebugWorldNames.Find(CurrentSelection) == INDEX_NONE) { if (DebugWorldNames.Num() > 0) { DebugWorldsComboBox->SetSelectedItem(DebugWorldNames[0]); } else { DebugWorldsComboBox->ClearSelection(); } } } }
void SBlueprintEditorSelectedDebugObjectWidget::GenerateDebugObjectNames(bool bRestoreSelection) { TSharedPtr<FString> OldSelection; // Store off the old selection if (bRestoreSelection && DebugObjectsComboBox.IsValid()) { OldSelection = DebugObjectsComboBox->GetSelectedItem(); } // Empty the lists of actors and regenerate them DebugObjects.Empty(); DebugObjectNames.Empty(); DebugObjects.Add(NULL); DebugObjectNames.Add(MakeShareable(new FString(GetNoDebugString()))); // Grab custom objects that should always be visible, regardless of the world TArray<FCustomDebugObject> CustomDebugObjects; BlueprintEditor.Pin()->GetCustomDebugObjects(/*inout*/ CustomDebugObjects); for (const FCustomDebugObject& Entry : CustomDebugObjects) { if (Entry.NameOverride.IsEmpty()) { AddDebugObject(Entry.Object); } else { AddDebugObjectWithName(Entry.Object, Entry.NameOverride); } } // Check for a specific debug world. If DebugWorld=NULL we take that as "any PIE world" UWorld* DebugWorld = NULL; if (DebugWorldsComboBox.IsValid()) { TSharedPtr<FString> CurrentWorldSelection = DebugWorldsComboBox->GetSelectedItem(); int32 SelectedIndex = DebugWorldNames.Find(CurrentWorldSelection); if (SelectedIndex > 0 && DebugWorldNames.IsValidIndex(SelectedIndex)) { DebugWorld = DebugWorlds[SelectedIndex].Get(); } } UWorld* PreviewWorld = NULL; TSharedPtr<SSCSEditorViewport> PreviewViewportPtr = BlueprintEditor.Pin()->GetSCSViewport(); if (PreviewViewportPtr.IsValid()) { PreviewWorld = PreviewViewportPtr->GetPreviewScene().GetWorld(); } for (TObjectIterator<UObject> It; It; ++It) { UObject* TestObject = *It; // Skip Blueprint preview objects (don't allow them to be selected for debugging) if (PreviewWorld != NULL && TestObject->IsIn(PreviewWorld)) { continue; } const bool bPassesFlags = !TestObject->HasAnyFlags(RF_PendingKill | RF_ClassDefaultObject); const bool bGeneratedByBlueprint = TestObject->GetClass()->ClassGeneratedBy == GetBlueprintObj(); if (bPassesFlags && bGeneratedByBlueprint) { UObject *ObjOuter = TestObject; UWorld *ObjWorld = NULL; while (ObjWorld == NULL && ObjOuter != NULL) { ObjOuter = ObjOuter->GetOuter(); ObjWorld = Cast<UWorld>(ObjOuter); } // Object not in any world if (!ObjWorld) { continue; } // Make check on owning level (not streaming level) if (ObjWorld->PersistentLevel && ObjWorld->PersistentLevel->OwningWorld) { ObjWorld = ObjWorld->PersistentLevel->OwningWorld; } // We have a specific debug world and the object isnt in it if (DebugWorld && ObjWorld != DebugWorld) { continue; } // We don't have a specific debug world, but the object isnt in a PIE world if (ObjWorld->WorldType != EWorldType::PIE) { continue; } AddDebugObject(TestObject); } } // Attempt to restore the old selection if (bRestoreSelection && DebugObjectsComboBox.IsValid()) { bool bMatchFound = false; for (int32 ObjectIndex = 0; ObjectIndex < DebugObjectNames.Num(); ++ObjectIndex) { if (*DebugObjectNames[ObjectIndex] == *OldSelection) { DebugObjectsComboBox->SetSelectedItem(DebugObjectNames[ObjectIndex]); bMatchFound = true; break; } } // No match found, use the default option if (!bMatchFound) { DebugObjectsComboBox->SetSelectedItem(DebugObjectNames[0]); } } // Finally ensure we have a valid selection if (DebugObjectsComboBox.IsValid()) { TSharedPtr<FString> CurrentSelection = DebugObjectsComboBox->GetSelectedItem(); if (DebugObjectNames.Find(CurrentSelection) == INDEX_NONE) { if (DebugObjectNames.Num() > 0) { DebugObjectsComboBox->SetSelectedItem(DebugObjectNames[0]); } else { DebugObjectsComboBox->ClearSelection(); } } DebugObjectsComboBox->RefreshOptions(); } }
TSharedRef<IDetailCustomization> FSpriteDetailsCustomization::MakeInstanceForSpriteEditor(TAttribute<ESpriteEditorMode::Type> InEditMode) { return MakeShareable(new FSpriteDetailsCustomization(InEditMode)); }
void FPythonEditorStyle::Initialize() { // Only register once if( StyleSet.IsValid() ) { return; } StyleSet = MakeShareable(new FSlateStyleSet("PythonEditor") ); StyleSet->SetContentRoot(IPluginManager::Get().FindPlugin("UnrealEnginePython")->GetBaseDir() / TEXT("Resources")); // Icons { StyleSet->Set("PythonEditor.TabIcon", new IMAGE_BRUSH("UI/PythonEditor_16x", Icon16x16)); StyleSet->Set("PythonEditor.New", new IMAGE_BRUSH("UI/GenericFile", Icon40x40)); StyleSet->Set("PythonEditor.NewDirectory", new IMAGE_BRUSH("UI/GenericFile", Icon40x40)); StyleSet->Set("PythonEditor.New.Small", new IMAGE_BRUSH("UI/GenericFile", Icon16x16)); StyleSet->Set("PythonEditor.Delete", new IMAGE_BRUSH("UI/DeleteFile", Icon40x40)); StyleSet->Set("PythonEditor.Delete.Small", new IMAGE_BRUSH("UI/DeleteFile", Icon16x16)); StyleSet->Set("PythonEditor.Save", new IMAGE_BRUSH("UI/Save_40x", Icon40x40)); StyleSet->Set("PythonEditor.Save.Small", new IMAGE_BRUSH("UI/Save_40x", Icon16x16)); StyleSet->Set("PythonEditor.SaveAll", new IMAGE_BRUSH("UI/SaveAll_40x", Icon40x40)); StyleSet->Set("PythonEditor.SaveAll.Small", new IMAGE_BRUSH("UI/SaveAll_40x", Icon16x16)); StyleSet->Set("PythonEditor.Execute", new IMAGE_BRUSH("UI/Excute_x40", Icon40x40)); StyleSet->Set("PythonEditor.Execute.Small", new IMAGE_BRUSH("UI/Excute_x40", Icon16x16)); StyleSet->Set("PythonEditor.ExecuteInSandbox", new IMAGE_BRUSH("UI/Excute_x40", Icon40x40)); StyleSet->Set("PythonEditor.ExecuteInSandbox.Small", new IMAGE_BRUSH("UI/Excute_x40", Icon16x16)); StyleSet->Set("PythonEditor.PEP8ize", new IMAGE_BRUSH("UI/Excute_x40", Icon40x40)); StyleSet->Set("PythonEditor.PEP8ize.Small", new IMAGE_BRUSH("UI/Excute_x40", Icon16x16)); } const FSlateFontInfo Consolas10 = TTF_FONT("Font/DroidSansMono", 9); const FTextBlockStyle NormalText = FTextBlockStyle() .SetFont(Consolas10) .SetColorAndOpacity(FLinearColor::White) .SetShadowOffset(FVector2D::ZeroVector) .SetShadowColorAndOpacity(FLinearColor::Black) .SetHighlightColor(FLinearColor(0.02f, 0.3f, 0.0f)) .SetHighlightShape(BOX_BRUSH("UI/TextBlockHighlightShape", FMargin(3.f / 8.f))); // Text editor { StyleSet->Set("TextEditor.NormalText", NormalText); StyleSet->Set("SyntaxHighlight.PY.Normal", FTextBlockStyle(NormalText).SetColorAndOpacity(FLinearColor(FColor(0xffffffff))));// yellow StyleSet->Set("SyntaxHighlight.PY.Operator", FTextBlockStyle(NormalText).SetColorAndOpacity(FLinearColor(FColor(0xfff92672)))); // light grey StyleSet->Set("SyntaxHighlight.PY.Keyword", FTextBlockStyle(NormalText).SetColorAndOpacity(FLinearColor(FColor(0xfff92672)))); // blue StyleSet->Set("SyntaxHighlight.PY.String", FTextBlockStyle(NormalText).SetColorAndOpacity(FLinearColor(FColor(0xffe6db74)))); // pinkish StyleSet->Set("SyntaxHighlight.PY.Number", FTextBlockStyle(NormalText).SetColorAndOpacity(FLinearColor(FColor(0xffae81dd)))); // cyan StyleSet->Set("SyntaxHighlight.PY.Comment", FTextBlockStyle(NormalText).SetColorAndOpacity(FLinearColor(FColor(0xff75715e)))); // green StyleSet->Set("SyntaxHighlight.PY.BuiltIn", FTextBlockStyle(NormalText).SetColorAndOpacity(FLinearColor(FColor(0xff52d9ef)))); // light grey StyleSet->Set("SyntaxHighlight.PY.Define", FTextBlockStyle(NormalText).SetColorAndOpacity(FLinearColor(FColor(0xffa6e22a)))); // light grey StyleSet->Set("TextEditor.Border", new BOX_BRUSH("UI/TextEditorBorder", FMargin(4.0f/16.0f), FLinearColor(0.02f,0.02f,0.02f,1))); const FEditableTextBoxStyle EditableTextBoxStyle = FEditableTextBoxStyle() .SetBackgroundImageNormal( FSlateNoResource() ) .SetBackgroundImageHovered( FSlateNoResource() ) .SetBackgroundImageFocused( FSlateNoResource() ) .SetBackgroundImageReadOnly( FSlateNoResource() ); StyleSet->Set("TextEditor.EditableTextBox", EditableTextBoxStyle); } // Project editor { StyleSet->Set("ProjectEditor.Border", new BOX_BRUSH("UI/TextEditorBorder", FMargin(4.0f/16.0f), FLinearColor(0.048f,0.048f,0.048f,1))); StyleSet->Set("ProjectEditor.Icon.Project", new IMAGE_BRUSH("UI/FolderClosed", Icon16x16, FLinearColor(0.25f,0.25f,0.25f,1))); StyleSet->Set("ProjectEditor.Icon.Folder", new IMAGE_BRUSH("UI/FolderClosed", Icon16x16, FLinearColor(0.25f,0.25f,0.25f,1))); StyleSet->Set("ProjectEditor.Icon.File", new IMAGE_BRUSH("UI/PythonEditor_16x", Icon16x16)); StyleSet->Set("ProjectEditor.Icon.GenericFile", new IMAGE_BRUSH("UI/GenericFile", Icon16x16)); } FSlateStyleRegistry::RegisterSlateStyle( *StyleSet.Get() ); }
void FSpriteDetailsCustomization::BuildCollisionSection(IDetailCategoryBuilder& CollisionCategory, IDetailLayoutBuilder& DetailLayout) { TSharedPtr<IPropertyHandle> SpriteCollisionDomainProperty = DetailLayout.GetProperty(GET_MEMBER_NAME_CHECKED(UPaperSprite, SpriteCollisionDomain)); CollisionCategory.HeaderContent ( SNew(SBox) .HAlign(HAlign_Right) [ SNew(SHorizontalBox) +SHorizontalBox::Slot() .Padding(FMargin(5.0f, 0.0f)) .AutoWidth() [ SNew(STextBlock) .Font(FEditorStyle::GetFontStyle("TinyText")) .Text(this, &FSpriteDetailsCustomization::GetCollisionHeaderContentText, SpriteCollisionDomainProperty) ] ] ); TAttribute<EVisibility> ParticipatesInPhysics = TAttribute<EVisibility>::Create(TAttribute<EVisibility>::FGetter::CreateSP( this, &FSpriteDetailsCustomization::AnyPhysicsMode, SpriteCollisionDomainProperty)); TAttribute<EVisibility> ParticipatesInPhysics3D = TAttribute<EVisibility>::Create(TAttribute<EVisibility>::FGetter::CreateSP(this, &FSpriteDetailsCustomization::PhysicsModeMatches, SpriteCollisionDomainProperty, ESpriteCollisionMode::Use3DPhysics)); TAttribute<EVisibility> HideWhenInRenderingMode = TAttribute<EVisibility>::Create(TAttribute<EVisibility>::FGetter::CreateSP(this, &FSpriteDetailsCustomization::EditorModeIsNot, ESpriteEditorMode::EditRenderingGeomMode)); TAttribute<EVisibility> ShowWhenInRenderingMode = TAttribute<EVisibility>::Create(TAttribute<EVisibility>::FGetter::CreateSP(this, &FSpriteDetailsCustomization::EditorModeMatches, ESpriteEditorMode::EditRenderingGeomMode)); static const FText EditCollisionInCollisionMode = LOCTEXT("CollisionPropertiesHiddenInRenderingMode", "Switch to 'Edit Collsion' mode\nto edit Collision settings"); CollisionCategory.AddCustomRow(EditCollisionInCollisionMode) .Visibility(ShowWhenInRenderingMode) .WholeRowContent() .HAlign(HAlign_Center) [ SNew(STextBlock) .Font(DetailLayout.GetDetailFontItalic()) .Justification(ETextJustify::Center) .Text(EditCollisionInCollisionMode) ]; CollisionCategory.AddProperty(SpriteCollisionDomainProperty).Visibility(HideWhenInRenderingMode); // Add the collision geometry mode into the parent container (renamed) { // Restrict the diced value TSharedPtr<FPropertyRestriction> PreventDicedRestriction = MakeShareable(new FPropertyRestriction(LOCTEXT("CollisionGeometryDoesNotSupportDiced", "Collision geometry can not be set to Diced"))); const UEnum* const SpritePolygonModeEnum = FindObject<UEnum>(ANY_PACKAGE, TEXT("ESpritePolygonMode")); PreventDicedRestriction->AddDisabledValue(SpritePolygonModeEnum->GetNameStringByValue((uint8)ESpritePolygonMode::Diced)); // Find and add the property const FString CollisionGeometryTypePropertyPath = FString::Printf(TEXT("%s.%s"), GET_MEMBER_NAME_STRING_CHECKED(UPaperSprite, CollisionGeometry), GET_MEMBER_NAME_STRING_CHECKED(FSpriteGeometryCollection, GeometryType)); TSharedPtr<IPropertyHandle> CollisionGeometryTypeProperty = DetailLayout.GetProperty(*CollisionGeometryTypePropertyPath); CollisionGeometryTypeProperty->AddRestriction(PreventDicedRestriction.ToSharedRef()); CollisionCategory.AddProperty(CollisionGeometryTypeProperty) .DisplayName(LOCTEXT("CollisionGeometryType", "Collision Geometry Type")) .Visibility(ParticipatesInPhysics); } // Show the collision thickness only in 3D mode CollisionCategory.AddProperty( DetailLayout.GetProperty(GET_MEMBER_NAME_CHECKED(UPaperSprite, CollisionThickness)) ) .Visibility(ParticipatesInPhysics3D); // Show the default body instance (and only it) from the body setup (if it exists) DetailLayout.HideProperty("BodySetup"); IDetailPropertyRow& BodySetupDefaultInstance = CollisionCategory.AddProperty("BodySetup.DefaultInstance"); TArray<TWeakObjectPtr<UObject>> SpritesBeingEdited; DetailLayout.GetObjectsBeingCustomized(/*out*/ SpritesBeingEdited); TArray<UObject*> BodySetupList; for (auto WeakSpritePtr : SpritesBeingEdited) { if (UPaperSprite* Sprite = Cast<UPaperSprite>(WeakSpritePtr.Get())) { if (UBodySetup* BodySetup = Sprite->BodySetup) { BodySetupList.Add(BodySetup); } } } if (BodySetupList.Num() > 0) { IDetailPropertyRow* DefaultInstanceRow = CollisionCategory.AddExternalObjectProperty(BodySetupList, GET_MEMBER_NAME_CHECKED(UBodySetup, DefaultInstance)); if (DefaultInstanceRow != nullptr) { DefaultInstanceRow->Visibility(ParticipatesInPhysics); } } // Show the collision geometry when not None CollisionCategory.AddProperty(DetailLayout.GetProperty(GET_MEMBER_NAME_CHECKED(UPaperSprite, CollisionGeometry))) .Visibility(ParticipatesInPhysics); // Add the collision polygons into advanced (renamed) const FString CollisionGeometryPolygonsPropertyPath = FString::Printf(TEXT("%s.%s"), GET_MEMBER_NAME_STRING_CHECKED(UPaperSprite, CollisionGeometry), GET_MEMBER_NAME_STRING_CHECKED(FSpriteGeometryCollection, Shapes)); CollisionCategory.AddProperty(DetailLayout.GetProperty(*CollisionGeometryPolygonsPropertyPath), EPropertyLocation::Advanced) .DisplayName(LOCTEXT("CollisionShapes", "Collision Shapes")) .Visibility(ParticipatesInPhysics); }
void UMediaPlayer::InitializePlayer() { if (URL != CurrentUrl) { // close previous player CurrentUrl = FString(); if (Player.IsValid()) { Player->Close(); Player->OnClosed().RemoveAll(this); Player->OnOpened().RemoveAll(this); Player.Reset(); } if (URL.IsEmpty()) { return; } // create new player IMediaModule* MediaModule = FModuleManager::LoadModulePtr<IMediaModule>("Media"); if (MediaModule == nullptr) { return; } Player = MediaModule->CreatePlayer(URL); if (!Player.IsValid()) { return; } Player->OnClosed().AddUObject(this, &UMediaPlayer::HandleMediaPlayerMediaClosed); Player->OnOpened().AddUObject(this, &UMediaPlayer::HandleMediaPlayerMediaOpened); // open the new media file bool OpenedSuccessfully = false; if (URL.Contains(TEXT("://"))) { OpenedSuccessfully = Player->Open(URL); } else { const FString FullUrl = FPaths::ConvertRelativePathToFull(FPaths::IsRelative(URL) ? FPaths::GameContentDir() / URL : URL); if (StreamMode == EMediaPlayerStreamModes::MASM_FromUrl) { OpenedSuccessfully = Player->Open(FullUrl); } else if (FPaths::FileExists(FullUrl)) { FArchive* FileReader = IFileManager::Get().CreateFileReader(*FullUrl); if (FileReader == nullptr) { return; } if (FileReader->TotalSize() > 0) { TArray<uint8>* FileData = new TArray<uint8>(); FileData->AddUninitialized(FileReader->TotalSize()); FileReader->Serialize(FileData->GetData(), FileReader->TotalSize()); OpenedSuccessfully = Player->Open(MakeShareable(FileData), FullUrl); } delete FileReader; } } // finish initialization if (OpenedSuccessfully) { CurrentUrl = URL; } } if (Player.IsValid()) { Player->SetLooping(Looping); } }
TSharedRef< FSlateFontMeasure > FSlateFontMeasure::Create( const TSharedRef<class FSlateFontCache>& FontCache ) { return MakeShareable( new FSlateFontMeasure( FontCache ) ); }
TSharedPtr<IMovieSceneTrackInstance> UFaceFXAnimationTrack::CreateInstance() { return MakeShareable(new FFaceFXAnimationTrackInstance(this)); }
void SBlueprintEditorSelectedDebugObjectWidget::AddDebugObjectWithName(UObject* TestObject, const FString& TestObjectName) { DebugObjects.Add(TestObject); DebugObjectNames.Add(MakeShareable(new FString(TestObjectName))); }
TSharedRef<IStructCustomization> FBlackboardSelectorDetails::MakeInstance() { return MakeShareable( new FBlackboardSelectorDetails ); }
TSharedPtr<FExtender> FCurveAssetEditor::GetToolbarExtender() { struct Local { static void FillToolbar(FToolBarBuilder& ToolbarBuilder, TSharedRef<SWidget> InputSnapWidget, TSharedRef<SWidget> OutputSnapWidget) { ToolbarBuilder.BeginSection("Curve"); { ToolbarBuilder.AddToolBarButton(FRichCurveEditorCommands::Get().ZoomToFitHorizontal); ToolbarBuilder.AddToolBarButton(FRichCurveEditorCommands::Get().ZoomToFitVertical); ToolbarBuilder.AddToolBarButton(FRichCurveEditorCommands::Get().ZoomToFitAll); ToolbarBuilder.AddToolBarButton(FRichCurveEditorCommands::Get().ZoomToFitSelected); } ToolbarBuilder.EndSection(); ToolbarBuilder.BeginSection("Interpolation"); { ToolbarBuilder.AddToolBarButton(FRichCurveEditorCommands::Get().InterpolationCubicAuto); ToolbarBuilder.AddToolBarButton(FRichCurveEditorCommands::Get().InterpolationCubicUser); ToolbarBuilder.AddToolBarButton(FRichCurveEditorCommands::Get().InterpolationCubicBreak); ToolbarBuilder.AddToolBarButton(FRichCurveEditorCommands::Get().InterpolationLinear); ToolbarBuilder.AddToolBarButton(FRichCurveEditorCommands::Get().InterpolationConstant); } ToolbarBuilder.EndSection(); ToolbarBuilder.BeginSection("Snap"); { ToolbarBuilder.AddToolBarButton(FRichCurveEditorCommands::Get().ToggleSnapping); ToolbarBuilder.AddWidget(InputSnapWidget); ToolbarBuilder.AddWidget(OutputSnapWidget); } ToolbarBuilder.EndSection(); } }; TSharedPtr<FExtender> ToolbarExtender = MakeShareable(new FExtender); TSharedRef<SWidget> InputSnapWidget = SNew(SVerticalBox) + SVerticalBox::Slot() .Padding(4) .AutoHeight() [ SNew(STextBlock) .Text(LOCTEXT("InputSnap", "Time Snap")) ] + SVerticalBox::Slot() .Padding(4) .AutoHeight() [ SNew(SComboButton) .ContentPadding(1) .OnGetMenuContent(this, &FCurveAssetEditor::BuildInputSnapMenu) .ButtonContent() [ SNew(SEditableTextBox) .Text(this, &FCurveAssetEditor::GetInputSnapText) .OnTextCommitted(this, &FCurveAssetEditor::InputSnapTextComitted) ] ]; TSharedRef<SWidget> OutputSnapWidget = SNew(SVerticalBox) + SVerticalBox::Slot() .Padding(4) .AutoHeight() [ SNew(STextBlock) .Text(LOCTEXT("OutputSnap", "Value Snap")) ] + SVerticalBox::Slot() .Padding(4) .AutoHeight() [ SNew(SComboButton) .ContentPadding(1) .OnGetMenuContent(this, &FCurveAssetEditor::BuildOutputSnapMenu) .ButtonContent() [ SNew(SEditableTextBox) .Text(this, &FCurveAssetEditor::GetOutputSnapText) .OnTextCommitted(this, &FCurveAssetEditor::OutputSnapTextComitted) ] ]; ToolbarExtender->AddToolBarExtension( "Asset", EExtensionHook::After, TrackWidget->GetCommands(), FToolBarExtensionDelegate::CreateStatic(&Local::FillToolbar, InputSnapWidget, OutputSnapWidget) ); return ToolbarExtender; }
TSharedRef< class IPropertyTableCustomColumn > FStatsViewerModule::CreateObjectCustomColumn(const FObjectHyperlinkColumnInitializationOptions& InOptions) const { return MakeShareable(new FObjectHyperlinkColumn(InOptions)); }
FCombinedGraphDataSourceRef FProfilerManager::CreateCombinedGraphDataSource( const uint32 StatID ) { FCombinedGraphDataSource* CombinedGraphDataSource = new FCombinedGraphDataSource( StatID, FTimeAccuracy::FPS060 ); return MakeShareable( CombinedGraphDataSource ); }
SMessagingDebugger::SMessagingDebugger() : CommandList(MakeShareable(new FUICommandList)) , MessageTracer(NULL) , Model(MakeShareable(new FMessagingDebuggerModel())) { }
TSharedRef<FMultiBox> FMultiBox::Create( const EMultiBoxType::Type InType, FMultiBoxCustomization InCustomization, const bool bInShouldCloseWindowAfterMenuSelection ) { TSharedRef<FMultiBox> NewBox = MakeShareable( new FMultiBox( InType, InCustomization, bInShouldCloseWindowAfterMenuSelection ) ); return NewBox; }
TSharedPtr<FOnlineSessionSettings> FOnlineSessionSearchQos::GetDefaultSessionSettings() const { return MakeShareable(new FOnlineSessionSettingsQos()); }
void SMultiBoxWidget::UpdateDropAreaPreviewBlock( TSharedRef<const FMultiBlock> MultiBlock, TSharedPtr<FUICommandDragDropOp> DragDropContent, const FGeometry& DragAreaGeometry, const FVector2D& DragPos ) { TSharedPtr<const FUICommandInfo> UICommand = DragDropContent->UICommand; FName OriginMultiBox = DragDropContent->OriginMultiBox; FVector2D LocalDragPos = DragAreaGeometry.AbsoluteToLocal( DragPos ); FVector2D DrawSize = DragAreaGeometry.GetDrawSize(); bool bAddedNewBlock = false; bool bValidCommand = true; if( DragPreview.UICommand != UICommand ) { TSharedPtr<const FMultiBlock> ExistingBlock = MultiBox->FindBlockFromCommand( UICommand ); // Check that the command does not already exist and that we can create it or that we are dragging an exisiting block in this box if( !ExistingBlock.IsValid() || ( ExistingBlock.IsValid() && OriginMultiBox == MultiBox->GetCustomizationName() ) ) { TSharedPtr<const FMultiBlock> NewBlock = ExistingBlock; if( !ExistingBlock.IsValid() ) { NewBlock = MultiBox->MakeMultiBlockFromCommand( UICommand, true ); } if( NewBlock.IsValid() ) { DragPreview.Reset(); DragPreview.UICommand = UICommand; DragPreview.PreviewBlock = MakeShareable( new FDropPreviewBlock( NewBlock.ToSharedRef(), NewBlock->MakeWidget( SharedThis(this), EMultiBlockLocation::None, NewBlock->HasIcon() ) ) ); bAddedNewBlock = true; } } else { // this command cannot be dropped here bValidCommand = false; } } if( bValidCommand ) { // determine whether or not to insert before or after bool bInsertBefore = false; if( MultiBox->GetType() == EMultiBoxType::ToolBar ) { DragPreview.InsertOrientation = EOrientation::Orient_Horizontal; if( LocalDragPos.X < DrawSize.X / 2 ) { // Insert before horizontally bInsertBefore = true; } else { // Insert after horizontally bInsertBefore = false; } } else { DragPreview.InsertOrientation = EOrientation::Orient_Vertical; if( LocalDragPos.Y < DrawSize.Y / 2 ) { // Insert before vertically bInsertBefore = true; } else { // Insert after vertically bInsertBefore = false; } } int32 CurrentIndex = DragPreview.InsertIndex; DragPreview.InsertIndex = INDEX_NONE; // Find the index of the multiblock being dragged over. This is where we will insert the new block if( DragPreview.PreviewBlock.IsValid() ) { const TArray< TSharedRef< const FMultiBlock > >& Blocks = MultiBox->GetBlocks(); for (int32 BlockIdx = 0; BlockIdx < Blocks.Num(); ++BlockIdx) { TSharedRef<const FMultiBlock> Block = Blocks[BlockIdx]; if( Block == MultiBlock ) { if( bInsertBefore) { DragPreview.InsertIndex = BlockIdx; } else { DragPreview.InsertIndex = FMath::Min(Blocks.Num()-1, BlockIdx+1); } break; } } } if( CurrentIndex != DragPreview.InsertIndex && DragPreview.InsertIndex != INDEX_NONE ) { BuildMultiBoxWidget(); } } }
void SSizeMap::GatherDependenciesRecursively( FAssetRegistryModule& AssetRegistryModule, TSharedPtr<FAssetThumbnailPool>& InAssetThumbnailPool, TMap<FName, TSharedPtr<FTreeMapNodeData>>& VisitedAssetPackageNames, const TArray<FName>& AssetPackageNames, const TSharedPtr<FTreeMapNodeData>& Node, TSharedPtr<FTreeMapNodeData>& SharedRootNode, int32& NumAssetsWhichFailedToLoad ) { for( const FName AssetPackageName : AssetPackageNames ) { // Have we already added this asset to the tree? If so, we'll either move it to a "shared" group or (if it's referenced again by the same // root-level asset) ignore it if( VisitedAssetPackageNames.Contains( AssetPackageName ) ) { // OK, we've determined that this asset has already been referenced by something else in our tree. We'll move it to a "shared" group // so all of the assets that are referenced in multiple places can be seen together. TSharedPtr<FTreeMapNodeData> ExistingNode = VisitedAssetPackageNames[ AssetPackageName ]; // Is the existing node not already under the "shared" group? Note that it might still be (indirectly) under // the "shared" group, in which case we'll still want to move it up to the root since we've figured out that it is // actually shared between multiple assets which themselves may be shared if( ExistingNode->Parent != SharedRootNode.Get() ) { // Don't bother moving any of the assets at the root level into a "shared" bucket. We're only trying to best // represent the memory used when all of the root-level assets have become loaded. It's OK if root-level assets // are referenced by other assets in the set -- we don't need to indicate they are shared explicitly FTreeMapNodeData* ExistingNodeParent = ExistingNode->Parent; check( ExistingNodeParent != nullptr ); const bool bExistingNodeIsAtRootLevel = ExistingNodeParent->Parent == nullptr || RootAssetPackageNames.Contains( AssetPackageName ); if( !bExistingNodeIsAtRootLevel ) { // OK, the current asset (AssetPackageName) is definitely not a root level asset, but its already in the tree // somewhere as a non-shared, non-root level asset. We need to make sure that this Node's reference is not from the // same root-level asset as the ExistingNodeInTree. Otherwise, there's no need to move it to a 'shared' group. FTreeMapNodeData* MyParentNode = Node.Get(); check( MyParentNode != nullptr ); FTreeMapNodeData* MyRootLevelAssetNode = MyParentNode; while( MyRootLevelAssetNode->Parent != nullptr && MyRootLevelAssetNode->Parent->Parent != nullptr ) { MyRootLevelAssetNode = MyRootLevelAssetNode->Parent; } if( MyRootLevelAssetNode->Parent == nullptr ) { // No root asset (Node must be a root level asset itself!) MyRootLevelAssetNode = nullptr; } // Find the existing node's root level asset node FTreeMapNodeData* ExistingNodeRootLevelAssetNode = ExistingNodeParent; while( ExistingNodeRootLevelAssetNode->Parent->Parent != nullptr ) { ExistingNodeRootLevelAssetNode = ExistingNodeRootLevelAssetNode->Parent; } // If we're being referenced by another node within the same asset, no need to move it to a 'shared' group. if( MyRootLevelAssetNode != ExistingNodeRootLevelAssetNode ) { // This asset was already referenced by something else (or was in our top level list of assets to display sizes for) if( !SharedRootNode.IsValid() ) { // Find the root-most tree node FTreeMapNodeData* RootNode = MyParentNode; while( RootNode->Parent != nullptr ) { RootNode = RootNode->Parent; } SharedRootNode = MakeShareable( new FTreeMapNodeData() ); RootNode->Children.Add( SharedRootNode ); SharedRootNode->Parent = RootNode; // Keep back-pointer to parent node } // Reparent the node that we've now determined to be shared ExistingNode->Parent->Children.Remove( ExistingNode ); SharedRootNode->Children.Add( ExistingNode ); ExistingNode->Parent = SharedRootNode.Get(); } } } } else { // This asset is new to us so far! Let's add it to the tree. Later as we descend through references, we might find that the // asset is referenced by something else as well, in which case we'll pull it out and move it to a "shared" top-level box // Don't bother showing code references const FString AssetPackageNameString = AssetPackageName.ToString(); if( !AssetPackageNameString.StartsWith( TEXT( "/Script/" ) ) ) { FTreeMapNodeDataRef ChildTreeMapNode = MakeShareable( new FTreeMapNodeData() ); Node->Children.Add( ChildTreeMapNode ); ChildTreeMapNode->Parent = Node.Get(); // Keep back-pointer to parent node VisitedAssetPackageNames.Add( AssetPackageName, ChildTreeMapNode ); FNodeSizeMapData& NodeSizeMapData = NodeSizeMapDataMap.Add( ChildTreeMapNode ); // Set some defaults for this node. These will be used if we can't actually locate the asset. // @todo sizemap urgent: We need a better indication in the UI when there are one or more missing assets. Because missing assets have a size // of zero, they are nearly impossible to zoom into. At the least, we should have some Output Log spew when assets cannot be loaded NodeSizeMapData.AssetData.AssetName = AssetPackageName; NodeSizeMapData.AssetData.AssetClass = FName( *LOCTEXT( "MissingAsset", "MISSING!" ).ToString() ); NodeSizeMapData.AssetSize = 0; NodeSizeMapData.bHasKnownSize = false; // Find the asset using the asset registry // @todo sizemap: Asset registry-based reference gathering is faster but possibly not as exhaustive (no PostLoad created references, etc.) Maybe should be optional? // @todo sizemap: With AR-based reference gathering, sometimes the size map is missing root level dependencies until you reopen it a few times (Buggy BP) // @todo sizemap: With AR-based reference gathering, reference changes at editor-time do not appear in the Size Map until you restart // @todo sizemap: With AR-based reference gathering, opening the size map for all engine content caused the window to not respond until a restart // @todo sizemap: We don't really need the asset registry given we need to load the objects to figure out their size, unless we make that AR-searchable. // ---> This would allow us to not have to wait for AR initialization. But if we made size AR-searchable, we could run very quickly for large data sets! const bool bUseAssetRegistryForDependencies = false; const FString AssetPathString = AssetPackageNameString + TEXT(".") + FPackageName::GetLongPackageAssetName( AssetPackageNameString ); const FAssetData FoundAssetData = AssetRegistryModule.Get().GetAssetByObjectPath( FName( *AssetPathString ) ); if( FoundAssetData.IsValid() ) { NodeSizeMapData.AssetData = FoundAssetData; // Now actually load up the asset. We need it in memory in order to accurately determine its size. // @todo sizemap: We could async load these packages to make the editor experience a bit nicer (smoother progress) UObject* Asset = StaticLoadObject( UObject::StaticClass(), nullptr, *AssetPathString ); if( Asset != nullptr ) { TArray<FName> ReferencedAssetPackageNames; if( bUseAssetRegistryForDependencies ) { AssetRegistryModule.Get().GetDependencies( AssetPackageName, ReferencedAssetPackageNames ); } else { SizeMapInternals::FAssetReferenceFinder References( Asset ); for( UObject* Object : References.GetReferencedAssets() ) { ReferencedAssetPackageNames.Add( FName( *Object->GetOutermost()->GetPathName() ) ); } } // For textures, make sure we're getting the worst case size, not the size of the currently loaded set of mips // @todo sizemap: We should instead have a special EResourceSizeMode that asks for the worst case size. Some assets (like UTextureCube) currently always report resident mip size, even when asked for inclusive size if( Asset->IsA( UTexture2D::StaticClass() ) ) { NodeSizeMapData.AssetSize = Asset->GetResourceSize( EResourceSizeMode::Inclusive ); } else { NodeSizeMapData.AssetSize = Asset->GetResourceSize( EResourceSizeMode::Exclusive ); } NodeSizeMapData.bHasKnownSize = NodeSizeMapData.AssetSize != UObject::RESOURCE_SIZE_NONE && NodeSizeMapData.AssetSize != 0; if( !NodeSizeMapData.bHasKnownSize ) { // Asset has no meaningful size NodeSizeMapData.AssetSize = 0; // @todo sizemap urgent: Try to serialize to figure out how big it is (not into sub-assets though!) // FObjectMemoryAnalyzer ObjectMemoryAnalyzer( Asset ); } // Now visit all of the assets that we are referencing GatherDependenciesRecursively( AssetRegistryModule, InAssetThumbnailPool, VisitedAssetPackageNames, ReferencedAssetPackageNames, ChildTreeMapNode, SharedRootNode, NumAssetsWhichFailedToLoad ); } else { ++NumAssetsWhichFailedToLoad; } } else { ++NumAssetsWhichFailedToLoad; } } } } }
virtual void StartupModule() override { Style = MakeShareable(new FActorAnimationEditorStyle()); RegisterAssetTools(); }
TSharedRef<IDetailCustomization> FLandscapeSplineDetails::MakeInstance() { return MakeShareable(new FLandscapeSplineDetails); }
/** Registers asset tool actions. */ void RegisterAssetTools() { IAssetTools& AssetTools = FModuleManager::LoadModuleChecked<FAssetToolsModule>("AssetTools").Get(); RegisterAssetTypeAction(AssetTools, MakeShareable(new FActorAnimationActions(Style.ToSharedRef()))); }
/** * Builds the Matinee Tool Bar */ void FMatinee::ExtendToolbar() { struct Local { static void FillToolbar(FToolBarBuilder& ToolbarBuilder, TSharedRef<SWidget> InterpolationBox, TSharedRef<SWidget> SpeedBox, TSharedRef<SWidget> SnapSettingBox) { ToolbarBuilder.BeginSection("CurveMode"); { ToolbarBuilder.AddToolBarButton(FMatineeCommands::Get().AddKey); } ToolbarBuilder.EndSection(); ToolbarBuilder.BeginSection("Interpolation"); { ToolbarBuilder.AddWidget(InterpolationBox); } ToolbarBuilder.EndSection(); ToolbarBuilder.BeginSection("Play"); { ToolbarBuilder.AddToolBarButton(FMatineeCommands::Get().Play); ToolbarBuilder.AddToolBarButton(FMatineeCommands::Get().PlayLoop); ToolbarBuilder.AddToolBarButton(FMatineeCommands::Get().Stop); ToolbarBuilder.AddToolBarButton(FMatineeCommands::Get().PlayReverse); } ToolbarBuilder.EndSection(); ToolbarBuilder.BeginSection("Camera"); { ToolbarBuilder.AddToolBarButton(FMatineeCommands::Get().CreateCameraActor); } ToolbarBuilder.EndSection(); ToolbarBuilder.BeginSection("Speed"); { ToolbarBuilder.AddWidget(SpeedBox); } ToolbarBuilder.EndSection(); //ToolbarBuilder.BeginSection("History"); //{ // ToolbarBuilder.AddToolBarButton(FMatineeCommands::Get().Undo); // ToolbarBuilder.AddToolBarButton(FMatineeCommands::Get().Redo); //} //ToolbarBuilder.EndSection(); ToolbarBuilder.BeginSection("SnapSetting"); { ToolbarBuilder.AddWidget(SnapSettingBox); } ToolbarBuilder.EndSection(); ToolbarBuilder.BeginSection("Curve"); { ToolbarBuilder.AddToolBarButton(FMatineeCommands::Get().ToggleCurveEditor); } ToolbarBuilder.EndSection(); ToolbarBuilder.BeginSection("Snap"); { ToolbarBuilder.AddToolBarButton(FMatineeCommands::Get().ToggleSnap); ToolbarBuilder.AddToolBarButton(FMatineeCommands::Get().ToggleSnapTimeToFrames); ToolbarBuilder.AddToolBarButton(FMatineeCommands::Get().FixedTimeStepPlayback); } ToolbarBuilder.EndSection(); ToolbarBuilder.BeginSection("View"); { ToolbarBuilder.AddToolBarButton(FMatineeCommands::Get().FitSequence); ToolbarBuilder.AddToolBarButton(FMatineeCommands::Get().FitViewToSelected); ToolbarBuilder.AddToolBarButton(FMatineeCommands::Get().FitLoop); ToolbarBuilder.AddToolBarButton(FMatineeCommands::Get().FitLoopSequence); ToolbarBuilder.AddToolBarButton(FMatineeCommands::Get().ViewEndofTrack); } ToolbarBuilder.EndSection(); ToolbarBuilder.BeginSection("Record"); { ToolbarBuilder.AddToolBarButton(FMatineeCommands::Get().LaunchRecordWindow); ToolbarBuilder.AddToolBarButton(FMatineeCommands::Get().CreateMovie); } ToolbarBuilder.EndSection(); } }; TSharedPtr<FExtender> ToolbarExtender = MakeShareable(new FExtender); InitialInterpModeStrings.Empty(); InitialInterpModeStrings.Add( MakeShareable( new FString(NSLOCTEXT("Matinee", "Linear", "Linear").ToString()) ) ); InitialInterpModeStrings.Add( MakeShareable( new FString(NSLOCTEXT("Matinee", "CurveAuto", "CurveAuto").ToString()) ) ); InitialInterpModeStrings.Add( MakeShareable( new FString(NSLOCTEXT("Matinee", "Constant", "Constant").ToString()) ) ); InitialInterpModeStrings.Add( MakeShareable( new FString(NSLOCTEXT("Matinee", "CurveUser", "CurveUser").ToString()) ) ); InitialInterpModeStrings.Add( MakeShareable( new FString(NSLOCTEXT("Matinee", "CurveBreak", "CurveBreak").ToString()) ) ); InitialInterpModeStrings.Add( MakeShareable( new FString(NSLOCTEXT("Matinee", "CurveAutoClamped", "CurveAutoClamped").ToString()) ) ); InitialInterpModeComboBox = SNew( STextComboBox ) .OptionsSource(&InitialInterpModeStrings) .InitiallySelectedItem(InitialInterpModeStrings[0]) .OnSelectionChanged(this, &FMatinee::OnChangeInitialInterpMode) .ToolTipText(NSLOCTEXT("Matinee", "ToolTipInitialInterp", "Initial Interp Mode | Selects the curve interpolation mode for newly created keys")) ; TSharedRef<SWidget> InterpolationBox = SNew(SBox) .WidthOverride(150) [ SNew(SVerticalBox) +SVerticalBox::Slot() .Padding(4) [ SNew(STextBlock) .Text(NSLOCTEXT("Matinee.Toolbar", "InterpMode", "Interpolation:")) .Visibility( this, &FMatinee::GetLargeIconVisibility ) ] +SVerticalBox::Slot() .AutoHeight() .Padding(4,0) [ InitialInterpModeComboBox.ToSharedRef() ] ]; SpeedSettingStrings.Empty(); SpeedSettingStrings.Add( MakeShareable( new FString(NSLOCTEXT("UnrealEd", "FullSpeed", "100%").ToString()) ) ); SpeedSettingStrings.Add( MakeShareable( new FString(NSLOCTEXT("UnrealEd", "50Speed", "50%").ToString()) ) ); SpeedSettingStrings.Add( MakeShareable( new FString(NSLOCTEXT("UnrealEd", "25Speed", "25%").ToString()) ) ); SpeedSettingStrings.Add( MakeShareable( new FString(NSLOCTEXT("UnrealEd", "10Speed", "10%").ToString()) ) ); SpeedSettingStrings.Add( MakeShareable( new FString(NSLOCTEXT("UnrealEd", "1Speed", "1%").ToString()) ) ); SpeedCombo = SNew(STextComboBox) .OptionsSource(&SpeedSettingStrings) .InitiallySelectedItem(SpeedSettingStrings[0]) .OnSelectionChanged(this, &FMatinee::OnChangePlaySpeed) ; TSharedRef<SWidget> SpeedBox = SNew(SBox) .WidthOverride(103) [ SNew(SVerticalBox) +SVerticalBox::Slot() .Padding(4) [ SNew(STextBlock) .Text(NSLOCTEXT("Matinee.Toolbar", "PlaybackSpeed", "Playback Speed:")) .Visibility( this, &FMatinee::GetLargeIconVisibility ) ] +SVerticalBox::Slot() .AutoHeight() .Padding(4,0) [ SpeedCombo.ToSharedRef() ] ]; // Append Second Snap Times SnapComboStrings.Empty(); for(int32 i=0; i<ARRAY_COUNT(InterpEdSnapSizes); i++) { FString SnapCaption = FString::Printf( TEXT("%1.2f"), InterpEdSnapSizes[i] ); SnapComboStrings.Add( MakeShareable( new FString(SnapCaption) ) ); } // Append FPS Snap Times for(int32 i=0; i<ARRAY_COUNT(InterpEdFPSSnapSizes); i++) { FString SnapCaption = GetInterpEdFPSSnapSizeLocName( i ); SnapComboStrings.Add( MakeShareable( new FString(SnapCaption) ) ); } // Add option for snapping to other keys. SnapComboStrings.Add( MakeShareable( new FString(NSLOCTEXT("UnrealEd", "InterpEd_Snap_Keys", "Snap to Keys" ).ToString()) ) ); SnapCombo = SNew(STextComboBox) .OptionsSource(&SnapComboStrings) .InitiallySelectedItem(SnapComboStrings[2]) .OnSelectionChanged(this, &FMatinee::OnChangeSnapSize) .ToolTipText( NSLOCTEXT("Matinee", "SnapComboToolTip", "Snap Size | Selects the timeline granularity for snapping and visualization purposes") ) ; TSharedRef<SWidget> SnapSettingBox = SNew(SBox) .WidthOverride(155) [ SNew(SVerticalBox) +SVerticalBox::Slot() .Padding(4) [ SNew(STextBlock) .Text(NSLOCTEXT("Matinee.Toolbar", "SnapSetting", "Snap Setting:")) .Visibility( this, &FMatinee::GetLargeIconVisibility ) ] +SVerticalBox::Slot() .AutoHeight() .Padding(4,0) [ SnapCombo.ToSharedRef() ] ]; ToolbarExtender->AddToolBarExtension( "Asset", EExtensionHook::After, GetToolkitCommands(), FToolBarExtensionDelegate::CreateStatic( &Local::FillToolbar, InterpolationBox, SpeedBox, SnapSettingBox) ); AddToolbarExtender(ToolbarExtender); IMatineeModule* MatineeModule = &FModuleManager::LoadModuleChecked<IMatineeModule>( "Matinee" ); AddToolbarExtender(MatineeModule->GetToolBarExtensibilityManager()->GetAllExtenders(GetToolkitCommands(), GetEditingObjects())); }
static void PopulateSpriteActionsMenu(FMenuBuilder& MenuBuilder, TArray<FAssetData> SelectedAssets) { // Create sprites TSharedPtr<FCreateSpriteFromTextureExtension> SpriteCreatorFunctor = MakeShareable(new FCreateSpriteFromTextureExtension()); SpriteCreatorFunctor->SelectedAssets = SelectedAssets; FUIAction Action_CreateSpritesFromTextures( FExecuteAction::CreateStatic(&FPaperContentBrowserExtensions_Impl::ExecuteSelectedContentFunctor, StaticCastSharedPtr<FContentBrowserSelectedAssetExtensionBase>(SpriteCreatorFunctor))); MenuBuilder.AddMenuEntry( LOCTEXT("CB_Extension_Texture_CreateSprite", "Create Sprite"), LOCTEXT("CB_Extension_Texture_CreateSprite_Tooltip", "Create sprites from selected textures"), FSlateIcon(FEditorStyle::GetStyleSetName(), "ClassIcon.PaperSprite"), Action_CreateSpritesFromTextures, NAME_None, EUserInterfaceActionType::Button); // Extract Sprites TSharedPtr<FCreateSpriteFromTextureExtension> SpriteExtractorFunctor = MakeShareable(new FCreateSpriteFromTextureExtension()); SpriteExtractorFunctor->SelectedAssets = SelectedAssets; SpriteExtractorFunctor->bExtractSprites = true; FUIAction Action_ExtractSpritesFromTextures( FExecuteAction::CreateStatic(&FPaperContentBrowserExtensions_Impl::ExecuteSelectedContentFunctor, StaticCastSharedPtr<FContentBrowserSelectedAssetExtensionBase>(SpriteExtractorFunctor))); MenuBuilder.AddMenuEntry( LOCTEXT("CB_Extension_Texture_ExtractSprites", "Extract Sprites"), LOCTEXT("CB_Extension_Texture_ExtractSprite_Tooltip", "Detects and extracts sprites from the selected textures using transparency"), FSlateIcon(), Action_ExtractSpritesFromTextures, NAME_None, EUserInterfaceActionType::Button); // Configure for retro sprites TSharedPtr<FConfigureTexturesForSpriteUsageExtension> TextureConfigFunctor = MakeShareable(new FConfigureTexturesForSpriteUsageExtension()); TextureConfigFunctor->SelectedAssets = SelectedAssets; FUIAction Action_ConfigureTexturesForSprites( FExecuteAction::CreateStatic(&FPaperContentBrowserExtensions_Impl::ExecuteSelectedContentFunctor, StaticCastSharedPtr<FContentBrowserSelectedAssetExtensionBase>(TextureConfigFunctor))); MenuBuilder.AddMenuEntry( LOCTEXT("CB_Extension_Texture_ConfigureTextureForSprites", "Configure For Retro Sprites"), LOCTEXT("CB_Extension_Texture_ConfigureTextureForSprites_Tooltip", "Sets compression settings and sampling modes to good defaults for retro sprites (nearest filtering, uncompressed, etc...)"), FSlateIcon(), Action_ConfigureTexturesForSprites, NAME_None, EUserInterfaceActionType::Button); // Create sprites TSharedPtr<FCreateTileSetFromTextureExtension> TileSetCreatorFunctor = MakeShareable(new FCreateTileSetFromTextureExtension()); TileSetCreatorFunctor->SelectedAssets = SelectedAssets; FUIAction Action_CreateTileSetFromTextures( FExecuteAction::CreateStatic(&FPaperContentBrowserExtensions_Impl::ExecuteSelectedContentFunctor, StaticCastSharedPtr<FContentBrowserSelectedAssetExtensionBase>(TileSetCreatorFunctor))); MenuBuilder.AddMenuEntry( LOCTEXT("CB_Extension_Texture_CreateTileSet", "Create Tile Set"), LOCTEXT("CB_Extension_Texture_CreateTileSet_Tooltip", "Create tile set from selected texture"), FSlateIcon(FEditorStyle::GetStyleSetName(), "ClassIcon.PaperTileSet"), Action_CreateTileSetFromTextures, NAME_None, EUserInterfaceActionType::Button); }