519 lines
17 KiB
C++
519 lines
17 KiB
C++
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
#include "MaterialsDatabase.h"
|
|
#include "Utils/AutoChangeDatabase.h"
|
|
|
|
#include "ModelMaterial.hpp"
|
|
#include "Texture.hpp"
|
|
#include "AttributeIndex.hpp"
|
|
|
|
#include "Synchronizer.h"
|
|
#include "TexturesCache.h"
|
|
|
|
#include "DatasmithSceneFactory.h"
|
|
|
|
BEGIN_NAMESPACE_UE_AC
|
|
#if AC_VERSION > 26
|
|
const API_AttributeIndex kInvalidMaterialIndex = ACAPI_CreateAttributeIndex(0);
|
|
#endif
|
|
|
|
class FMaterialInfo
|
|
{
|
|
public:
|
|
FMaterialInfo(FMaterialsDatabase::FMaterialSyncData* IOMaterialSyncData)
|
|
: SyncData(*IOMaterialSyncData)
|
|
{
|
|
}
|
|
|
|
void Init(const FSyncContext& SyncContext, const API_Component3D& CUmat, const FMaterialKey& MaterialKey);
|
|
|
|
void UpdateMaterial(const TSharedPtr< IDatasmithUEPbrMaterialElement >& DSMaterial);
|
|
|
|
bool bIdIsSynthetized = false;
|
|
FString DatasmithId;
|
|
FString DatasmithLabel;
|
|
|
|
double Rotation = 0.0; // Rotation angle
|
|
double InvXSize = 1.0; // Used to compute uv
|
|
double InvYSize = 1.0; // Used to compute uv
|
|
bool bMirrorX = false;
|
|
bool bMirrorY = false;
|
|
|
|
bool bTwoSide = false;
|
|
float Opacity = 0.0f;
|
|
float SpecularReflection = 0.0f;
|
|
ModelerAPI::Color SurfaceColor;
|
|
ModelerAPI::Color EmissiveColor;
|
|
|
|
const FTexturesCache::FTexturesCacheElem* Texture = nullptr;
|
|
FMaterialsDatabase::FMaterialSyncData& SyncData;
|
|
};
|
|
|
|
void FMaterialInfo::Init(const FSyncContext& SyncContext, const API_Component3D& CUmat, const FMaterialKey& MaterialKey)
|
|
{
|
|
// Get modeler material
|
|
ModelerAPI::AttributeIndex IndexMaterial(ModelerAPI::AttributeIndex::MaterialIndex, MaterialKey.ACMaterialIndex);
|
|
ModelerAPI::Material AcMaterial;
|
|
SyncContext.GetModel().GetMaterial(IndexMaterial, &AcMaterial);
|
|
ModelerAPI::AttributeIndex IndexTexture;
|
|
AcMaterial.GetTextureIndex(IndexTexture);
|
|
GS::Int32 textureIndex = IndexTexture.GetOriginalModelerIndex();
|
|
if (MaterialKey.ACTextureIndex != kInvalidMaterialIndex)
|
|
{
|
|
textureIndex = MaterialKey.ACTextureIndex;
|
|
}
|
|
|
|
if (SyncData.MaterialId == APINULLGuid)
|
|
{
|
|
API_Guid MatGuid = CUmat.umat.mater.head.guid;
|
|
if (MatGuid == APINULLGuid)
|
|
{
|
|
bIdIsSynthetized = true;
|
|
// Simulate a Guid from material name and properties
|
|
MD5::Generator g;
|
|
std::string name(CUmat.umat.mater.head.uniStringNamePtr->ToUtf8());
|
|
g.Update(name.c_str(), (unsigned int)name.size());
|
|
const char* p1 = (const char*)&CUmat.umat.mater.mtype;
|
|
g.Update(p1, (unsigned int)((const char*)&CUmat.umat.mater.texture - p1));
|
|
MD5::FingerPrint fp;
|
|
g.Finish(fp);
|
|
MatGuid = Fingerprint2API_Guid(fp);
|
|
if (textureIndex > 0)
|
|
{
|
|
// Add the texture finderprint
|
|
MatGuid = CombineGuid(MatGuid,
|
|
SyncContext.GetTexturesCache().GetTexture(SyncContext, textureIndex).Fingerprint);
|
|
}
|
|
UE_AC_VerboseF("Simulate Guid for material %d, %s Guid=%s\n", MaterialKey.ACMaterialIndex,
|
|
TCHAR_TO_UTF8(*DatasmithLabel), APIGuidToString(MatGuid).ToUtf8());
|
|
}
|
|
SyncData.MaterialId = APIGuid2GSGuid(MatGuid);
|
|
SyncData.MaterialIndex = CUmat.umat.mater.head.index;
|
|
}
|
|
|
|
DatasmithId = GSStringToUE(SyncData.MaterialId.ToUniString());
|
|
DatasmithLabel = GSStringToUE((*CUmat.umat.mater.head.uniStringNamePtr));
|
|
|
|
// If the material use a texture
|
|
if (textureIndex > 0)
|
|
{
|
|
// Add the texture info to SyncDatabase
|
|
Texture = &SyncContext.GetTexturesCache().GetTexture(SyncContext, textureIndex);
|
|
|
|
Rotation = AcMaterial.GetTextureRotationAngle();
|
|
InvXSize = Texture->InvXSize;
|
|
InvYSize = Texture->InvYSize;
|
|
bMirrorX = Texture->bMirrorX;
|
|
bMirrorY = Texture->bMirrorY;
|
|
|
|
if (MaterialKey.ACTextureIndex != kInvalidMaterialIndex)
|
|
{
|
|
GS::UniString fingerprint = APIGuidToString(Texture->Fingerprint);
|
|
|
|
DatasmithId += TEXT("_");
|
|
DatasmithId += GSStringToUE(fingerprint);
|
|
|
|
DatasmithLabel += GSStringToUE(fingerprint);
|
|
DatasmithLabel += "_";
|
|
DatasmithLabel += GSStringToUE(Texture->TextureLabel);
|
|
}
|
|
}
|
|
|
|
if (MaterialKey.Sided == kDoubleSide)
|
|
{
|
|
DatasmithId += TEXT("_DS");
|
|
DatasmithLabel += TEXT("_DS");
|
|
}
|
|
|
|
Opacity = 1.0f - (float)AcMaterial.GetTransparency();
|
|
SurfaceColor = AcMaterial.GetSurfaceColor();
|
|
SpecularReflection = (float)AcMaterial.GetSpecularReflection();
|
|
EmissiveColor = AcMaterial.GetEmissionColor();
|
|
bTwoSide = MaterialKey.Sided == kDoubleSide;
|
|
}
|
|
|
|
void FMaterialInfo::UpdateMaterial(const TSharedPtr< IDatasmithUEPbrMaterialElement >& DSMaterial)
|
|
{
|
|
bool bRemoveAllExpressions = true;
|
|
DSMaterial->ResetExpressionGraph(bRemoveAllExpressions);
|
|
DSMaterial->SetLabel(*DatasmithLabel);
|
|
|
|
const bool bIsTransparent = Opacity != 1.0;
|
|
bool bHasAphaMask = false;
|
|
|
|
if (Texture != nullptr)
|
|
{
|
|
IDatasmithMaterialExpressionTexture* BaseTextureExpression =
|
|
DSMaterial->AddMaterialExpression< IDatasmithMaterialExpressionTexture >();
|
|
BaseTextureExpression->SetTexturePathName(GSStringToUE(APIGuidToString(Texture->Fingerprint)));
|
|
BaseTextureExpression->SetName(TEXT("Diffuse_Map"));
|
|
BaseTextureExpression->ConnectExpression(DSMaterial->GetBaseColor());
|
|
|
|
if (PIVOT_0_5_0_5 != 0 || InvXSize != 1.0 || InvYSize != 1.0 || bMirrorX || bMirrorY || Rotation != 0.0)
|
|
{
|
|
IDatasmithMaterialExpressionFunctionCall* UVEditExpression =
|
|
DSMaterial->AddMaterialExpression< IDatasmithMaterialExpressionFunctionCall >();
|
|
UVEditExpression->SetFunctionPathName(TEXT("/DatasmithContent/Materials/UVEdit.UVEdit"));
|
|
UVEditExpression->ConnectExpression(BaseTextureExpression->GetInputCoordinate());
|
|
|
|
// Mirror
|
|
IDatasmithMaterialExpressionBool* MirrorUFlag =
|
|
DSMaterial->AddMaterialExpression< IDatasmithMaterialExpressionBool >();
|
|
MirrorUFlag->SetName(TEXT("Mirror U"));
|
|
MirrorUFlag->GetBool() = bMirrorX;
|
|
|
|
MirrorUFlag->ConnectExpression(*UVEditExpression->GetInput(3));
|
|
|
|
IDatasmithMaterialExpressionBool* MirrorVFlag =
|
|
DSMaterial->AddMaterialExpression< IDatasmithMaterialExpressionBool >();
|
|
MirrorVFlag->SetName(TEXT("Mirror V"));
|
|
MirrorVFlag->GetBool() = bMirrorY;
|
|
|
|
MirrorVFlag->ConnectExpression(*UVEditExpression->GetInput(4));
|
|
|
|
// Tiling
|
|
IDatasmithMaterialExpressionColor* TilingValue =
|
|
DSMaterial->AddMaterialExpression< IDatasmithMaterialExpressionColor >();
|
|
TilingValue->SetName(TEXT("UV Tiling"));
|
|
TilingValue->GetColor() = FLinearColor(float(InvXSize), float(InvYSize), 0.0f);
|
|
|
|
TilingValue->ConnectExpression(*UVEditExpression->GetInput(2));
|
|
|
|
IDatasmithMaterialExpressionColor* OffsetValue =
|
|
DSMaterial->AddMaterialExpression< IDatasmithMaterialExpressionColor >();
|
|
OffsetValue->SetName(TEXT("UV Offset"));
|
|
#if PIVOT_0_5_0_5
|
|
OffsetValue->GetColor() = FLinearColor(-0.5f, -0.5f, 0.0f);
|
|
#else
|
|
OffsetValue->GetColor() = FLinearColor(0.0f, 0.0f, 0.0f);
|
|
#endif
|
|
|
|
OffsetValue->ConnectExpression(*UVEditExpression->GetInput(7));
|
|
|
|
IDatasmithMaterialExpressionColor* TilingPivot =
|
|
DSMaterial->AddMaterialExpression< IDatasmithMaterialExpressionColor >();
|
|
TilingPivot->SetName(TEXT("Tiling Pivot"));
|
|
TilingPivot->GetColor() = FLinearColor(0.0f, 0.0f, 0.f);
|
|
|
|
TilingPivot->ConnectExpression(*UVEditExpression->GetInput(1));
|
|
|
|
// Rotation
|
|
if (!FMath::IsNearlyZero(Rotation))
|
|
{
|
|
IDatasmithMaterialExpressionScalar* RotationValue =
|
|
DSMaterial->AddMaterialExpression< IDatasmithMaterialExpressionScalar >();
|
|
RotationValue->SetName(TEXT("W Rotation"));
|
|
double intPart;
|
|
float Rot = float(modf(Rotation * -(1.0 / PI), &intPart) * 0.5);
|
|
RotationValue->GetScalar() = Rot;
|
|
|
|
RotationValue->ConnectExpression(*UVEditExpression->GetInput(6));
|
|
|
|
IDatasmithMaterialExpressionColor* RotationPivot =
|
|
DSMaterial->AddMaterialExpression< IDatasmithMaterialExpressionColor >();
|
|
RotationPivot->SetName(TEXT("Rotation Pivot"));
|
|
#if PIVOT_0_5_0_5
|
|
RotationPivot->GetColor() = FLinearColor(0.5f, 0.5f, 0.0f);
|
|
#else
|
|
RotationPivot->GetColor() = FLinearColor(0.0f, 0.0f, 0.0f);
|
|
#endif
|
|
RotationPivot->ConnectExpression(*UVEditExpression->GetInput(5));
|
|
}
|
|
|
|
IDatasmithMaterialExpressionTextureCoordinate* TextureCoordinateExpression =
|
|
DSMaterial->AddMaterialExpression< IDatasmithMaterialExpressionTextureCoordinate >();
|
|
TextureCoordinateExpression->SetCoordinateIndex(0);
|
|
TextureCoordinateExpression->ConnectExpression(*UVEditExpression->GetInput(0));
|
|
}
|
|
if (Texture->bHasAlpha && Texture->bAlphaIsTransparence)
|
|
{
|
|
if (bIsTransparent)
|
|
{
|
|
IDatasmithMaterialExpressionGeneric* MultiplyExpression =
|
|
DSMaterial->AddMaterialExpression< IDatasmithMaterialExpressionGeneric >();
|
|
MultiplyExpression->SetExpressionName(TEXT("Multiply"));
|
|
MultiplyExpression->SetName(TEXT("Multiply Expression"));
|
|
|
|
IDatasmithMaterialExpressionScalar* OpacityExpression =
|
|
DSMaterial->AddMaterialExpression< IDatasmithMaterialExpressionScalar >();
|
|
OpacityExpression->GetScalar() = Opacity;
|
|
OpacityExpression->SetName(TEXT("Opacity"));
|
|
|
|
IDatasmithExpressionInput* MultiplyInputA = MultiplyExpression->GetInput(0);
|
|
IDatasmithExpressionInput* MultiplyInputB = MultiplyExpression->GetInput(1);
|
|
|
|
MultiplyExpression->ConnectExpression(DSMaterial->GetOpacity());
|
|
|
|
BaseTextureExpression->ConnectExpression(*MultiplyInputA, 4);
|
|
OpacityExpression->ConnectExpression(*MultiplyInputB);
|
|
}
|
|
else
|
|
{
|
|
BaseTextureExpression->ConnectExpression(DSMaterial->GetOpacity(), 4);
|
|
}
|
|
bHasAphaMask = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Diffuse color
|
|
IDatasmithMaterialExpressionColor* DiffuseExpression =
|
|
DSMaterial->AddMaterialExpression< IDatasmithMaterialExpressionColor >();
|
|
if (DiffuseExpression != nullptr)
|
|
{
|
|
DiffuseExpression->GetColor() = ACRGBColorToUELinearColor(SurfaceColor);
|
|
DiffuseExpression->SetName(TEXT("Base Color"));
|
|
DiffuseExpression->ConnectExpression(DSMaterial->GetBaseColor());
|
|
}
|
|
}
|
|
|
|
// Specular color
|
|
IDatasmithMaterialExpressionScalar* specularExpression =
|
|
DSMaterial->AddMaterialExpression< IDatasmithMaterialExpressionScalar >();
|
|
specularExpression->GetScalar() = SpecularReflection;
|
|
specularExpression->SetName(TEXT("Specular"));
|
|
specularExpression->ConnectExpression(DSMaterial->GetSpecular());
|
|
|
|
// Emissive color
|
|
IDatasmithMaterialExpressionColor* EmissiveExpression =
|
|
DSMaterial->AddMaterialExpression< IDatasmithMaterialExpressionColor >();
|
|
EmissiveExpression->GetColor() = ACRGBColorToUELinearColor(EmissiveColor);
|
|
EmissiveExpression->SetName(TEXT("Emissive Color"));
|
|
EmissiveExpression->ConnectExpression(DSMaterial->GetEmissiveColor());
|
|
|
|
// Opacity
|
|
if (!bHasAphaMask && bIsTransparent)
|
|
{
|
|
IDatasmithMaterialExpressionScalar* OpacityExpression =
|
|
DSMaterial->AddMaterialExpression< IDatasmithMaterialExpressionScalar >();
|
|
OpacityExpression->GetScalar() = Opacity;
|
|
OpacityExpression->SetName(TEXT("Opacity"));
|
|
OpacityExpression->ConnectExpression(DSMaterial->GetOpacity());
|
|
}
|
|
|
|
if (bTwoSide)
|
|
{
|
|
DSMaterial->SetTwoSided(bTwoSide);
|
|
}
|
|
|
|
#if 0
|
|
// Metallic
|
|
float Metallic = 0.0;
|
|
if (DatasmithLabel.Contains(TEXT("Metal"))) // Experimental
|
|
{
|
|
Metallic = 1.0;
|
|
}
|
|
IDatasmithMaterialExpressionScalar* MetallicExpression =
|
|
DSMaterial->AddMaterialExpression< IDatasmithMaterialExpressionScalar >();
|
|
MetallicExpression->GetScalar() = Metallic;
|
|
MetallicExpression->SetName(TEXT("Metallic"));
|
|
MetallicExpression->ConnectExpression(DSMaterial->GetMetallic());
|
|
#endif
|
|
}
|
|
|
|
// Constructor
|
|
FMaterialsDatabase::FMaterialsDatabase() {}
|
|
|
|
// Destructor
|
|
FMaterialsDatabase::~FMaterialsDatabase() {}
|
|
|
|
// Reset
|
|
void FMaterialsDatabase::Clear()
|
|
{
|
|
MapMaterials.Reset();
|
|
MaterialsNamesSet.Reset();
|
|
}
|
|
|
|
// Return true if at least one material have been modified
|
|
bool FMaterialsDatabase::CheckModify()
|
|
{
|
|
FAutoChangeDatabase changeDB(APIWind_3DModelID);
|
|
|
|
for (TPair< FMaterialKey, TUniquePtr< FMaterialSyncData > >& Iter : MapMaterials)
|
|
{
|
|
UE_AC_Assert(Iter.Value.IsValid());
|
|
if (Iter.Value->CheckModify(Iter.Key))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Scan all material and update modified ones
|
|
void FMaterialsDatabase::UpdateModified(const FSyncContext& SyncContext)
|
|
{
|
|
for (TPair< FMaterialKey, TUniquePtr< FMaterialSyncData > >& Iter : MapMaterials)
|
|
{
|
|
UE_AC_Assert(Iter.Value.IsValid());
|
|
Iter.Value->Update(SyncContext, Iter.Key);
|
|
}
|
|
}
|
|
|
|
// Return true if the material have been modified
|
|
bool FMaterialsDatabase::FMaterialSyncData::CheckModify(const FMaterialKey& /* MaterialKey */)
|
|
{
|
|
if (!bIsDuplicate && !bIdIsSynthetized && MaterialIndex != kInvalidMaterialIndex)
|
|
{
|
|
API_Attribute MaterialAttibute;
|
|
Zap(&MaterialAttibute);
|
|
MaterialAttibute.header.typeID = API_MaterialID;
|
|
MaterialAttibute.header.index = MaterialIndex;
|
|
GSErrCode GSErr = ACAPI_Attribute_Get(&MaterialAttibute);
|
|
if (GSErr == NoError)
|
|
{
|
|
if (MaterialAttibute.header.modiTime == 0)
|
|
{
|
|
MaterialAttibute.header.modiTime = 1;
|
|
}
|
|
if (LastModificationStamp != MaterialAttibute.header.modiTime)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
UE_AC_DebugF("FMaterialsDatabase::FMaterialSyncData::CheckModify - ACAPI_Attribute_Search error=%s\n",
|
|
GetErrorName(GSErr));
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
const FMaterialsDatabase::FMaterialSyncData& FMaterialsDatabase::GetMaterial(const FSyncContext& SyncContext,
|
|
GS::Int32 inACMaterialIndex,
|
|
GS::Int32 inACTextureIndex, ESided InSided)
|
|
{
|
|
// Test invariant
|
|
if (inACMaterialIndex <= kInvalidMaterialIndex)
|
|
{
|
|
UE_AC_DebugF("FMaterialsDatabase::GetMaterial - Invalid material index (%d)\n", inACMaterialIndex);
|
|
inACMaterialIndex = 1;
|
|
}
|
|
// Test invariant
|
|
if (inACTextureIndex < kInvalidMaterialIndex)
|
|
{
|
|
UE_AC_DebugF("FMaterialsDatabase::GetMaterial - Invalid texture index (%d)\n", inACTextureIndex);
|
|
#if AC_VERSION > 26
|
|
inACTextureIndex = kInvalidMaterialIndex.ToInt32_Deprecated();
|
|
#else
|
|
inACTextureIndex = kInvalidMaterialIndex;
|
|
#endif
|
|
}
|
|
FMaterialKey MaterialKey(inACMaterialIndex, inACTextureIndex, InSided);
|
|
|
|
TUniquePtr< FMaterialSyncData >& material = MapMaterials.FindOrAdd(MaterialKey);
|
|
if (!material.IsValid())
|
|
{
|
|
FMaterialSyncData* MatSyncData = new FMaterialSyncData();
|
|
material.Reset(MatSyncData);
|
|
MatSyncData->Init(SyncContext, MaterialKey);
|
|
}
|
|
|
|
return *material;
|
|
}
|
|
|
|
void FMaterialsDatabase::FMaterialSyncData::Init(const FSyncContext& SyncContext, const FMaterialKey& MaterialKey)
|
|
{
|
|
if (bIsInitialized)
|
|
{
|
|
return;
|
|
}
|
|
bIsInitialized = true;
|
|
|
|
GS::UniString DisplayName;
|
|
API_Component3D CUmat;
|
|
Zap(&CUmat);
|
|
CUmat.header.typeID = API_UmatID;
|
|
CUmat.header.index = MaterialKey.ACMaterialIndex;
|
|
CUmat.umat.mater.head.uniStringNamePtr = &DisplayName;
|
|
GSErrCode GSErr = ACAPI_3D_GetComponent(&CUmat);
|
|
if (GSErr == NoError)
|
|
{
|
|
LastModificationStamp = CUmat.umat.mater.head.modiTime;
|
|
|
|
FMaterialInfo MaterialInfo(this);
|
|
|
|
MaterialInfo.Init(SyncContext, CUmat, MaterialKey);
|
|
bIdIsSynthetized = MaterialInfo.bIdIsSynthetized;
|
|
DatasmithId = MaterialInfo.DatasmithId;
|
|
DatasmithLabel = MaterialInfo.DatasmithLabel;
|
|
bHasTexture = MaterialInfo.Texture != nullptr;
|
|
|
|
FMaterialsDatabase::SetMaterialsNames& MaterialsNamesSet = SyncContext.GetMaterialsDatabase().MaterialsNamesSet;
|
|
if (MaterialsNamesSet.Find(DatasmithId) != nullptr)
|
|
{
|
|
bIsDuplicate = true;
|
|
return; // An identical material already exist (Can happen for simulated Guid)
|
|
}
|
|
MaterialsNamesSet.Add(DatasmithId);
|
|
|
|
Element = FDatasmithSceneFactory::CreateUEPbrMaterial(*MaterialInfo.DatasmithId);
|
|
MaterialInfo.UpdateMaterial(Element);
|
|
}
|
|
else
|
|
{
|
|
// Set a gray diffuse color
|
|
MaterialId.Generate();
|
|
bIdIsSynthetized = true;
|
|
DatasmithId = GSStringToUE(MaterialId.ToUniString());
|
|
DatasmithLabel = FString(TEXT("Invalid material index"));
|
|
Element = FDatasmithSceneFactory::CreateUEPbrMaterial(*DatasmithId);
|
|
Element->SetLabel(*DatasmithLabel);
|
|
{
|
|
IDatasmithMaterialExpressionColor* DiffuseExpression =
|
|
Element->AddMaterialExpression< IDatasmithMaterialExpressionColor >();
|
|
if (DiffuseExpression != nullptr)
|
|
{
|
|
DiffuseExpression->GetColor() = FLinearColor(0.5f, 0.5f, 0.5f);
|
|
DiffuseExpression->SetName(TEXT("Base Color"));
|
|
DiffuseExpression->ConnectExpression(Element->GetBaseColor());
|
|
}
|
|
}
|
|
}
|
|
SyncContext.GetScene().AddMaterial(Element);
|
|
}
|
|
|
|
// Return true if the material have been modified
|
|
void FMaterialsDatabase::FMaterialSyncData::Update(const FSyncContext& SyncContext, const FMaterialKey& MaterialKey)
|
|
{
|
|
if (bIsDuplicate)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Get 3D DB material
|
|
GS::UniString DisplayName;
|
|
API_Component3D CUmat;
|
|
Zap(&CUmat);
|
|
CUmat.header.typeID = API_UmatID;
|
|
CUmat.header.index = MaterialKey.ACMaterialIndex;
|
|
CUmat.umat.mater.head.uniStringNamePtr = &DisplayName;
|
|
GSErrCode GSErr = ACAPI_3D_GetComponent(&CUmat);
|
|
if (GSErr == NoError)
|
|
{
|
|
if (CUmat.umat.mater.head.modiTime == 0)
|
|
{
|
|
CUmat.umat.mater.head.modiTime = 1;
|
|
}
|
|
if (LastModificationStamp != CUmat.umat.mater.head.modiTime)
|
|
{
|
|
LastModificationStamp = CUmat.umat.mater.head.modiTime;
|
|
|
|
FMaterialInfo MaterialInfo(this);
|
|
MaterialInfo.Init(SyncContext, CUmat, MaterialKey);
|
|
DatasmithLabel = MaterialInfo.DatasmithLabel;
|
|
bHasTexture = MaterialInfo.Texture != nullptr;
|
|
MaterialInfo.UpdateMaterial(Element);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
UE_AC_DebugF("FMaterialsDatabase::FMaterialSyncData::Update - ACAPI_3D_GetComponent error=%s\n",
|
|
GetErrorName(GSErr));
|
|
}
|
|
}
|
|
|
|
END_NAMESPACE_UE_AC
|