Function RenderDriver

BakingLab/MeshBaker.cpp:1099–1221

Runs a single iteration of the ground truth render thread. This function will compute a single radiance for every pixel within a tile, and blend with with the previous result.

// Runs a single iteration of the ground truth render thread. This function will compute
// a single radiance for every pixel within a tile, and blend with with the previous result.
static bool RenderDriver(RenderThreadContext& context)
{
    if(context.CurrNumTiles == 0)
        return false;

    const uint64 tileIdx = InterlockedIncrement64(context.CurrTile) - 1;
    const uint64 passIdx = tileIdx / context.CurrNumTiles;
    const uint64 passTileIdx = tileIdx % context.CurrNumTiles;

    const uint64 sqrtNumSamples = context.CurrNumSamples;
    const uint64 numSamplesPerPixel = sqrtNumSamples * sqrtNumSamples;
    if(passIdx >= numSamplesPerPixel)
        return false;

    const uint64 numPixelsPerTile = TileSize * TileSize;

    const Float4x4 viewProjInv = context.ViewProjInv;
    const uint64 screenWidth = context.OutputWidth;
    const uint64 screenHeight = context.OutputHeight;
    const uint64 numTilesX = (screenWidth + (TileSize - 1)) / TileSize;
    const uint64 numTilesY = (screenHeight + (TileSize - 1)) / TileSize;
    const uint64 tileX = passTileIdx % numTilesX;
    const uint64 tileY = passTileIdx / numTilesX;
    const uint64 startX = tileX * TileSize;
    const uint64 startY = tileY * TileSize;
    const uint64 endX = std::min(startX + TileSize, screenWidth);
    const uint64 endY = std::min(startY + TileSize, screenHeight);

    const Float3x3 cameraRot = context.CameraOrientation.ToFloat3x3();
    const Float3 cameraX = cameraRot.Right();
    const Float3 cameraY = cameraRot.Up();

    const float focusDistance = AppSettings::FocusDistance;
    const float apertureSize = AppSettings::ApertureWidth;

    const float numSides = float(AppSettings::NumBlades);
    const float polyAmt = AppSettings::BokehPolygonAmount;

    const uint64 passIdxX = passIdx % sqrtNumSamples;
    const uint64 passIdxY = passIdx / sqrtNumSamples;

    const bool32 enableDOF = AppSettings::EnableDOF;

    const uint64 numThreads = context.Samples->size();
    const IntegrationSamples& samples = (*context.Samples)[passTileIdx % numThreads];

    const int32 pathLength = AppSettings::EnableIndirectLighting ? AppSettings::MaxRenderPathLength : 2;

    uint64 tilePixelIdx = 0;
    for(uint64 y = startY; y < endY; ++y)
    {
        for(uint64 x = startX; x < endX; ++x)
        {
            const uint64 pixelIdx = (y * screenWidth + x);
            IntegrationSampleSet sampleSet;
            sampleSet.Init(samples, tilePixelIdx, passIdx);

            Float2 pixelSample = sampleSet.Pixel();