StaticLighting.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    StaticLighting.h: Static lighting definitions.
=============================================================================*/
 
#pragma once
 
#include "CoreMinimal.h"
#include "Misc/Guid.h"
#include "Templates/RefCounting.h"
#include "Components.h"
 
class FStaticLightingMapping;
class FStaticLightingBuildContext;
class FStaticLightingTextureMapping;
class ULevel;
class ULightComponent;
class UPrimitiveComponent;
 
struct FStaticLightingVertex
{
    FVector WorldPosition;
    FVector WorldTangentX;
    FVector WorldTangentY;
    FVector WorldTangentZ;
    FVector2D TextureCoordinates[MAX_STATIC_TEXCOORDS];
 
    // Operators used for linear combinations of static lighting vertices.
 
    friend FStaticLightingVertex operator+(const FStaticLightingVertex& A,const FStaticLightingVertex& B)
    {
        FStaticLightingVertex Result;
        Result.WorldPosition =  A.WorldPosition + B.WorldPosition;
        Result.WorldTangentX =  A.WorldTangentX + B.WorldTangentX;
        Result.WorldTangentY =  A.WorldTangentY + B.WorldTangentY;
        Result.WorldTangentZ =  A.WorldTangentZ + B.WorldTangentZ;
        for(int32 CoordinateIndex = 0;CoordinateIndex < MAX_STATIC_TEXCOORDS;CoordinateIndex++)
        {
            Result.TextureCoordinates[CoordinateIndex] = A.TextureCoordinates[CoordinateIndex] + B.TextureCoordinates[CoordinateIndex];
        }
        return Result;
    }
 
    friend FStaticLightingVertex operator-(const FStaticLightingVertex& A,const FStaticLightingVertex& B)
    {
        FStaticLightingVertex Result;
        Result.WorldPosition =  A.WorldPosition - B.WorldPosition;
        Result.WorldTangentX =  A.WorldTangentX - B.WorldTangentX;
        Result.WorldTangentY =  A.WorldTangentY - B.WorldTangentY;
        Result.WorldTangentZ =  A.WorldTangentZ - B.WorldTangentZ;
        for(int32 CoordinateIndex = 0;CoordinateIndex < MAX_STATIC_TEXCOORDS;CoordinateIndex++)
        {
            Result.TextureCoordinates[CoordinateIndex] = A.TextureCoordinates[CoordinateIndex] - B.TextureCoordinates[CoordinateIndex];
        }
        return Result;
    }
 
    friend FStaticLightingVertex operator*(const FStaticLightingVertex& A,float B)
    {
        FStaticLightingVertex Result;
        Result.WorldPosition =  A.WorldPosition * B;
        Result.WorldTangentX =  A.WorldTangentX * B;
        Result.WorldTangentY =  A.WorldTangentY * B;
        Result.WorldTangentZ =  A.WorldTangentZ * B;
        for(int32 CoordinateIndex = 0;CoordinateIndex < MAX_STATIC_TEXCOORDS;CoordinateIndex++)
        {
            Result.TextureCoordinates[CoordinateIndex] = A.TextureCoordinates[CoordinateIndex] * B;
        }
        return Result;
    }
 
    friend FStaticLightingVertex operator/(const FStaticLightingVertex& A,float B)
    {
        const float InvB = 1.0f / B;
 
        FStaticLightingVertex Result;
        Result.WorldPosition =  A.WorldPosition * InvB;
        Result.WorldTangentX =  A.WorldTangentX * InvB;
        Result.WorldTangentY =  A.WorldTangentY * InvB;
        Result.WorldTangentZ =  A.WorldTangentZ * InvB;
        for(int32 CoordinateIndex = 0;CoordinateIndex < MAX_STATIC_TEXCOORDS;CoordinateIndex++)
        {
            Result.TextureCoordinates[CoordinateIndex] = A.TextureCoordinates[CoordinateIndex] * InvB;
        }
        return Result;
    }
};
 
class FLightRayIntersection
{
public:
 
    uint32 bIntersects : 1;
 
    FStaticLightingVertex IntersectionVertex;
 
    FLightRayIntersection(bool bInIntersects,const FStaticLightingVertex& InIntersectionVertex):
        bIntersects(bInIntersects),
        IntersectionVertex(InIntersectionVertex)
    {}
 
    static FLightRayIntersection None() { return FLightRayIntersection(false,FStaticLightingVertex()); }
};
 
