ImportanceSamplingLibrary.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "UObject/ObjectMacros.h"
#include "Engine/Texture2D.h"
#include "Kismet/BlueprintFunctionLibrary.h"
#include "ImportanceSamplingLibrary.generated.h"
 
UENUM(BlueprintType)
namespace EImportanceWeight
{
    enum Type : int
    {
        Luminance,
 
        Red,
        
        Green,
        
        Blue,
 
        Alpha,
    };
}
 
USTRUCT(BlueprintType, meta = (HasNativeMake = "/Script/Engine.ImportanceSamplingLibrary.MakeImportanceTexture", HasNativeBreak = "/Script/Engine.ImportanceSamplingLibrary.BreakImportanceTexture"))
struct FImportanceTexture
{
    GENERATED_BODY()
 
    // active texture dimensions, capped to 1024 x 1024
    UPROPERTY()
    FIntPoint Size;
 
    // active number of MIP levels
    UPROPERTY()
    int NumMips;
 
    // Unnormalized cumulative density of the image by rows (Size.Y+1)
    // First entry is zero, final entry is the CDF normalization factor
    UPROPERTY()
    TArray<float> MarginalCDF;
 
    // Unnormalized cumulative probability of each pixel in a row (Size.Y row CDFs of Size.X+1) 
    // First entry of each row is zero, final entry in each row is the CDF normalization factor for that row
    UPROPERTY()
    TArray<float> ConditionalCDF;
 
    UE_DEPRECATED(5.6, "FColor TextureData has been deprecated, use LinearTextureData")
    UPROPERTY(Transient, meta = (DeprecatedProperty, DeprecationMessage = "Please use LinearTextureData instead."))
    TArray<FColor> TextureData_DEPRECATED;
    
    // packed copy of MIP level data for filtered sampling (capped to 1024x1024)
    // local copy seems better than allocating and copying the same data temporarily for each sample
    UPROPERTY(Transient)
    TArray<FLinearColor> LinearTextureData;
 
    // Original texture object for Break function
    UPROPERTY()
    TWeakObjectPtr<UTexture2D> Texture;
 
    // Original importance weight for Break function
    UPROPERTY()
    TEnumAsByte<EImportanceWeight::Type> Weighting;
 
public:
    /* Default constructor, must Initialize before use */
    FImportanceTexture();
 
    /* Constructor with initialization */
    FImportanceTexture(UTexture2D *SourceTexture, TEnumAsByte<EImportanceWeight::Type> WeightingFunc);
 
    FImportanceTexture(const FImportanceTexture& Other);
    FImportanceTexture(FImportanceTexture&& Other);
    FImportanceTexture& operator=(const FImportanceTexture& Other);
    FImportanceTexture& operator=(FImportanceTexture&& Other);
 
 
    /* Allocate and compute PDF arrays for a texture */
    void Initialize(UTexture2D *SourceTexture, TEnumAsByte<EImportanceWeight::Type> WeightingFunc);
 
    void ImportanceSample(const FVector2D &Rand, int Samples, float Intensity,
            FVector2D &SamplePosition, FLinearColor &SampleColor, float &SampleIntensity, float &SampleSize) const;
 
    /* return color of texel at given MIP level, clamped to available Mip levels */
    FLinearColor GetColorBilinear(FVector2D Position, int32 Mip) const;
 
    /* return color interpolated between MIP levels */
    FLinearColor GetColorTrilinear(FVector2D Position, float Mip) const;
 
    /* importance probability weight for given texel */
    float ImportanceWeight(FColor Texel, TEnumAsByte<EImportanceWeight::Type> WeightingFunc) const;
};
 
 
UCLASS(MinimalAPI)
class UImportanceSamplingLibrary : public UBlueprintFunctionLibrary
{
    GENERATED_UCLASS_BODY()
 
    //
    // Sobol quasi-random generator functions
    //
 
    
    UFUNCTION(BlueprintPure, Category = "Math|Random")
    static ENGINE_API float RandomSobolFloat(int32 Index, int32 Dimension, float Seed);
 
    UFUNCTION(BlueprintPure, Category = "Math|Random")
    static ENGINE_API float NextSobolFloat(int32 Index, int32 Dimension, float PreviousValue);
 
    UFUNCTION(BlueprintPure, Category = "Math|Random")
    static ENGINE_API FVector2D RandomSobolCell2D(int32 Index, int32 NumCells = 1, FVector2D Cell = FVector2D(0,0), FVector2D Seed = FVector2D(0,0));
 
    UFUNCTION(BlueprintPure, Category = "Math|Random")
    static ENGINE_API FVector2D NextSobolCell2D(int32 Index, int32 NumCells = 1, FVector2D PreviousValue = FVector2D(0,0));
 
    UFUNCTION(BlueprintPure, Category = "Math|Random")
    static ENGINE_API FVector RandomSobolCell3D(int32 Index, int32 NumCells = 1, FVector Cell = FVector(0,0,0), FVector Seed = FVector(0,0,0));
 
    UFUNCTION(BlueprintPure, Category = "Math|Random")
    static ENGINE_API FVector NextSobolCell3D(int32 Index, int32 NumCells = 1, FVector PreviousValue = FVector(0,0,0));
 
    UFUNCTION(BlueprintPure, meta = (NativeMakeFunc), Category = "Math|Random")
    static ENGINE_API FImportanceTexture MakeImportanceTexture(UTexture2D *Texture, TEnumAsByte<EImportanceWeight::Type> WeightingFunc);
 
    UFUNCTION(BlueprintPure, meta = (NativeBreakFunc), Category = "Math|Random")
    static ENGINE_API void BreakImportanceTexture(const FImportanceTexture &ImportanceTexture, UTexture2D *&Texture, TEnumAsByte<EImportanceWeight::Type> &WeightingFunc);
 
    UFUNCTION(BlueprintPure, Category = "Math|Random")
    static ENGINE_API void ImportanceSample(const FImportanceTexture &Texture, const FVector2D &Rand, int Samples, float Intensity,
        FVector2D &SamplePosition, FLinearColor &SampleColor, float &SampleIntensity, float &SampleSize);
};