dev/api/usd_imaging_2usd_imaging_g_l_2engine_8h_source.html

//

// 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/engine.h"

#include "pxr/imaging/hd/rprimCollection.h"

#include "pxr/imaging/hd/pluginRenderDelegateUniqueHandle.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 HdRenderIndex;

class HdxTaskController;

class UsdImagingDelegate;


TF_DECLARE_WEAK_AND_REF_PTRS(GlfSimpleLightingContext);

TF_DECLARE_REF_PTRS(HdNoticeBatchingSceneIndex);

TF_DECLARE_REF_PTRS(UsdImagingStageSceneIndex);

TF_DECLARE_REF_PTRS(UsdImagingRootOverridesSceneIndex);

TF_DECLARE_REF_PTRS(UsdImagingSelectionSceneIndex);

TF_DECLARE_REF_PTRS(HdCachingSceneIndex);

TF_DECLARE_REF_PTRS(HdsiLegacyDisplayStyleOverrideSceneIndex);

TF_DECLARE_REF_PTRS(HdsiPrimTypeAndPathPruningSceneIndex);

TF_DECLARE_REF_PTRS(HdsiSceneGlobalsSceneIndex);

TF_DECLARE_REF_PTRS(HdSceneIndexBase);

TF_DECLARE_REF_PTRS(HdMergingSceneIndex);

TF_DECLARE_REF_PTRS(HdxTaskControllerSceneIndex);


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);


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

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


    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);


    // Pick result

    struct IntersectionResult

    {

        GfVec3d hitPoint;

        GfVec3d hitNormal;

        SdfPath hitPrimPath;

        SdfPath hitInstancerPath;

        int hitInstanceIndex;

        HdInstancerContext instancerContext;

    };


    typedef std::vector<struct IntersectionResult> IntersectionResultVector;


    // Pick params

    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);


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

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


    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

    HdRenderIndex *_GetRenderIndex() const;


    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

    void _InitializeHgiIfNecessary();


    USDIMAGINGGL_API

    void _SetRenderDelegateAndRestoreState(

        HdPluginRenderDelegateUniqueHandle &&,

        HdContainerDataSourceHandle const &sceneIndexInputArgs);


    USDIMAGINGGL_API

    void _SetRenderDelegate(

        HdPluginRenderDelegateUniqueHandle &&,

        HdContainerDataSourceHandle const &sceneIndexInputArgs);


    USDIMAGINGGL_API

    SdfPath _ComputeControllerPath(const TfToken &pluginId);


    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;


    // Create UsdImagingStageSceneIndex and subsequent scene indices.

    void

    _CreateUsdImagingSceneIndices(HdContainerDataSourceHandle const &inputArgs);


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;


    /* Hydra 2.0 */


    HdPluginRendererUniqueHandle _renderer;

    HdxTaskControllerSceneIndexRefPtr _taskControllerSceneIndex;


    /* Hydra 1.0 */

    HdPluginRenderDelegateUniqueHandle _renderDelegate;

    std::unique_ptr<HdRenderIndex> _renderIndex;

    std::unique_ptr<HdxTaskController> _taskController;


    SdfPath const _sceneDelegateId;


    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:

    bool _HasRenderer() const;

    HdSceneIndexBaseRefPtr _GetTerminalSceneIndex() const;


    HdSceneIndexBaseRefPtr

    _AppendOverridesSceneIndices(

        const HdSceneIndexBaseRefPtr &inputScene);


    UsdImagingGLEngine_Impl::_AppSceneIndicesSharedPtr _appSceneIndices;


    bool _CreateSceneIndicesAndRenderer(

        HdRendererPluginHandle const &plugin,

        HdContainerDataSourceHandle const &sceneIndexInputArgs);


    void _DestroyHydraObjects();


    SdfPath _GetInstancerForPrim(const SdfPath &sceneIndexPath) const;


    // Note that we'll only ever use one of _sceneIndex/_sceneDelegate

    // at a time.

    UsdImagingStageSceneIndexRefPtr _stageSceneIndex;

    HdNoticeBatchingSceneIndexRefPtr _postInstancingNoticeBatchingSceneIndex;

    UsdImagingSelectionSceneIndexRefPtr _selectionSceneIndex;

    UsdImagingRootOverridesSceneIndexRefPtr _rootOverridesSceneIndex;

    UsdImagingLegacyRenderSettingsSceneIndexRefPtr _legacyRenderSettingsSceneIndex;

    HdsiLegacyDisplayStyleOverrideSceneIndexRefPtr _displayStyleSceneIndex;

    HdsiPrimTypeAndPathPruningSceneIndexRefPtr _lightPruningSceneIndex;

    // State of the _lightPruningSceneIndex.

    bool _lightPruningSceneIndexEnableSceneLights;

    HdSceneIndexBaseRefPtr _usdImagingFinalSceneIndex;


    HdMergingSceneIndexRefPtr _mergingSceneIndex;

    HdCachingSceneIndexRefPtr _cachingSceneIndex;

    HdSceneIndexBaseRefPtr _terminalSceneIndex;


    /* Hydra 1.0 */

    std::unique_ptr<UsdImagingDelegate> _sceneDelegate;

    std::unique_ptr<HdEngine> _engine;


    bool _allowAsynchronousSceneProcessing = false;

    bool _enableUsdDrawModes = true;

};


