engine.h

Go to the documentation of this file.

//
// Copyright 2016 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_USD_IMAGING_USD_IMAGING_GL_ENGINE_H
#define PXR_USD_IMAGING_USD_IMAGING_GL_ENGINE_H
 
#include "pxr/pxr.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/engine.h"
#include "pxr/imaging/hd/rprimCollection.h"
#include "pxr/imaging/hd/pluginRenderDelegateUniqueHandle.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 HdRenderIndex;
class HdxTaskController;
class UsdImagingDelegate;
 
TF_DECLARE_WEAK_AND_REF_PTRS(GlfSimpleLightingContext);
TF_DECLARE_REF_PTRS(UsdImagingStageSceneIndex);
TF_DECLARE_REF_PTRS(UsdImagingRootOverridesSceneIndex);
TF_DECLARE_REF_PTRS(UsdImagingSelectionSceneIndex);
TF_DECLARE_REF_PTRS(HdsiLegacyDisplayStyleOverrideSceneIndex);
TF_DECLARE_REF_PTRS(HdsiPrimTypePruningSceneIndex);
TF_DECLARE_REF_PTRS(HdsiSceneGlobalsSceneIndex);
TF_DECLARE_REF_PTRS(HdSceneIndexBase);
 
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;
    };
 
    // ---------------------------------------------------------------------
    // ---------------------------------------------------------------------
 
    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(),
                       bool gpuEnabled = true,
                       bool displayUnloadedPrimsWithBounds = false,
                       bool allowAsynchronousSceneProcessing = false);
 
    // 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);
 
    
    // ---------------------------------------------------------------------
    // ---------------------------------------------------------------------
    
    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
    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
    static TfTokenVector GetRendererPlugins();
 
    USDIMAGINGGL_API
    static std::string GetRendererDisplayName(TfToken const &id);
 
    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
    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
    void SetActiveRenderSettingsPrimPath(SdfPath const &);
 
    USDIMAGINGGL_API
    static SdfPathVector
    GetAvailableRenderSettingsPrimPaths(UsdPrim const &root);
 
 
    // ---------------------------------------------------------------------
    // ---------------------------------------------------------------------
    
    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;
 
 
protected:
 
    friend class UsdImagingGL_UnitTestGLDrawing;
 
    USDIMAGINGGL_API
    HdRenderIndex *_GetRenderIndex() const;
 
    USDIMAGINGGL_API
    void _Execute(const UsdImagingGLRenderParams &params,
                  HdTaskSharedPtrVector tasks);
 
    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 _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
    void _InitializeHgiIfNecessary();
 
    USDIMAGINGGL_API
    void _SetRenderDelegateAndRestoreState(
        HdPluginRenderDelegateUniqueHandle &&);
 
    USDIMAGINGGL_API
    void _SetRenderDelegate(HdPluginRenderDelegateUniqueHandle &&);
 
    USDIMAGINGGL_API
    SdfPath _ComputeControllerPath(const HdPluginRenderDelegateUniqueHandle &);
 
    USDIMAGINGGL_API
    static TfToken _GetDefaultRendererPluginId();
 
    USDIMAGINGGL_API
    UsdImagingDelegate *_GetSceneDelegate() const;
 
    USDIMAGINGGL_API
    HdEngine *_GetHdEngine();
 
    USDIMAGINGGL_API
    HdxTaskController *_GetTaskController() const;
 
    USDIMAGINGGL_API
    HdSelectionSharedPtr _GetSelection() const;
 
protected:
 
    // Note that any of the fields below might become private
    // in the future and subclasses should use the above getters
    // to access them instead.
 
    HgiUniquePtr _hgi;
    // Similar for HdDriver.
    HdDriver _hgiDriver;
 
    VtValue _userFramebuffer;
 
protected:
    bool _displayUnloadedPrimsWithBounds;
    bool _gpuEnabled;
    HdPluginRenderDelegateUniqueHandle _renderDelegate;
    std::unique_ptr<HdRenderIndex> _renderIndex;
 
    SdfPath const _sceneDelegateId;
 
    std::unique_ptr<HdxTaskController> _taskController;
 
    HdxSelectionTrackerSharedPtr _selTracker;
    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:
    // Registers app-managed scene indices with the scene index plugin registry.
    // This needs to be called once *before* the render index is constructed.
    static void _RegisterApplicationSceneIndices();
 
    // Creates and returns the scene globals scene index. This callback is
    // registered prior to render index construction and is invoked during
    // render index construction via
    // HdSceneIndexPluginRegistry::AppendSceneIndicesForRenderer(..).
    static HdSceneIndexBaseRefPtr
    _AppendSceneGlobalsSceneIndexCallback(
        const std::string &renderInstanceId,
        const HdSceneIndexBaseRefPtr &inputScene,
        const HdContainerDataSourceHandle &inputArgs);
 
    HdSceneIndexBaseRefPtr
    _AppendOverridesSceneIndices(
        const HdSceneIndexBaseRefPtr &inputScene);
    
    UsdImagingGLEngine_Impl::_AppSceneIndicesSharedPtr _appSceneIndices;
 
    void _DestroyHydraObjects();
 
    // Note that we'll only ever use one of _sceneIndex/_sceneDelegate
    // at a time.
    UsdImagingStageSceneIndexRefPtr _stageSceneIndex;
    UsdImagingSelectionSceneIndexRefPtr _selectionSceneIndex;
    UsdImagingRootOverridesSceneIndexRefPtr _rootOverridesSceneIndex;
    HdsiLegacyDisplayStyleOverrideSceneIndexRefPtr _displayStyleSceneIndex;
    HdsiPrimTypePruningSceneIndexRefPtr _materialPruningSceneIndex;
    HdsiPrimTypePruningSceneIndexRefPtr _lightPruningSceneIndex;
    HdSceneIndexBaseRefPtr _sceneIndex;
    
    std::unique_ptr<UsdImagingDelegate> _sceneDelegate;
 
    std::unique_ptr<HdEngine> _engine;
 
    bool _allowAsynchronousSceneProcessing = false;
};
 
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_USD_IMAGING_USD_IMAGING_GL_ENGINE_H