engine.h

Go to the documentation of this file.

//
// Copyright 2016 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//


#ifndef PXR_USD_IMAGING_USD_IMAGING_GL_ENGINE_H
#define PXR_USD_IMAGING_USD_IMAGING_GL_ENGINE_H

#include "pxr/pxr.h"
#include "pxr/usdImaging/usdImaging/legacyRenderSettingsSceneIndex.h"
#include "pxr/usdImaging/usdImagingGL/api.h"
#include "pxr/usdImaging/usdImagingGL/version.h"
#include "pxr/usdImaging/usdImaging/version.h"

#include "pxr/usdImaging/usdImagingGL/renderParams.h"
#include "pxr/usdImaging/usdImagingGL/rendererSettings.h"

#include "pxr/imaging/cameraUtil/conformWindow.h"

#include "pxr/imaging/hd/driver.h"
#include "pxr/imaging/hd/noticeBatchingSceneIndex.h"
#include "pxr/imaging/hd/rprimCollection.h"
#include "pxr/imaging/hd/pluginRendererUniqueHandle.h"

#include "pxr/imaging/hdx/selectionTracker.h"
#include "pxr/imaging/hdx/renderSetupTask.h"

#include "pxr/imaging/hgi/hgi.h"

#include "pxr/imaging/glf/simpleLight.h"
#include "pxr/imaging/glf/simpleMaterial.h"

#include "pxr/imaging/hgi/hgi.h"

#include "pxr/usd/sdf/path.h"
#include "pxr/usd/usd/timeCode.h"

#include "pxr/base/gf/frustum.h"
#include "pxr/base/gf/matrix4d.h"
#include "pxr/base/gf/vec4d.h"
#include "pxr/base/gf/vec4f.h"
#include "pxr/base/gf/vec4i.h"

#include "pxr/base/vt/dictionary.h"

#include "pxr/base/tf/declarePtrs.h"

PXR_NAMESPACE_OPEN_SCOPE

class UsdPrim;
class UsdImagingDelegate;
class HdRendererCreateArgsSchema;
class HdLegacyRenderControlInterface;

TF_DECLARE_WEAK_AND_REF_PTRS(GlfSimpleLightingContext);
TF_DECLARE_REF_PTRS(UsdImagingSceneIndex);
TF_DECLARE_REF_PTRS(UsdImagingRootOverridesSceneIndex);
TF_DECLARE_REF_PTRS(HdCachingSceneIndex);
TF_DECLARE_REF_PTRS(HdsiLegacyDisplayStyleOverrideSceneIndex);
TF_DECLARE_REF_PTRS(HdsiPrimTypeAndPathPruningSceneIndex);
TF_DECLARE_REF_PTRS(HdsiSceneGlobalsSceneIndex);
TF_DECLARE_REF_PTRS(HdsiApplicationRenderSettingsSceneIndex);
TF_DECLARE_REF_PTRS(HdSceneIndexBase);
TF_DECLARE_REF_PTRS(HdMergingSceneIndex);
TF_DECLARE_REF_PTRS(HdxTaskControllerSceneIndex);
TF_DECLARE_REF_PTRS(UsdImagingStageSceneIndexInterface);

using UsdStageWeakPtr = TfWeakPtr<class UsdStage>;

namespace UsdImagingGLEngine_Impl
{
    using _AppSceneIndicesSharedPtr = std::shared_ptr<struct _AppSceneIndices>;
}

class UsdImagingGLEngine
{
public:
    struct Parameters
    {
        SdfPath rootPath = SdfPath::AbsoluteRootPath();
        SdfPathVector excludedPaths;
        SdfPathVector invisedPaths;
        SdfPath sceneDelegateID = SdfPath::AbsoluteRootPath();
        HdDriver driver;
        TfToken rendererPluginId;
        bool gpuEnabled = true;
        bool displayUnloadedPrimsWithBounds = false;
        bool allowAsynchronousSceneProcessing = false;
        bool enableUsdDrawModes = true;
    };

    // ---------------------------------------------------------------------
    // ---------------------------------------------------------------------

    USDIMAGINGGL_API
    UsdImagingGLEngine(const Parameters &params);

    USDIMAGINGGL_API
    UsdImagingGLEngine(const HdDriver& driver = HdDriver(),
                       const TfToken& rendererPluginId = TfToken(),
                       bool gpuEnabled = true);