PXR_NAMESPACE_CLOSE_SCOPE


#endif // PXR_USD_IMAGING_USD_IMAGING_GL_ENGINE_H

CameraUtilFraming
Framing information.
Definition: framing.h:63

GfMatrix4d
Stores a 4x4 matrix of double elements.
Definition: matrix4d.h:71

GfVec2i
Basic type for a vector of 2 int components.
Definition: vec2i.h:44

GfVec3d
Basic type for a vector of 3 double components.
Definition: vec3d.h:46

GfVec4d
Basic type for a vector of 4 double components.
Definition: vec4d.h:46

GfVec4f
Basic type for a vector of 4 float components.
Definition: vec4f.h:46

HdCachingSceneIndex
A scene index that caches the prim data source and child prim paths.
Definition: cachingSceneIndex.h:29

HdDriver
HdDriver represents a device object, commonly a render device, that is owned by the application and p...
Definition: driver.h:23

HdEngine
The application-facing entry point top-level entry point for accessing Hydra.
Definition: engine.h:31

HdMergingSceneIndex
Merges multiple scenes together.
Definition: mergingSceneIndex.h:30

HdPluginRenderDelegateUniqueHandle
A (movable) handle for a render delegate that was created using a a plugin.
Definition: pluginRenderDelegateUniqueHandle.h:31

HdPluginRendererUniqueHandle
A handle for a renderer that was created by a renderer plugin.
Definition: pluginRendererUniqueHandle.h:29

HdRenderBuffer
A render buffer is a handle to a data resource that can be rendered into, such as a 2d image for a dr...
Definition: renderBuffer.h:33

HdRenderIndex
The Hydra render index is a flattened representation of the client scene graph, which may be composed...
Definition: renderIndex.h:105

HdRendererPluginHandle
A handle for HdRendererPlugin also storing the plugin id.
Definition: rendererPluginHandle.h:31

HdRprimCollection
A named, semantic collection of objects.
Definition: rprimCollection.h:37

HdSceneIndexBase
Abstract interface to scene data.
Definition: sceneIndex.h:54

HdsiLegacyDisplayStyleOverrideSceneIndex
A scene index overriding the legacy display style for each prim.
Definition: legacyDisplayStyleOverrideSceneIndex.h:32

HdsiPrimTypeAndPathPruningSceneIndex
Scene Index that prunes prims if its type is in a given list and its path matches a given predicate.
Definition: primTypeAndPathPruningSceneIndex.h:37

HdsiSceneGlobalsSceneIndex
Scene index that populates the "sceneGlobals" data source as modeled by HdSceneGlobalsSchema and prov...
Definition: sceneGlobalsSceneIndex.h:30

HdxTaskControllerSceneIndex
Manages tasks necessary to render an image (or perform picking) as well as the related render buffers...
Definition: taskControllerSceneIndex.h:52

HgiHandle< class HgiTexture >

