LightMap.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    LightMap.h: Light-map definitions.
=============================================================================*/
 
#pragma once
 
#include "CoreMinimal.h"
#include "Containers/ChunkedArray.h"
#include "Misc/Guid.h"
#include "Engine/EngineTypes.h"
#include "RenderDeferredCleanup.h"
#include "Serialization/BulkData.h"
#include "SceneManagement.h"
#include "Engine/LightMapTexture2D.h"
 
class FLightMap2D;
class UInstancedStaticMeshComponent;
class UMapBuildDataRegistry;
class UPrimitiveComponent;
struct FQuantizedLightmapData;
class ULightComponent;
class UVirtualTexture;
class FShadowMapData2D;
class FFourDistanceFieldSamples;
 
extern ENGINE_API bool GUseBilinearLightmaps;
 
extern ENGINE_API bool GAllowLightmapPadding;
 
extern ENGINE_API ELightingBuildQuality GLightingBuildQuality;
 
#if WITH_EDITOR
extern ENGINE_API FLightmassDebugOptions GLightmassDebugOptions;
#endif
 
extern ENGINE_API FColor GTexelSelectionColor;
 
extern ENGINE_API bool IsTexelDebuggingEnabled();
 
class FLightMap : private FDeferredCleanupInterface
{
public:
    enum
    {
        LMT_None = 0,
        LMT_1D = 1,
        LMT_2D = 2,
    };
 
    TArray<FGuid> LightGuids;
 
    ENGINE_API FLightMap();
 
    virtual ~FLightMap() { check(NumRefs == 0); }
 
    bool ContainsLight(const FGuid& LightGuid) const
    {
        return LightGuids.Find(LightGuid) != INDEX_NONE;
    }
 
    // FLightMap interface.
    virtual void AddReferencedObjects( FReferenceCollector& Collector ) {}
    ENGINE_API virtual void Serialize(FArchive& Ar);
    virtual FLightMapInteraction GetInteraction(ERHIFeatureLevel::Type InFeatureLevel) const = 0;
    virtual FShadowMapInteraction GetShadowInteraction(ERHIFeatureLevel::Type InFeatureLevel) const { return FShadowMapInteraction::None(); }
 
    // Runtime type casting.
    virtual FLightMap2D* GetLightMap2D() { return NULL; }
    virtual const FLightMap2D* GetLightMap2D() const { return NULL; }
 
    // Reference counting.
    void AddRef()
    {
        check(IsInGameThread() || IsInAsyncLoadingThread() || IsInParallelLoadingThread());
        NumRefs++;
    }
    void Release()
    {
        check(IsInGameThread() || IsInAsyncLoadingThread() || IsInParallelLoadingThread());
        checkSlow(NumRefs > 0);
        if(--NumRefs == 0)
        {
            Cleanup();
        }
    }
 
    inline bool AllowsHighQualityLightmaps() const
    {
        return bAllowHighQualityLightMaps;
    }
 
protected:
 
    bool bAllowHighQualityLightMaps;
 
    ENGINE_API virtual void Cleanup();
 
private:
    int32 NumRefs;
};
 
 
 
extern ENGINE_API FArchive& operator<<(FArchive& Ar, FLightMap*& R);
 
struct FLightSample
{
    float Coefficients[NUM_STORED_LIGHTMAP_COEF][3];
 
    bool bIsMapped;
 
    FLightSample():
        bIsMapped(false)
    {
        FMemory::Memzero(Coefficients,sizeof(Coefficients));
    }
};
 
class FLightMapData2D
{
public:
 
    TArray<FGuid> LightGuids;
 
    FLightMapData2D(uint32 InSizeX,uint32 InSizeY):
        Data(InSizeX * InSizeY),
        SizeX(InSizeX),
        SizeY(InSizeY)
    {}
 
    // Accessors.
    const FLightSample& operator()(uint32 X,uint32 Y) const { return Data(SizeX * Y + X); }
    FLightSample& operator()(uint32 X,uint32 Y) { return Data(SizeX * Y + X); }
    uint32 GetSizeX() const { return SizeX; }
    uint32 GetSizeY() const { return SizeY; }
 
private:
 
