MeshComponent.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "Engine/TextureStreamingTypes.h"
#include "Components/PrimitiveComponent.h"
#include "Containers/SortedMap.h"
 
#include "MeshComponent.generated.h"
 
class UMaterialInterface;
struct FMaterialRelevance;
 
UCLASS(abstract, ShowCategories = (VirtualTexture), MinimalAPI)
class UMeshComponent : public UPrimitiveComponent
{
    GENERATED_UCLASS_BODY()
 
public:
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category=Rendering, Meta=(ToolTip="Material overrides."))
    TArray<TObjectPtr<class UMaterialInterface>> OverrideMaterials;
 
    UFUNCTION(BlueprintCallable, Category="Rendering|Material")
    ENGINE_API virtual TArray<class UMaterialInterface*> GetMaterials() const;
 
    virtual bool UseNaniteOverrideMaterials() const { return false; }
 
    ENGINE_API virtual int32 GetNumOverrideMaterials() const;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, AdvancedDisplay, Category=Rendering)
    TObjectPtr<class UMaterialInterface> OverlayMaterial;
    
    UPROPERTY(EditAnywhere, BlueprintReadOnly, AdvancedDisplay, Category=Rendering)
    float OverlayMaterialMaxDrawDistance;
 
    UFUNCTION(BlueprintCallable, Category="Rendering|Material")
    ENGINE_API class UMaterialInterface* GetOverlayMaterial() const;
 
    UFUNCTION(BlueprintCallable, Category="Rendering|Material")
    ENGINE_API void SetOverlayMaterial(class UMaterialInterface* NewOverlayMaterial);
 
    UFUNCTION(BlueprintCallable, Category="Rendering|Material")
    ENGINE_API float GetOverlayMaterialMaxDrawDistance() const;
 
    UFUNCTION(BlueprintCallable, Category="Rendering|Material")
    ENGINE_API void SetOverlayMaterialMaxDrawDistance(float InMaxDrawDistance);
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, AdvancedDisplay, Category=Rendering)
    TArray<TObjectPtr<class UMaterialInterface>> MaterialSlotsOverlayMaterial;
 
    ENGINE_API void GetMaterialSlotsOverlayMaterial(TArray<TObjectPtr<class UMaterialInterface>>& OutMaterialSlotOverlayMaterials) const;
 
#if WITH_EDITOR
    /*
     * Make sure the Override array is using only the space it should use.
     * 1. The override array cannot be bigger then the number of mesh material.
     * 2. The override array must not end with a nullptr UMaterialInterface.
     */
    ENGINE_API void CleanUpOverrideMaterials();
 
    /*
     * Make sure the MaterialSlotsOverlayMaterial is using only the space it should use.
     * - The data should be only on existing mesh material slot.
     */
    ENGINE_API void CleanUpMaterialSlotsOverlayMaterial();
#endif
 
    ENGINE_API void EmptyOverrideMaterials();
 
    ENGINE_API bool HasOverrideMaterials();
 
#if WITH_EDITOR
    ENGINE_API virtual void PostEditChangeChainProperty(FPropertyChangedChainEvent& PropertyChangedEvent) override;
#endif
 
    //~ Begin UPrimitiveComponent Interface
    ENGINE_API virtual int32 GetNumMaterials() const override;
    ENGINE_API virtual UMaterialInterface* GetMaterial(int32 ElementIndex) const override;
    ENGINE_API virtual UMaterialInterface* GetMaterialByName(FName MaterialSlotName) const override;
    ENGINE_API virtual void SetMaterial(int32 ElementIndex, UMaterialInterface* Material) override;
    ENGINE_API virtual void SetMaterialByName(FName MaterialSlotName, class UMaterialInterface* Material) override;
    ENGINE_API virtual void GetUsedMaterials(TArray<UMaterialInterface*>& OutMaterials, bool bGetDebugMaterials = false) const override;    
    //~ End UPrimitiveComponent Interface
 
    UE_DEPRECATED(5.7, "Please use GetMaterialRelevance with EShaderPlatform argument and not ERHIFeatureLevel::Type")
    ENGINE_API virtual FMaterialRelevance GetMaterialRelevance(ERHIFeatureLevel::Type InFeatureLevel) const;
    ENGINE_API virtual FMaterialRelevance GetMaterialRelevance(EShaderPlatform InShaderPlatform) const;
 
    ENGINE_API virtual void SetTextureForceResidentFlag( bool bForceMiplevelsToBeResident );
 
