taskController.h

//
// Copyright 2017 Pixar
//
// Licensed under the Apache License, Version 2.0 (the "Apache License")
// with the following modification; you may not use this file except in
// compliance with the Apache License and the following modification to it:
// Section 6. Trademarks. is deleted and replaced with:
//
// 6. Trademarks. This License does not grant permission to use the trade
//    names, trademarks, service marks, or product names of the Licensor
//    and its affiliates, except as required to comply with Section 4(c) of
//    the License and to reproduce the content of the NOTICE file.
//
// You may obtain a copy of the Apache License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the Apache License with the above modification is
// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the Apache License for the specific
// language governing permissions and limitations under the Apache License.
//
#ifndef PXR_IMAGING_HDX_TASK_CONTROLLER_H
#define PXR_IMAGING_HDX_TASK_CONTROLLER_H
 
#include "pxr/pxr.h"
 
#include "pxr/imaging/hdx/api.h"
#include "pxr/imaging/hdx/selectionTracker.h"
#include "pxr/imaging/hdx/renderSetupTask.h"
#include "pxr/imaging/hdx/shadowTask.h"
#include "pxr/imaging/hdx/colorCorrectionTask.h"
#include "pxr/imaging/hdx/boundingBoxTask.h"
 
#include "pxr/imaging/hd/aov.h"
#include "pxr/imaging/hd/renderIndex.h"
#include "pxr/imaging/hd/sceneDelegate.h"
#include "pxr/imaging/hd/task.h"
 
#include "pxr/imaging/cameraUtil/framing.h"
#include "pxr/imaging/glf/simpleLightingContext.h"
#include "pxr/usd/sdf/path.h"
 
#include "pxr/base/gf/bbox3d.h"
#include "pxr/base/gf/matrix4d.h"
 
PXR_NAMESPACE_OPEN_SCOPE
 
// XXX: This API is transitional. At the least, render/picking/selection
// APIs should be decoupled.
 
class HdRenderBuffer;
 
class HdxTaskController final
{
public:
    HDX_API
    HdxTaskController(HdRenderIndex *renderIndex,
                      SdfPath const& controllerId,
                      bool gpuEnabled = true);
    HDX_API
    ~HdxTaskController();
 
    HdRenderIndex* GetRenderIndex() { return _index; }
    HdRenderIndex const* GetRenderIndex() const { return _index; }
 
    SdfPath const& GetControllerId() const { return _controllerId; }
 
 
    HDX_API
    HdTaskSharedPtrVector const GetRenderingTasks() const;
 
    HDX_API
    HdTaskSharedPtrVector const GetPickingTasks() const;
 
 
    HDX_API
    void SetCollection(HdRprimCollection const& collection);
 
    HDX_API
    void SetRenderParams(HdxRenderTaskParams const& params);
 
    HDX_API
    void SetRenderTags(TfTokenVector const& renderTags);
 
 
    HDX_API
    void SetRenderOutputs(TfTokenVector const& names);
 
    HDX_API
    void SetViewportRenderOutput(TfToken const& name);
 
    HDX_API
    HdRenderBuffer* GetRenderOutput(TfToken const& name);
 
    HDX_API
    void SetRenderOutputSettings(TfToken const& name,
                                 HdAovDescriptor const& desc);
 
    HDX_API
    HdAovDescriptor GetRenderOutputSettings(TfToken const& name) const;
 
