Finish v1.0-r6

README.md

@@ -9,7 +9,7 @@ The plugin is designed to work with **sprite sheet data** exported from [Texture
 
 Check the [Wiki](https://hiazma.atlassian.net/wiki/display/VTA/) for plugin usage examples and installation notes.
 
-Current version: **1.0 R 5** (UE 4.19-4.20)
+Current version: **1.0 R 6** (UE 4.19-4.21)
 
 ![SCREENSHOT](SCREENSHOT.jpg)
 

Source/VaTexAtlasEditorPlugin/Classes/VtaEditorPluginSettings.h

@@ -21,4 +21,7 @@ class UVtaEditorPluginSettings : public UObject
 	/** Generate material instances */
 	UPROPERTY(Config, EditAnywhere)
 	bool bUseMultiAtlas;
+
+	UPROPERTY(Config, EditAnywhere)
+	bool bUseNewAtlasAsset;
 };

Source/VaTexAtlasEditorPlugin/Classes/VtaTextureAtlasAsset.h

@@ -0,0 +1,53 @@
+// Copyright 2016 Vladimir Alyamkin. All Rights Reserved.
+
+#pragma once
+#include "VtaTextureAtlasDataModel.h"
+#include "VtaAsset.h"
+#include "VtaTextureAtlasAsset.generated.h"
+
+UCLASS(meta = (DisplayThumbnail = "true"))
+class VATEXATLASEDITORPLUGIN_API UVtaTextureAtlasAsset: public UObject
+{
+	GENERATED_BODY()
+public:
+	UVtaTextureAtlasAsset();
+
+	UPROPERTY(VisibleAnywhere, Category = "Texture Atlas Asset")
+	FString AtlasName;
+
+	UPROPERTY(VisibleAnywhere, Category = "Texture Atlas Asset")
+	FString ImportPath;
+
+	UPROPERTY(VisibleAnywhere, Category = "Texture Atlas Asset")
+	uint32 bIsMultipack : 1;
+
+	UPROPERTY(VisibleAnywhere, Category = "Texture Atlas Asset")
+	TEnumAsByte<TextureCompressionSettings> TextureCompressionSetting;
+
+	UPROPERTY(VisibleAnywhere, Category = "Texture Atlas Asset")
+	TMap<FString, FVtaDataFile> ImportedData;
+
+	UPROPERTY(VisibleAnywhere, Category = "Texture Atlas Asset")
+	TMap< FString, class UTexture2D* > Textures;
+
+	UPROPERTY(VisibleAnywhere, Category = "Texture Atlas Asset")
+	TMap< FString, FVtaAsset > Frames;
+
+	UPROPERTY(VisibleAnywhere, Category = "Texture Atlas Asset")
+	class UDataTable* DataTable;
+
+	class UTexture2D* GetTexture(const FString& Name);
+	FVtaAsset* GetFrame(const FString& Name);
+
+#if WITH_EDITORONLY_DATA
+	// Import data for this 
+	UPROPERTY(VisibleAnywhere, Instanced, Category = ImportSettings)
+	class UAssetImportData* AssetImportData;
+
+	// UObject interface
+	virtual void PostInitProperties() override;
+	virtual void GetAssetRegistryTags(TArray<FAssetRegistryTag>& OutTags) const override;
+	virtual void Serialize(FArchive& Ar) override;
+	// End of UObject interface
+#endif
+};

Source/VaTexAtlasEditorPlugin/Classes/VtaTextureAtlasAssetActions.h

@@ -0,0 +1,24 @@
+// Copyright 2016 Vladimir Alyamkin. All Rights Reserved.
+
+#pragma once
+#include "AssetTypeActions_Base.h"
+
+/**
+* VtaTextureAtlasAsset actions
+*/
+class VATEXATLASEDITORPLUGIN_API FVtaTextureAtlasAssetActions : public FAssetTypeActions_Base
+{
+
+public:
+	// IAssetTypeActions interface
+	virtual FText GetName() const override;
+	virtual FColor GetTypeColor() const override;
+	virtual UClass* GetSupportedClass() const override;
+	virtual bool HasActions(const TArray<UObject*>& InObjects) const override { return true; }
+	virtual void GetActions(const TArray<UObject*>& InObjects, FMenuBuilder& MenuBuilder) override;
+	virtual uint32 GetCategories() override;
+	virtual bool IsImportedAsset() const override;
+	virtual void GetResolvedSourceFilePaths(const TArray<UObject*>& TypeAssets, TArray<FString>& OutSourceFilePaths) const override;
+	// End of IAssetTypeActions interface
+
+};

Source/VaTexAtlasEditorPlugin/Classes/VtaTextureAtlasAssetImportFactory.h

@@ -0,0 +1,48 @@
+// Copyright 2016 Vladimir Alyamkin. All Rights Reserved.
+
+#pragma once
+#include "Factories/Factory.h"
+#include "EditorReimportHandler.h"
+#include "VtaAsset.h"
+#include "VtaTextureAtlasAssetImportFactory.generated.h"
+
+UCLASS()
+class VATEXATLASEDITORPLUGIN_API UVtaTextureAtlasAssetImportFactory final: public UFactory, public FReimportHandler
+{
+	GENERATED_BODY()
+
+public:
+	UVtaTextureAtlasAssetImportFactory();
+
+	// Begin UFactory interface
+	virtual bool FactoryCanImport(const FString& Filename) override;
+	virtual FText GetToolTip() const override;
+	virtual UObject* FactoryCreateFile(UClass* InClass, UObject* InParent, FName InName, EObjectFlags Flags, const FString& Filename, const TCHAR* Parms, FFeedbackContext* Warn, bool& bOutOperationCanceled) override;
+	virtual void Cleanup() { CurrentAtlas = nullptr; }
+	// End UFactory interface
+
+	// Begin ReimportHandler interface
+	virtual bool CanReimport(UObject* Obj, TArray<FString>& OutFilenames) override;
+	virtual void SetReimportPaths(UObject* Obj, const TArray<FString>& NewReimportPaths) override;
+	virtual EReimportResult::Type Reimport(UObject* Obj) override;
+	virtual const UObject* GetFactoryObject() const override { return this; }
+	// End ReimportHandler interface
+
+private:
+	UPROPERTY(Transient)
+	class UVtaTextureAtlasAsset* CurrentAtlas;
+
+	static bool SplitMultipackAtlasName(const FString& Filename, FString& OutAtlasName, int32& OutIndex);
+
+	static TSharedPtr<class FJsonObject> ParseJSON(const FString& FileName);
+	static bool ImportAtlas(class UVtaTextureAtlasAsset* Atlas, FFeedbackContext* Warn);
+
+	static UObject* CreateAsset(UClass* Class, const FString& TargetPath, const FString& Name, EObjectFlags Flags);
+	static UObject* ImportAsset(const FString& SourceFilename, const FString& TargetPath);
+	static UObject* FindAsset(UClass* AssetClass, const FString& Path, const FString& Name);
+
+	static class UTexture2D* ProcessTexture(class UVtaTextureAtlasAsset* Atlas, const FString& TextureName);
+	static FVtaAsset ProcessFrame(class UVtaTextureAtlasAsset* Atlas, class UTexture2D* AtlasTexture, const struct FVtaMeta& Meta, const struct FVtaFrame& Frame);
+
+	static FString GetNormalizedFrameName(const FString& Name);
+};

Source/VaTexAtlasEditorPlugin/Classes/VtaTextureAtlasDataModel.h

@@ -137,7 +137,7 @@ struct FVtaDataFile
 {
 public:
 	GENERATED_USTRUCT_BODY()
-
+		
 	UPROPERTY(VisibleAnywhere, Category = "VaTexAtlas")
 	FVtaMeta Meta;
 

Source/VaTexAtlasEditorPlugin/Classes/VtaTextureAtlasImportFactory.h

@@ -32,7 +32,7 @@ class VATEXATLASEDITORPLUGIN_API UVtaTextureAtlasImportFactory : public UFactory
 	static UTexture2D* ImportTexture(const FString& SourceFilename, const FString& TargetSubPath);
 	static UTexture2D* ImportOrReimportTexture(UTexture2D* ExistingTexture, const FString& SourceFilename, const FString& TargetSubPath);
 
-	void ImportOrReimportDataTable(UVtaTextureAtlas* TextureAtlas, const FString& TargetPath, const FString& DesiredName, EObjectFlags Flags);
+	void ImportOrReimportDataTable(UVtaTextureAtlas* TextureAtlas, const FString& TargetPath, const FString& DesiredName, EObjectFlags Flags, bool bUseExistingTable = true);
 	void ImportOrReimportMultiAtlasDataTable(const FString& TargetPath, const FString& MultiAtlasName, EObjectFlags Flags);
 
 	static FString BuildFrameName(const FString& AtlasName, const FString& FrameName);
@@ -42,6 +42,7 @@ class VATEXATLASEDITORPLUGIN_API UVtaTextureAtlasImportFactory : public UFactory
 	// Reimport (used by derived class to provide existing data)
 
 protected:
+	void SetMultipackFrames(const FString& Path, const FString& MultuipackName);
 	void SetReimportData(UVtaTextureAtlas* TextureAtlas);
 	void ResetImportData();
 	UMaterialInstanceConstant* FindExistingFrame(const FString& Name);
@@ -50,6 +51,8 @@ class VATEXATLASEDITORPLUGIN_API UVtaTextureAtlasImportFactory : public UFactory
 	UMaterialInstanceConstant* FindMaterialByFrameName(const FString& Name, TArray<TSoftObjectPtr<UMaterialInstanceConstant>> List);
 	UVtaSlateTexture* FindSlateTextureByFrameName(const FString& Name, TArray<TSoftObjectPtr<UVtaSlateTexture>> List);
 
+	UMaterialInstanceConstant* FindMaterialOnDisk(const FString& Path, const FString& Name);
+	UVtaSlateTexture* FindSlateTextureOnDisk(const FString& Path, const FString& Name);
 
 protected:
 	bool bIsReimporting;
@@ -69,5 +72,8 @@ class VATEXATLASEDITORPLUGIN_API UVtaTextureAtlasImportFactory : public UFactory
 
 	/** Map of a slate texture name (as seen in the importer) -> UVtaSlateTexture */
 	TMap<FString, UVtaSlateTexture*> ExistingSlateTextures;
+
+	/** Existing frames in multipack atlases */
+	TMap< FString, UVtaTextureAtlas* > MultipackFrames;
 
 };

Source/VaTexAtlasEditorPlugin/Private/VtaEditorPlugin.cpp

@@ -10,6 +10,7 @@
 #include "VtaSlateTextureThumbnailRenderer.h"
 #include "VtaEditorPluginSettings.h"
 #include "VtaTextureAtlasAssetTypeActions.h"
+#include "VtaTextureAtlasAssetActions.h"
 
 #define LOCTEXT_NAMESPACE "VaTexAtlasEditorPlugin"
 
@@ -24,6 +25,10 @@ class FVaTexAtlasEditorPlugin : public IVaTexAtlasEditorPlugin
 		TextureAtlasAssetTypeActions = MakeShareable(new FVtaTextureAtlasAssetTypeActions);
 		AssetTools.RegisterAssetTypeActions(TextureAtlasAssetTypeActions.ToSharedRef());
 
+		/** New texture atlas asset actions */
+		TextureAtlasAssetActions = MakeShareable(new FVtaTextureAtlasAssetActions);
+		AssetTools.RegisterAssetTypeActions(TextureAtlasAssetActions.ToSharedRef());
+
 		// Registration thumbnail renderer for slate texture
 		UThumbnailManager::Get().RegisterCustomRenderer(UVtaSlateTexture::StaticClass(), UVtaSlateTextureThumbnailRenderer::StaticClass());
 
@@ -65,6 +70,7 @@ class FVaTexAtlasEditorPlugin : public IVaTexAtlasEditorPlugin
 private:
 	/** Asset type action */
 	TSharedPtr<IAssetTypeActions> TextureAtlasAssetTypeActions;
+	TSharedPtr<IAssetTypeActions> TextureAtlasAssetActions;
 
 };
 

