Precompute.hpp

Go to the documentation of this file.

#pragma once
#include <Core/Container.hpp>
#include <Core/JobSystem.hpp>
#include <Math/Math.hpp>
#include "Texture.hpp"
using namespace Foundation;
using namespace Core;
using namespace Math;
// https://www.pbr-book.org/4ed/Sampling_Algorithms/The_Alias_Method#AliasTable
struct GSAlias
{
    float prob, select;
    uint alias;
};
static_assert(sizeof(GSAlias) == 12);
 
struct AliasTable
{
    Vector<GSAlias> mBins;
    AliasTable(Span<const float> f, Allocator* alloc);
    // Index into mBins
    uint Sample(float u, float& pdf) const;
    float PDF(uint sample) const { return mBins[sample].prob; }
};
[[nodiscard]] bool AliasTableRunSelfTests(Allocator* alloc, String* outError = nullptr);
// https://www.pbr-book.org/4ed/Sampling_Algorithms/Sampling_1D_Functions#eq:piecewise-step-integral
struct PiecewiseConstant1D
{
    Vector<float> mF, mCDF;
    float mInt;
    PiecewiseConstant1D(Span<const float> f, Allocator* alloc);
 
    float Int() const { return mInt; }
    // Uniform location in [0,1]
    float Sample(float u, float& pdf, uint& offset) const;
    float PDF(float sample) const {
        uint offset = clamp(static_cast<uint>(sample * mF.size()), 0u, static_cast<uint>(mF.size() - 1));
        return mInt > 0.0f ? mF[offset] / mInt : 0.0f;
    }
};
// https://www.pbr-book.org/4ed/Sampling_Algorithms/Sampling_Multidimensional_Functions#PiecewiseConstant2D
struct PiecewiseConstant2D
{
    Vector<float> mF;
    UniquePtr<PiecewiseConstant1D> mMarginal; // p(v)
    Vector<UniquePtr<PiecewiseConstant1D>> mConditional; // p(u|v)
 
    PiecewiseConstant2D(Span<const float> f, uint nu, uint nv, Allocator* alloc);
 
    uint2 Domain() const { return { mConditional[0]->mF.size(), mConditional.size() }; }
 
    float Int() const { return mMarginal->Int(); }
    float2 Sample(float2 u, float& pdf, uint2& offset) const;
    float PDF(float2 sample) const;
};
void PrefilterEnvmapSH9(const FTexture& source, Span<float3> sh9, JobSystem* jobs, Allocator* alloc);
FTexture PrefilterEnvmapSpecular(const FTexture& source, JobSystem* jobs, Allocator* alloc);
float ReflectionRoughnessFromMip(uint32_t mip, uint32_t numMips);
float ReflectionMipFromRoughness(float roughness, uint32_t numMips);