    TChunkedArray<FLightSample> Data;
 
    uint32 SizeX;
 
    uint32 SizeY;
};
 
class FLightMap2D : public FLightMap
{
public:
 
    ENGINE_API FLightMap2D();
    ENGINE_API FLightMap2D(bool InAllowHighQualityLightMaps);
 
    // FLightMap2D interface.
 
    ENGINE_API const UTexture2D* GetTexture(uint32 BasisIndex) const;
    ENGINE_API UTexture2D* GetTexture(uint32 BasisIndex);
 
    void GetReferencedTextures(TArray<UTexture2D*>& OutTextures) const
    {
        for (int32 BasisIndex = 0; BasisIndex < UE_ARRAY_COUNT(Textures); BasisIndex++)
        {
            if (Textures[BasisIndex])
            {
                OutTextures.Add(Textures[BasisIndex]);
            }
        }
 
        if (GetSkyOcclusionTexture())
        {
            OutTextures.Add(GetSkyOcclusionTexture());
        }
 
        if (GetAOMaterialMaskTexture())
        {
            OutTextures.Add(GetAOMaterialMaskTexture());
        }
    }
 
    ENGINE_API UTexture2D* GetSkyOcclusionTexture() const;
 
    ENGINE_API UTexture2D* GetAOMaterialMaskTexture() const;
 
    ULightMapVirtualTexture2D* GetVirtualTexture(uint32 BasisIndex) const { return VirtualTextures[BasisIndex]; }
 
    ENGINE_API bool IsVirtualTextureValid() const;
 
    ENGINE_API bool IsValid(uint32 BasisIndex) const;
 
    const FVector2D& GetCoordinateScale() const { return CoordinateScale; }
    const FVector2D& GetCoordinateBias() const { return CoordinateBias; }
 
    // FLightMap interface.
    ENGINE_API virtual void AddReferencedObjects( FReferenceCollector& Collector );
 
    ENGINE_API virtual void Serialize(FArchive& Ar);
    ENGINE_API virtual FLightMapInteraction GetInteraction(ERHIFeatureLevel::Type InFeatureLevel) const;
    ENGINE_API virtual FShadowMapInteraction GetShadowInteraction(ERHIFeatureLevel::Type InFeatureLevel) const;
 
    // Runtime type casting.
    virtual const FLightMap2D* GetLightMap2D() const { return this; }
    virtual FLightMap2D* GetLightMap2D() { return this; }
 
    static ENGINE_API TRefCountPtr<FLightMap2D> AllocateLightMap(UObject* LightMapOuter,
        FQuantizedLightmapData*& SourceQuantizedData,
        const TMap<ULightComponent*, FShadowMapData2D*>& SourceShadowMapData,
        const FBoxSphereBounds& Bounds, ELightMapPaddingType InPaddingType, ELightMapFlags InLightmapFlags );
 
    static ENGINE_API TRefCountPtr<FLightMap2D> AllocateInstancedLightMap(UObject* LightMapOuter, UInstancedStaticMeshComponent* Component,
        TArray<TUniquePtr<FQuantizedLightmapData>> SourceQuantizedData,
        TArray<TMap<ULightComponent*, TUniquePtr<FShadowMapData2D>>>&& InstancedShadowMapData,
        UMapBuildDataRegistry* Registry, FGuid MapBuildDataId, const FBoxSphereBounds& Bounds, ELightMapPaddingType InPaddingType, ELightMapFlags LightmapFlags);
 
    static ENGINE_API void EncodeTextures(const FStaticLightingBuildContext* LightingContext, bool bLightingSuccessful, bool bMultithreadedEncode = false );
 
#if WITH_EDITOR
    static ENGINE_API int32 EncodeShadowTexture(const FStaticLightingBuildContext* LightingContext, struct FLightMapPendingTexture& PendingTexture, TArray<TArray<FFourDistanceFieldSamples>>& MipData);
#endif // WITH_EDITOR
 
    static void SetStatusUpdate(bool bInEnable)
    {
        bUpdateStatus = bInEnable;
    }
 