Hgi
Hydra Graphics Interface.
Definition: hgi.h:95

SdfPath
A path value used to locate objects in layers or scenegraphs.
Definition: path.h:281

SdfPath::AbsoluteRootPath
static SDF_API const SdfPath & AbsoluteRootPath()
The absolute path representing the top of the namespace hierarchy.

TfToken
Token for efficient comparison, assignment, and hashing of known strings.
Definition: token.h:71

TfWeakPtr
Pointer storage with deletion detection.
Definition: weakPtr.h:128

UsdImagingDelegate
The primary translation layer between the Hydra (Hd) core and the Usd scene graph.
Definition: delegate.h:67

UsdImagingGLEngine
The UsdImagingGLEngine is the main entry point API for rendering USD scenes.
Definition: engine.h:85

UsdImagingGLEngine::SetSelectionColor
USDIMAGINGGL_API void SetSelectionColor(GfVec4f const &color)
Sets the selection highlighting color.

UsdImagingGLEngine::StopRenderer
USDIMAGINGGL_API bool StopRenderer()
Stop the renderer.

UsdImagingGLEngine::SetRenderBufferSize
USDIMAGINGGL_API void SetRenderBufferSize(GfVec2i const &size)
Set the size of the render buffers baking the AOVs.

UsdImagingGLEngine::SetRendererAov
USDIMAGINGGL_API bool SetRendererAov(TfToken const &id)
Set the current renderer AOV to id.

