Dron/Onejsky4U
1
0
Fork 0
Code Pull Requests Releases Activity
Files
master
Onejsky4U/Plugins/Runtime/HoudiniEngine/Source/HoudiniEngineEditor/Private/HoudiniEngineEditor.cpp
T

2134 lines
81 KiB
C++
Raw Permalink Blame History

/*
* Copyright (c) <2017> Side Effects Software Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
*/
#include "HoudiniEngineEditor.h"
#include "HoudiniApi.h"
#include "HoudiniEngineEditorPrivatePCH.h"
#include "HoudiniEngineUtils.h"
#include "HoudiniAsset.h"
#include "HoudiniEngine.h"
#include "HoudiniAssetActor.h"
#include "HoudiniAssetComponent.h"
#include "HoudiniHandleComponentVisualizer.h"
#include "HoudiniHandleComponent.h"
#include "HoudiniSplineComponentVisualizer.h"
#include "HoudiniSplineComponent.h"
#include "HoudiniAssetComponentDetails.h"
#include "HoudiniRuntimeSettingsDetails.h"
#include "HoudiniAssetTypeActions.h"
#include "HoudiniAssetBroker.h"
#include "HoudiniAssetActorFactory.h"
#include "HoudiniEngineBakeUtils.h"
#include "UnrealEdGlobals.h"
#include "Editor/UnrealEdEngine.h"
#include "Engine/ObjectLibrary.h"
#include "EditorDirectories.h"
#include "Styling/SlateStyleRegistry.h"
#include "SHoudiniToolPalette.h"
#include "IPlacementModeModule.h"
#include "Framework/MultiBox/MultiBoxBuilder.h"
#include "AssetRegistryModule.h"
#include "Engine/Selection.h"
#include "ContentBrowserModule.h"
#include "IContentBrowserSingleton.h"
#include "SlateOptMacros.h"
#include "HAL/FileManager.h"
#include "HAL/PlatformFilemanager.h"
#include "Dom/JsonObject.h"
#include "Misc/FileHelper.h"
#include "Serialization/JsonReader.h"
#include "Serialization/JsonSerializer.h"
#include "Interfaces/IPluginManager.h"
#define LOCTEXT_NAMESPACE HOUDINI_LOCTEXT_NAMESPACE
#define IMAGE_BRUSH( RelativePath, ... ) FSlateImageBrush( StyleSet->RootToContentDir( RelativePath, TEXT(".png") ), __VA_ARGS__ )
#define BOX_BRUSH( RelativePath, ... ) FSlateBoxBrush( StyleSet->RootToContentDir( RelativePath, TEXT(".png") ), __VA_ARGS__ )
#define BORDER_BRUSH( RelativePath, ... ) FSlateBorderBrush( StyleSet->RootToContentDir( RelativePath, TEXT(".png") ), __VA_ARGS__ )
#define TTF_FONT( RelativePath, ... ) FSlateFontInfo( StyleSet->RootToContentDir( RelativePath, TEXT(".ttf") ), __VA_ARGS__ )
#define TTF_CORE_FONT( RelativePath, ... ) FSlateFontInfo( StyleSet->RootToCoreContentDir( RelativePath, TEXT(".ttf") ), __VA_ARGS__ )
#define OTF_FONT( RelativePath, ... ) FSlateFontInfo( StyleSet->RootToContentDir( RelativePath, TEXT(".otf") ), __VA_ARGS__ )
#define OTF_CORE_FONT( RelativePath, ... ) FSlateFontInfo( StyleSet->RootToCoreContentDir( RelativePath, TEXT(".otf") ), __VA_ARGS__ )
TSharedPtr<FSlateStyleSet> FHoudiniEngineStyle::StyleSet = nullptr;
TSharedPtr<class ISlateStyle>
FHoudiniEngineStyle::Get()
{
return StyleSet;
}
FName
FHoudiniEngineStyle::GetStyleSetName()
{
static FName HoudiniStyleName(TEXT("HoudiniEngineStyle"));
return HoudiniStyleName;
}
BEGIN_SLATE_FUNCTION_BUILD_OPTIMIZATION
void
FHoudiniEngineStyle::Initialize()
{
// Only register the StyleSet once
if ( StyleSet.IsValid() )
return;
StyleSet = MakeShareable( new FSlateStyleSet( GetStyleSetName() ) );
StyleSet->SetContentRoot(FPaths::EngineContentDir() / TEXT("Editor/Slate"));
StyleSet->SetCoreContentRoot(FPaths::EngineContentDir() / TEXT("Slate"));
// Note, these sizes are in Slate Units.
// Slate Units do NOT have to map to pixels.
const FVector2D Icon5x16(5.0f, 16.0f);
const FVector2D Icon8x4(8.0f, 4.0f);
const FVector2D Icon8x8(8.0f, 8.0f);
const FVector2D Icon10x10(10.0f, 10.0f);
const FVector2D Icon12x12(12.0f, 12.0f);
const FVector2D Icon12x16(12.0f, 16.0f);
const FVector2D Icon14x14(14.0f, 14.0f);
const FVector2D Icon16x16(16.0f, 16.0f);
const FVector2D Icon20x20(20.0f, 20.0f);
const FVector2D Icon22x22(22.0f, 22.0f);
const FVector2D Icon24x24(24.0f, 24.0f);
const FVector2D Icon25x25(25.0f, 25.0f);
const FVector2D Icon32x32(32.0f, 32.0f);
const FVector2D Icon40x40(40.0f, 40.0f);
const FVector2D Icon64x64(64.0f, 64.0f);
const FVector2D Icon36x24(36.0f, 24.0f);
const FVector2D Icon128x128(128.0f, 128.0f);
static FString IconsDir = FHoudiniEngineEditor::GetHoudiniEnginePluginDir() / TEXT("Content/Icons/");
StyleSet->Set(
"HoudiniEngine.HoudiniEngineLogo",
new FSlateImageBrush(IconsDir + TEXT("icon_houdini_logo_16.png"), Icon16x16));
StyleSet->Set(
"ClassIcon.HoudiniAssetActor",
new FSlateImageBrush(IconsDir + TEXT("icon_houdini_logo_16.png"), Icon16x16));
StyleSet->Set(
"HoudiniEngine.HoudiniEngineLogo40",
new FSlateImageBrush(IconsDir + TEXT("icon_houdini_logo_40.png"), Icon40x40));
StyleSet->Set(
"ClassIcon.HoudiniAsset",
new FSlateImageBrush(IconsDir + TEXT("icon_houdini_logo_16.png"), Icon16x16));
StyleSet->Set(
"ClassThumbnail.HoudiniAsset",
new FSlateImageBrush(IconsDir + TEXT("icon_houdini_logo_128.png"), Icon64x64));
//FSlateImageBrush* HoudiniLogo16 = new FSlateImageBrush(IconsDir + TEXT("icon_houdini_logo_16.png"), Icon16x16);
StyleSet->Set("HoudiniEngine.SaveHIPFile", new FSlateImageBrush(IconsDir + TEXT("icon_houdini_logo_16.png"), Icon16x16));
StyleSet->Set("HoudiniEngine.ReportBug", new FSlateImageBrush(IconsDir + TEXT("icon_houdini_logo_16.png"), Icon16x16));
StyleSet->Set("HoudiniEngine.OpenInHoudini", new FSlateImageBrush(IconsDir + TEXT("icon_houdini_logo_16.png"), Icon16x16));
StyleSet->Set("HoudiniEngine.CleanUpTempFolder", new FSlateImageBrush(IconsDir + TEXT("icon_houdini_logo_16.png"), Icon16x16));
StyleSet->Set("HoudiniEngine.BakeAllAssets", new FSlateImageBrush(IconsDir + TEXT("icon_houdini_logo_16.png"), Icon16x16));
StyleSet->Set("HoudiniEngine.PauseAssetCooking", new FSlateImageBrush(IconsDir + TEXT("icon_houdini_logo_16.png"), Icon16x16));
StyleSet->Set("HoudiniEngine.RestartSession", new FSlateImageBrush(IconsDir + TEXT("icon_houdini_logo_16.png"), Icon16x16));
// We need some colors from Editor Style & this is the only way to do this at the moment
const FSlateColor DefaultForeground = FEditorStyle::GetSlateColor("DefaultForeground");
const FSlateColor InvertedForeground = FEditorStyle::GetSlateColor("InvertedForeground");
const FSlateColor SelectorColor = FEditorStyle::GetSlateColor("SelectorColor");
const FSlateColor SelectionColor = FEditorStyle::GetSlateColor("SelectionColor");
const FSlateColor SelectionColor_Inactive = FEditorStyle::GetSlateColor("SelectionColor_Inactive");
const FTableRowStyle &NormalTableRowStyle = FEditorStyle::Get().GetWidgetStyle<FTableRowStyle>("TableView.Row");
StyleSet->Set(
"HoudiniEngine.TableRow", FTableRowStyle( NormalTableRowStyle)
.SetEvenRowBackgroundBrush( FSlateNoResource() )
.SetEvenRowBackgroundHoveredBrush( IMAGE_BRUSH( "Common/Selection", Icon8x8, FLinearColor( 1.0f, 1.0f, 1.0f, 0.1f ) ) )
.SetOddRowBackgroundBrush( FSlateNoResource() )
.SetOddRowBackgroundHoveredBrush( IMAGE_BRUSH( "Common/Selection", Icon8x8, FLinearColor( 1.0f, 1.0f, 1.0f, 0.1f ) ) )
.SetSelectorFocusedBrush( BORDER_BRUSH( "Common/Selector", FMargin( 4.f / 16.f ), SelectorColor ) )
.SetActiveBrush( IMAGE_BRUSH( "Common/Selection", Icon8x8, SelectionColor ) )
.SetActiveHoveredBrush( IMAGE_BRUSH( "Common/Selection", Icon8x8, SelectionColor ) )
.SetInactiveBrush( IMAGE_BRUSH( "Common/Selection", Icon8x8, SelectionColor_Inactive ) )
.SetInactiveHoveredBrush( IMAGE_BRUSH( "Common/Selection", Icon8x8, SelectionColor_Inactive ) )
.SetTextColor( DefaultForeground )
.SetSelectedTextColor( InvertedForeground )
);
// Normal Text
const FTextBlockStyle& NormalText = FEditorStyle::Get().GetWidgetStyle<FTextBlockStyle>("NormalText");
StyleSet->Set(
"HoudiniEngine.ThumbnailText", FTextBlockStyle(NormalText)
.SetFont(TTF_CORE_FONT("Fonts/Roboto-Regular", 9))
.SetColorAndOpacity(FSlateColor::UseForeground())
.SetShadowOffset(FVector2D::ZeroVector)
.SetShadowColorAndOpacity(FLinearColor::Black)
.SetHighlightColor(FLinearColor(0.02f, 0.3f, 0.0f))
.SetHighlightShape(BOX_BRUSH("Common/TextBlockHighlightShape", FMargin(3.f / 8.f)))
);
StyleSet->Set("HoudiniEngine.ThumbnailShadow", new BOX_BRUSH("ContentBrowser/ThumbnailShadow", FMargin(4.0f / 64.0f)));
StyleSet->Set("HoudiniEngine.ThumbnailBackground", new IMAGE_BRUSH("Common/ClassBackground_64x", FVector2D(64.f, 64.f), FLinearColor(0.75f, 0.75f, 0.75f, 1.0f)));
// Register Slate style.
FSlateStyleRegistry::RegisterSlateStyle(*StyleSet.Get());
};
END_SLATE_FUNCTION_BUILD_OPTIMIZATION
#undef IMAGE_BRUSH
#undef BOX_BRUSH
#undef BORDER_BRUSH
#undef TTF_FONT
#undef TTF_CORE_FONT
#undef OTF_FONT
#undef OTF_CORE_FONT
void
FHoudiniEngineStyle::Shutdown()
{
if (StyleSet.IsValid())
{
FSlateStyleRegistry::UnRegisterSlateStyle(*StyleSet.Get());
ensure(StyleSet.IsUnique());
StyleSet.Reset();
}
}
const FName
FHoudiniEngineEditor::HoudiniEngineEditorAppIdentifier = FName( TEXT( "HoudiniEngineEditorApp" ) );
IMPLEMENT_MODULE( FHoudiniEngineEditor, HoudiniEngineEditor );
DEFINE_LOG_CATEGORY( LogHoudiniEngineEditor );
FHoudiniEngineEditor *
FHoudiniEngineEditor::HoudiniEngineEditorInstance = nullptr;
FHoudiniEngineEditor &
FHoudiniEngineEditor::Get()
{
return *HoudiniEngineEditorInstance;
}
bool
FHoudiniEngineEditor::IsInitialized()
{
return FHoudiniEngineEditor::HoudiniEngineEditorInstance != nullptr;
}
FHoudiniEngineEditor::FHoudiniEngineEditor()
: CurrentHoudiniToolDirIndex(-1),
LastHoudiniAssetComponentUndoObject( nullptr )
{}
void
FHoudiniEngineEditor::StartupModule()
{
HOUDINI_LOG_MESSAGE( TEXT( "Starting the Houdini Engine Editor module." ) );
// Create style set.
FHoudiniEngineStyle::Initialize();
// Register asset type actions.
RegisterAssetTypeActions();
// Register asset brokers.
RegisterAssetBrokers();
// Register component visualizers.
RegisterComponentVisualizers();
// Register detail presenters.
RegisterDetails();
// Register actor factories.
RegisterActorFactories();
// Extends the file menu.
ExtendMenu();
// Extend the World Outliner Menu
AddLevelViewportMenuExtender();
// Adds the custom console commands
RegisterConsoleCommands();
// Register global undo / redo callbacks.
RegisterForUndo();
#ifdef HOUDINI_MODE
// Register editor modes
RegisterModes();
#endif
RegisterPlacementModeExtensions();
// Store the instance.
FHoudiniEngineEditor::HoudiniEngineEditorInstance = this;
HOUDINI_LOG_MESSAGE( TEXT("Houdini Engine Editor module startup complete." ) );
}
void
FHoudiniEngineEditor::ShutdownModule()
{
HOUDINI_LOG_MESSAGE( TEXT( "Shutting down the Houdini Engine Editor module." ) );
// Remove the level viewport Menu extender%
RemoveLevelViewportMenuExtender();
// Unregister asset type actions.
UnregisterAssetTypeActions();
// Unregister asset brokers.
UnregisterAssetBrokers();
// Unregister detail presenters.
UnregisterDetails();
// Unregister our component visualizers.
UnregisterComponentVisualizers();
// Unregister global undo / redo callbacks.
UnregisterForUndo();
#ifdef HOUDINI_MODE
UnregisterModes();
#endif
UnregisterPlacementModeExtensions();
// Unregister the styleset
FHoudiniEngineStyle::Shutdown();
HOUDINI_LOG_MESSAGE( TEXT("Houdini Engine Editor module shutdown complete." ) );
}
void
FHoudiniEngineEditor::RegisterComponentVisualizers()
{
if ( GUnrealEd )
{
if ( !SplineComponentVisualizer.IsValid() )
{
SplineComponentVisualizer = MakeShareable( new FHoudiniSplineComponentVisualizer );
GUnrealEd->RegisterComponentVisualizer(
UHoudiniSplineComponent::StaticClass()->GetFName(),
SplineComponentVisualizer
);
SplineComponentVisualizer->OnRegister();
}
if ( !HandleComponentVisualizer.IsValid() )
{
HandleComponentVisualizer = MakeShareable( new FHoudiniHandleComponentVisualizer );
GUnrealEd->RegisterComponentVisualizer(
UHoudiniHandleComponent::StaticClass()->GetFName(),
HandleComponentVisualizer
);
HandleComponentVisualizer->OnRegister();
}
}
}
void
FHoudiniEngineEditor::UnregisterComponentVisualizers()
{
if ( GUnrealEd )
{
if ( SplineComponentVisualizer.IsValid() )
GUnrealEd->UnregisterComponentVisualizer( UHoudiniSplineComponent::StaticClass()->GetFName() );
if ( HandleComponentVisualizer.IsValid() )
GUnrealEd->UnregisterComponentVisualizer( UHoudiniHandleComponent::StaticClass()->GetFName() );
}
}
void
FHoudiniEngineEditor::RegisterDetails()
{
FPropertyEditorModule & PropertyModule = FModuleManager::LoadModuleChecked< FPropertyEditorModule >( "PropertyEditor" );
// Register details presenter for our component type and runtime settings.
PropertyModule.RegisterCustomClassLayout(
TEXT( "HoudiniAssetComponent" ),
FOnGetDetailCustomizationInstance::CreateStatic( &FHoudiniAssetComponentDetails::MakeInstance ) );
PropertyModule.RegisterCustomClassLayout(
TEXT( "HoudiniRuntimeSettings" ),
FOnGetDetailCustomizationInstance::CreateStatic( &FHoudiniRuntimeSettingsDetails::MakeInstance ) );
}
void
FHoudiniEngineEditor::UnregisterDetails()
{
if ( FModuleManager::Get().IsModuleLoaded( "PropertyEditor" ) )
{
FPropertyEditorModule & PropertyModule =
FModuleManager::LoadModuleChecked<FPropertyEditorModule>( "PropertyEditor" );
PropertyModule.UnregisterCustomClassLayout( TEXT( "HoudiniAssetComponent" ) );
PropertyModule.UnregisterCustomClassLayout( TEXT( "HoudiniRuntimeSettings" ) );
}
}
void
FHoudiniEngineEditor::RegisterAssetTypeActions()
{
// Create and register asset type actions for Houdini asset.
IAssetTools& AssetTools = FModuleManager::LoadModuleChecked< FAssetToolsModule >( "AssetTools" ).Get();
RegisterAssetTypeAction( AssetTools, MakeShareable( new FHoudiniAssetTypeActions() ) );
}
void
FHoudiniEngineEditor::UnregisterAssetTypeActions()
{
// Unregister asset type actions we have previously registered.
if ( FModuleManager::Get().IsModuleLoaded( "AssetTools" ) )
{
IAssetTools & AssetTools = FModuleManager::GetModuleChecked< FAssetToolsModule >( "AssetTools" ).Get();
for ( int32 Index = 0; Index < AssetTypeActions.Num(); ++Index )
AssetTools.UnregisterAssetTypeActions( AssetTypeActions[ Index ].ToSharedRef() );
AssetTypeActions.Empty();
}
}
void
FHoudiniEngineEditor::RegisterAssetTypeAction( IAssetTools & AssetTools, TSharedRef< IAssetTypeActions > Action )
{
AssetTools.RegisterAssetTypeActions( Action );
AssetTypeActions.Add( Action );
}
void
FHoudiniEngineEditor::RegisterAssetBrokers()
{
// Create and register broker for Houdini asset.
HoudiniAssetBroker = MakeShareable( new FHoudiniAssetBroker() );
FComponentAssetBrokerage::RegisterBroker( HoudiniAssetBroker, UHoudiniAssetComponent::StaticClass(), true, true );
}
void
FHoudiniEngineEditor::UnregisterAssetBrokers()
{
if ( UObjectInitialized() )
{
// Unregister broker.
FComponentAssetBrokerage::UnregisterBroker( HoudiniAssetBroker );
}
}
void
FHoudiniEngineEditor::RegisterActorFactories()
{
if ( GEditor )
{
UHoudiniAssetActorFactory * HoudiniAssetActorFactory =
NewObject< UHoudiniAssetActorFactory >( GetTransientPackage(), UHoudiniAssetActorFactory::StaticClass() );
GEditor->ActorFactories.Add( HoudiniAssetActorFactory );
}
}
void
FHoudiniEngineEditor::ExtendMenu()
{
if ( !IsRunningCommandlet() )
{
// We need to add/bind the UI Commands to their functions first
BindMenuCommands();
// Extend main menu, we will add Houdini section.
MainMenuExtender = MakeShareable( new FExtender );
MainMenuExtender->AddMenuExtension(
"FileLoadAndSave", EExtensionHook::After, HEngineCommands,
FMenuExtensionDelegate::CreateRaw( this, &FHoudiniEngineEditor::AddHoudiniMenuExtension ) );
FLevelEditorModule& LevelEditorModule = FModuleManager::LoadModuleChecked< FLevelEditorModule >( "LevelEditor" );
LevelEditorModule.GetMenuExtensibilityManager()->AddExtender( MainMenuExtender );
}
}
void
FHoudiniEngineEditor::AddHoudiniMenuExtension( FMenuBuilder & MenuBuilder )
{
MenuBuilder.BeginSection( "Houdini", LOCTEXT( "HoudiniLabel", "Houdini Engine" ) );
MenuBuilder.AddMenuEntry( FHoudiniEngineCommands::Get().OpenInHoudini );
MenuBuilder.AddMenuEntry( FHoudiniEngineCommands::Get().SaveHIPFile );
MenuBuilder.AddMenuEntry( FHoudiniEngineCommands::Get().ReportBug );
MenuBuilder.AddMenuEntry( FHoudiniEngineCommands::Get().CleanUpTempFolder );
MenuBuilder.AddMenuEntry( FHoudiniEngineCommands::Get().BakeAllAssets );
MenuBuilder.AddMenuEntry( FHoudiniEngineCommands::Get().PauseAssetCooking );
MenuBuilder.AddMenuEntry( FHoudiniEngineCommands::Get().RestartSession);
MenuBuilder.EndSection();
}
void
FHoudiniEngineEditor::BindMenuCommands()
{
HEngineCommands = MakeShareable( new FUICommandList );
FHoudiniEngineCommands::Register();
const FHoudiniEngineCommands& Commands = FHoudiniEngineCommands::Get();
HEngineCommands->MapAction(
Commands.OpenInHoudini,
FExecuteAction::CreateRaw( this, &FHoudiniEngineEditor::OpenInHoudini ),
FCanExecuteAction::CreateRaw( this, &FHoudiniEngineEditor::CanOpenInHoudini ) );
HEngineCommands->MapAction(
Commands.SaveHIPFile,
FExecuteAction::CreateRaw( this, &FHoudiniEngineEditor::SaveHIPFile ),
FCanExecuteAction::CreateRaw( this, &FHoudiniEngineEditor::CanSaveHIPFile ) );
HEngineCommands->MapAction(
Commands.ReportBug,
FExecuteAction::CreateRaw( this, &FHoudiniEngineEditor::ReportBug ),
FCanExecuteAction::CreateRaw( this, &FHoudiniEngineEditor::CanReportBug ) );
HEngineCommands->MapAction(
Commands.CleanUpTempFolder,
FExecuteAction::CreateRaw( this, &FHoudiniEngineEditor::CleanUpTempFolder ),
FCanExecuteAction::CreateRaw( this, &FHoudiniEngineEditor::CanCleanUpTempFolder ) );
HEngineCommands->MapAction(
Commands.BakeAllAssets,
FExecuteAction::CreateRaw( this, &FHoudiniEngineEditor::BakeAllAssets ),
FCanExecuteAction::CreateRaw( this, &FHoudiniEngineEditor::CanBakeAllAssets ) );
HEngineCommands->MapAction(
Commands.PauseAssetCooking,
FExecuteAction::CreateRaw( this, &FHoudiniEngineEditor::PauseAssetCooking ),
FCanExecuteAction::CreateRaw( this, &FHoudiniEngineEditor::CanPauseAssetCooking ),
FIsActionChecked::CreateRaw( this, &FHoudiniEngineEditor::IsAssetCookingPaused ) );
HEngineCommands->MapAction(
Commands.RestartSession,
FExecuteAction::CreateRaw( this, &FHoudiniEngineEditor::RestartSession),
FCanExecuteAction::CreateRaw( this, &FHoudiniEngineEditor::CanRestartSession ) );
// Non menu command (used for shortcuts only)
HEngineCommands->MapAction(
Commands.CookSelec,
FExecuteAction::CreateRaw( this, &FHoudiniEngineEditor::RecookSelection ),
FCanExecuteAction() );
HEngineCommands->MapAction(
Commands.RebuildSelec,
FExecuteAction::CreateRaw( this, &FHoudiniEngineEditor::RebuildSelection ),
FCanExecuteAction() );
HEngineCommands->MapAction(
Commands.BakeSelec,
FExecuteAction::CreateRaw( this, &FHoudiniEngineEditor::BakeSelection ),
FCanExecuteAction() );
// Append the command to the editor module
FLevelEditorModule& LevelEditorModule = FModuleManager::LoadModuleChecked< FLevelEditorModule >("LevelEditor");
LevelEditorModule.GetGlobalLevelEditorActions()->Append(HEngineCommands.ToSharedRef());
}
void
FHoudiniEngineEditor::RegisterConsoleCommands()
{
// Register corresponding console commands
static FAutoConsoleCommand CCmdOpen = FAutoConsoleCommand(
TEXT("Houdini.Open"),
TEXT("Open the scene in Houdini."),
FConsoleCommandDelegate::CreateRaw( this, &FHoudiniEngineEditor::OpenInHoudini ) );
static FAutoConsoleCommand CCmdSave = FAutoConsoleCommand(
TEXT("Houdini.Save"),
TEXT("Save the current Houdini scene to a hip file."),
FConsoleCommandDelegate::CreateRaw(this, &FHoudiniEngineEditor::SaveHIPFile ) );
static FAutoConsoleCommand CCmdBake = FAutoConsoleCommand(
TEXT("Houdini.BakeAll"),
TEXT("Bakes and replaces with blueprints all Houdini Asset Actors in the current level."),
FConsoleCommandDelegate::CreateRaw(this, &FHoudiniEngineEditor::BakeAllAssets ) );
static FAutoConsoleCommand CCmdClean = FAutoConsoleCommand(
TEXT("Houdini.Clean"),
TEXT("Cleans up unused/unreferenced Houdini Engine temporary files."),
FConsoleCommandDelegate::CreateRaw(this, &FHoudiniEngineEditor::CleanUpTempFolder ) );
static FAutoConsoleCommand CCmdPause = FAutoConsoleCommand(
TEXT( "Houdini.Pause"),
TEXT( "Pauses Houdini Engine Asset cooking." ),
FConsoleCommandDelegate::CreateRaw( this, &FHoudiniEngineEditor::PauseAssetCooking ) );
// Additional console only commands
static FAutoConsoleCommand CCmdCookAll = FAutoConsoleCommand(
TEXT("Houdini.CookAll"),
TEXT("Re-cooks all Houdini Engine Asset Actors in the current level."),
FConsoleCommandDelegate::CreateRaw( this, &FHoudiniEngineEditor::RecookAllAssets ) );
static FAutoConsoleCommand CCmdRebuildAll = FAutoConsoleCommand(
TEXT("Houdini.RebuildAll"),
TEXT("Rebuilds all Houdini Engine Asset Actors in the current level."),
FConsoleCommandDelegate::CreateRaw( this, &FHoudiniEngineEditor::RebuildAllAssets ) );
static FAutoConsoleCommand CCmdCookSelec = FAutoConsoleCommand(
TEXT("Houdini.Cook"),
TEXT("Re-cooks selected Houdini Asset Actors in the current level."),
FConsoleCommandDelegate::CreateRaw( this, &FHoudiniEngineEditor::RecookSelection ) );
static FAutoConsoleCommand CCmdRebuildSelec = FAutoConsoleCommand(
TEXT("Houdini.Rebuild"),
TEXT("Rebuilds selected Houdini Asset Actors in the current level."),
FConsoleCommandDelegate::CreateRaw( this, &FHoudiniEngineEditor::RebuildSelection ) );
static FAutoConsoleCommand CCmdBakeSelec = FAutoConsoleCommand(
TEXT("Houdini.Bake"),
TEXT("Bakes and replaces with blueprints selected Houdini Asset Actors in the current level."),
FConsoleCommandDelegate::CreateRaw( this, &FHoudiniEngineEditor::BakeSelection ) );
static FAutoConsoleCommand CCmdRestartSession = FAutoConsoleCommand(
TEXT("Houdini.RestartSession"),
TEXT("Restart the current Houdini Session."),
FConsoleCommandDelegate::CreateRaw(this, &FHoudiniEngineEditor::RestartSession ) );
}
bool
FHoudiniEngineEditor::CanSaveHIPFile() const
{
return FHoudiniEngine::IsInitialized();
}
void
FHoudiniEngineEditor::SaveHIPFile()
{
IDesktopPlatform * DesktopPlatform = FDesktopPlatformModule::Get();
if ( DesktopPlatform && FHoudiniEngineUtils::IsInitialized() )
{
TArray< FString > SaveFilenames;
bool bSaved = false;
void * ParentWindowWindowHandle = NULL;
IMainFrameModule & MainFrameModule = FModuleManager::LoadModuleChecked< IMainFrameModule >( TEXT( "MainFrame" ) );
const TSharedPtr< SWindow > & MainFrameParentWindow = MainFrameModule.GetParentWindow();
if ( MainFrameParentWindow.IsValid() && MainFrameParentWindow->GetNativeWindow().IsValid() )
ParentWindowWindowHandle = MainFrameParentWindow->GetNativeWindow()->GetOSWindowHandle();
bSaved = DesktopPlatform->SaveFileDialog(
ParentWindowWindowHandle,
NSLOCTEXT( "SaveHIPFile", "SaveHIPFile", "Saves a .hip file of the current Houdini scene." ).ToString(),
*( FEditorDirectories::Get().GetLastDirectory( ELastDirectory::GENERIC_EXPORT ) ),
TEXT( "" ),
TEXT( "Houdini HIP file|*.hip" ),
EFileDialogFlags::None,
SaveFilenames );
if ( bSaved && SaveFilenames.Num() )
{
// Add a slate notification
FString Notification = TEXT("Saving internal Houdini scene...");
FHoudiniEngineUtils::CreateSlateNotification(Notification);
// ... and a log message
HOUDINI_LOG_MESSAGE(TEXT("Saved Houdini scene to %s"), *SaveFilenames[ 0 ] );
// Get first path.
std::string HIPPathConverted( TCHAR_TO_UTF8(*SaveFilenames[0]) );
// Save HIP file through Engine.
FHoudiniApi::SaveHIPFile( FHoudiniEngine::Get().GetSession(), HIPPathConverted.c_str(), false );
}
}
}
bool
FHoudiniEngineEditor::CanOpenInHoudini() const
{
return FHoudiniEngine::IsInitialized();
}
void
FHoudiniEngineEditor::OpenInHoudini()
{
if ( !FHoudiniEngine::IsInitialized() )
return;
// First, saves the current scene as a hip file
// Creates a proper temporary file name
FString UserTempPath = FPaths::CreateTempFilename(
FPlatformProcess::UserTempDir(),
TEXT( "HoudiniEngine" ), TEXT( ".hip" ) );
// Save HIP file through Engine.
std::string TempPathConverted( TCHAR_TO_UTF8( *UserTempPath ) );
FHoudiniApi::SaveHIPFile(
FHoudiniEngine::Get().GetSession(),
TempPathConverted.c_str(), false);
if ( !FPaths::FileExists( UserTempPath ) )
return;
// Add a slate notification
FString Notification = TEXT( "Opening scene in Houdini..." );
FHoudiniEngineUtils::CreateSlateNotification( Notification );
// ... and a log message
HOUDINI_LOG_MESSAGE( TEXT("Opened scene in Houdini.") );
// Add quotes to the path to avoid issues with spaces
UserTempPath = TEXT("\"") + UserTempPath + TEXT("\"");
// Then open the hip file in Houdini
FString LibHAPILocation = FHoudiniEngine::Get().GetLibHAPILocation();
FString HoudiniLocation = LibHAPILocation + TEXT("//houdini");
FPlatformProcess::CreateProc(
*HoudiniLocation,
*UserTempPath,
true, false, false,
nullptr, 0,
FPlatformProcess::UserTempDir(),
nullptr, nullptr );
// Unfortunately, LaunchFileInDefaultExternalApplication doesn't seem to be working properly
//FPlatformProcess::LaunchFileInDefaultExternalApplication( UserTempPath.GetCharArray().GetData(), nullptr, ELaunchVerb::Open );
}
void
FHoudiniEngineEditor::ReportBug()
{
FPlatformProcess::LaunchURL( HAPI_UNREAL_BUG_REPORT_URL, nullptr, nullptr );
}
bool
FHoudiniEngineEditor::CanReportBug() const
{
return FHoudiniEngine::IsInitialized();
}
void
FHoudiniEngineEditor::RegisterForUndo()
{
if ( GUnrealEd )
GUnrealEd->RegisterForUndo( this );
}
void
FHoudiniEngineEditor::UnregisterForUndo()
{
if ( GUnrealEd )
GUnrealEd->UnregisterForUndo( this );
}
/** Registers placement mode extensions. */
void
FHoudiniEngineEditor::RegisterPlacementModeExtensions()
{
// Load custom houdini tools
const UHoudiniRuntimeSettings * HoudiniRuntimeSettings = GetDefault< UHoudiniRuntimeSettings >();
check( HoudiniRuntimeSettings );
if ( HoudiniRuntimeSettings->bHidePlacementModeHoudiniTools )
return;
FPlacementCategoryInfo Info(
LOCTEXT( "HoudiniCategoryName", "Houdini Engine" ),
"HoudiniEngine",
TEXT( "PMHoudiniEngine" ),
25
);
Info.CustomGenerator = []() -> TSharedRef<SWidget> { return SNew( SHoudiniToolPalette ); };
IPlacementModeModule::Get().RegisterPlacementCategory( Info );
}
FString
FHoudiniEngineEditor::GetDefaultHoudiniToolIcon()
{
return FHoudiniEngineEditor::GetHoudiniEnginePluginDir() / TEXT("Content/Icons/icon_houdini_logo_40.png");
}
FString
FHoudiniEngineEditor::GetHoudiniEnginePluginDir()
{
FString EnginePluginDir = FPaths::EnginePluginsDir() / TEXT("Runtime/HoudiniEngine");
if ( FPaths::DirectoryExists(EnginePluginDir) )
return EnginePluginDir;
FString ProjectPluginDir = FPaths::ProjectPluginsDir() / TEXT("Runtime/HoudiniEngine");
if ( FPaths::DirectoryExists(ProjectPluginDir) )
return ProjectPluginDir;
TSharedPtr<IPlugin> HoudiniPlugin = IPluginManager::Get().FindPlugin(TEXT("HoudiniEngine"));
FString PluginBaseDir = HoudiniPlugin.IsValid() ? HoudiniPlugin->GetBaseDir() : EnginePluginDir;
if ( FPaths::DirectoryExists(PluginBaseDir) )
return PluginBaseDir;
HOUDINI_LOG_WARNING(TEXT("Could not find the Houdini Engine plugin's directory"));
return EnginePluginDir;
}
void
FHoudiniEngineEditor::UnregisterPlacementModeExtensions()
{
if ( IPlacementModeModule::IsAvailable() )
{
IPlacementModeModule::Get().UnregisterPlacementCategory( "HoudiniEngine" );
}
HoudiniTools.Empty();
}
bool
FHoudiniEngineEditor::MatchesContext(const FTransactionContext& InContext, const TArray<TPair<UObject*, FTransactionObjectEvent>>& TransactionObjects) const
{
if (InContext.Context == TEXT(HOUDINI_MODULE_EDITOR) || InContext.Context == TEXT(HOUDINI_MODULE_RUNTIME))
{
// Check if we care about the undo/redo
for (const TPair<UObject*, FTransactionObjectEvent>& TransactionObjectPair : TransactionObjects)
{
LastHoudiniAssetComponentUndoObject = Cast< UHoudiniAssetComponent >(TransactionObjectPair.Key);
if ( LastHoudiniAssetComponentUndoObject )
return true;
}
}
LastHoudiniAssetComponentUndoObject = nullptr;
return false;
}
void
FHoudiniEngineEditor::PostUndo( bool bSuccess )
{
if ( LastHoudiniAssetComponentUndoObject && bSuccess )
{
LastHoudiniAssetComponentUndoObject->UpdateEditorProperties( false );
LastHoudiniAssetComponentUndoObject = nullptr;
}
}
void
FHoudiniEngineEditor::PostRedo( bool bSuccess )
{
if ( LastHoudiniAssetComponentUndoObject && bSuccess )
{
LastHoudiniAssetComponentUndoObject->UpdateEditorProperties( false );
LastHoudiniAssetComponentUndoObject = nullptr;
}
}
void
FHoudiniEngineEditor::CleanUpTempFolder()
{
// Add a slate notification
FString Notification = TEXT("Cleaning up Houdini Engine temporary folder");
FHoudiniEngineUtils::CreateSlateNotification( Notification );
// Get Runtime settings to get the Temp Cook Folder
const UHoudiniRuntimeSettings * HoudiniRuntimeSettings = GetDefault< UHoudiniRuntimeSettings >();
if (!HoudiniRuntimeSettings)
return;
FString TempCookFolder = HoudiniRuntimeSettings->TemporaryCookFolder.ToString();
// The Asset registry will help us finding if the content of the asset is referenced
FAssetRegistryModule& AssetRegistryModule = FModuleManager::LoadModuleChecked<FAssetRegistryModule>("AssetRegistry");
int32 DeletedCount = 0;
bool bDidDeleteAsset = true;
while ( bDidDeleteAsset )
{
// To correctly clean the temp folder, we need to iterate multiple times, because some of the temp assets
// might be referenced by other temp assets.. (ie Textures are referenced by Materials)
// We'll stop looking for assets to delete when no deletion occured.
bDidDeleteAsset = false;
// The Object library will list all UObjects found in the TempFolder
auto ObjectLibrary = UObjectLibrary::CreateLibrary( UObject::StaticClass(), false, true );
ObjectLibrary->LoadAssetDataFromPath( TempCookFolder );
// Get all the assets found in the TEMP folder
TArray<FAssetData> AssetDataList;
ObjectLibrary->GetAssetDataList( AssetDataList );
// All the assets we're going to delete
TArray<FAssetData> AssetDataToDelete;
for ( FAssetData Data : AssetDataList )
{
UPackage* CurrentPackage = Data.GetPackage();
if ( !CurrentPackage || CurrentPackage->IsPendingKill() )
continue;
// Do not try to delete the package if it's referenced anywhere
TArray<FName> ReferenceNames;
AssetRegistryModule.Get().GetReferencers(CurrentPackage->GetFName(), ReferenceNames, EAssetRegistryDependencyType::All );
if (ReferenceNames.Num() > 0)
continue;
bool bAssetDataSafeToDelete = true;
TArray<FAssetData> AssetsInPackage;
AssetRegistryModule.Get().GetAssetsByPackageName( CurrentPackage->GetFName(), AssetsInPackage );
for ( const auto& AssetInfo : AssetsInPackage )
{
// Check if the objects contained in the package are referenced by something that won't be garbage collected (*including* the undo buffer)
UObject* AssetInPackage = AssetInfo.GetAsset();
if (!AssetInPackage || AssetInPackage->IsPendingKill())
continue;
FReferencerInformationList ReferencesIncludingUndo;
bool bReferencedInMemoryOrUndoStack = IsReferenced( AssetInPackage, GARBAGE_COLLECTION_KEEPFLAGS, EInternalObjectFlags::GarbageCollectionKeepFlags, true, &ReferencesIncludingUndo );
if ( !bReferencedInMemoryOrUndoStack )
continue;
// We do have external references, check if the external references are in our ObjectToDelete list
// If they are, we can delete the asset because its references are going to be deleted as well.
for ( auto ExtRef : ReferencesIncludingUndo.ExternalReferences )
{
UObject* Outer = ExtRef.Referencer->GetOuter();
if (!Outer || Outer->IsPendingKill())
continue;
bool bOuterFound = false;
for ( auto DataToDelete : AssetDataToDelete )
{
if ( DataToDelete.GetPackage() == Outer )
{
bOuterFound = true;
break;
}
else if ( DataToDelete.GetAsset() == Outer )
{
bOuterFound = true;
break;
}
}
// We have at least one reference that's not going to be deleted, we have to keep the asset
if ( !bOuterFound )
{
bAssetDataSafeToDelete = false;
break;
}
}
}
if ( bAssetDataSafeToDelete )
AssetDataToDelete.Add( Data );
}
// Nothing to delete
if ( AssetDataToDelete.Num() <= 0 )
break;
int32 CurrentDeleted = ObjectTools::DeleteAssets( AssetDataToDelete, false );
/*
// DO NOT FORCE DELETE!!
// This will actually cause more problems than it solves
if ( CurrentDeleted <= 0 )
{
// Normal deletion failed... Try to force delete the objects?
TArray<UObject*> ObjectsToDelete;
for (int i = 0; i < AssetDataToDelete.Num(); i++)
{
const FAssetData& AssetData = AssetDataToDelete[i];
UObject *ObjectToDelete = AssetData.GetAsset();
// Assets can be loaded even when their underlying type/class no longer exists...
if ( ObjectToDelete && !ObjectToDelete->IsPendingKill() )
{
ObjectsToDelete.Add(ObjectToDelete);
}
}
CurrentDeleted = ObjectTools::ForceDeleteObjects(ObjectsToDelete, false);
}
*/
if ( CurrentDeleted > 0 )
{
DeletedCount += CurrentDeleted;
bDidDeleteAsset = true;
}
}
// Add a slate notification
Notification = TEXT("Deleted ") + FString::FromInt( DeletedCount ) + TEXT(" temporary files.");
FHoudiniEngineUtils::CreateSlateNotification( Notification );
// ... and a log message
HOUDINI_LOG_MESSAGE( TEXT("Deleted %d temporary files."), DeletedCount );
}
bool
FHoudiniEngineEditor::CanCleanUpTempFolder() const
{
return FHoudiniEngine::IsInitialized();
}
void
FHoudiniEngineEditor::BakeAllAssets()
{
// Add a slate notification
FString Notification = TEXT("Baking all assets in the current level...");
FHoudiniEngineUtils::CreateSlateNotification( Notification );
// Bakes and replaces with blueprints all Houdini Assets in the current level
int32 BakedCount = 0;
for (TObjectIterator<UHoudiniAssetComponent> Itr; Itr; ++Itr)
{
UHoudiniAssetComponent * HoudiniAssetComponent = *Itr;
if ( !HoudiniAssetComponent || HoudiniAssetComponent->IsPendingKill() )
{
HOUDINI_LOG_ERROR( TEXT( "Failed to bake a Houdini Asset in the scene! - Invalid Houdini Asset Component" ) );
continue;
}
if ( !HoudiniAssetComponent->IsComponentValid() )
{
FString AssetName = HoudiniAssetComponent->GetOuter() ? HoudiniAssetComponent->GetOuter()->GetName() : HoudiniAssetComponent->GetName();
if ( AssetName != "Default__HoudiniAssetActor" )
HOUDINI_LOG_ERROR( TEXT( "Failed to bake a Houdini Asset in the scene! - %s is invalid" ), *AssetName );
continue;
}
// If component is not cooking or instancing, we can bake blueprint.
if ( HoudiniAssetComponent->IsInstantiatingOrCooking() )
{
FString AssetName = HoudiniAssetComponent->GetOuter() ? HoudiniAssetComponent->GetOuter()->GetName() : HoudiniAssetComponent->GetName();
HOUDINI_LOG_ERROR(TEXT("Failed to bake a Houdini Asset in the scene! - %s is actively instantiating or cooking"), *AssetName);
continue;
}
bool bSuccess = false;
bool BakeToBlueprints = true;
if (BakeToBlueprints)
{
if (FHoudiniEngineBakeUtils::ReplaceHoudiniActorWithBlueprint(HoudiniAssetComponent))
bSuccess = true;
}
else
{
if (FHoudiniEngineBakeUtils::ReplaceHoudiniActorWithActors(HoudiniAssetComponent, false))
bSuccess = true;
}
if ( bSuccess )
BakedCount++;
}
// Add a slate notification
Notification = TEXT("Baked ") + FString::FromInt( BakedCount ) + TEXT(" Houdini assets.");
FHoudiniEngineUtils::CreateSlateNotification( Notification );
// ... and a log message
HOUDINI_LOG_MESSAGE( TEXT("Baked all %d Houdini assets in the current level."), BakedCount );
}
bool
FHoudiniEngineEditor::CanBakeAllAssets() const
{
if ( !FHoudiniEngine::IsInitialized() )
return false;
return true;
}
void
FHoudiniEngineEditor::PauseAssetCooking()
{
// Revert the global flag
bool CurrentEnableCookingGlobal = !FHoudiniEngine::Get().GetEnableCookingGlobal();
FHoudiniEngine::Get().SetEnableCookingGlobal( CurrentEnableCookingGlobal );
// Add a slate notification
FString Notification = TEXT("Houdini Engine cooking paused");
if ( CurrentEnableCookingGlobal )
Notification = TEXT("Houdini Engine cooking resumed");
FHoudiniEngineUtils::CreateSlateNotification( Notification );
// ... and a log message
if ( CurrentEnableCookingGlobal )
HOUDINI_LOG_MESSAGE( TEXT("Houdini Engine cooking resumed.") );
else
HOUDINI_LOG_MESSAGE( TEXT("Houdini Engine cooking paused.") );
if ( !CurrentEnableCookingGlobal )
return;
// If we are unpausing, tick each asset component to "update" them
for (TObjectIterator<UHoudiniAssetComponent> Itr; Itr; ++Itr)
{
UHoudiniAssetComponent * HoudiniAssetComponent = *Itr;
if (!HoudiniAssetComponent || HoudiniAssetComponent->IsPendingKill() || !HoudiniAssetComponent->IsValidLowLevel())
{
HOUDINI_LOG_ERROR( TEXT("Failed to cook a Houdini Asset in the scene!") );
continue;
}
HoudiniAssetComponent->StartHoudiniTicking();
}
}
bool
FHoudiniEngineEditor::CanPauseAssetCooking()
{
if ( !FHoudiniEngine::IsInitialized() )
return false;
return true;
}
bool
FHoudiniEngineEditor::IsAssetCookingPaused()
{
return !FHoudiniEngine::Get().GetEnableCookingGlobal();
}
void
FHoudiniEngineEditor::RecookSelection()
{
// Get current world selection
TArray<UObject*> WorldSelection;
int32 SelectedHoudiniAssets = FHoudiniEngineEditor::GetWorldSelection( WorldSelection, true );
if ( SelectedHoudiniAssets <= 0 )
{
HOUDINI_LOG_MESSAGE( TEXT( "No Houdini Assets selected in the world outliner" ) );
return;
}
// Add a slate notification
FString Notification = TEXT("Cooking selected Houdini Assets...");
FHoudiniEngineUtils::CreateSlateNotification( Notification );
// Iterates over the selection and cook the assets if they're in a valid state
int32 CookedCount = 0;
for ( int32 Idx = 0; Idx < SelectedHoudiniAssets; Idx++ )
{
AHoudiniAssetActor * HoudiniAssetActor = Cast<AHoudiniAssetActor>( WorldSelection[ Idx ] );
if ( !HoudiniAssetActor || HoudiniAssetActor->IsPendingKill() )
continue;
UHoudiniAssetComponent * HoudiniAssetComponent = HoudiniAssetActor->GetHoudiniAssetComponent();
if ( !HoudiniAssetComponent || HoudiniAssetComponent->IsPendingKill() || !HoudiniAssetComponent->IsComponentValid() )
continue;
HoudiniAssetComponent->StartTaskAssetCookingManual();
CookedCount++;
}
// Add a slate notification
Notification = TEXT("Re-cooked ") + FString::FromInt( CookedCount ) + TEXT(" Houdini assets.");
FHoudiniEngineUtils::CreateSlateNotification(Notification);
// ... and a log message
HOUDINI_LOG_MESSAGE( TEXT("Re-cooked %d selected Houdini assets."), CookedCount );
}
void
FHoudiniEngineEditor::RecookAllAssets()
{
// Add a slate notification
FString Notification = TEXT("Cooking all assets in the current level...");
FHoudiniEngineUtils::CreateSlateNotification(Notification);
// Bakes and replaces with blueprints all Houdini Assets in the current level
int32 CookedCount = 0;
for (TObjectIterator<UHoudiniAssetComponent> Itr; Itr; ++Itr)
{
UHoudiniAssetComponent * HoudiniAssetComponent = *Itr;
if (!HoudiniAssetComponent || HoudiniAssetComponent->IsPendingKill() || !HoudiniAssetComponent->IsComponentValid())
continue;
HoudiniAssetComponent->StartTaskAssetCookingManual();
CookedCount++;
}
// Add a slate notification
Notification = TEXT("Re-cooked ") + FString::FromInt( CookedCount ) + TEXT(" Houdini assets.");
FHoudiniEngineUtils::CreateSlateNotification( Notification );
// ... and a log message
HOUDINI_LOG_MESSAGE(TEXT("Re-cooked %d Houdini assets in the current level."), CookedCount );
}
void
FHoudiniEngineEditor::RebuildAllAssets()
{
// Add a slate notification
FString Notification = TEXT("Re-building all assets in the current level...");
FHoudiniEngineUtils::CreateSlateNotification(Notification);
// Bakes and replaces with blueprints all Houdini Assets in the current level
int32 RebuiltCount = 0;
for (TObjectIterator<UHoudiniAssetComponent> Itr; Itr; ++Itr)
{
UHoudiniAssetComponent * HoudiniAssetComponent = *Itr;
if ( !HoudiniAssetComponent || HoudiniAssetComponent->IsPendingKill() || !HoudiniAssetComponent->IsComponentValid() )
continue;
HoudiniAssetComponent->StartTaskAssetRebuildManual();
RebuiltCount++;
}
// Add a slate notification
Notification = TEXT("Rebuilt ") + FString::FromInt( RebuiltCount ) + TEXT(" Houdini assets.");
FHoudiniEngineUtils::CreateSlateNotification( Notification );
// ... and a log message
HOUDINI_LOG_MESSAGE(TEXT("Rebuilt %d Houdini assets in the current level."), RebuiltCount );
}
void
FHoudiniEngineEditor::RebuildSelection()
{
// Get current world selection
TArray<UObject*> WorldSelection;
int32 SelectedHoudiniAssets = FHoudiniEngineEditor::GetWorldSelection( WorldSelection, true );
if ( SelectedHoudiniAssets <= 0 )
{
HOUDINI_LOG_MESSAGE(TEXT("No Houdini Assets selected in the world outliner"));
return;
}
// Add a slate notification
FString Notification = TEXT("Rebuilding selected Houdini Assets...");
FHoudiniEngineUtils::CreateSlateNotification( Notification );
// Iterates over the selection and rebuilds the assets if they're in a valid state
int32 RebuiltCount = 0;
for ( int32 Idx = 0; Idx < SelectedHoudiniAssets; Idx++ )
{
AHoudiniAssetActor * HoudiniAssetActor = Cast<AHoudiniAssetActor>( WorldSelection[ Idx ] );
if ( !HoudiniAssetActor || HoudiniAssetActor->IsPendingKill() )
continue;
UHoudiniAssetComponent * HoudiniAssetComponent = HoudiniAssetActor->GetHoudiniAssetComponent();
if ( !HoudiniAssetComponent || HoudiniAssetComponent->IsPendingKill() || !HoudiniAssetComponent->IsComponentValid() )
continue;
HoudiniAssetComponent->StartTaskAssetRebuildManual();
RebuiltCount++;
}
// Add a slate notification
Notification = TEXT("Rebuilt ") + FString::FromInt( RebuiltCount ) + TEXT(" Houdini assets.");
FHoudiniEngineUtils::CreateSlateNotification( Notification );
// ... and a log message
HOUDINI_LOG_MESSAGE( TEXT("Rebuilt %d selected Houdini assets."), RebuiltCount );
}
void
FHoudiniEngineEditor::BakeSelection()
{
// Get current world selection
TArray<UObject*> WorldSelection;
int32 SelectedHoudiniAssets = FHoudiniEngineEditor::GetWorldSelection( WorldSelection, true );
if ( SelectedHoudiniAssets <= 0 )
{
HOUDINI_LOG_MESSAGE( TEXT("No Houdini Assets selected in the world outliner") );
return;
}
// Add a slate notification
FString Notification = TEXT("Baking selected Houdini Asset Actors in the current level...");
FHoudiniEngineUtils::CreateSlateNotification( Notification );
// Iterates over the selection and rebuilds the assets if they're in a valid state
int32 BakedCount = 0;
for ( int32 Idx = 0; Idx < SelectedHoudiniAssets; Idx++ )
{
AHoudiniAssetActor * HoudiniAssetActor = Cast<AHoudiniAssetActor>( WorldSelection[ Idx ] );
if ( !HoudiniAssetActor || HoudiniAssetActor->IsPendingKill() )
continue;
UHoudiniAssetComponent* HoudiniAssetComponent = HoudiniAssetActor->GetHoudiniAssetComponent();
if ( !HoudiniAssetComponent || HoudiniAssetComponent->IsPendingKill() )
{
HOUDINI_LOG_ERROR( TEXT("Failed to export a Houdini Asset in the scene!") );
continue;
}
if ( !HoudiniAssetComponent->IsComponentValid() )
{
FString AssetName = HoudiniAssetComponent->GetOuter() ? HoudiniAssetComponent->GetOuter()->GetName() : HoudiniAssetComponent->GetName();
HOUDINI_LOG_ERROR(TEXT("Failed to export Houdini Asset: %s in the scene!"), *AssetName);
continue;
}
// If component is not cooking or instancing, we can bake blueprint.
if ( !HoudiniAssetComponent->IsInstantiatingOrCooking() )
{
if ( FHoudiniEngineBakeUtils::ReplaceHoudiniActorWithBlueprint( HoudiniAssetComponent ) )
BakedCount++;
}
}
// Add a slate notification
Notification = TEXT("Baked ") + FString::FromInt(BakedCount) + TEXT(" Houdini assets.");
FHoudiniEngineUtils::CreateSlateNotification( Notification );
// ... and a log message
HOUDINI_LOG_MESSAGE(TEXT("Baked all %d Houdini assets in the current level."), BakedCount);
}
// Recentre HoudiniAsset actors' pivots to their input / cooked static-mesh average centre.
void FHoudiniEngineEditor::RecentreSelection()
{
#if WITH_EDITOR
//Get current world selection
TArray<UObject*> WorldSelection;
int32 SelectedHoudiniAssets = FHoudiniEngineEditor::GetWorldSelection(WorldSelection, true);
if (SelectedHoudiniAssets <= 0)
{
HOUDINI_LOG_MESSAGE(TEXT("No Houdini Assets selected in the world outliner"));
return;
}
// Add a slate notification
FString Notification = TEXT("Recentering selected Houdini Assets...");
FHoudiniEngineUtils::CreateSlateNotification(Notification);
// Iterates over the selection and cook the assets if they're in a valid state
int32 RecentreCount = 0;
for (int32 Idx = 0; Idx < SelectedHoudiniAssets; Idx++)
{
AHoudiniAssetActor * HoudiniAssetActor = Cast<AHoudiniAssetActor>(WorldSelection[Idx]);
if (!HoudiniAssetActor || HoudiniAssetActor->IsPendingKill())
continue;
UHoudiniAssetComponent * HoudiniAssetComponent = HoudiniAssetActor->GetHoudiniAssetComponent();
if (!HoudiniAssetComponent || !HoudiniAssetComponent->IsComponentValid())
continue;
// Get the average centre of all the created Static Meshes
FVector AverageBoundsCentre = FVector::ZeroVector;
int32 NumBounds = 0;
const FVector CurrentLocation = HoudiniAssetComponent->GetComponentLocation();
{
//Check Static Meshes
TArray<UStaticMesh*> StaticMeshes;
StaticMeshes.Reserve(16);
HoudiniAssetComponent->GetAllUsedStaticMeshes(StaticMeshes);
//Get average centre of all the static meshes.
for (const UStaticMesh* pMesh : StaticMeshes)
{
if (!pMesh)
continue;
//to world space
AverageBoundsCentre += (pMesh->GetBounds().Origin + CurrentLocation);
NumBounds++;
}
}
//Check Inputs
if (0 == NumBounds)
{
const TArray< UHoudiniAssetInput* >& AssetInputs = HoudiniAssetComponent->GetInputs();
for (const UHoudiniAssetInput* pInput : AssetInputs)
{
if (!pInput || pInput->IsPendingKill())
continue;
// to world space
FBox Bounds = pInput->GetInputBounds(CurrentLocation);
if (Bounds.IsValid)
{
AverageBoundsCentre += Bounds.GetCenter();
NumBounds++;
}
}
}
//if we have more than one, get the average centre
if (NumBounds > 1)
{
AverageBoundsCentre /= (float)NumBounds;
}
//if we need to move...
float fDist = FVector::DistSquared(CurrentLocation, AverageBoundsCentre);
if (NumBounds && fDist > 1.0f)
{
// Move actor to average centre and recook
// This will refresh the static mesh under the HoudiniAssestComponent ( undoing the translation ).
HoudiniAssetActor->SetActorLocation(AverageBoundsCentre, false, nullptr, ETeleportType::TeleportPhysics);
// Recook now the houdini-static-mesh has a new origin
HoudiniAssetComponent->StartTaskAssetCookingManual();
RecentreCount++;
}
}
if (RecentreCount)
{
// UE4 Editor doesn't refresh the translation-handles until they are re-selected, confusing the user, deselect the objects.
GEditor->SelectNone(true, false);
}
// Add a slate notification
Notification = TEXT("Re-centred ") + FString::FromInt(RecentreCount) + TEXT(" Houdini assets.");
FHoudiniEngineUtils::CreateSlateNotification(Notification);
// ... and a log message
HOUDINI_LOG_MESSAGE(TEXT("Re-centred %d selected Houdini assets."), RecentreCount);
#endif //WITH_EDITOR
}
int32
FHoudiniEngineEditor::GetContentBrowserSelection( TArray< UObject* >& ContentBrowserSelection )
{
ContentBrowserSelection.Empty();
// Get the current Content browser selection
FContentBrowserModule& ContentBrowserModule = FModuleManager::Get().LoadModuleChecked< FContentBrowserModule >( "ContentBrowser" );
TArray<FAssetData> SelectedAssets;
ContentBrowserModule.Get().GetSelectedAssets( SelectedAssets );
for( int32 n = 0; n < SelectedAssets.Num(); n++ )
{
// Get the current object
UObject * Object = SelectedAssets[ n ].GetAsset();
if ( !Object || Object->IsPendingKill() )
continue;
// Only static meshes are supported
if ( Object->GetClass() != UStaticMesh::StaticClass() )
continue;
ContentBrowserSelection.Add( Object );
}
return ContentBrowserSelection.Num();
}
int32
FHoudiniEngineEditor::GetWorldSelection( TArray< UObject* >& WorldSelection, bool bHoudiniAssetActorsOnly )
{
WorldSelection.Empty();
// Get the current editor selection
if ( GEditor )
{
USelection* SelectedActors = GEditor->GetSelectedActors();
if ( SelectedActors && !SelectedActors->IsPendingKill() )
{
for ( FSelectionIterator It( *SelectedActors ); It; ++It )
{
AActor * Actor = Cast< AActor >( *It );
if ( !Actor && Actor->IsPendingKill() )
continue;
// Ignore the SkySphere?
FString ClassName = Actor->GetClass() ? Actor->GetClass()->GetName() : FString();
if ( ClassName == TEXT( "BP_Sky_Sphere_C" ) )
continue;
// We're normally only selecting actors with StaticMeshComponents and SplineComponents
// Heightfields? Filter here or later? also allow HoudiniAssets?
WorldSelection.Add( Actor );
}
}
}
// If we only want Houdini Actors...
if ( bHoudiniAssetActorsOnly )
{
// ... remove all but them
for ( int32 Idx = WorldSelection.Num() - 1; Idx >= 0; Idx-- )
{
AHoudiniAssetActor * HoudiniAssetActor = Cast<AHoudiniAssetActor>( WorldSelection[ Idx ] );
if ( !HoudiniAssetActor || HoudiniAssetActor->IsPendingKill() )
WorldSelection.RemoveAt( Idx );
}
}
return WorldSelection.Num();
}
bool
FHoudiniEngineEditor::CanRestartSession() const
{
return true;
}
void
FHoudiniEngineEditor::RestartSession()
{
// Add a slate notification
FString Notification = TEXT("Restarting Current Houdini Session");
FHoudiniEngineUtils::CreateSlateNotification( Notification );
// Restart the current Houdini Engine Session
bool bSuccess = FHoudiniEngine::Get().RestartSession();
// Notify all the HoudiniAssetComponent that they need to reinstantiate themselves in the new session.
for ( TObjectIterator<UHoudiniAssetComponent> Itr; Itr; ++Itr )
{
UHoudiniAssetComponent * HoudiniAssetComponent = *Itr;
if ( !HoudiniAssetComponent || HoudiniAssetComponent->IsPendingKill() )
continue;
HoudiniAssetComponent->NotifyAssetNeedsToBeReinstantiated();
}
// Add a slate notification
if ( bSuccess )
Notification = TEXT("Houdini Session successfully restarted.");
else
Notification = TEXT("Failed to restart the current Houdini Session.");
FHoudiniEngineUtils::CreateSlateNotification(Notification);
// ... and a log message
//HOUDINI_LOG_MESSAGE( *Notification );
}
void
FHoudiniEngineEditor::AddLevelViewportMenuExtender()
{
FLevelEditorModule& LevelEditorModule = FModuleManager::Get().LoadModuleChecked<FLevelEditorModule>( "LevelEditor" );
auto& MenuExtenders = LevelEditorModule.GetAllLevelViewportContextMenuExtenders();
MenuExtenders.Add( FLevelEditorModule::FLevelViewportMenuExtender_SelectedActors::CreateRaw( this, &FHoudiniEngineEditor::GetLevelViewportContextMenuExtender ) );
LevelViewportExtenderHandle = MenuExtenders.Last().GetHandle();
}
void
FHoudiniEngineEditor::RemoveLevelViewportMenuExtender()
{
if ( LevelViewportExtenderHandle.IsValid() )
{
FLevelEditorModule* LevelEditorModule = FModuleManager::Get().GetModulePtr<FLevelEditorModule>("LevelEditor");
if ( LevelEditorModule )
{
typedef FLevelEditorModule::FLevelViewportMenuExtender_SelectedActors DelegateType;
LevelEditorModule->GetAllLevelViewportContextMenuExtenders().RemoveAll(
[=]( const DelegateType& In ) { return In.GetHandle() == LevelViewportExtenderHandle; } );
}
}
}
TSharedRef<FExtender>
FHoudiniEngineEditor::GetLevelViewportContextMenuExtender( const TSharedRef<FUICommandList> CommandList, const TArray<AActor*> InActors )
{
TSharedRef<FExtender> Extender = MakeShareable(new FExtender);
// Build an array of the HoudiniAssets corresponding to the selected actors
TArray< TWeakObjectPtr< UHoudiniAsset > > HoudiniAssets;
TArray< TWeakObjectPtr< AHoudiniAssetActor > > HoudiniAssetActors;
for ( auto CurrentActor : InActors )
{
AHoudiniAssetActor * HoudiniAssetActor = Cast<AHoudiniAssetActor>( CurrentActor );
if ( !HoudiniAssetActor || HoudiniAssetActor->IsPendingKill() )
continue;
HoudiniAssetActors.Add( HoudiniAssetActor );
UHoudiniAssetComponent* HoudiniAssetComponent = HoudiniAssetActor->GetHoudiniAssetComponent();
if ( !HoudiniAssetComponent || HoudiniAssetComponent->IsPendingKill() )
continue;
HoudiniAssets.AddUnique( HoudiniAssetComponent->GetHoudiniAsset() );
}
if ( HoudiniAssets.Num() > 0 )
{
// Add the Asset menu extension
if ( AssetTypeActions.Num() > 0 )
{
// Add the menu extensions via our HoudiniAssetTypeActions
FHoudiniAssetTypeActions * HATA = static_cast<FHoudiniAssetTypeActions*>( AssetTypeActions[0].Get() );
if ( HATA )
Extender = HATA->AddLevelEditorMenuExtenders( HoudiniAssets );
}
}
if ( HoudiniAssetActors.Num() > 0 )
{
// Add some actor menu extensions
FLevelEditorModule& LevelEditor = FModuleManager::GetModuleChecked<FLevelEditorModule>( TEXT("LevelEditor") );
TSharedRef<FUICommandList> LevelEditorCommandBindings = LevelEditor.GetGlobalLevelEditorActions();
Extender->AddMenuExtension(
"ActorControl",
EExtensionHook::After,
LevelEditorCommandBindings,
FMenuExtensionDelegate::CreateLambda( [ this, HoudiniAssetActors ]( FMenuBuilder& MenuBuilder )
{
MenuBuilder.AddMenuEntry(
NSLOCTEXT("HoudiniAssetLevelViewportContextActions", "HoudiniActor_Recentre", "Recentre selected"),
NSLOCTEXT("HoudiniAssetLevelViewportContextActions", "HoudiniActor_RecentreTooltip", "Recentres the selected Houdini Asset Actors pivots to their input/cooked static mesh average centre."),
FSlateIcon(FHoudiniEngineStyle::GetStyleSetName(), "HoudiniEngine.HoudiniEngineLogo"),
FUIAction(
FExecuteAction::CreateRaw(this, &FHoudiniEngineEditor::RecentreSelection),
FCanExecuteAction::CreateLambda([=] { return (HoudiniAssetActors.Num() > 0); })
)
);
MenuBuilder.AddMenuEntry(
NSLOCTEXT("HoudiniAssetLevelViewportContextActions", "HoudiniActor_Recook", "Recook selected"),
NSLOCTEXT("HoudiniAssetLevelViewportContextActions", "HoudiniActor_RecookTooltip", "Forces a recook on the selected Houdini Asset Actors."),
FSlateIcon( FHoudiniEngineStyle::GetStyleSetName(), "HoudiniEngine.HoudiniEngineLogo"),
FUIAction(
FExecuteAction::CreateRaw(this, &FHoudiniEngineEditor::RecookSelection ),
FCanExecuteAction::CreateLambda([=] { return ( HoudiniAssetActors.Num() > 0 ); })
)
);
MenuBuilder.AddMenuEntry(
NSLOCTEXT("HoudiniAssetLevelViewportContextActions", "HoudiniActor_Rebuild", "Rebuild selected"),
NSLOCTEXT("HoudiniAssetLevelViewportContextActions", "HoudiniActor_RebuildTooltip", "Rebuilds selected Houdini Asset Actors in the current level."),
FSlateIcon( FHoudiniEngineStyle::GetStyleSetName(), "HoudiniEngine.HoudiniEngineLogo"),
FUIAction(
FExecuteAction::CreateRaw(this, &FHoudiniEngineEditor::RebuildSelection ),
FCanExecuteAction::CreateLambda([=] { return ( HoudiniAssetActors.Num() > 0 ); })
)
);
} )
);
}
return Extender;
}
void
FHoudiniEngineEditor::GetAllHoudiniToolDirectories( TArray<FHoudiniToolDirectory>& HoudiniToolsDirectoryArray ) const
{
HoudiniToolsDirectoryArray.Empty();
// Read the default tools from the $HFS/engine/tool folder
FDirectoryPath DefaultToolPath;
FString HFSPath = FPaths::GetPath(FHoudiniEngine::Get().GetLibHAPILocation());
FString DefaultPath = FPaths::Combine(HFSPath, TEXT("engine"));
DefaultPath = FPaths::Combine(DefaultPath, TEXT("tools"));
FHoudiniToolDirectory ToolDir;
ToolDir.Name = TEXT("Default");
ToolDir.Path.Path = DefaultPath;
ToolDir.ContentDirID = TEXT("Default");
HoudiniToolsDirectoryArray.Add( ToolDir );
// Append all the custom tools directory from the runtime settings
UHoudiniRuntimeSettings * HoudiniRuntimeSettings = GetMutableDefault< UHoudiniRuntimeSettings >();
if ( !HoudiniRuntimeSettings )
return;
// We have to make sure all Custom tool dir have a ContentDirID
bool NeedToSave = false;
for (int32 n = 0; n < HoudiniRuntimeSettings->CustomHoudiniToolsLocation.Num(); n++ )
{
if (!HoudiniRuntimeSettings->CustomHoudiniToolsLocation[n].ContentDirID.IsEmpty())
continue;
// Generate a new Directory ID for that directory
HoudiniRuntimeSettings->CustomHoudiniToolsLocation[n].ContentDirID = ObjectTools::SanitizeObjectName(
HoudiniRuntimeSettings->CustomHoudiniToolsLocation[n].Name + TEXT(" ") + FGuid::NewGuid().ToString() );
NeedToSave = true;
}
if ( NeedToSave )
HoudiniRuntimeSettings->SaveConfig();
// Add all the custom tool paths
HoudiniToolsDirectoryArray.Append( HoudiniRuntimeSettings->CustomHoudiniToolsLocation );
}
void
FHoudiniEngineEditor::GetHoudiniToolDirectories(const int32& SelectedDirIndex, TArray<FHoudiniToolDirectory>& HoudiniToolsDirectoryArray) const
{
HoudiniToolsDirectoryArray.Empty();
// Get All the houdini tool directories
GetAllHoudiniToolDirectories(HoudiniToolsDirectoryArray);
// Only keep the selected one
// -1 indicates we want all directories
if ( SelectedDirIndex >= 0 )
{
for (int32 n = HoudiniToolsDirectoryArray.Num() - 1; n >= 0; n--)
{
if (n != CurrentHoudiniToolDirIndex)
HoudiniToolsDirectoryArray.RemoveAt(n);
}
}
}
void
FHoudiniEngineEditor::UpdateHoudiniToolList(const int32 SelectedDir/*=-1*/)
{
CurrentHoudiniToolDirIndex = SelectedDir;
// Clean up the existing tool list
HoudiniTools.Empty();
// Get All the houdini tool directories
TArray<FHoudiniToolDirectory> HoudiniToolsDirectoryArray;
GetHoudiniToolDirectories( SelectedDir, HoudiniToolsDirectoryArray );
// Add the tools for all the directories
for ( int32 n = 0; n < HoudiniToolsDirectoryArray.Num(); n++ )
{
FHoudiniToolDirectory CurrentDir = HoudiniToolsDirectoryArray[n];
bool isDefault = ( (n == 0) && (CurrentHoudiniToolDirIndex <= 0) );
UpdateHoudiniToolList( CurrentDir, isDefault );
}
}
void
FHoudiniEngineEditor::UpdateHoudiniToolList(const FHoudiniToolDirectory& HoudiniToolsDirectory, const bool& isDefault)
{
FString ToolDirPath = HoudiniToolsDirectory.Path.Path;
if ( ToolDirPath.IsEmpty() )
return;
// We need to either load or create a new HoudiniAsset from the tool's HDA
FString ToolPath = TEXT("/Game/HoudiniEngine/Tools/");
ToolPath = FPaths::Combine(ToolPath, HoudiniToolsDirectory.ContentDirID );
ToolPath = ObjectTools::SanitizeObjectPath(ToolPath);
// List all the json files in the current directory
TArray<FString> JSONFiles;
IFileManager::Get().FindFiles(JSONFiles, *ToolDirPath, TEXT(".json"));
for ( const FString& CurrentJsonFile : JSONFiles )
{
FString CurrentToolName;
EHoudiniToolType CurrentToolType;
EHoudiniToolSelectionType CurrentToolSelectionType;
FString CurrentToolToolTip;
FFilePath CurrentToolIconPath;
FFilePath CurrentToolAssetPath;
FString CurrentToolHelpURL;
// Extract the Tool info from the JSON file
FString CurrentJsonFilePath = ToolDirPath / CurrentJsonFile;
if ( !GetHoudiniToolDescriptionFromJSON(
CurrentJsonFilePath, CurrentToolName, CurrentToolType, CurrentToolSelectionType,
CurrentToolToolTip, CurrentToolIconPath, CurrentToolAssetPath, CurrentToolHelpURL))
continue;
FText ToolName = FText::FromString(CurrentToolName);
FText ToolTip = FText::FromString(CurrentToolToolTip);
FString IconPath = FPaths::ConvertRelativePathToFull(CurrentToolIconPath.FilePath);
const FSlateBrush* CustomIconBrush = nullptr;
if (FPaths::FileExists(IconPath))
{
FName BrushName = *IconPath;
CustomIconBrush = new FSlateDynamicImageBrush(BrushName, FVector2D(40.f, 40.f));
}
else
{
CustomIconBrush = FHoudiniEngineStyle::Get()->GetBrush(TEXT("HoudiniEngine.HoudiniEngineLogo40"));
}
// Construct the asset's ref
FString BaseToolName = ObjectTools::SanitizeObjectName( FPaths::GetBaseFilename( CurrentToolAssetPath.FilePath ) );
FString ToolAssetRef = TEXT("HoudiniAsset'") + FPaths::Combine(ToolPath, BaseToolName) + TEXT(".") + BaseToolName + TEXT("'");
TSoftObjectPtr<UHoudiniAsset> HoudiniAsset(ToolAssetRef);
// See if the HDA needs to be imported in Unreal, or just loaded
bool NeedsImport = false;
if ( !HoudiniAsset.IsValid() )
{
NeedsImport = true;
// Try to load the asset
UHoudiniAsset* LoadedAsset = HoudiniAsset.LoadSynchronous();
if ( LoadedAsset && !LoadedAsset->IsPendingKill() )
NeedsImport = !HoudiniAsset.IsValid();
}
if ( NeedsImport )
{
// Automatically import the HDA and create a uasset for it
FAssetToolsModule& AssetToolsModule = FModuleManager::Get().LoadModuleChecked<FAssetToolsModule>("AssetTools");
TArray<FString> FileNames;
FileNames.Add(CurrentToolAssetPath.FilePath);
UAutomatedAssetImportData* ImportData = NewObject<UAutomatedAssetImportData>();
ImportData->bReplaceExisting = true;
ImportData->bSkipReadOnly = true;
ImportData->Filenames = FileNames;
ImportData->DestinationPath = ToolPath;
TArray<UObject*> AssetArray = AssetToolsModule.Get().ImportAssetsAutomated(ImportData);
if ( AssetArray.Num() <= 0 )
continue;
HoudiniAsset = Cast< UHoudiniAsset >(AssetArray[0]);
if (!HoudiniAsset || HoudiniAsset->IsPendingKill() )
continue;
// Try to save the newly created package
UPackage* Pckg = Cast<UPackage>( HoudiniAsset->GetOuter() );
if (Pckg && !Pckg->IsPendingKill() && Pckg->IsDirty() )
{
Pckg->FullyLoad();
UPackage::SavePackage(
Pckg, nullptr, EObjectFlags::RF_Public | EObjectFlags::RF_Standalone,
*FPackageName::LongPackageNameToFilename( Pckg->GetName(), FPackageName::GetAssetPackageExtension() ) );
}
}
// Add the tool to the tool list
HoudiniTools.Add( MakeShareable( new FHoudiniTool(
HoudiniAsset, ToolName, CurrentToolType, CurrentToolSelectionType, ToolTip, CustomIconBrush, CurrentToolHelpURL, isDefault, CurrentToolAssetPath, HoudiniToolsDirectory, CurrentJsonFile ) ) );
}
}
bool
FHoudiniEngineEditor::GetHoudiniToolDescriptionFromJSON(const FString& JsonFilePath,
FString& OutName, EHoudiniToolType& OutType, EHoudiniToolSelectionType& OutSelectionType,
FString& OutToolTip, FFilePath& OutIconPath, FFilePath& OutAssetPath, FString& OutHelpURL )
{
if ( JsonFilePath.IsEmpty() )
return false;
// Read the file as a string
FString FileContents;
if ( !FFileHelper::LoadFileToString( FileContents, *JsonFilePath ) )
{
HOUDINI_LOG_ERROR( TEXT("Failed to import Houdini Tool .json file: %s"), *JsonFilePath);
return false;
}
// Parse it as JSON
TSharedPtr<FJsonObject> JSONObject;
TSharedRef< TJsonReader<> > Reader = TJsonReaderFactory<>::Create( FileContents );
if (!FJsonSerializer::Deserialize(Reader, JSONObject) || !JSONObject.IsValid())
{
HOUDINI_LOG_ERROR( TEXT("Invalid json in Houdini Tool .json file: %s"), *JsonFilePath);
return false;
}
// First, check that the tool is compatible with UE4
bool IsCompatible = true;
if (JSONObject->HasField(TEXT("target")))
{
IsCompatible = false;
TArray<TSharedPtr<FJsonValue> >TargetArray = JSONObject->GetArrayField("target");
for (TSharedPtr<FJsonValue> TargetValue : TargetArray)
{
if ( !TargetValue.IsValid() )
continue;
// Check the target array field contains either "all" or "unreal"
FString TargetString = TargetValue->AsString();
if ( TargetString.Equals( TEXT("all"), ESearchCase::IgnoreCase )
|| TargetString.Equals(TEXT("unreal"), ESearchCase::IgnoreCase) )
{
IsCompatible = true;
break;
}
}
}
if ( !IsCompatible )
{
// The tool is not compatible with unreal, skip it
HOUDINI_LOG_MESSAGE( TEXT("Skipped Houdini Tool due to invalid target in JSON file: %s"), *JsonFilePath );
return false;
}
// Then, we need to make sure the json file has a correponding hda
// Start by looking at the assetPath field
FString HDAFilePath = FString();
if ( JSONObject->HasField( TEXT("assetPath") ) )
{
// If the json has the assetPath field, read it from there
HDAFilePath = JSONObject->GetStringField(TEXT("assetPath"));
if (!FPaths::FileExists(HDAFilePath))
HDAFilePath = FString();
}
if (HDAFilePath.IsEmpty())
{
// Look for an hda file with the same name as the json file
HDAFilePath = JsonFilePath.Replace(TEXT(".json"), TEXT(".hda"));
if (!FPaths::FileExists(HDAFilePath))
{
// Try .hdalc
HDAFilePath = JsonFilePath.Replace(TEXT(".json"), TEXT(".hdalc"));
if (!FPaths::FileExists(HDAFilePath))
{
// Try .hdanc
HDAFilePath = JsonFilePath.Replace(TEXT(".json"), TEXT(".hdanc"));
if (!FPaths::FileExists(HDAFilePath))
HDAFilePath = FString();
}
}
}
if ( HDAFilePath.IsEmpty() )
{
HOUDINI_LOG_ERROR(TEXT("Could not find the hda for the Houdini Tool .json file: %s"), *JsonFilePath);
return false;
}
// Create a new asset.
OutAssetPath = FFilePath{ HDAFilePath };
// Read the tool name
OutName = FPaths::GetBaseFilename(JsonFilePath);
if ( JSONObject->HasField(TEXT("name") ) )
OutName = JSONObject->GetStringField(TEXT("name"));
// Read the tool type
OutType = EHoudiniToolType::HTOOLTYPE_OPERATOR_SINGLE;
if ( JSONObject->HasField( TEXT("toolType") ) )
{
FString ToolType = JSONObject->GetStringField(TEXT("toolType"));
if ( ToolType.Equals( TEXT("GENERATOR"), ESearchCase::IgnoreCase ) )
OutType = EHoudiniToolType::HTOOLTYPE_GENERATOR;
else if (ToolType.Equals( TEXT("OPERATOR_SINGLE"), ESearchCase::IgnoreCase ) )
OutType = EHoudiniToolType::HTOOLTYPE_OPERATOR_SINGLE;
else if (ToolType.Equals(TEXT("OPERATOR_MULTI"), ESearchCase::IgnoreCase))
OutType = EHoudiniToolType::HTOOLTYPE_OPERATOR_MULTI;
else if (ToolType.Equals(TEXT("BATCH"), ESearchCase::IgnoreCase))
OutType = EHoudiniToolType::HTOOLTYPE_OPERATOR_BATCH;
}
// Read the tooltip
OutToolTip = FString();
if ( JSONObject->HasField( TEXT("toolTip") ) )
{
OutToolTip = JSONObject->GetStringField(TEXT("toolTip"));
}
// Read the help url
OutHelpURL = FString();
if (JSONObject->HasField(TEXT("helpURL")))
{
OutHelpURL = JSONObject->GetStringField(TEXT("helpURL"));
}
// Read the icon path
FString IconPath = FString();
if (JSONObject->HasField(TEXT("iconPath")))
{
// If the json has the iconPath field, read it from there
IconPath = JSONObject->GetStringField(TEXT("iconPath"));
if (!FPaths::FileExists(IconPath))
IconPath = FString();
}
if (IconPath.IsEmpty())
{
// Look for a png file with the same name as the json file
IconPath = JsonFilePath.Replace(TEXT(".json"), TEXT(".png"));
if (!FPaths::FileExists(IconPath))
{
IconPath = GetDefaultHoudiniToolIcon();
}
}
OutIconPath = FFilePath{ IconPath };
// Read the selection types
FString SelectionType = TEXT("All");
if ( JSONObject->HasField(TEXT("UE_SelectionType")) )
SelectionType = JSONObject->GetStringField( TEXT("UE_SelectionType") );
if ( SelectionType.Equals( TEXT("CB"), ESearchCase::IgnoreCase ) )
OutSelectionType = EHoudiniToolSelectionType::HTOOL_SELECTION_CB_ONLY;
else if ( SelectionType.Equals( TEXT("World"), ESearchCase::IgnoreCase ) )
OutSelectionType = EHoudiniToolSelectionType::HTOOL_SELECTION_WORLD_ONLY;
else
OutSelectionType = EHoudiniToolSelectionType::HTOOL_SELECTION_ALL;
// TODO: Handle Tags in the JSON?
return true;
}
bool
FHoudiniEngineEditor::WriteJSONFromHoudiniTool(const FHoudiniTool& Tool)
{
// Start by building a JSON object from the tool
TSharedPtr<FJsonObject> JSONObject = MakeShareable(new FJsonObject);
// Mark the target as unreal only
TArray< TSharedPtr<FJsonValue> > TargetValue;
TargetValue.Add(MakeShareable(new FJsonValueString(TEXT("unreal"))));
JSONObject->SetArrayField(TEXT("target"), TargetValue );
// Write the asset Path
if (!Tool.SourceAssetPath.FilePath.IsEmpty())
{
// Only write the assetPath if it's different from the default one (same path as JSON)
if (FPaths::GetBaseFilename(Tool.SourceAssetPath.FilePath) != (FPaths::GetBaseFilename(Tool.JSONFile))
&& (FPaths::GetPath(Tool.SourceAssetPath.FilePath) != Tool.ToolDirectory.Path.Path))
{
JSONObject->SetStringField(TEXT("assetPath"), FPaths::ConvertRelativePathToFull(Tool.SourceAssetPath.FilePath));
}
}
// The Tool Name
if ( !Tool.Name.IsEmpty() )
JSONObject->SetStringField(TEXT("name"), Tool.Name.ToString());
// Tooltype
FString ToolType = TEXT("GENERATOR");
if ( Tool.Type == EHoudiniToolType::HTOOLTYPE_OPERATOR_SINGLE)
ToolType = TEXT("OPERATOR_SINGLE");
else if (Tool.Type == EHoudiniToolType::HTOOLTYPE_OPERATOR_MULTI)
ToolType = TEXT("OPERATOR_MULTI");
else if ( Tool.Type == EHoudiniToolType::HTOOLTYPE_OPERATOR_BATCH)
ToolType = TEXT("BATCH");
JSONObject->SetStringField(TEXT("toolType"), ToolType);
// Tooltip
if ( !Tool.ToolTipText.IsEmpty() )
JSONObject->SetStringField(TEXT("toolTip"), Tool.ToolTipText.ToString());
// Help URL
if ( !Tool.HelpURL.IsEmpty() )
JSONObject->SetStringField(TEXT("helpURL"), Tool.HelpURL);
// IconPath
if ( Tool.Icon )
{
FString IconPath = Tool.Icon->GetResourceName().ToString();
JSONObject->SetStringField(TEXT("iconPath"), IconPath);
}
// Selection Type
FString SelectionType = TEXT("All");
if (Tool.SelectionType == EHoudiniToolSelectionType::HTOOL_SELECTION_CB_ONLY)
SelectionType = TEXT("CB");
else if (Tool.SelectionType == EHoudiniToolSelectionType::HTOOL_SELECTION_WORLD_ONLY)
SelectionType = TEXT("World");
JSONObject->SetStringField(TEXT("UE_SelectionType"), SelectionType);
FString ToolJSONFilePath = Tool.ToolDirectory.Path.Path / Tool.JSONFile;
// Output the JSON to a String
FString OutputString;
TSharedRef< TJsonWriter<> > Writer = TJsonWriterFactory<>::Create(&OutputString);
FJsonSerializer::Serialize(JSONObject.ToSharedRef(), Writer);
// Then write the output string to the json file itself
FString SaveDirectory = Tool.ToolDirectory.Path.Path;
FString FileName = Tool.JSONFile;
IPlatformFile& PlatformFile = FPlatformFileManager::Get().GetPlatformFile();
// Returns true if the directory existed or has been created
if ( PlatformFile.CreateDirectoryTree(*SaveDirectory) )
{
FString AbsoluteFilePath = SaveDirectory / FileName;
return FFileHelper::SaveStringToFile(OutputString, *AbsoluteFilePath);
}
return false;
}
bool
FHoudiniEngineEditor::FindHoudiniTool( const FHoudiniTool& Tool, int32& FoundIndex, bool& IsDefault )
{
// Return -1 if we cant find the Tool
FoundIndex = -1;
for ( int32 Idx = 0; Idx < HoudiniTools.Num(); Idx++ )
{
TSharedPtr<FHoudiniTool> Current = HoudiniTools[ Idx ];
if ( !Current.IsValid() )
continue;
if ( Current->HoudiniAsset != Tool.HoudiniAsset )
continue;
if ( Current->Type != Tool.Type )
continue;
if ( Current->JSONFile != Tool.JSONFile )
continue;
if (Current->ToolDirectory != Tool.ToolDirectory)
continue;
// We found the Houdini Tool
IsDefault = Current->DefaultTool;
FoundIndex = Idx;
return true;
}
return false;
}
bool
FHoudiniEngineEditor::FindHoudiniToolInHoudiniSettings( const FHoudiniTool& Tool, int32& FoundIndex )
{
// Return -1 if we cant find the Tool
FoundIndex = -1;
// Remove the tool from the runtime settings
const UHoudiniRuntimeSettings * HoudiniRuntimeSettings = GetDefault< UHoudiniRuntimeSettings >();
if ( !HoudiniRuntimeSettings )
return false;
// TODO: FIX ME!
/*
for ( int32 Idx = 0; Idx < HoudiniRuntimeSettings->CustomHoudiniTools.Num(); Idx++ )
{
FHoudiniToolDescription CurrentDesc = HoudiniRuntimeSettings->CustomHoudiniTools[ Idx ];
if ( CurrentDesc.HoudiniAsset != Tool.HoudiniAsset )
continue;
if ( CurrentDesc.Type != Tool.Type )
continue;
FoundIndex = Idx;
return true;
}
*/
return false;
}
void
FHoudiniEngineCommands::RegisterCommands()
{
UI_COMMAND( OpenInHoudini, "Open scene in Houdini", "Opens the current Houdini scene in Houdini.", EUserInterfaceActionType::Button, FInputChord( EKeys::O, EModifierKey::Control | EModifierKey::Alt) );
UI_COMMAND( SaveHIPFile, "Save Houdini scene (HIP)", "Saves a .hip file of the current Houdini scene.", EUserInterfaceActionType::Button, FInputChord() );
UI_COMMAND( ReportBug, "Report a plugin bug", "Report a bug for Houdini Engine plugin.", EUserInterfaceActionType::Button, FInputChord() );
UI_COMMAND( CleanUpTempFolder, "Clean Houdini Engine Temp Folder", "Deletes the unused temporary files in the Temporary Cook Folder.", EUserInterfaceActionType::Button, FInputChord() );
UI_COMMAND( BakeAllAssets, "Bake And Replace All Houdini Assets", "Bakes and replaces with blueprints all Houdini Assets in the scene.", EUserInterfaceActionType::Button, FInputChord() );
UI_COMMAND( PauseAssetCooking, "Pause Houdini Engine Cooking", "When activated, prevents Houdini Engine from cooking assets until unpaused.", EUserInterfaceActionType::Check, FInputChord( EKeys::P, EModifierKey::Control | EModifierKey::Alt ) );
UI_COMMAND( CookSelec, "Recook Selection", "Recooks selected Houdini Asset Actors in the current level.", EUserInterfaceActionType::Button, FInputChord( EKeys::C, EModifierKey::Control | EModifierKey::Alt ) );
UI_COMMAND( RebuildSelec, "Rebuild Selection", "Rebuilds selected Houdini Asset Actors in the current level.", EUserInterfaceActionType::Button, FInputChord( EKeys::R, EModifierKey::Control | EModifierKey::Alt ) );
UI_COMMAND( BakeSelec, "Bake Selection", "Bakes and replaces with blueprints selected Houdini Asset Actors in the current level.", EUserInterfaceActionType::Button, FInputChord( EKeys::B, EModifierKey::Control | EModifierKey::Alt ) );
UI_COMMAND( RestartSession, "Restart the Houdini Engine Session", "Restarts the current Houdini Engine session.", EUserInterfaceActionType::Button, FInputChord());
}
#undef LOCTEXT_NAMESPACE
View Git Blame Copy Permalink