MyFactory.cpp

#include "MyFactory.h"


UMyFactory::UMyFactory()
{
	SupportedClass = UMaterial::StaticClass();

	bCreateNew = true;
	bEditorImport = false;
}

FText UMyFactory::GetDisplayName()const
{
	return FText::FromString("Sun Material");
}

UObject* UMyFactory::FactoryCreateNew
(
	UClass * InClass,
	UObject * InParent,
	FName InName,
	EObjectFlags Flags,
	UObject * Context,
	FFeedbackContext * Warn
)
{
	UE_LOG(LogTemp, Warning, TEXT("CIAONE PRP"));
	UE_LOG(LogTemp, Warning, TEXT("%s"), *InParent->GetPathName());

	UMaterial* Material = NewObject<UMaterial>(InParent,InName, Flags | RF_Transactional);
	//Material->MarkPackageDirty();
	Material->SetShadingModel(EMaterialShadingModel::MSM_Unlit);		//set material unlit

	FString CurrentPath = InParent->GetPathName().Replace(*InName.ToString(), TEXT(""));

	//load sun texture 
	UTexture* SunTexture = LoadObject<UTexture>(nullptr, TEXT("Texture2D'%sSun.Sun'"), *CurrentPath);
	if (!SunTexture)
	{
		UE_LOG(LogTemp,Warning,TEXT("Cannot load sun texture, texture must be named Sun.  Material always created but not compiled."))
	}
	//"Texture2D'/Game/MyMaterials/Sun.Sun'"
	
	/******************************************************************************************************/
	//GET ALL CLASSES
	UClass* TextureCoordinateClass = FindObject<UClass>(ANY_PACKAGE, TEXT("MaterialExpressionTextureCoordinate"));	
	if (!TextureCoordinateClass)
	{
		LOG;
		ESC;
	}
	UClass* ParameterClass = FindObject<UClass>(ANY_PACKAGE, TEXT("MaterialExpressionScalarParameter"));
	if (!ParameterClass)
	{
		LOG;
		ESC;
	}
	UClass* MultiplyClass = FindObject<UClass>(ANY_PACKAGE, TEXT("MaterialExpressionMultiply"));
	if (!MultiplyClass)
	{
		LOG;
		ESC;
	}
	UClass* PannerClass = FindObject<UClass>(ANY_PACKAGE, TEXT("MaterialExpressionPanner"));
	if (!PannerClass)
	{
		LOG;
		ESC;
	}
	UClass* TextureSampleClass = FindObject<UClass>(ANY_PACKAGE, TEXT("MaterialExpressionTextureSample"));
	if (!TextureSampleClass)
	{
		LOG;
		ESC;
	}
	UClass* AddClass = FindObject<UClass>(ANY_PACKAGE, TEXT("MaterialExpressionAdd"));
	if (!AddClass)
	{
		LOG;
		ESC;
	}
	UClass* VectorParameterClass = FindObject<UClass>(ANY_PACKAGE, TEXT("MaterialExpressionVectorParameter"));
	if (!VectorParameterClass)
	{
		LOG;
		ESC;
	}
	
	
	/******************************************************************************************************/
	
	////TEXTURE COORD
	UMaterialExpressionTextureCoordinate* TextureCoordinate = (UMaterialExpressionTextureCoordinate*)NewObject<UObject>(Material, TextureCoordinateClass);
	Material->Expressions.Add(TextureCoordinate);
	TextureCoordinate->UTiling = 1.0f;
	TextureCoordinate->VTiling = 1.0f;
	TextureCoordinate->MaterialExpressionEditorX = -150 * 8;
	TextureCoordinate->MaterialExpressionEditorY = -100;


	////TILING PARAMETER
	UMaterialExpressionScalarParameter* TilingParameter = (UMaterialExpressionScalarParameter*)NewObject<UObject>(Material, ParameterClass);
	Material->Expressions.Add(TilingParameter);
	TilingParameter->ParameterName = "Tiling";
	TilingParameter->DefaultValue = 3.0f;
	TilingParameter->MaterialExpressionEditorX = -150 * 8;
	TilingParameter->MaterialExpressionEditorY = 100;

	//MULTIPLY NODE
	UMaterialExpressionMultiply* MultiplyCoordsTiling = (UMaterialExpressionMultiply*)NewObject<UObject>(Material, MultiplyClass);
	Material->Expressions.Add(MultiplyCoordsTiling);
	MultiplyCoordsTiling->MaterialExpressionEditorX = -150 * 7;
	MultiplyCoordsTiling->MaterialExpressionEditorY = 0;
	
	FExpressionInput MultiplyCoordsTilingInputA;
	MultiplyCoordsTilingInputA.Expression = TextureCoordinate;				//multiply A

	FExpressionInput MultiplyCoordsTilingInputB;
	MultiplyCoordsTilingInputB.Expression = TilingParameter;				//multiply B

	MultiplyCoordsTiling->A = MultiplyCoordsTilingInputA;
	MultiplyCoordsTiling->B = MultiplyCoordsTilingInputB;

	/*FColorMaterialInput Emissive;
	Emissive.Expression = MultiplyCoordsTiling;*/

	//PANNERS
	FExpressionInput PannersInput;
	PannersInput.Expression = MultiplyCoordsTiling;

	UMaterialExpressionPanner* UpperPanner = (UMaterialExpressionPanner*)NewObject<UObject>(Material, PannerClass);
	Material->Expressions.Add(UpperPanner);
	UpperPanner->MaterialExpressionEditorX = -150 * 6;
	UpperPanner->MaterialExpressionEditorY = -100;
	UpperPanner->SpeedX = 0.1f;
	UpperPanner->Coordinate = PannersInput;

	UMaterialExpressionPanner* LowerPanner = (UMaterialExpressionPanner*)NewObject<UObject>(Material, PannerClass);
	Material->Expressions.Add(LowerPanner);
	LowerPanner->MaterialExpressionEditorX = -150 * 6;
	LowerPanner->MaterialExpressionEditorY = 100;
	LowerPanner->SpeedY = 0.1f;
	LowerPanner->Coordinate = PannersInput;

	//TEXTURE SAMPLES
	UMaterialExpressionTextureSample* UpperTextureSampleR = (UMaterialExpressionTextureSample*)NewObject<UObject>(Material, TextureSampleClass);
	Material->Expressions.Add(UpperTextureSampleR);
	UpperTextureSampleR->MaterialExpressionEditorX = -150 * 5;
	UpperTextureSampleR->MaterialExpressionEditorY = -100;
	FExpressionInput UpperTextureSampleRUV;
	UpperTextureSampleRUV.Expression = UpperPanner;
	UpperTextureSampleR->Coordinates = UpperTextureSampleRUV;
	if(SunTexture)
		UpperTextureSampleR->Texture = SunTexture;

	UMaterialExpressionTextureSample* LowerTextureSampleG = (UMaterialExpressionTextureSample*)NewObject<UObject>(Material, TextureSampleClass);
	Material->Expressions.Add(LowerTextureSampleG);
	LowerTextureSampleG->MaterialExpressionEditorX = -150 * 5;
	LowerTextureSampleG->MaterialExpressionEditorY = 100;
	FExpressionInput LowerTextureSampleGUV;
	LowerTextureSampleGUV.Expression = LowerPanner;
	LowerTextureSampleG->Coordinates = LowerTextureSampleGUV;
	if (SunTexture)
		LowerTextureSampleG->Texture = SunTexture;

	//MULTIPLY TWO TEXTURES
	UMaterialExpressionMultiply* TexturesMultiply = (UMaterialExpressionMultiply*)NewObject<UObject>(Material, MultiplyClass);
	Material->Expressions.Add(TexturesMultiply);
	TexturesMultiply->MaterialExpressionEditorX = -150 * 4;
	
	FExpressionInput TexturesMultiplyA;
	TexturesMultiplyA.Connect(1,UpperTextureSampleR);

	FExpressionInput TexturesMultiplyB;
	TexturesMultiplyB.Connect(2, LowerTextureSampleG);

	TexturesMultiply->A = TexturesMultiplyA;
	TexturesMultiply->B = TexturesMultiplyB;

	//TEXTURE COORD
	UMaterialExpressionTextureCoordinate* TextureCoord = (UMaterialExpressionTextureCoordinate*)NewObject<UObject>(Material, TextureCoordinateClass);
	Material->Expressions.Add(TextureCoord);
	TextureCoord->MaterialExpressionEditorX = -150 * 4;
	TextureCoord->MaterialExpressionEditorY = -150;
	TextureCoord->UTiling = 1;
	TextureCoord->VTiling = 1;

	//ADD
	UMaterialExpressionAdd* Add = (UMaterialExpressionAdd*)NewObject<UObject>(Material, AddClass);
	Material->Expressions.Add(Add);
	Add->MaterialExpressionEditorX = -150 * 3;
	Add->MaterialExpressionEditorY = 150;

	FExpressionInput AddInputA;
	AddInputA.Expression = TextureCoord;

	FExpressionInput AddInputB;
	AddInputB.Expression = TexturesMultiply;

	Add->A = AddInputA;
	Add->B = AddInputB;

	//SUN COLOR PARAM
	UMaterialExpressionVectorParameter* VectorParameter = (UMaterialExpressionVectorParameter*)NewObject<UObject>(Material, VectorParameterClass);
	Material->Expressions.Add(VectorParameter);
	VectorParameter->MaterialExpressionEditorX = -150 * 3;
	VectorParameter->MaterialExpressionEditorY = -150;
	VectorParameter->DefaultValue = FLinearColor(10, 4, 0.1f, 1);


	//FINAL TEXTURE SAMPLE
	UMaterialExpressionTextureSample* FinalTextureSample = (UMaterialExpressionTextureSample*)NewObject<UObject>(Material, TextureSampleClass);
	Material->Expressions.Add(FinalTextureSample);
	FinalTextureSample->MaterialExpressionEditorX = -150 * 2;
	FinalTextureSample->MaterialExpressionEditorY = 150;
	if (SunTexture)
		FinalTextureSample->Texture = SunTexture;

	FExpressionInput FinalTextureUV;
	FinalTextureUV.Expression = Add;
	FinalTextureSample->Coordinates = FinalTextureUV;

	//MULTIPLY SUN COLOR
	UMaterialExpressionMultiply* SunColorMultiply = (UMaterialExpressionMultiply*)NewObject<UObject>(Material, MultiplyClass);
	Material->Expressions.Add(SunColorMultiply);
	SunColorMultiply->MaterialExpressionEditorX = -150 * 2;
	SunColorMultiply->MaterialExpressionEditorY = -150;

	FExpressionInput SunColorMultiplyInputA;
	SunColorMultiplyInputA.Connect(0, VectorParameter);

	FExpressionInput SunColorMultiplyInputB;
	SunColorMultiplyInputB.Connect(4, VectorParameter);

	SunColorMultiply->A = SunColorMultiplyInputA;
	SunColorMultiply->B = SunColorMultiplyInputB;

	//FINAL EMISSIVE COLOR
	UMaterialExpressionMultiply* FinalEmissiveColor = (UMaterialExpressionMultiply*)NewObject<UObject>(Material, MultiplyClass);
	Material->Expressions.Add(FinalEmissiveColor);
	FinalEmissiveColor->MaterialExpressionEditorX = -150;

	FExpressionInput FinalEmissiveInputA;
	FinalEmissiveInputA.Expression = SunColorMultiply;

	FExpressionInput FinalEmissiveInputB;
	FinalEmissiveInputB.Expression = FinalTextureSample;

	FinalEmissiveColor->A = FinalEmissiveInputA;
	FinalEmissiveColor->B = FinalEmissiveInputB;

	FColorMaterialInput Emissive;
	Emissive.Expression = FinalEmissiveColor;
	Material->EmissiveColor = Emissive;

	Material->PostEditChange();
	return Material;
}