    USDIMAGINGGL_API
    UsdImagingGLEngine(const SdfPath& rootPath,
                       const SdfPathVector& excludedPaths,
                       const SdfPathVector& invisedPaths = SdfPathVector(),
                       const SdfPath& sceneDelegateID =
                                        SdfPath::AbsoluteRootPath(),
                       const HdDriver& driver = HdDriver(),
                       const TfToken& rendererPluginId = TfToken(),
                       const bool gpuEnabled = true,
                       const bool displayUnloadedPrimsWithBounds = false,
                       const bool allowAsynchronousSceneProcessing = false,
                       const bool enableUsdDrawModes = true);

    // Disallow copies
    UsdImagingGLEngine(const UsdImagingGLEngine&) = delete;
    UsdImagingGLEngine& operator=(const UsdImagingGLEngine&) = delete;

    USDIMAGINGGL_API
    ~UsdImagingGLEngine();


    // ---------------------------------------------------------------------
    // ---------------------------------------------------------------------

    USDIMAGINGGL_API
    void PrepareBatch(const UsdPrim& root,
                      const UsdImagingGLRenderParams& params);
    USDIMAGINGGL_API
    void RenderBatch(const SdfPathVector& paths,
                     const UsdImagingGLRenderParams& params);

    USDIMAGINGGL_API
    void Render(const UsdPrim& root,
                const UsdImagingGLRenderParams &params);

    USDIMAGINGGL_API
    bool IsConverged() const;


    // ---------------------------------------------------------------------
    // ---------------------------------------------------------------------

    USDIMAGINGGL_API
    void SetRootTransform(GfMatrix4d const& xf);

    USDIMAGINGGL_API
    void SetRootVisibility(bool isVisible);


    // ---------------------------------------------------------------------
    // ---------------------------------------------------------------------

    USDIMAGINGGL_API
    void SetCameraPath(SdfPath const& id);

    USDIMAGINGGL_API
    void SetFraming(CameraUtilFraming const& framing);

    USDIMAGINGGL_API
    void SetOverrideWindowPolicy(
        const std::optional<CameraUtilConformWindowPolicy> &policy);

    USDIMAGINGGL_API
    void SetRenderBufferSize(GfVec2i const& size);

    USDIMAGINGGL_API
    void SetRenderViewport(GfVec4d const& viewport);

    USDIMAGINGGL_API
    void SetWindowPolicy(CameraUtilConformWindowPolicy policy);

    USDIMAGINGGL_API
    void SetCameraState(const GfMatrix4d& viewMatrix,
                        const GfMatrix4d& projectionMatrix);


    // ---------------------------------------------------------------------
    // ---------------------------------------------------------------------

    USDIMAGINGGL_API
    void SetLightingState(GlfSimpleLightingContextPtr const &src);

    USDIMAGINGGL_API
    void SetLightingState(GlfSimpleLightVector const &lights,
                          GlfSimpleMaterial const &material,
                          GfVec4f const &sceneAmbient);


    // ---------------------------------------------------------------------
    // ---------------------------------------------------------------------

    USDIMAGINGGL_API
    void SetSelected(SdfPathVector const& paths);

    USDIMAGINGGL_API
    void ClearSelected();

    USDIMAGINGGL_API
    void AddSelected(SdfPath const &path, int instanceIndex);

    USDIMAGINGGL_API
    void SetSelectionColor(GfVec4f const& color);


    // ---------------------------------------------------------------------
    // ---------------------------------------------------------------------

    struct IntersectionResult
    {
        GfVec3d hitPoint;
        GfVec3d hitNormal;
        SdfPath hitPrimPath;
        SdfPath hitInstancerPath;
        int hitInstanceIndex;
        HdInstancerContext instancerContext;
    };

    using IntersectionResultVector = std::vector<IntersectionResult>;

    struct PickParams
    {
        TfToken resolveMode;
    };

    USDIMAGINGGL_API
    bool TestIntersection(
        const PickParams& pickParams,
        const GfMatrix4d& viewMatrix,
        const GfMatrix4d& projectionMatrix,
        const UsdPrim& root,
        const UsdImagingGLRenderParams& params,
        IntersectionResultVector* outResults);

    USDIMAGINGGL_API
    bool DecodeIntersection(
        unsigned char const primIdColor[4],
        unsigned char const instanceIdColor[4],
        SdfPath *outHitPrimPath = NULL,
        SdfPath *outHitInstancerPath = NULL,
        int *outHitInstanceIndex = NULL,
        HdInstancerContext *outInstancerContext = NULL);

    USDIMAGINGGL_API
    bool DecodeIntersection(
        int primIdx,
        int instanceIdx,
        SdfPath *outHitPrimPath = NULL,
        SdfPath *outHitInstancerPath = NULL,
        int *outHitInstanceIndex = NULL,
        HdInstancerContext *outInstancerContext = NULL);