class FStaticLightingMesh : public virtual FRefCountedObject
{
public:
 
    const int32 NumTriangles;
 
    const int32 NumShadingTriangles;
 
    const int32 NumVertices;
 
    const int32 NumShadingVertices;
 
    const int32 TextureCoordinateIndex;
 
    TArray<int32> VisibilityIds;
 
    const uint32 bCastShadow : 1;
 
    const uint32 bTwoSidedMaterial : 1;
 
    const TArray<ULightComponent*> RelevantLights;
 
    TArray<FGuid> RelevantLightsGuid;
    
    const UPrimitiveComponent* const Component;
 
    FGuid ComponentGuid;
 
    FBox BoundingBox;
 
    FGuid Guid;
 
    FGuid SourceMeshGuid;
 
    TArray<TRefCountPtr<FStaticLightingMesh> > OtherMeshLODs;
 
    uint32 HLODTreeIndex;
    uint32 HLODChildStartIndex;
    uint32 HLODChildEndIndex;
 
    ENGINE_API FStaticLightingMesh(
        int32 InNumTriangles,
        int32 InNumShadingTriangles,
        int32 InNumVertices,
        int32 InNumShadingVertices,
        int32 InTextureCoordinateIndex,
        bool bInCastShadow,
        bool bInTwoSidedMaterial,
        const TArray<ULightComponent*>& InRelevantLights,
        const UPrimitiveComponent* const InComponent,
        const FBox& InBoundingBox,
        const FGuid& InSourceMeshGuid,
        const FGuid& InComponentGuid
        );
 
    ENGINE_API FStaticLightingMesh();
 
    ENGINE_API virtual void Serialize(FArchive& Ar);
 
    virtual ~FStaticLightingMesh() {}
 
    virtual void GetTriangle(int32 TriangleIndex,FStaticLightingVertex& OutV0,FStaticLightingVertex& OutV1,FStaticLightingVertex& OutV2) const = 0;
 
    virtual void GetShadingTriangle(int32 TriangleIndex,FStaticLightingVertex& OutV0,FStaticLightingVertex& OutV1,FStaticLightingVertex& OutV2) const
    {
        checkSlow(NumTriangles == NumShadingTriangles);
        // By default the geometry used for shading is the same as the geometry used for visibility testing.
        GetTriangle(TriangleIndex, OutV0, OutV1, OutV2);
    }
 
    virtual void GetTriangleIndices(int32 TriangleIndex,int32& OutI0,int32& OutI1,int32& OutI2) const = 0;
 
    virtual void GetShadingTriangleIndices(int32 TriangleIndex,int32& OutI0,int32& OutI1,int32& OutI2) const
    { 
        checkSlow(NumTriangles == NumShadingTriangles);
        // By default the geometry used for shading is the same as the geometry used for visibility testing.
        GetTriangleIndices(TriangleIndex, OutI0, OutI1, OutI2);
    }
 
    virtual bool ShouldCastShadow(ULightComponent* Light,const FStaticLightingMapping* Receiver) const;
 
    virtual bool IsTriangleCastingShadow(uint32 TriangleIndex) const
    {
        return true;
    }
 
    virtual bool IsControllingShadowPerElement() const
    {
        return false;
    }
 
    virtual bool IsUniformShadowCaster() const
    {
        return bCastShadow;
    }
 
    virtual FLightRayIntersection IntersectLightRay(const FVector& Start,const FVector& End,bool bFindNearestIntersection) const = 0;
 
#if WITH_EDITOR
    virtual void ExportMeshInstance(class FLightmassExporter* Exporter) const {}
#endif  //#if WITH_EDITOR
 
    virtual const FGuid&    GetLightingGuid() const
    {
        return Guid;
    }
 
    virtual bool IsInstancedMesh() const = 0;
};
 
class FStaticLightingMapping : public virtual FRefCountedObject
{
public:
 
    class FStaticLightingMesh* Mesh;
 
    UObject* Owner;
 
    uint32 bProcessMapping : 1;
 
    uint32 bIsDeferred : 1;
 
    FStaticLightingMapping(FStaticLightingMesh* InMesh,UObject* InOwner):
        Mesh(InMesh),
        Owner(InOwner),
        bProcessMapping(false),
        bIsDeferred(false)
    {}
 
    virtual ~FStaticLightingMapping() {}
 