Source/VaTexAtlasEditorPlugin/Private/VtaEditorPluginSettings.cpp

@@ -7,6 +7,7 @@ UVtaEditorPluginSettings::UVtaEditorPluginSettings(const FObjectInitializer& Obj
 , bGenerateSlateTextures(true)
 , bGenerateMaterialInstances(false)
 , bUseMultiAtlas(false)
+, bUseNewAtlasAsset(true)
 {
 
 }

Source/VaTexAtlasEditorPlugin/Private/VtaTextureAtlasAssetActions.cpp

@@ -0,0 +1,59 @@
+// Copyright 2016 Vladimir Alyamkin. All Rights Reserved.
+
+#include "VtaTextureAtlasAssetActions.h"
+#include "VtaTextureAtlasAsset.h"
+
+#include "EditorFramework/AssetImportData.h"
+
+#define LOCTEXT_NAMESPACE "VtaEditorPlugin"
+
+//////////////////////////////////////////////////////////////////////////
+// FVtaTextureAtlasAssetActions
+
+FText FVtaTextureAtlasAssetActions::GetName() const
+{
+	return LOCTEXT("FVtaTextureAtlasAssetActions", "Texture Atlas Asset");
+}
+
+FColor FVtaTextureAtlasAssetActions::GetTypeColor() const
+{
+	return FColor::Red;
+}
+
+UClass* FVtaTextureAtlasAssetActions::GetSupportedClass() const
+{
+	return UVtaTextureAtlasAsset::StaticClass();
+}
+
+uint32 FVtaTextureAtlasAssetActions::GetCategories()
+{
+	return EAssetTypeCategories::Misc;
+}
+
+bool FVtaTextureAtlasAssetActions::IsImportedAsset() const
+{
+	return true;
+}
+
+void FVtaTextureAtlasAssetActions::GetResolvedSourceFilePaths(const TArray<UObject*>& TypeAssets, TArray<FString>& OutSourceFilePaths) const
+{
+	FAssetTypeActions_Base::GetResolvedSourceFilePaths(TypeAssets, OutSourceFilePaths);
+
+	for (auto& Asset : TypeAssets)
+	{
+		const auto TexttureAtlas = CastChecked<UVtaTextureAtlasAsset>(Asset);
+		if (TexttureAtlas->AssetImportData)
+		{
+			TexttureAtlas->AssetImportData->ExtractFilenames(OutSourceFilePaths);
+		}
+	}
+}
+
+void FVtaTextureAtlasAssetActions::GetActions(const TArray<UObject*>& InObjects, FMenuBuilder& MenuBuilder)
+{
+
+}
+
+//////////////////////////////////////////////////////////////////////////
+
+#undef LOCTEXT_NAMESPACE