UsdImagingGLEngine::DecodeIntersection
USDIMAGINGGL_API bool DecodeIntersection(int primIdx, int instanceIdx, SdfPath *outHitPrimPath=NULL, SdfPath *outHitInstancerPath=NULL, int *outHitInstanceIndex=NULL, HdInstancerContext *outInstancerContext=NULL)
Decodes a pick result given hydra prim ID/instance ID (like you'd get from an ID render),...

UsdImagingGLEngine::_GetSceneDelegate
USDIMAGINGGL_API UsdImagingDelegate * _GetSceneDelegate() const
Get a direct pointer to the scene delegate.

UsdImagingGLEngine::SetActiveRenderPassPrimPath
USDIMAGINGGL_API void SetActiveRenderPassPrimPath(SdfPath const &)
Set active render pass prim to use to drive rendering.

UsdImagingGLEngine::SetRenderViewport
USDIMAGINGGL_API void SetRenderViewport(GfVec4d const &viewport)
Set the viewport to use for rendering as (x,y,w,h), where (x,y) represents the lower left corner of t...

UsdImagingGLEngine::DecodeIntersection
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)
Decodes a pick result given hydra prim ID/instance ID (like you'd get from an ID render),...

UsdImagingGLEngine::RestartRenderer
USDIMAGINGGL_API bool RestartRenderer()
Restart the renderer.

UsdImagingGLEngine::GetHgi
USDIMAGINGGL_API Hgi * GetHgi()
Returns the HGI interface.

UsdImagingGLEngine::GetRendererPlugins
static USDIMAGINGGL_API TfTokenVector GetRendererPlugins()
Return the vector of available render-graph delegate plugins.

UsdImagingGLEngine::Parameters::driver
HdDriver driver
An HdDriver, containing the Hgi of your choice, can be optionally passed in during construction.
Definition: engine.h:97

UsdImagingGLEngine::Render
USDIMAGINGGL_API void Render(const UsdPrim &root, const UsdImagingGLRenderParams &params)
Entry point for kicking off a render.

UsdImagingGLEngine::GetRendererSetting
USDIMAGINGGL_API VtValue GetRendererSetting(TfToken const &id) const
Gets a renderer setting's current value.

UsdImagingGLEngine::ResumeRenderer
USDIMAGINGGL_API bool ResumeRenderer()
Resume the renderer.

UsdImagingGLEngine::_GetRenderIndex
USDIMAGINGGL_API HdRenderIndex * _GetRenderIndex() const
Returns the render index of the engine, if any.

UsdImagingGLEngine::SetEnablePresentation
USDIMAGINGGL_API void SetEnablePresentation(bool enabled)
Enable / disable presenting the render to bound framebuffer.

UsdImagingGLEngine::SetLightingState
USDIMAGINGGL_API void SetLightingState(GlfSimpleLightingContextPtr const &src)
Copy lighting state from another lighting context.

UsdImagingGLEngine::GetActiveRenderSettingsPrimPath
USDIMAGINGGL_API SdfPath GetActiveRenderSettingsPrimPath() const
Returns the active render settings prim path by querying the terminal scene index.

UsdImagingGLEngine::PauseRenderer
USDIMAGINGGL_API bool PauseRenderer()
Pause the renderer.

UsdImagingGLEngine::GetActiveRenderPassPrimPath
USDIMAGINGGL_API SdfPath GetActiveRenderPassPrimPath() const
Returns the active render pass prim path by querying the terminal scene index.

UsdImagingGLEngine::SetCameraPath
USDIMAGINGGL_API void SetCameraPath(SdfPath const &id)
Scene camera API Set the scene camera path to use for rendering.

UsdImagingGLEngine::PrepareBatch
USDIMAGINGGL_API void PrepareBatch(const UsdPrim &root, const UsdImagingGLRenderParams &params)
Support for batched drawing.

UsdImagingGLEngine::SetRootVisibility
USDIMAGINGGL_API void SetRootVisibility(bool isVisible)
Sets the root visibility.

UsdImagingGLEngine::SetColorCorrectionSettings
USDIMAGINGGL_API void SetColorCorrectionSettings(TfToken const &ccType, TfToken const &ocioDisplay={}, TfToken const &ocioView={}, TfToken const &ocioColorSpace={}, TfToken const &ocioLook={})
Set ccType to one of the HdxColorCorrectionTokens: {disabled, sRGB, openColorIO}.

UsdImagingGLEngine::SetLightingState
USDIMAGINGGL_API void SetLightingState(GlfSimpleLightVector const &lights, GlfSimpleMaterial const &material, GfVec4f const &sceneAmbient)
Set lighting state Derived classes should ensure that passing an empty lights vector disables lightin...

UsdImagingGLEngine::Parameters::rendererPluginId
TfToken rendererPluginId
The rendererPluginId argument indicates the renderer plugin that Hydra should use.
Definition: engine.h:101

UsdImagingGLEngine::Parameters::enableUsdDrawModes
bool enableUsdDrawModes
enableUsdDrawModes enables the UsdGeomModelAPI draw mode feature.
Definition: engine.h:114

UsdImagingGLEngine::UsdImagingGLEngine
USDIMAGINGGL_API UsdImagingGLEngine(const HdDriver &driver=HdDriver(), const TfToken &rendererPluginId=TfToken(), bool gpuEnabled=true)
An HdDriver, containing the Hgi of your choice, can be optionally passed in during construction.

UsdImagingGLEngine::GetRendererAovs
USDIMAGINGGL_API TfTokenVector GetRendererAovs() const
Return the vector of available renderer AOV settings.

UsdImagingGLEngine::_GetTaskController
USDIMAGINGGL_API HdxTaskController * _GetTaskController() const

UsdImagingGLEngine::PollForAsynchronousUpdates
USDIMAGINGGL_API bool PollForAsynchronousUpdates() const
If allowAsynchronousSceneProcessing is true within the Parameters provided to the UsdImagingGLEngine ...

UsdImagingGLEngine::IsStopRendererSupported
USDIMAGINGGL_API bool IsStopRendererSupported() const
Query the renderer as to whether it supports stopping and restarting.

UsdImagingGLEngine::IsConverged
USDIMAGINGGL_API bool IsConverged() const
Returns true if the resulting image is fully converged.

UsdImagingGLEngine::SetCameraState
USDIMAGINGGL_API void SetCameraState(const GfMatrix4d &viewMatrix, const GfMatrix4d &projectionMatrix)
Free camera API Set camera framing state directly (without pointing to a camera on the USD stage).

UsdImagingGLEngine::Parameters::displayUnloadedPrimsWithBounds
bool displayUnloadedPrimsWithBounds
displayUnloadedPrimsWithBounds draws bounding boxes for unloaded prims if they have extents/extentsHi...
Definition: engine.h:107

UsdImagingGLEngine::GetAovRenderBuffer
USDIMAGINGGL_API HdRenderBuffer * GetAovRenderBuffer(TfToken const &name) const
Returns the AOV render buffer for the given token.

UsdImagingGLEngine::InvokeRendererCommand
USDIMAGINGGL_API bool InvokeRendererCommand(const TfToken &command, const HdCommandArgs &args=HdCommandArgs()) const
Invokes command on the active render delegate.

UsdImagingGLEngine::SetRendererPlugin
USDIMAGINGGL_API bool SetRendererPlugin(TfToken const &id)
Set the current render-graph delegate to id.

UsdImagingGLEngine::SetRendererAovs
USDIMAGINGGL_API bool SetRendererAovs(TfTokenVector const &ids)
Set the current renderer AOVs to a list of ids.

UsdImagingGLEngine::IsColorCorrectionCapable
static USDIMAGINGGL_API bool IsColorCorrectionCapable()
Returns true if the platform is color correction capable.

UsdImagingGLEngine::GetAvailableRenderSettingsPrimPaths
static USDIMAGINGGL_API SdfPathVector GetAvailableRenderSettingsPrimPaths(UsdPrim const &root)
Utility method to query available render settings prims.

UsdImagingGLEngine::GetAovTexture
USDIMAGINGGL_API HgiTextureHandle GetAovTexture(TfToken const &name) const
Returns an AOV texture handle for the given token.

UsdImagingGLEngine::IsPauseRendererSupported
USDIMAGINGGL_API bool IsPauseRendererSupported() const
Query the renderer as to whether it supports pausing and resuming.

UsdImagingGLEngine::GetRendererDisplayName
static USDIMAGINGGL_API std::string GetRendererDisplayName(TfToken const &id)
Return the user-friendly name of a renderer plugin.

UsdImagingGLEngine::SetRendererSetting
USDIMAGINGGL_API void SetRendererSetting(TfToken const &id, VtValue const &value)
Sets a renderer setting's value.

UsdImagingGLEngine::Parameters::allowAsynchronousSceneProcessing
bool allowAsynchronousSceneProcessing
allowAsynchronousSceneProcessing indicates to constructed hydra scene indices that asynchronous proce...
Definition: engine.h:111

UsdImagingGLEngine::SetPresentationOutput
USDIMAGINGGL_API void SetPresentationOutput(TfToken const &api, VtValue const &framebuffer)
The destination API (e.g., OpenGL, see hgiInterop for details) and framebuffer that the AOVs are pres...

UsdImagingGLEngine::GetRendererSettingsList
USDIMAGINGGL_API UsdImagingGLRendererSettingsList GetRendererSettingsList() const
Returns the list of renderer settings.

UsdImagingGLEngine::GetRendererHgiDisplayName
USDIMAGINGGL_API std::string GetRendererHgiDisplayName() const
Return the user-friendly name of the Hgi implementation.

UsdImagingGLEngine::GetCurrentRendererId
USDIMAGINGGL_API TfToken GetCurrentRendererId() const
Return the id of the currently used renderer plugin.

UsdImagingGLEngine::SetOverrideWindowPolicy
USDIMAGINGGL_API void SetOverrideWindowPolicy(const std::optional< CameraUtilConformWindowPolicy > &policy)
Specifies whether to force a window policy when conforming the frustum of the camera to match the dis...

UsdImagingGLEngine::UseUsdImagingSceneIndex
static USDIMAGINGGL_API bool UseUsdImagingSceneIndex()
Returns true if using the UsdImaging scene index.

UsdImagingGLEngine::ClearSelected
USDIMAGINGGL_API void ClearSelected()
Clear the list of prim paths that should be included in selection highlighting.

UsdImagingGLEngine::GetRenderStats
USDIMAGINGGL_API VtDictionary GetRenderStats() const
Returns render statistics.

UsdImagingGLEngine::GetRendererCommandDescriptors
USDIMAGINGGL_API HdCommandDescriptors GetRendererCommandDescriptors() const
Return command deescriptors for commands supported by the active render delegate.

UsdImagingGLEngine::SetSelected
USDIMAGINGGL_API void SetSelected(SdfPathVector const &paths)
Sets (replaces) the list of prim paths that should be included in selection highlighting.

UsdImagingGLEngine::Parameters::gpuEnabled
bool gpuEnabled
The gpuEnabled argument determines if this instance will allow Hydra to use the GPU to produce images...
Definition: engine.h:104

UsdImagingGLEngine::TestIntersection
USDIMAGINGGL_API bool TestIntersection(const PickParams &pickParams, const GfMatrix4d &viewMatrix, const GfMatrix4d &projectionMatrix, const UsdPrim &root, const UsdImagingGLRenderParams &params, IntersectionResultVector *outResults)
Perform picking by finding the intersection of objects in the scene with a renderered frustum.

UsdImagingGLEngine::SetFraming
USDIMAGINGGL_API void SetFraming(CameraUtilFraming const &framing)
Determines how the filmback of the camera is mapped into the pixels of the render buffer and what pix...

UsdImagingGLEngine::SetWindowPolicy
USDIMAGINGGL_API void SetWindowPolicy(CameraUtilConformWindowPolicy policy)
Set the window policy to use.

UsdImagingGLEngine::TestIntersection
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)
Finds closest point of intersection with a frustum by rendering.