#if WITH_EDITOR
    ENGINE_API void SetMarkTextureAsEditorStreamingPool(bool bInMarkAsEditorStreamingPool);
#endif
 
    UFUNCTION(BlueprintCallable, Category = "Rendering")
    ENGINE_API virtual void PrestreamTextures( float Seconds, bool bPrioritizeCharacterTextures, int32 CinematicTextureGroups = 0 );
 
    UFUNCTION(BlueprintCallable, Category = "Rendering", meta=(ScriptName="PrestreamMeshLods;PrestreamMeshLODs"))
    virtual bool PrestreamMeshLODs( float Seconds ) { return false; }
 
    ENGINE_API virtual void RegisterLODStreamingCallback(FLODStreamingCallback&& Callback, int32 LODIdx, float TimeoutSecs, bool bOnStreamIn);
    ENGINE_API virtual void RegisterLODStreamingCallback(FLODStreamingCallback&& CallbackStreamingStart, FLODStreamingCallback&& CallbackStreamingDone, float TimeoutStartSecs, float TimeoutDoneSecs);
 
    virtual bool GetMaterialStreamingData(int32 MaterialIndex, FPrimitiveMaterialInfo& MaterialData) const { return false; }
 
    ENGINE_API void GetStreamingTextureInfoInner(FStreamingTextureLevelContext& LevelContext, const TArray<FStreamingTextureBuildInfo>* PreBuiltData, float ComponentScaling, TArray<FStreamingRenderAssetPrimitiveInfo>& OutStreamingTextures) const;
 
    ENGINE_API FColor GetWireframeColorForSceneProxy() const;
 
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
    ENGINE_API virtual void LogMaterialsAndTextures(FOutputDevice& Ar, int32 Indent) const;
#endif
 
    virtual UTexture* GetMeshPaintTexture() const { return nullptr; }
    virtual void SetMeshPaintTexture(UTexture* Texture) {}
    virtual void SetMeshPaintTextureOverride(UTexture* OverrideTexture) {}
    virtual int32 GetMeshPaintTextureCoordinateIndex() const { return 0; }
 
public:
 
    UFUNCTION(BlueprintCallable, Category = "Rendering|Material")
    ENGINE_API void SetScalarParameterValueOnMaterials(const FName ParameterName, const float ParameterValue);
 
    UFUNCTION(BlueprintCallable, Category = "Rendering|Material")
    ENGINE_API void SetVectorParameterValueOnMaterials(const FName ParameterName, const FVector ParameterValue);
 
    UFUNCTION(BlueprintCallable, Category = "Rendering|Material")
    ENGINE_API void SetColorParameterValueOnMaterials(const FName ParameterName, const FLinearColor ParameterValue);
 
    float GetScalarParameterDefaultValue(const FName ParameterName)
    {
        FMaterialParameterCache* ParameterCache = MaterialParameterCache.Find(ParameterName);
        return (ParameterCache ? ParameterCache->ScalarParameterDefaultValue : 0.f);
    }
 
    ENGINE_API const TArray<TObjectPtr<UMaterialInterface>>& GetComponentMaterialSlotsOverlayMaterial() const;
 
    virtual void GetDefaultMaterialSlotsOverlayMaterial(TArray<TObjectPtr<UMaterialInterface>>& OutMaterialSlotOverlayMaterials) const { return; }
 
protected:
 
    //~ Begin UObject Interface.
    ENGINE_API virtual void BeginDestroy() override;
    //~ End UObject Interface.
 
    virtual UMaterialInterface* GetDefaultOverlayMaterial() const { return nullptr; };
    
    virtual float GetDefaultOverlayMaterialMaxDrawDistance() const { return 0.f; };
 
    ENGINE_API void CacheMaterialParameterNameIndices();
 
    ENGINE_API void MarkCachedMaterialParameterNameIndicesDirty();
 
    struct FMaterialParameterCache
    {
        TArray<int32> ScalarParameterMaterialIndices;
        TArray<int32> VectorParameterMaterialIndices;
        float ScalarParameterDefaultValue = 0.f;
    };
 
public:
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category = MaterialParameters)
    uint8 bEnableMaterialParameterCaching : 1;
 
protected:
 
    uint8 bCachedMaterialParameterIndicesAreDirty : 1;
 
    TSortedMap<FName, FMaterialParameterCache, FDefaultAllocator, FNameFastLess> MaterialParameterCache;
};