taskControllerSceneIndex.h

//
// Copyright 2025 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
#ifndef PXR_IMAGING_HDX_TASK_CONTROLLER_SCENE_INDEX_H
#define PXR_IMAGING_HDX_TASK_CONTROLLER_SCENE_INDEX_H
 
#include "pxr/pxr.h"
 
#include "pxr/imaging/hdx/api.h"
#include "pxr/imaging/hdx/boundingBoxTask.h"
#include "pxr/imaging/hdx/colorCorrectionTask.h"
#include "pxr/imaging/hdx/renderSetupTask.h"
#include "pxr/imaging/hdx/shadowTask.h"
 
#include "pxr/imaging/hd/aov.h"
#include "pxr/imaging/hd/renderIndex.h"
#include "pxr/imaging/hd/sceneIndex.h"
#include "pxr/imaging/hd/task.h"
 
#include "pxr/imaging/cameraUtil/framing.h"
#include "pxr/imaging/glf/simpleLightingContext.h"
 
#include "pxr/base/gf/matrix4d.h"
 
PXR_NAMESPACE_OPEN_SCOPE
 
HDX_API
extern TfEnvSetting<int> HDX_MSAA_SAMPLE_COUNT;
 
TF_DECLARE_REF_PTRS(HdRetainedSceneIndex);
TF_DECLARE_REF_PTRS(HdxTaskControllerSceneIndex);
 
// XXX: This API is transitional. At the least, render/picking/selection
// APIs should be decoupled.
//
class HdxTaskControllerSceneIndex final : public HdSceneIndexBase
{
public:
    using AovDescriptorCallback =
        std::function<HdAovDescriptor(const TfToken &name)>;
 
    struct Parameters
    {
        const SdfPath prefix;
        const AovDescriptorCallback aovDescriptorCallback;
        bool isForStorm;
        bool gpuEnabled;
    };
 
    HDX_API
    static
    HdxTaskControllerSceneIndexRefPtr
    New(const Parameters& params);
 
    HDX_API
    ~HdxTaskControllerSceneIndex() override;
 
    HDX_API
    HdSceneIndexPrim GetPrim(const SdfPath &primPath) const override;
 
    HDX_API
    SdfPathVector GetChildPrimPaths(const SdfPath &primPath) const override;
 
 
    HDX_API
    SdfPathVector GetRenderingTaskPaths() const;
 
    HDX_API
    SdfPathVector GetPickingTaskPaths() const;
 
    HDX_API
    SdfPath GetRenderBufferPath(const TfToken &aovName) const;
 
 
    HDX_API
    void SetCollection(const HdRprimCollection &collection);
 
    HDX_API
    void SetRenderParams(const HdxRenderTaskParams &params);
 
    HDX_API
    void SetRenderTags(const TfTokenVector &renderTags);
 
 
    HDX_API
    void SetRenderOutputs(const TfTokenVector &aovNames);
 
    HDX_API
    void SetViewportRenderOutput(TfToken const &aovName);
 
    HDX_API
    void SetRenderOutputSettings(TfToken const& aovName,
                                 const HdAovDescriptor &desc);
 
    HDX_API
    HdAovDescriptor GetRenderOutputSettings(const TfToken &aovName) const;
 
    HDX_API
    void SetPresentationOutput(const TfToken &api, const VtValue &framebuffer);
 
 
    HDX_API
    void SetLightingState(GlfSimpleLightingContextPtr const& src);
 
 
    HDX_API
    void SetRenderBufferSize(const GfVec2i &size);
 
    HDX_API
    void SetFraming(const CameraUtilFraming &framing);
 
    HDX_API
    void SetOverrideWindowPolicy(
        const std::optional<CameraUtilConformWindowPolicy> &policy);
 
    HDX_API
    void SetCameraPath(const SdfPath &path);
 
    HDX_API
    void SetRenderViewport(const GfVec4d &viewport);
 
    HDX_API
    void SetFreeCameraMatrices(const GfMatrix4d &viewMatrix,
                               const GfMatrix4d &projectionMatrix);
    HDX_API
    void SetFreeCameraClipPlanes(const std::vector<GfVec4d> &clipPlanes);
 
 
    HDX_API
    void SetEnableSelection(bool enable);
 
    HDX_API
    void SetSelectionColor(const GfVec4f &color);
 
    HDX_API
    void SetSelectionLocateColor(const GfVec4f &color);
 
    HDX_API
    void SetSelectionEnableOutline(bool enableOutline);
 
    HDX_API
    void SetSelectionOutlineRadius(unsigned int radius);
 
 
    HDX_API
    void SetEnableShadows(bool enable);
 
    HDX_API
    void SetShadowParams(const HdxShadowTaskParams &params);
 
 
    HDX_API
    void SetColorCorrectionParams(const HdxColorCorrectionTaskParams &params);
 
 
    HDX_API
    void SetBBoxParams(const HdxBoundingBoxTaskParams& params);
 
 
    HDX_API
    void SetEnablePresentation(bool enabled);
 
private:
    HdxTaskControllerSceneIndex(const Parameters& params);
 
    bool _IsForStorm() const;
    bool _RunGpuAovTasks() const;
 
    void _CreateStormTasks();
    void _CreateGenericTasks();
 
    SdfPathVector _GetRenderingTaskPathsForStorm() const;
    SdfPathVector _GetRenderingTaskPathsForGenericRenderer() const;
 
    GfVec3i _RenderBufferDimensions() const;
 
    void _SetRenderOutputs(const TfTokenVector &aovNames);
    void _SetCameraFramingForTasks();
    void _SetRenderBufferSize();
    void _SetSimpleLightTaskParams(GlfSimpleLightingContextPtr const& src);
    void _SetLights(const GlfSimpleLightVector &lights);
 
    const Parameters _params;
 
    HdRetainedSceneIndexRefPtr const _retainedSceneIndex;
 
    // All tasks using HdxRenderTaskParams.
    SdfPathVector _renderTaskPaths;
    SdfPath _activeCameraId;
 
    // Generated renderbuffers
    TfTokenVector _aovNames;
    TfToken _viewportAov;
 
    GfVec2i _renderBufferSize;
    CameraUtilFraming _framing;
    std::optional<CameraUtilConformWindowPolicy> _overrideWindowPolicy;
 
    GfVec4d _viewport;
 
    friend class _Observer;
    class _Observer : public HdSceneIndexObserver
    {
    public:
        _Observer(HdxTaskControllerSceneIndex * const owner)
         : _owner(owner) {}
 
          HDX_API
          void PrimsAdded(
                  const HdSceneIndexBase &sender,
                  const AddedPrimEntries &entries) override;
 
          HDX_API
          void PrimsRemoved(
                  const HdSceneIndexBase &sender,
                  const RemovedPrimEntries &entries) override;
 
          HDX_API
          void PrimsDirtied(
                  const HdSceneIndexBase &sender,
                  const DirtiedPrimEntries &entries) override;
 
          HDX_API
          void PrimsRenamed(
                  const HdSceneIndexBase &sender,
                  const RenamedPrimEntries &entries) override;
    private:
        HdxTaskControllerSceneIndex * const _owner;
    };
    _Observer _observer;
};
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_IMAGING_HDX_TASK_CONTROLLER_SCENE_INDEX_H