UsdImagingGLEngine::AddSelected
USDIMAGINGGL_API void AddSelected(SdfPath const &path, int instanceIndex)
Add a path with instanceIndex to the list of prim paths that should be included in selection highligh...

UsdImagingGLEngine::SetRootTransform
USDIMAGINGGL_API void SetRootTransform(GfMatrix4d const &xf)
Sets the root transform.

UsdImagingGLEngine::SetActiveRenderSettingsPrimPath
USDIMAGINGGL_API void SetActiveRenderSettingsPrimPath(SdfPath const &)
Set active render settings prim to use to drive rendering.

UsdImagingGLEngine::GetGPUEnabled
USDIMAGINGGL_API bool GetGPUEnabled() const
Return if the GPU is enabled and can be used for any rendering tasks.

UsdImagingGLEngine::Parameters
Parameters to construct UsdImagingGLEngine.
Definition: engine.h:89

UsdImagingGLRenderParams
Used as an arguments class for various methods in UsdImagingGLEngine.
Definition: renderParams.h:57

UsdImagingRootOverridesSceneIndex
Overrides some data sources on the root prim.
Definition: rootOverridesSceneIndex.h:29

UsdImagingSelectionSceneIndex
A simple scene index adding HdSelectionsSchema to all prims selected with AddSelection.
Definition: selectionSceneIndex.h:30