MyFactory.h

#pragma once

#include "CoreMinimal.h"
#include "Runtime/Engine/Classes/Materials/MaterialExpressionTextureCoordinate.h"
#include "Runtime/Engine/Classes/Materials/MaterialExpressionScalarParameter.h"
#include "Runtime/Engine/Classes/Materials/MaterialExpressionMultiply.h"
#include "Runtime/Engine/Classes/Materials/MaterialExpressionTextureSample.h"
#include "Runtime/Engine/Classes/Materials/MaterialExpressionPanner.h"
#include "Runtime/Engine/Classes/Materials/MaterialExpressionTextureSample.h"
#include "Runtime/Engine/Classes/Materials/MaterialExpressionAdd.h"
#include "Runtime/Engine/Classes/Materials/MaterialExpressionVectorParameter.h"

#include "Runtime/Engine/Classes/Engine/Texture.h"
#include "Runtime/Core/Public/Misc/FeedbackContext.h"
#include "Runtime/Engine/Classes/Materials/Material.h"
#include "Factories/Factory.h"
#include "MyFactory.generated.h"

UCLASS()
class MATERIAL_GENERATOR_API UMyFactory : public UFactory
{
	GENERATED_BODY()

public:
	UMyFactory();
		virtual UObject* FactoryCreateNew
		(
			UClass * InClass,
			UObject * InParent,
			FName InName,
			EObjectFlags Flags,
			UObject * Context,
			FFeedbackContext * Warn
		) override;
	
		virtual FText GetDisplayName() const override;

#define LOG UE_LOG(LogTemp, Error, TEXT("Error, unable to build material"))
#define ESC return nullptr
};