    static bool GetStatusUpdate()
    {
        return bUpdateStatus;
    }
    
    TObjectPtr<ULightMapTexture2D> Textures[2];
 
    TObjectPtr<ULightMapTexture2D> SkyOcclusionTexture;
 
    TObjectPtr<ULightMapTexture2D> AOMaterialMaskTexture;
 
    TObjectPtr<UShadowMapTexture2D> ShadowMapTexture;
 
    TObjectPtr<ULightMapVirtualTexture2D >VirtualTextures[2];
 
    FVector4f ScaleVectors[NUM_STORED_LIGHTMAP_COEF];
 
    FVector4f AddVectors[NUM_STORED_LIGHTMAP_COEF];
 
    FVector2D CoordinateScale;
 
    FVector2D CoordinateBias;
 
    FVector4f InvUniformPenumbraSize;
 
    bool bShadowChannelValid[4];
 
protected:
    ENGINE_API FLightMap2D(const TArray<FGuid>& InLightGuids);
 
    static ENGINE_API bool bUpdateStatus;
};
 
struct FLegacyQuantizedDirectionalLightSample
{
    FColor  Coefficients[2];
};
 
struct FLegacyQuantizedSimpleLightSample
{
    FColor  Coefficients[1];
};
 
struct FQuantizedDirectionalLightSample
{
    FColor  Coefficients[NUM_HQ_LIGHTMAP_COEF];
};
 
struct FQuantizedSimpleLightSample
{
    FColor  Coefficients[NUM_LQ_LIGHTMAP_COEF];
};
 
// These act like a POD as FColor is also set to act like POD
template <> struct TIsPODType<FQuantizedDirectionalLightSample> { enum { Value = true }; };
template <> struct TIsPODType<FQuantizedSimpleLightSample> { enum { Value = true }; };
 
template<class QuantizedLightSampleType>
struct TQuantizedLightSampleBulkData : public TBulkData<QuantizedLightSampleType>
{
    typedef QuantizedLightSampleType SampleType;
};
 
class FLegacyLightMap1D : public FLightMap
{
public:
 
    FLegacyLightMap1D()
    {
        bAllowHighQualityLightMaps = false;
    }
 
    // FLightMap interface.
    virtual void Serialize(FArchive& Ar);
 
    virtual FLightMapInteraction GetInteraction(ERHIFeatureLevel::Type InFeatureLevel) const { return FLightMapInteraction::None(); }
};
 
struct FSelectedLightmapSample
{
    UPrimitiveComponent* Component;
    int32 NodeIndex;
    FLightMapRef Lightmap;
    FVector Position;
    int32 LocalX;
    int32 LocalY;
    int32 MappingSizeX;
    int32 MappingSizeY;
    
    FSelectedLightmapSample() :
        Component(NULL),
        NodeIndex(INDEX_NONE),
        Lightmap(NULL),
        Position(FVector::ZeroVector),
        LocalX(-1),
        LocalY(-1),
        MappingSizeX(-1),
        MappingSizeY(-1)
    {}
 
    FSelectedLightmapSample(
        UPrimitiveComponent* InComponent, 
        int32 InNodeIndex,
        FLightMapRef& InLightmap, 
        FVector InPosition, 
        int32 InLocalX,
        int32 InLocalY,
        int32 InMappingSizeX,
        int32 InMappingSizeY) 
        :
        Component(InComponent),
        NodeIndex(InNodeIndex),
        Lightmap(InLightmap),
        Position(InPosition),
        LocalX(InLocalX),
        LocalY(InLocalY),
        MappingSizeX(InMappingSizeX),
        MappingSizeY(InMappingSizeY)
    {}
};
 
class FDebugShadowRay
{
public:
    FVector Start;
    FVector End;
    int32 bHit;
 
    FDebugShadowRay(const FVector& InStart, const FVector& InEnd, bool bInHit) :
        Start(InStart),
        End(InEnd),
        bHit(bInHit)
    {}
};
 
struct FLightMapCoefficients
{
    uint8 Coverage;
    uint8 Coefficients[NUM_STORED_LIGHTMAP_COEF][4];
    uint8 SkyOcclusion[4];
    uint8 AOMaterialMask;
};
 