UsdImagingStageSceneIndex
A scene index consuming a UsdStage.
Definition: stageSceneIndex.h:47

UsdPrim
UsdPrim is the sole persistent scenegraph object on a UsdStage, and is the embodiment of a "Prim" as ...
Definition: prim.h:117

UsdTimeCode
Represent a time value, which may be either numeric, holding a double value, or a sentinel value UsdT...
Definition: timeCode.h:72

VtDictionary
A map with string keys and VtValue values.
Definition: dictionary.h:52

VtValue
Provides a container which may hold any type, and provides introspection and iteration over array typ...
Definition: value.h:90

declarePtrs.h
Standard pointer typedefs.

TF_DECLARE_REF_PTRS
#define TF_DECLARE_REF_PTRS(type)
Define standard ref pointer types.
Definition: declarePtrs.h:58

TF_DECLARE_WEAK_AND_REF_PTRS
#define TF_DECLARE_WEAK_AND_REF_PTRS(type)
Define standard weak, ref, and vector pointer types.
Definition: declarePtrs.h:72

dictionary.h

frustum.h

matrix4d.h

pxr.h

renderParams.h

simpleLight.h

simpleMaterial.h

HdxRenderTaskParams
RenderTask parameters (renderpass state).
Definition: renderSetupTask.h:121

TfTokenVector
std::vector< TfToken > TfTokenVector
Convenience types.
Definition: token.h:440

vec4d.h

vec4f.h

vec4i.h