    struct DecodeResult
    {
        SdfPath primPath;
        HdInstancerContext instancerContext;
    };

    using DecodeResultVector = std::vector<DecodeResult>;

    struct PickId
    {
        int primId;
        int instanceId;
    };

    using PickIdVector = std::vector<PickId>;

    USDIMAGINGGL_API
    DecodeResultVector DecodeIntersections(const PickIdVector& pickIds);

    USDIMAGINGGL_API
    bool TestIntersection(
        const GfMatrix4d &viewMatrix,
        const GfMatrix4d &projectionMatrix,
        const UsdPrim& root,
        const UsdImagingGLRenderParams &params,
        GfVec3d *outHitPoint,
        GfVec3d *outHitNormal,
        SdfPath *outHitPrimPath = NULL,
        SdfPath *outHitInstancerPath = NULL,
        int *outHitInstanceIndex = NULL,
        HdInstancerContext *outInstancerContext = NULL);
    

    // ---------------------------------------------------------------------
    // ---------------------------------------------------------------------

    USDIMAGINGGL_API
    static TfTokenVector GetRendererPlugins();

    USDIMAGINGGL_API
    static std::string GetRendererDisplayName(TfToken const &id);

    USDIMAGINGGL_API
    std::string GetRendererHgiDisplayName() const;

    USDIMAGINGGL_API
    bool GetGPUEnabled() const;

    USDIMAGINGGL_API
    TfToken GetCurrentRendererId() const;

    USDIMAGINGGL_API
    bool SetRendererPlugin(TfToken const &id);


    // ---------------------------------------------------------------------
    // ---------------------------------------------------------------------

    USDIMAGINGGL_API
    TfTokenVector GetRendererAovs() const;

    USDIMAGINGGL_API
    bool SetRendererAov(TfToken const& id);

    USDIMAGINGGL_API
    bool SetRendererAovs(TfTokenVector const &ids);

    USDIMAGINGGL_API
    HgiTextureHandle GetAovTexture(TfToken const& name) const;

    USDIMAGINGGL_API
    HdRenderBuffer* GetAovRenderBuffer(TfToken const& name) const;

    // ---------------------------------------------------------------------
    // ---------------------------------------------------------------------

    USDIMAGINGGL_API
    UsdImagingGLRendererSettingsList GetRendererSettingsList() const;

    USDIMAGINGGL_API
    VtValue GetRendererSetting(TfToken const& id) const;

    USDIMAGINGGL_API
    void SetRendererSetting(TfToken const& id,
                            VtValue const& value);


    // ---------------------------------------------------------------------
    // ---------------------------------------------------------------------

    USDIMAGINGGL_API
    SdfPath GetActiveRenderPassPrimPath() const;

    USDIMAGINGGL_API
    SdfPath GetActiveRenderSettingsPrimPath() const;

    USDIMAGINGGL_API
    static SdfPathVector
    GetAvailableRenderSettingsPrimPaths(UsdPrim const &root);

    USDIMAGINGGL_API
    void SetActiveRenderPassPrimPath(SdfPath const &);

    USDIMAGINGGL_API
    void SetActiveRenderSettingsPrimPath(SdfPath const &);



    // ---------------------------------------------------------------------
    // ---------------------------------------------------------------------

    USDIMAGINGGL_API
    void SetEnablePresentation(bool enabled);

    USDIMAGINGGL_API
    void SetPresentationOutput(TfToken const &api, VtValue const &framebuffer);


    // ---------------------------------------------------------------------
    // ---------------------------------------------------------------------

    USDIMAGINGGL_API
    HdCommandDescriptors GetRendererCommandDescriptors() const;

    USDIMAGINGGL_API
    bool InvokeRendererCommand(
            const TfToken &command,
            const HdCommandArgs &args = HdCommandArgs()) const;

    // ---------------------------------------------------------------------
    // ---------------------------------------------------------------------

    USDIMAGINGGL_API
    bool IsPauseRendererSupported() const;

    USDIMAGINGGL_API
    bool PauseRenderer();

    USDIMAGINGGL_API
    bool ResumeRenderer();

    USDIMAGINGGL_API
    bool IsStopRendererSupported() const;

    USDIMAGINGGL_API
    bool StopRenderer();

    USDIMAGINGGL_API
    bool RestartRenderer();


    // ---------------------------------------------------------------------
    // ---------------------------------------------------------------------