struct FQuantizedLightmapData
{
    uint32 SizeX;
 
    uint32 SizeY;
 
    TArray<FLightMapCoefficients> Data;
 
    float Scale[NUM_STORED_LIGHTMAP_COEF][4];
 
    float Add[NUM_STORED_LIGHTMAP_COEF][4];
 
    TArray<FGuid> LightGuids;
 
    bool bHasSkyShadowing;
 
    FQuantizedLightmapData() :
        bHasSkyShadowing(false)
    {}
 
    ENGINE_API bool HasNonZeroData() const;
 
    ENGINE_API void Serialize(FArchive& Ar);
};
 
inline bool IsTexelMapped( const TArray<FLightMapCoefficients>& MappingData, int32 X, int32 Y, int32 Pitch )
{
    const FLightMapCoefficients& Sample = MappingData[Y * Pitch + X];
    bool bIsMapped = (Sample.Coverage > 0);
    return bIsMapped;
}
 
template <class TMappingData>
void CropUnmappedTexels( const TMappingData& MappingData, int32 SizeX, int32 SizeY, FIntRect& CroppedRect )
{
    int32 StartX = 0;
    int32 StartY = 0;
    int32 EndX = SizeX;
    int32 EndY = SizeY;
 
    CroppedRect.Min.X = EndX;
    CroppedRect.Min.Y = EndY;
    CroppedRect.Max.X = StartX - 1;
    CroppedRect.Max.Y = StartY - 1;
 
    for ( int32 Y = StartY; Y < EndY; ++Y )
    {
        bool bIsMappedRow = false;
 
        // Scan for first mapped texel in this row (also checks whether the row contains a mapped texel at all).
        for ( int32 X = StartX; X < EndX; ++X )
        {
            if ( IsTexelMapped( MappingData, X, Y, SizeX ) )
            {
                CroppedRect.Min.X = FMath::Min<int32>(CroppedRect.Min.X, X);
                bIsMappedRow = true;
                break;
            }
        }
 
        // Scan for the last mapped texel in this row.
        for ( int32 X = EndX-1; X > CroppedRect.Max.X; --X )
        {
            if ( IsTexelMapped( MappingData, X, Y, SizeX ) )
            {
                CroppedRect.Max.X = X;
                break;
            }
        }
 
        if ( bIsMappedRow )
        {
            CroppedRect.Min.Y = FMath::Min<int32>(CroppedRect.Min.Y, Y);
            CroppedRect.Max.Y = FMath::Max<int32>(CroppedRect.Max.Y, Y);
        }
    }
 
    CroppedRect.Max.X = CroppedRect.Max.X + 1;
    CroppedRect.Max.Y = CroppedRect.Max.Y + 1;
    CroppedRect.Min.X = FMath::Min<int32>(CroppedRect.Min.X, CroppedRect.Max.X);
    CroppedRect.Min.Y = FMath::Min<int32>(CroppedRect.Min.Y, CroppedRect.Max.Y);
}
 
class FLightmapResourceCluster : public FRenderResource
{
public:
    FLightmapResourceCluster() : AllocatedVT(nullptr) {}
    ENGINE_API virtual ~FLightmapResourceCluster();
 
    ENGINE_API virtual void InitRHI(FRHICommandListBase& RHICmdList);
    ENGINE_API virtual void ReleaseRHI();
 
    ENGINE_API void SetFeatureLevelAndInitialize(const FStaticFeatureLevel InFeatureLevel);
    ENGINE_API void TryInitializeUniformBuffer();
    ENGINE_API void UpdateUniformBuffer();
    
    ENGINE_API const IAllocatedVirtualTexture* GetAllocatedVT() const;
    ENGINE_API void ConditionalCreateAllocatedVT();
    ENGINE_API void ReleaseAllocatedVT();
    ENGINE_API bool GetUseVirtualTexturing() const;
 
    FLightmapClusterResourceInput Input;
    mutable IAllocatedVirtualTexture* AllocatedVT;
    FUniformBufferRHIRef UniformBuffer;
};