    HDX_API
    void SetPresentationOutput(TfToken const &api, VtValue const &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(SdfPath const& id);
 
    HDX_API
    void SetRenderViewport(GfVec4d const& viewport);
 
    HDX_API
    void SetFreeCameraMatrices(GfMatrix4d const& viewMatrix,
                               GfMatrix4d const& projectionMatrix);
    HDX_API
    void SetFreeCameraClipPlanes(std::vector<GfVec4d> const& clipPlanes);
 
 
    HDX_API
    void SetEnableSelection(bool enable);
 
    HDX_API
    void SetSelectionColor(GfVec4f const& color);
 
    HDX_API
    void SetSelectionLocateColor(GfVec4f const& color);
 
    HDX_API
    void SetSelectionEnableOutline(bool enableOutline);
 
    HDX_API
    void SetSelectionOutlineRadius(unsigned int radius);
 
 
    HDX_API
    void SetEnableShadows(bool enable);
 
    HDX_API
    void SetShadowParams(HdxShadowTaskParams const& params);
 
 
    HDX_API
    bool IsConverged() const;
 
 
    HDX_API
    void SetColorCorrectionParams(HdxColorCorrectionTaskParams const& params);
 
 
    HDX_API
    void SetBBoxParams(const HdxBoundingBoxTaskParams& params);
 
 
    HDX_API
    void SetEnablePresentation(bool enabled);
 
private:
    HdxTaskController(HdxTaskController const&) = delete;
    HdxTaskController &operator=(HdxTaskController const&) = delete;
 
    HdRenderIndex *_index;
    SdfPath const _controllerId;
    bool _gpuEnabled;
 
    // Create taskController objects. Since the camera is a parameter
    // to the tasks, _CreateCamera() should be called first.
    void _CreateRenderGraph();
 
    void _CreateLightingTask();
    void _CreateShadowTask();
    SdfPath _CreateSkydomeTask();
    SdfPath _CreateRenderTask(TfToken const& materialTag);
    void _CreateOitResolveTask();
    void _CreateSelectionTask();
    void _CreateColorizeSelectionTask();
    void _CreateColorCorrectionTask();
    void _CreateVisualizeAovTask();
    void _CreatePickTask();
    void _CreatePickFromRenderBufferTask();
    void _CreateBoundingBoxTask();
    void _CreateAovInputTask();
    void _CreatePresentTask();
 
    void _SetCameraParamForTasks(SdfPath const& id);
    void _SetCameraFramingForTasks();
    void _UpdateAovDimensions(GfVec2i const& dimensions);
 
    void _SetBlendStateForMaterialTag(TfToken const& materialTag,
                                      HdxRenderTaskParams *renderParams) const;
 
    // Render graph topology control.
    bool _ShadowsEnabled() const;
    bool _SelectionEnabled() const;
    bool _ColorizeSelectionEnabled() const;
    bool _ColorCorrectionEnabled() const;
    bool _VisualizeAovEnabled() const;
    bool _ColorizeQuantizationEnabled() const;
    bool _AovsSupported() const;
    bool _UsingAovs() const;
 
    // Helper function for renderbuffer management.
    SdfPath _GetRenderTaskPath(TfToken const& materialTag) const;
    SdfPath _GetAovPath(TfToken const& aov) const;
    SdfPathVector _GetAovEnabledTasks() const;
 
    // Helper functions to set up the lighting state for the built-in lights
    bool _SupportBuiltInLightTypes();
    void _SetBuiltInLightingState(GlfSimpleLightingContextPtr const& src);
 
    // Helper function to get the built-in Camera light type SimpleLight for
    // Storm, and DistantLight otherwise
    TfToken _GetCameraLightType();
    
    // Helper functions to set the parameters of a light, get a particular light 
    // in the scene, replace and remove Sprims from the scene 
    VtValue _GetDomeLightTexture(GlfSimpleLight const& light);
    void _SetParameters(SdfPath const& pathName, GlfSimpleLight const& light);
    void _SetMaterialNetwork(SdfPath const& pathName, 
                             GlfSimpleLight const& light);
    GlfSimpleLight _GetLightAtId(size_t const& pathIdx);
    void _RemoveLightSprim(size_t const& pathIdx);
    void _ReplaceLightSprim(size_t const& pathIdx, GlfSimpleLight const& light, 
                        SdfPath const& pathName);
 
    // A private scene delegate member variable backs the tasks and the free cam
    // this controller generates. To keep _Delegate simple, the containing class
    // is responsible for marking things dirty.
    class _Delegate : public HdSceneDelegate
    {
    public:
        _Delegate(HdRenderIndex *parentIndex,
                  SdfPath const& delegateID)
            : HdSceneDelegate(parentIndex, delegateID)
            {}
        ~_Delegate() override = default;
 
        // HdxTaskController set/get interface
        template <typename T>
        void SetParameter(SdfPath const& id, TfToken const& key,
                          T const& value) {
            _valueCacheMap[id][key] = value;
        }
        template <typename T>
        T GetParameter(SdfPath const& id, TfToken const& key) const {
            VtValue vParams;
            _ValueCache vCache;
            TF_VERIFY(
                TfMapLookup(_valueCacheMap, id, &vCache) &&
                TfMapLookup(vCache, key, &vParams) &&
                vParams.IsHolding<T>());
            return vParams.Get<T>();
        }
        bool HasParameter(SdfPath const& id, TfToken const& key) const {
            _ValueCache vCache;
            if (TfMapLookup(_valueCacheMap, id, &vCache) &&
                vCache.count(key) > 0) {
                return true;
            }
            return false;
        }
 
        // HdSceneDelegate interface
        VtValue Get(SdfPath const& id, TfToken const& key) override;
        GfMatrix4d GetTransform(SdfPath const& id) override;
        VtValue GetLightParamValue(SdfPath const& id, 
                                   TfToken const& paramName) override;
        VtValue GetMaterialResource(SdfPath const& id) override;
        bool IsEnabled(TfToken const& option) const override;
        HdRenderBufferDescriptor
            GetRenderBufferDescriptor(SdfPath const& id) override;
        TfTokenVector GetTaskRenderTags(SdfPath const& taskId) override;
 
 
    private:
        using _ValueCache = TfHashMap<TfToken, VtValue, TfToken::HashFunctor>;
        using _ValueCacheMap = TfHashMap<SdfPath, _ValueCache, SdfPath::Hash>;
        _ValueCacheMap _valueCacheMap;
    };
    _Delegate _delegate;
    std::unique_ptr<class HdxFreeCameraSceneDelegate> _freeCameraSceneDelegate;
 
    // Generated tasks.
    SdfPath _simpleLightTaskId;
    SdfPath _shadowTaskId;
    SdfPathVector _renderTaskIds;
    SdfPath _aovInputTaskId;
    SdfPath _oitResolveTaskId;
    SdfPath _selectionTaskId;
    SdfPath _colorizeSelectionTaskId;
    SdfPath _colorCorrectionTaskId;
    SdfPath _visualizeAovTaskId;
    SdfPath _pickTaskId;
    SdfPath _pickFromRenderBufferTaskId;
    SdfPath _boundingBoxTaskId;
    SdfPath _presentTaskId;
 
    // Current active camera
    SdfPath _activeCameraId;
    
    // Built-in lights
    SdfPathVector _lightIds;
 
    // Generated renderbuffers
    SdfPathVector _aovBufferIds;
    TfTokenVector _aovOutputs;
    TfToken _viewportAov;
 
    GfVec2i _renderBufferSize;
    CameraUtilFraming _framing;
    std::optional<CameraUtilConformWindowPolicy> _overrideWindowPolicy;
 
    GfVec4d _viewport;
};
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_IMAGING_HDX_TASK_CONTROLLER_H