    USDIMAGINGGL_API
    void SetColorCorrectionSettings(
        TfToken const& ccType,
        TfToken const& ocioDisplay = {},
        TfToken const& ocioView = {},
        TfToken const& ocioColorSpace = {},
        TfToken const& ocioLook = {});


    USDIMAGINGGL_API
    static bool IsColorCorrectionCapable();

    // ---------------------------------------------------------------------
    // ---------------------------------------------------------------------

    USDIMAGINGGL_API
    VtDictionary GetRenderStats() const;


    // ---------------------------------------------------------------------
    // ---------------------------------------------------------------------

    USDIMAGINGGL_API
    Hgi* GetHgi();


    // ---------------------------------------------------------------------
    // ---------------------------------------------------------------------

    USDIMAGINGGL_API
    bool PollForAsynchronousUpdates() const;



    // ---------------------------------------------------------------------
    // ---------------------------------------------------------------------

    USDIMAGINGGL_API
    static bool UseUsdImagingSceneIndex();

protected:

    friend class UsdImagingGL_UnitTestGLDrawing;

    USDIMAGINGGL_API
    void _Execute(const UsdImagingGLRenderParams &params,
                  const SdfPathVector &taskPaths);

    USDIMAGINGGL_API
    bool _CanPrepare(const UsdPrim& root);
    USDIMAGINGGL_API
    void _PreSetTime(const UsdImagingGLRenderParams& params);
    USDIMAGINGGL_API
    void _PostSetTime(const UsdImagingGLRenderParams& params);

    USDIMAGINGGL_API
    void _PrepareRender(const UsdImagingGLRenderParams& params);

    USDIMAGINGGL_API
    void _SetActiveRenderSettingsPrimFromStageMetadata(UsdStageWeakPtr stage);

    USDIMAGINGGL_API
    void _SetSceneGlobalsCurrentFrame(UsdTimeCode const &time);

    USDIMAGINGGL_API
    void _UpdateDomeLightCameraVisibility();

    using BBoxVector = std::vector<GfBBox3d>;

    USDIMAGINGGL_API
    void _SetBBoxParams(
        const BBoxVector& bboxes,
        const GfVec4f& bboxLineColor,
        float bboxLineDashSize);

    // Create a hydra collection given root paths and render params.
    // Returns true if the collection was updated.
    USDIMAGINGGL_API
    static bool _UpdateHydraCollection(HdRprimCollection *collection,
                          SdfPathVector const& roots,
                          UsdImagingGLRenderParams const& params);
    USDIMAGINGGL_API
    static HdxRenderTaskParams _MakeHydraUsdImagingGLRenderParams(
                          UsdImagingGLRenderParams const& params);
    USDIMAGINGGL_API
    static void _ComputeRenderTags(UsdImagingGLRenderParams const& params,
                          TfTokenVector *renderTags);

    USDIMAGINGGL_API
    SdfPath _ComputeControllerPath(const TfToken &pluginId);

    USDIMAGINGGL_API
    static TfToken _GetDefaultRendererPluginId();

    USDIMAGINGGL_API
    UsdImagingDelegate *_GetSceneDelegate() const;

    USDIMAGINGGL_API
    HdSelectionSharedPtr _GetSelection() const;

    USDIMAGINGGL_API
    HdContainerDataSourceHandle
    _GetSceneIndexCreateArgs(
        HdRendererPluginHandle const &plugin);

    USDIMAGINGGL_API
    HdContainerDataSourceHandle
    _GetSceneIndexCreateArgsFromLegacyRenderControl();

    // Create UsdImagingStageSceneIndex and subsequent scene indices.
    USDIMAGINGGL_API
    HdSceneIndexBaseRefPtr
    _CreateUsdImagingSceneIndices(HdContainerDataSourceHandle const &inputArgs);

    // Create the merging scene index and all subsequent filtering scene index
    // and the renderer fed by those.
    USDIMAGINGGL_API
    void
    _CreateSceneIndexChainAndRenderer(
        HdContainerDataSourceHandle const &sceneIndexCreateArgs,
        HdRendererPluginHandle const &plugin,
        const HdRendererCreateArgsSchema &rendererCreateArgs);

    Hgi *
    _GetOrCreateHgi();

protected:
    // The Hgi used by the renderer.
    // It is either provided by the user or the Hgi::CreatePlatformDefaultHgi().
    Hgi * _hgi;

    // Result of Hgi::CreatePlatformDefaultHgi() if needed.
    HgiUniquePtr _defaultHgi;

    VtValue _userFramebuffer;

protected:
    bool _displayUnloadedPrimsWithBounds;
    bool _gpuEnabled;

