HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
engine.h
Go to the documentation of this file.
1 //
2 // Copyright 2016 Pixar
3 //
4 // Licensed under the Apache License, Version 2.0 (the "Apache License")
5 // with the following modification; you may not use this file except in
6 // compliance with the Apache License and the following modification to it:
7 // Section 6. Trademarks. is deleted and replaced with:
8 //
9 // 6. Trademarks. This License does not grant permission to use the trade
10 // names, trademarks, service marks, or product names of the Licensor
11 // and its affiliates, except as required to comply with Section 4(c) of
12 // the License and to reproduce the content of the NOTICE file.
13 //
14 // You may obtain a copy of the Apache License at
15 //
16 // http://www.apache.org/licenses/LICENSE-2.0
17 //
18 // Unless required by applicable law or agreed to in writing, software
19 // distributed under the Apache License with the above modification is
20 // distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
21 // KIND, either express or implied. See the Apache License for the specific
22 // language governing permissions and limitations under the Apache License.
23 //
24 
25 /// \file usdImagingGL/engine.h
26 
27 #ifndef USDIMAGINGGL_ENGINE_H
28 #define USDIMAGINGGL_ENGINE_H
29 
30 #include "pxr/pxr.h"
33 
36 
38 
39 #include "pxr/imaging/hd/engine.h"
41 
46 
50 
51 #include "pxr/usd/sdf/path.h"
52 #include "pxr/usd/usd/timeCode.h"
53 
54 #include "pxr/base/gf/frustum.h"
55 #include "pxr/base/gf/matrix4d.h"
56 #include "pxr/base/gf/vec4d.h"
57 #include "pxr/base/gf/vec4f.h"
58 #include "pxr/base/gf/vec4i.h"
59 
60 #include "pxr/base/vt/dictionary.h"
61 
63 
65 
66 class UsdPrim;
67 class HdRenderIndex;
68 class HdRendererPlugin;
69 class HdxTaskController;
70 class UsdImagingDelegate;
71 class UsdImagingGLLegacyEngine;
72 
73 typedef hboost::shared_ptr<class GlfGLContext> GlfGLContextSharedPtr;
76 
77 /// \class UsdImagingGLEngine
78 ///
79 /// The UsdImagingGLEngine is the main entry point API for rendering USD scenes.
80 ///
82 {
83 public:
84 
85  // ---------------------------------------------------------------------
86  /// \name Global State
87  /// @{
88  // ---------------------------------------------------------------------
89 
90  /// Returns true if Hydra is enabled for GL drawing.
92  static bool IsHydraEnabled();
93 
94  /// @}
95 
96  // ---------------------------------------------------------------------
97  /// \name Construction
98  /// @{
99  // ---------------------------------------------------------------------
102 
104  UsdImagingGLEngine(const SdfPath& rootPath,
105  const SdfPathVector& excludedPaths,
106  const SdfPathVector& invisedPaths=SdfPathVector(),
107  const SdfPath& delegateID = SdfPath::AbsoluteRootPath());
108 
109  // Disallow copies
110  UsdImagingGLEngine(const UsdImagingGLEngine&) = delete;
111  UsdImagingGLEngine& operator=(const UsdImagingGLEngine&) = delete;
112 
115 
116  /// @}
117 
118  // ---------------------------------------------------------------------
119  /// \name Rendering
120  /// @{
121  // ---------------------------------------------------------------------
122 
123  /// Support for batched drawing
125  void PrepareBatch(const UsdPrim& root,
128  void RenderBatch(const SdfPathVector& paths,
129  const UsdImagingGLRenderParams& params);
130 
131  /// Entry point for kicking off a render
133  void Render(const UsdPrim& root,
134  const UsdImagingGLRenderParams &params);
135 
137  void InvalidateBuffers();
138 
139  /// Returns true if the resulting image is fully converged.
140  /// (otherwise, caller may need to call Render() again to refine the result)
142  bool IsConverged() const;
143 
144  /// @}
145 
146  // ---------------------------------------------------------------------
147  /// \name Root Transform and Visibility
148  /// @{
149  // ---------------------------------------------------------------------
150 
151  /// Sets the root transform.
153  void SetRootTransform(GfMatrix4d const& xf);
154 
155  /// Sets the root visibility.
157  void SetRootVisibility(bool isVisible);
158 
159  /// @}
160 
161  // ---------------------------------------------------------------------
162  /// \name Camera State
163  /// @{
164  // ---------------------------------------------------------------------
165 
166  /// Set the viewport to use for rendering as (x,y,w,h), where (x,y)
167  /// represents the lower left corner of the viewport rectangle, and (w,h)
168  /// is the width and height of the viewport in pixels.
170  void SetRenderViewport(GfVec4d const& viewport);
171 
172  /// Set the window policy to use.
173  /// XXX: This is currently used for scene cameras set via SetCameraPath.
174  /// See comment in SetCameraState for the free cam.
177 
178  /// Scene camera API
179  /// Set the scene camera path to use for rendering.
181  void SetCameraPath(SdfPath const& id);
182 
183  /// Free camera API
184  /// Set camera framing state directly (without pointing to a camera on the
185  /// USD stage). The projection matrix is expected to be pre-adjusted for the
186  /// window policy.
188  void SetCameraState(const GfMatrix4d& viewMatrix,
189  const GfMatrix4d& projectionMatrix);
190 
191  /// Helper function to extract camera and viewport state from opengl and
192  /// then call SetCameraState and SetRenderViewport
195 
196  /// @}
197 
198  // ---------------------------------------------------------------------
199  /// \name Light State
200  /// @{
201  // ---------------------------------------------------------------------
202 
203  /// Helper function to extract lighting state from opengl and then
204  /// call SetLights.
207 
208  /// Copy lighting state from another lighting context.
210  void SetLightingState(GlfSimpleLightingContextPtr const &src);
211 
212  /// Set lighting state
213  /// Derived classes should ensure that passing an empty lights
214  /// vector disables lighting.
215  /// \param lights is the set of lights to use, or empty to disable lighting.
217  void SetLightingState(GlfSimpleLightVector const &lights,
218  GlfSimpleMaterial const &material,
219  GfVec4f const &sceneAmbient);
220 
221  /// @}
222 
223  // ---------------------------------------------------------------------
224  /// \name Selection Highlighting
225  /// @{
226  // ---------------------------------------------------------------------
227 
228  /// Sets (replaces) the list of prim paths that should be included in
229  /// selection highlighting. These paths may include root paths which will
230  /// be expanded internally.
232  void SetSelected(SdfPathVector const& paths);
233 
234  /// Clear the list of prim paths that should be included in selection
235  /// highlighting.
237  void ClearSelected();
238 
239  /// Add a path with instanceIndex to the list of prim paths that should be
240  /// included in selection highlighting. UsdImagingDelegate::ALL_INSTANCES
241  /// can be used for highlighting all instances if path is an instancer.
243  void AddSelected(SdfPath const &path, int instanceIndex);
244 
245  /// Sets the selection highlighting color.
247  void SetSelectionColor(GfVec4f const& color);
248 
249  /// @}
250 
251  // ---------------------------------------------------------------------
252  /// \name Picking
253  /// @{
254  // ---------------------------------------------------------------------
255 
256  /// Finds closest point of intersection with a frustum by rendering.
257  ///
258  /// This method uses a PickRender and a customized depth buffer to find an
259  /// approximate point of intersection by rendering. This is less accurate
260  /// than implicit methods or rendering with GL_SELECT, but leverages any
261  /// data already cached in the renderer.
262  ///
263  /// Returns whether a hit occurred and if so, \p outHitPoint will contain
264  /// the intersection point in world space (i.e. \p projectionMatrix and
265  /// \p viewMatrix factored back out of the result).
266  ///
268  bool TestIntersection(
269  const GfMatrix4d &viewMatrix,
270  const GfMatrix4d &projectionMatrix,
271  const GfMatrix4d &worldToLocalSpace,
272  const UsdPrim& root,
273  const UsdImagingGLRenderParams& params,
274  GfVec3d *outHitPoint,
275  SdfPath *outHitPrimPath = NULL,
276  SdfPath *outHitInstancerPath = NULL,
277  int *outHitInstanceIndex = NULL,
278  int *outHitElementIndex = NULL);
279 
280  /// Using an Id extracted from an Id render, returns the associated
281  /// rprim path.
282  ///
283  /// Note that this function doesn't resolve instancer relationship.
284  /// returning prim can be a prototype mesh which may not exist in usd stage.
285  /// It can be resolved to the actual usd prim and corresponding instance
286  /// index by GetPrimPathFromInstanceIndex().
287  ///
289  SdfPath GetRprimPathFromPrimId(int primId) const;
290 
291  /// Using colors extracted from an Id render, returns the associated
292  /// prim path and optional instance index.
293  ///
294  /// Note that this function doesn't resolve instancer relationship.
295  /// returning prim can be a prototype mesh which may not exist in usd stage.
296  /// It can be resolved to the actual usd prim and corresponding instance
297  /// index by GetPrimPathFromInstanceIndex().
298  ///
299  /// XXX: consider renaming to GetRprimPathFromPrimIdColor
300  ///
303  GfVec4i const & primIdColor,
304  GfVec4i const & instanceIdColor,
305  int * instanceIndexOut = NULL);
306 
307  /// Returns the rprim id path of the instancer being rendered by this
308  /// engine that corresponds to the instance index generated by the
309  /// specified instanced prototype rprim id.
310  /// Returns an empty path if no such instance prim exists.
311  ///
312  /// \p instancerIndex is also returned, which is an instance index
313  /// of all instances in the top-level instancer. Note that if the instancer
314  /// instances heterogeneously, or there are multiple levels of hierarchy,
315  /// \p protoIndex of the prototype rprim doesn't match the
316  /// \p instancerIndex in the instancer (see usdImaging/delegate.h)
317  ///
318  /// If \p masterCachePath is not NULL, and the input rprim is an instance
319  /// resulting from an instanceable reference (and not from a
320  /// PointInstancer), then it will be set to the cache path of the
321  /// corresponding instance master prim. Otherwise, it will be set to null.
322  ///
323  /// If \p instanceContext is not NULL, it is populated with the list of
324  /// instance roots that must be traversed to get to the rprim. If this
325  /// list is non-empty, the last prim is always the forwarded rprim.
326  ///
329  const SdfPath &protoRprimId,
330  int protoIndex,
331  int *instancerIndex=NULL,
332  SdfPath *masterCachePath=NULL,
333  SdfPathVector *instanceContext=NULL);
334 
335  /// Resolves a 4-byte pixel from an id render to an int32 prim ID.
336  static inline int DecodeIDRenderColor(unsigned char const idColor[4]) {
337  return HdxPickTask::DecodeIDRenderColor(idColor);
338  }
339 
340  /// @}
341 
342  // ---------------------------------------------------------------------
343  /// \name Renderer Plugin Management
344  /// @{
345  // ---------------------------------------------------------------------
346 
347  /// Return the vector of available render-graph delegate plugins.
350 
351  /// Return the user-friendly description of a renderer plugin.
353  static std::string GetRendererDisplayName(TfToken const &id);
354 
355  /// Return the id of the currently used renderer plugin.
358 
359  /// Set the current render-graph delegate to \p id.
360  /// the plugin will be loaded if it's not yet.
362  bool SetRendererPlugin(TfToken const &id);
363 
364  /// @}
365 
366  // ---------------------------------------------------------------------
367  /// \name AOVs and Renderer Settings
368  /// @{
369  // ---------------------------------------------------------------------
370 
371  /// Return the vector of available renderer AOV settings.
374 
375  /// Set the current renderer AOV to \p id.
377  bool SetRendererAov(TfToken const& id);
378 
379  /// Returns the list of renderer settings.
382 
383  /// Gets a renderer setting's current value.
385  VtValue GetRendererSetting(TfToken const& id) const;
386 
387  /// Sets a renderer setting's value.
389  void SetRendererSetting(TfToken const& id,
390  VtValue const& value);
391 
392  /// @}
393 
394  // ---------------------------------------------------------------------
395  /// \name Control of background rendering threads.
396  /// @{
397  // ---------------------------------------------------------------------
398 
399  /// Query the renderer as to whether it supports pausing and resuming.
401  bool IsPauseRendererSupported() const;
402 
403  /// Pause the renderer.
404  ///
405  /// Returns \c true if successful.
407  bool PauseRenderer();
408 
409  /// Resume the renderer.
410  ///
411  /// Returns \c true if successful.
413  bool ResumeRenderer();
414 
415  /// @}
416 
417  // ---------------------------------------------------------------------
418  /// \name Color Correction
419  /// @{
420  // ---------------------------------------------------------------------
421 
422  /// Set \p id to one of the HdxColorCorrectionTokens.
423  /// \p framebufferResolution should be the size of the bound framebuffer
424  /// that will be color corrected. It is recommended that a 16F or higher
425  /// AOV is bound for color correction.
428  TfToken const& id,
429  GfVec2i const& framebufferResolution);
430 
431  /// @}
432 
433  /// Returns true if the platform is color correction capable.
435  static bool IsColorCorrectionCapable();
436 
437  // ---------------------------------------------------------------------
438  /// \name Render Statistics
439  /// @{
440  // ---------------------------------------------------------------------
441 
442  /// Returns render statistics.
443  ///
444  /// The contents of the dictionary will depend on the current render
445  /// delegate.
446  ///
449 
450  /// @}
451 
452 
453 protected:
454 
455  /// Open some protected methods for whitebox testing.
457 
458  /// Returns the render index of the engine, if any. This is only used for
459  /// whitebox testing.
462 
464  void _Execute(const UsdImagingGLRenderParams &params,
465  HdTaskSharedPtrVector tasks);
466 
467  // These functions factor batch preparation into separate steps so they
468  // can be reused by both the vectorized and non-vectorized API.
470  bool _CanPrepareBatch(const UsdPrim& root,
471  const UsdImagingGLRenderParams& params);
473  void _PreSetTime(const UsdPrim& root,
474  const UsdImagingGLRenderParams& params);
476  void _PostSetTime(const UsdPrim& root,
477  const UsdImagingGLRenderParams& params);
478 
479  // Create a hydra collection given root paths and render params.
480  // Returns true if the collection was updated.
482  static bool _UpdateHydraCollection(HdRprimCollection *collection,
483  SdfPathVector const& roots,
484  UsdImagingGLRenderParams const& params);
487  UsdImagingGLRenderParams const& params);
489  static void _ComputeRenderTags(UsdImagingGLRenderParams const& params,
490  TfTokenVector *renderTags);
491 
492  // This function disposes of: the render index, the render plugin,
493  // the task controller, and the usd imaging delegate.
495  void _DeleteHydraResources();
496 
499 
501 
503 
507 
510 
514 
515  GlfSimpleLightingContextRefPtr _lightingContextForOpenGLState;
516 
517  // Data we want to live across render plugin switches:
519 
524 
525  // An implementation of much of the engine functionality that doesn't
526  // invoke any of the advanced Hydra features. It is kept around for
527  // backwards compatibility and may one day be deprecated. Most of the
528  // time we expect this to be null. When it is not null, none of the other
529  // member variables of this class are used.
530  std::unique_ptr<UsdImagingGLLegacyEngine> _legacyImpl;
531 };
532 
533 
535 
536 #endif // USDIMAGINGGL_ENGINE_H
USDIMAGINGGL_API void SetRenderViewport(GfVec4d const &viewport)
Definition: vec4i.h:61
HdxTaskController * _taskController
Definition: engine.h:513
USDIMAGINGGL_API TfToken GetCurrentRendererId() const
Return the id of the currently used renderer plugin.
static SDF_API const SdfPath & AbsoluteRootPath()
USDIMAGINGGL_API void SetLightingStateFromOpenGL()
GLenum src
Definition: glew.h:2410
GlfSimpleLightingContextRefPtr _lightingContextForOpenGLState
Definition: engine.h:515
HdEngine _engine
Definition: engine.h:500
USDIMAGINGGL_API void _Execute(const UsdImagingGLRenderParams &params, HdTaskSharedPtrVector tasks)
hboost::shared_ptr< class GlfGLContext > GlfGLContextSharedPtr
Definition: engine.h:71
HdRprimCollection _intersectCollection
Definition: engine.h:506
hboost::math::policies::policy< hboost::math::policies::domain_error< hboost::math::policies::ignore_error >, hboost::math::policies::pole_error< hboost::math::policies::ignore_error >, hboost::math::policies::overflow_error< hboost::math::policies::ignore_error >, hboost::math::policies::underflow_error< hboost::math::policies::ignore_error >, hboost::math::policies::denorm_error< hboost::math::policies::ignore_error >, hboost::math::policies::rounding_error< hboost::math::policies::ignore_error >, hboost::math::policies::evaluation_error< hboost::math::policies::ignore_error >, hboost::math::policies::indeterminate_result_error< hboost::math::policies::ignore_error > > policy
Definition: SYS_MathCbrt.h:35
USDIMAGINGGL_API void SetSelectionColor(GfVec4f const &color)
Sets the selection highlighting color.
Definition: vec2i.h:61
SdfPath const _delegateID
Definition: engine.h:508
static USDIMAGINGGL_API HdxRenderTaskParams _MakeHydraUsdImagingGLRenderParams(UsdImagingGLRenderParams const &params)
USDIMAGINGGL_API void SetCameraPath(SdfPath const &id)
static USDIMAGINGGL_API bool _UpdateHydraCollection(HdRprimCollection *collection, SdfPathVector const &roots, UsdImagingGLRenderParams const &params)
USDIMAGINGGL_API void _PreSetTime(const UsdPrim &root, const UsdImagingGLRenderParams &params)
USDIMAGINGGL_API bool PauseRenderer()
USDIMAGINGGL_API void SetCameraStateFromOpenGL()
UsdImagingGLEngine & operator=(const UsdImagingGLEngine &)=delete
Definition: vec4d.h:63
static USDIMAGINGGL_API bool IsColorCorrectionCapable()
Returns true if the platform is color correction capable.
USDIMAGINGGL_API SdfPath GetPrimPathFromPrimIdColor(GfVec4i const &primIdColor, GfVec4i const &instanceIdColor, int *instanceIndexOut=NULL)
USDIMAGINGGL_API bool _CanPrepareBatch(const UsdPrim &root, const UsdImagingGLRenderParams &params)
USDIMAGINGGL_API void InvalidateBuffers()
Support for batched drawing.
USDIMAGINGGL_API bool IsPauseRendererSupported() const
Query the renderer as to whether it supports pausing and resuming.
TfToken _rendererId
Definition: engine.h:512
USDIMAGINGGL_API void SetColorCorrectionSettings(TfToken const &id, GfVec2i const &framebufferResolution)
USDIMAGINGGL_API void SetCameraState(const GfMatrix4d &viewMatrix, const GfMatrix4d &projectionMatrix)
USDIMAGINGGL_API bool SetRendererPlugin(TfToken const &id)
USDIMAGINGGL_API bool TestIntersection(const GfMatrix4d &viewMatrix, const GfMatrix4d &projectionMatrix, const GfMatrix4d &worldToLocalSpace, const UsdPrim &root, const UsdImagingGLRenderParams &params, GfVec3d *outHitPoint, SdfPath *outHitPrimPath=NULL, SdfPath *outHitInstancerPath=NULL, int *outHitInstanceIndex=NULL, int *outHitElementIndex=NULL)
friend class UsdImagingGL_UnitTestGLDrawing
Open some protected methods for whitebox testing.
Definition: engine.h:456
USDIMAGINGGL_API SdfPath GetPrimPathFromInstanceIndex(const SdfPath &protoRprimId, int protoIndex, int *instancerIndex=NULL, SdfPath *masterCachePath=NULL, SdfPathVector *instanceContext=NULL)
static int DecodeIDRenderColor(unsigned char const idColor[4])
Resolves a 4-byte pixel from an id render to an int32 prim ID.
Definition: engine.h:336
Definition: token.h:89
#define USDIMAGINGGL_API
Definition: api.h:40
static USDIMAGINGGL_API void _ComputeRenderTags(UsdImagingGLRenderParams const &params, TfTokenVector *renderTags)
USDIMAGINGGL_API void AddSelected(SdfPath const &path, int instanceIndex)
GfVec4f _selectionColor
Definition: engine.h:518
HdRprimCollection _renderCollection
Definition: engine.h:505
USDIMAGINGGL_API SdfPath GetRprimPathFromPrimId(int primId) const
USDIMAGINGGL_API void SetSelected(SdfPathVector const &paths)
static USDIMAGINGGL_API bool IsHydraEnabled()
Returns true if Hydra is enabled for GL drawing.
USDIMAGINGGL_API HdRenderIndex * _GetRenderIndex() const
static USDIMAGINGGL_API TfTokenVector GetRendererPlugins()
Return the vector of available render-graph delegate plugins.
USDIMAGINGGL_API void SetRootTransform(GfMatrix4d const &xf)
Sets the root transform.
USDIMAGINGGL_API void SetWindowPolicy(CameraUtilConformWindowPolicy policy)
USDIMAGINGGL_API ~UsdImagingGLEngine()
Definition: prim.h:131
USDIMAGINGGL_API void _PostSetTime(const UsdPrim &root, const UsdImagingGLRenderParams &params)
std::vector< TfToken > TfTokenVector
Convenience types.
Definition: token.h:438
HdRendererPlugin * _rendererPlugin
Definition: engine.h:511
USDIMAGINGGL_API void _DeleteHydraResources()
USDIMAGINGGL_API bool SetRendererAov(TfToken const &id)
Set the current renderer AOV to id.
GLuint color
Definition: glew.h:7902
Definition: path.h:287
std::vector< class SdfPath > SdfPathVector
A vector of SdfPaths.
Definition: path.h:208
HdxSelectionTrackerSharedPtr _selTracker
Definition: engine.h:504
USDIMAGINGGL_API UsdImagingGLRendererSettingsList GetRendererSettingsList() const
Returns the list of renderer settings.
USDIMAGINGGL_API bool IsConverged() const
USDIMAGINGGL_API void SetRendererSetting(TfToken const &id, VtValue const &value)
Sets a renderer setting's value.
GLsizei const GLchar *const * path
Definition: glew.h:6461
Definition: vec4f.h:63
CameraUtilConformWindowPolicy
Definition: conformWindow.h:44
USDIMAGINGGL_API void Render(const UsdPrim &root, const UsdImagingGLRenderParams &params)
Entry point for kicking off a render.
SdfPathVector _invisedPrimPaths
Definition: engine.h:522
GLsizei const GLchar *const * string
Definition: glew.h:1844
UsdImagingDelegate * _delegate
Definition: engine.h:509
USDIMAGINGGL_API void PrepareBatch(const UsdPrim &root, const UsdImagingGLRenderParams &params)
Support for batched drawing.
TF_DECLARE_WEAK_AND_REF_PTRS(GlfDrawTarget)
PXR_NAMESPACE_CLOSE_SCOPE PXR_NAMESPACE_OPEN_SCOPE
Definition: path.h:1245
USDIMAGINGGL_API UsdImagingGLEngine()
USDIMAGINGGL_API void ClearSelected()
std::vector< UsdImagingGLRendererSetting > UsdImagingGLRendererSettingsList
USDIMAGINGGL_API void SetLightingState(GlfSimpleLightingContextPtr const &src)
Copy lighting state from another lighting context.
std::unique_ptr< UsdImagingGLLegacyEngine > _legacyImpl
Definition: engine.h:530
Definition: vec3d.h:63
USDIMAGINGGL_API void RenderBatch(const SdfPathVector &paths, const UsdImagingGLRenderParams &params)
Support for batched drawing.
static int DecodeIDRenderColor(unsigned char const idColor[4])
Utility: Given a UNorm8Vec4 pixel, unpack it into an int32 ID.
Definition: pickTask.h:190
#define PXR_NAMESPACE_CLOSE_SCOPE
Definition: pxr.h:83
USDIMAGINGGL_API TfTokenVector GetRendererAovs() const
Return the vector of available renderer AOV settings.
USDIMAGINGGL_API VtValue GetRendererSetting(TfToken const &id) const
Gets a renderer setting's current value.
const GLfloat * params
Definition: glew.h:1531
USDIMAGINGGL_API bool ResumeRenderer()
SdfPathVector _excludedPrimPaths
Definition: engine.h:521
static USDIMAGINGGL_API std::string GetRendererDisplayName(TfToken const &id)
Return the user-friendly description of a renderer plugin.
std::vector< HdTaskSharedPtr > HdTaskSharedPtrVector
Definition: renderIndex.h:73
USDIMAGINGGL_API VtDictionary GetRenderStats() const
GLsizei const GLfloat * value
Definition: glew.h:1849
HdRenderIndex * _renderIndex
Definition: engine.h:502
Definition: value.h:182
static USDIMAGINGGL_API TfToken _GetDefaultRendererPluginId()
USDIMAGINGGL_API void SetRootVisibility(bool isVisible)
Sets the root visibility.
std::vector< class GlfSimpleLight > GlfSimpleLightVector
Definition: simpleLight.h:195
hboost::shared_ptr< class HdxSelectionTracker > HdxSelectionTrackerSharedPtr
SdfPath _rootPath
Definition: engine.h:520
GLenum const void * paths
Definition: glew.h:13589