    virtual FStaticLightingTextureMapping* GetTextureMapping()
    {
        return NULL;
    }
 
    virtual bool IsTextureMapping() const
    {
        return false;
    }
 
#if WITH_EDITOR
    virtual bool DebugThisMapping() const = 0;
 
    virtual void ExportMapping(class FLightmassExporter* Exporter) {};
#endif  //WITH_EDITOR
 
    virtual const FGuid& GetLightingGuid() const
    {
        return Mesh->Guid;
    }
 
    virtual FString GetDescription() const
    {
        return FString(TEXT("Mapping"));
    }
 
    virtual int32 GetTexelCount() const
    {
        return 0;
    }
 
    bool IsDeferred() const
    {
        return !!bIsDeferred;
    }
 
    FStaticLightingMapping(const FArchive&) : Mesh(nullptr), Owner(nullptr), bProcessMapping(false), bIsDeferred(false) { }
 
#if WITH_EDITOR
 
    ENGINE_API virtual void Serialize(FArchive& Ar);
    
    virtual UObject* GetMappedObject() const
    {
        return Owner;
    }
#endif  //WITH_EDITOR
};
 
inline bool FStaticLightingMesh::ShouldCastShadow(ULightComponent* Light,const FStaticLightingMapping* Receiver) const
{
    // If this is a shadow casting mesh, then it is allowed to cast a shadow on the receiver from this light.
    return bCastShadow;
}
 
class FStaticLightingTextureMapping : public FStaticLightingMapping
{
public:
 
    int32 SizeX;
 
    int32 SizeY;
 
    int32 LightmapTextureCoordinateIndex;
 
    bool bBilinearFilter;
 
    ENGINE_API FStaticLightingTextureMapping(FStaticLightingMesh* InMesh, UObject* InOwner, int32 InSizeX, int32 InSizeY, int32 InLightmapTextureCoordinateIndex, bool bInBilinearFilter = true);
 
    virtual void Apply(struct FQuantizedLightmapData* QuantizedData, const TMap<ULightComponent*,class FShadowMapData2D*>& ShadowMapData, const FStaticLightingBuildContext* LightingContext) = 0;
 
    // FStaticLightingMapping interface.
    virtual FStaticLightingTextureMapping* GetTextureMapping()
    {
        return this;
    }
 
    virtual bool IsTextureMapping() const
    {
        return true;
    }
 
    virtual bool IsValidMapping() const {return true;}
 
#if WITH_EDITOR
    UNREALED_API virtual bool DebugThisMapping() const;
    ENGINE_API virtual void Serialize(FArchive& Ar);
#endif  //WITH_EDITOR
 
    virtual FString GetDescription() const
    {
        return FString(TEXT("TextureMapping"));
    }
 
    virtual int32 GetTexelCount() const
    {
        return (SizeX * SizeY);
    }
 
    FStaticLightingTextureMapping(const FArchive& Ar) : FStaticLightingMapping(Ar) { }
};
 
class FStaticLightingGlobalVolumeMapping : public FStaticLightingTextureMapping
{
public:
 
    ENGINE_API FStaticLightingGlobalVolumeMapping(FStaticLightingMesh* InMesh, UObject* InOwner, int32 InSizeX, int32 InSizeY, int32 InLightmapTextureCoordinateIndex);
 
    virtual void Apply(struct FQuantizedLightmapData* QuantizedData, const TMap<ULightComponent*,class FShadowMapData2D*>& ShadowMapData, const FStaticLightingBuildContext* LightingContext) override
    {
        // Should never be processed
        check(false);
    }
 
#if WITH_EDITOR
    virtual bool DebugThisMapping() const
    {
        return false;
    }
 
    UNREALED_API virtual void ExportMapping(class FLightmassExporter* Exporter) override;
#endif  //WITH_EDITOR
 
    virtual bool IsValidMapping() const {return true;}
 
    virtual FString GetDescription() const
    {
        return FString(TEXT("VolumeMapping"));
    }
};
 
struct FStaticLightingPrimitiveInfo
{
    FStaticLightingPrimitiveInfo() :
        VisibilityId(INDEX_NONE)
    {}
    int32 VisibilityId;
    TArray< TRefCountPtr<FStaticLightingMesh> > Meshes;
 
    TArray< TRefCountPtr<FStaticLightingMapping> > Mappings;
};