    HdPluginRendererUniqueHandle _renderer; // Hydra 2.0
    HdxTaskControllerSceneIndexRefPtr _taskControllerSceneIndex; // Hydra 2.0

    SdfPath const _sceneDelegateId;

    HdxSelectionTrackerSharedPtr _selTracker; // Hydra 1.0
    HdRprimCollection _renderCollection;
    HdRprimCollection _intersectCollection;

    GlfSimpleLightingContextRefPtr _lightingContextForOpenGLState;

    // Data we want to live across render plugin switches:
    GfVec4f _selectionColor;
    bool _domeLightCameraVisibility;

    SdfPath _rootPath;
    SdfPathVector _excludedPrimPaths;
    SdfPathVector _invisedPrimPaths;
    bool _isPopulated;

private:
    HdSceneIndexBaseRefPtr _GetTerminalSceneIndex() const;

    HdLegacyRenderControlInterface * _GetLegacyRenderControl() const;

    // The application-managed render settings scene index, if the renderer
    // advertised render setting descriptors (the Hydra 2.0 path). Null
    // otherwise (in which case callers fall back to the legacy render control).
    HdsiApplicationRenderSettingsSceneIndexRefPtr
    _GetApplicationRenderSettingsSceneIndex() const;

    SdfPath _GetSceneIndexPrimPathFromPrimId(int primId) const;

    HdSceneIndexBaseRefPtr
    _AppendOverridesSceneIndices(
        HdSceneIndexBaseRefPtr const &inputScene,
        HdContainerDataSourceHandle const &sceneIndexCreateArgs);

    UsdImagingGLEngine_Impl::_AppSceneIndicesSharedPtr _appSceneIndices;

    HdSceneIndexBaseRefPtr
    _CreateExecSceneIndices(const HdSceneIndexBaseRefPtr &inputScene);

    bool _CreateSceneIndicesAndRenderer(
        HdRendererPluginHandle const &plugin,
        const HdRendererCreateArgsSchema &rendererCreateArgs);

    void _DestroyHydraObjects();

    SdfPath _GetInstancerForPrim(const SdfPath &sceneIndexPath) const;

    // Note that we'll only ever use one of _sceneIndex/_sceneDelegate
    // at a time.
    UsdImagingStageSceneIndexInterfaceRefPtr _execStageSceneIndex;
    HdNoticeBatchingSceneIndexRefPtr _noticeBatchingStageSceneIndex;
    UsdImagingRootOverridesSceneIndexRefPtr _rootOverridesSceneIndex;
    UsdImagingLegacyRenderSettingsSceneIndexRefPtr _legacyRenderSettingsSceneIndex;
    HdsiLegacyDisplayStyleOverrideSceneIndexRefPtr _displayStyleSceneIndex;
    HdsiPrimTypeAndPathPruningSceneIndexRefPtr _lightPruningSceneIndex;
    // State of the _lightPruningSceneIndex.
    bool _lightPruningSceneIndexEnableSceneLights;

    UsdImagingSceneIndexRefPtr _usdImagingSceneIndex;

    HdMergingSceneIndexRefPtr _mergingSceneIndex;
    HdCachingSceneIndexRefPtr _cachingSceneIndex;
    HdSceneIndexBaseRefPtr _terminalSceneIndex;

    // Create-args container data source returned by the renderer plugin
    // (see HdRendererPlugin::GetSceneIndexCreateArgs). Retained so that
    // GetRendererSettingsList() can source the render settings from it.
    HdContainerDataSourceHandle _sceneIndexCreateArgs;

    /* Hydra 1.0 */
    std::unique_ptr<UsdImagingDelegate> _sceneDelegate;

    bool _allowAsynchronousSceneProcessing = false;
    bool _enableUsdDrawModes = true;

    /* Hydra 1.0 */
    // A flag indicating whether the active render pass prim path
    // on the scene globals scene index was set.
    //
    // Explanation: The active render passs prim path can be set by a
    // client of UsdImagingGLEngine through SetActiveRenderSettingsPrimPath
    // and or by reading the stage metadata when using the UsdImagingDelegate.
    //
    // Thus, we could get into a situation where a user explicitly sets it
    // through the UsdImagingGLEngine API first and then we wrongfully change
    // it later by reading the stage metadata.
    //
    // This flag is here to prevent this.
    bool _setActiveRenderSettingsPrimPathCalled = false;
};

PXR_NAMESPACE_CLOSE_SCOPE

#endif // PXR_USD_IMAGING_USD_IMAGING_GL_ENGINE_H