Renderer.h

Go to the documentation of this file.

#pragma once
 
#include "Core/Renderer/RenderWorker.h"
#include "Core/Renderer/RenderWork.h"
#include "Core/SampleGenerator/SampleGenerator.h"
#include "Math/Geometry/TAABB2D.h"
#include "Core/Renderer/ERegionStatus.h"
#include "Core/Renderer/Statistics.h"
#include "Frame/frame_fwd.h"
#include "Core/Renderer/AttributeTags.h"
#include "Core/Renderer/RenderStats.h"
#include "Core/Scheduler/Region.h"
#include "Core/Renderer/RenderRegionStatus.h"
#include "Core/Renderer/RenderObservationInfo.h"
#include "Frame/Viewport.h"
#include "Utility/Timer.h"
#include "Utility/TSpan.h"
 
#include <Common/assertion.h>
#include <Common/primitive_type.h>
 
#include <cstddef>
#include <vector>
#include <mutex>
#include <memory>
#include <atomic>
#include <deque>
#include <string>
 
namespace ph { class CoreCookedUnit; }
namespace ph { class VisualWorld; }
 
namespace ph
{
 
class RenderWorker;
 
class Renderer
{
public:
    Renderer(Viewport viewport, uint32 numWorkers);
 
    virtual ~Renderer();
 
    virtual void doUpdate(const CoreCookedUnit& cooked, const VisualWorld& world) = 0;
 
    virtual void doRender() = 0;
 
    virtual void retrieveFrame(std::size_t layerIndex, HdrRgbFrame& out_frame) = 0;
 
    virtual std::size_t asyncPollUpdatedRegions(TSpan<RenderRegionStatus> out_regions) = 0;
    
    virtual RenderStats asyncQueryRenderStats() = 0;
 
    virtual RenderProgress asyncQueryRenderProgress() = 0;
 
    virtual void asyncPeekFrame(
        std::size_t   layerIndex,
        const Region& region,
        HdrRgbFrame&  out_frame) = 0;
 
    virtual RenderObservationInfo getObservationInfo() const = 0;
 
    void update(const CoreCookedUnit& cooked, const VisualWorld& world);
 
    void render();
 
    void setNumWorkers(uint32 numWorkers);
 
    uint32 numWorkers() const;
    uint32 getRenderWidthPx() const;
    uint32 getRenderHeightPx() const;
 
    math::TAABB2D<int64> getCropWindowPx() const;
 
    math::TAABB2D<int64> getRenderRegionPx() const;
 
    const Viewport& getViewport() const;
 
    bool asyncIsUpdating() const;
    bool asyncIsRendering() const;
 
    std::size_t asyncPollMergedUpdatedRegions(
        TSpan<RenderRegionStatus> out_regions,
        std::size_t mergeSize);
 
private:
    Viewport m_viewport;
    uint32   m_numWorkers;
 
    std::vector<RenderWorker> m_workers;
 
    std::atomic_bool m_isUpdating;
    std::atomic_bool m_isRendering;
};
 
// In-header Implementations:
 
inline uint32 Renderer::numWorkers() const
{
    return m_numWorkers;
}
 
inline uint32 Renderer::getRenderWidthPx() const
{
    return m_viewport.getBaseSizePx().x();
}
 
inline uint32 Renderer::getRenderHeightPx() const
{
    return m_viewport.getBaseSizePx().y();
}
 
inline math::TAABB2D<int64> Renderer::getCropWindowPx() const
{
    return m_viewport.getWindowPx();
}
 
inline math::TAABB2D<int64> Renderer::getRenderRegionPx() const
{
    return m_viewport.getCroppedRegionPx();
}
 
inline const Viewport& Renderer::getViewport() const
{
    return m_viewport;
}
 
inline bool Renderer::asyncIsUpdating() const
{
    return m_isUpdating.load(std::memory_order_relaxed);
}
 
inline bool Renderer::asyncIsRendering() const
{
    return m_isRendering.load(std::memory_order_relaxed);
}
 
}// end namespace ph