HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
renderSetupTask.h
Go to the documentation of this file.
1 //
2 // Copyright 2016 Pixar
3 //
4 // Licensed under the terms set forth in the LICENSE.txt file available at
5 // https://openusd.org/license.
6 //
7 #ifndef PXR_IMAGING_HDX_RENDER_SETUP_TASK_H
8 #define PXR_IMAGING_HDX_RENDER_SETUP_TASK_H
9 
10 #include "pxr/pxr.h"
11 #include "pxr/imaging/hdx/api.h"
13 #include "pxr/imaging/hd/task.h"
14 #include "pxr/imaging/hd/tokens.h"
15 #include "pxr/imaging/hd/enums.h"
17 
19 
20 #include "pxr/base/gf/vec2f.h"
21 #include "pxr/base/gf/vec4f.h"
22 #include "pxr/base/gf/vec4d.h"
23 
24 #include <memory>
25 #include <optional>
26 
28 
30  std::shared_ptr<class HdxRenderSetupTask>;
32  std::shared_ptr<class HdStRenderPassShader>;
33 using HdStShaderCodeSharedPtr = std::shared_ptr<class HdStShaderCode>;
34 
35 using HdRenderPassStateSharedPtr = std::shared_ptr<class HdRenderPassState>;
36 
37 struct HdxRenderTaskParams;
39 
40 
41 /// \class HdxRenderSetupTask
42 ///
43 /// A task for setting up render pass state (camera, renderpass shader, GL
44 /// states).
45 ///
46 /// HdxRenderTask depends on the output of this task. Applications can choose
47 /// to create a render setup task, and pass it the HdxRenderTaskParams; or they
48 /// can pass the HdxRenderTaskParams directly to the render task, which will
49 /// create a render setup task internally. See the HdxRenderTask documentation
50 /// for details.
51 ///
52 class HdxRenderSetupTask : public HdTask
53 {
54 public:
56 
57  HDX_API
58  HdxRenderSetupTask(HdSceneDelegate* delegate, SdfPath const& id);
59 
60  HDX_API
61  ~HdxRenderSetupTask() override;
62 
63 
64  // APIs used from HdxRenderTask to manage the sync/prepare process.
65  HDX_API
66  void SyncParams(HdSceneDelegate* delegate,
68  HDX_API
69  void PrepareCamera(HdRenderIndex* renderIndex);
70 
72  return _renderPassState;
73  }
74 
75  /// Sync the render pass resources
76  HDX_API
77  void Sync(HdSceneDelegate* delegate,
78  HdTaskContext* ctx,
79  HdDirtyBits* dirtyBits) override;
80 
81  /// Prepare the tasks resources
82  HDX_API
83  void Prepare(HdTaskContext* ctx,
84  HdRenderIndex* renderIndex) override;
85 
86  /// Execute render pass task
87  HDX_API
88  void Execute(HdTaskContext* ctx) override;
89 
90 private:
91  HdRenderPassStateSharedPtr _renderPassState;
92  HdStRenderPassShaderSharedPtr _colorRenderPassShader;
93  SdfPath _cameraId;
94  CameraUtilFraming _framing;
95  std::optional<CameraUtilConformWindowPolicy> _overrideWindowPolicy;
96  // Used when client did not specify the camera framing (more expressive
97  // and preferred).
98  GfVec4d _viewport;
99  HdRenderPassAovBindingVector _aovBindings;
100  HdRenderPassAovBindingVector _aovInputBindings;
101 
102  void _SetRenderpassShadersForStorm(
103  HdStRenderPassState *renderPassState,
104  HdResourceRegistrySharedPtr const &resourceRegistry);
105 
106  HdRenderPassStateSharedPtr &_GetRenderPassState(HdRenderIndex* renderIndex);
107 
108  void _PrepareAovBindings(HdTaskContext* ctx, HdRenderIndex* renderIndex);
109 
110 
111  HdxRenderSetupTask() = delete;
112  HdxRenderSetupTask(const HdxRenderSetupTask &) = delete;
113  HdxRenderSetupTask &operator =(const HdxRenderSetupTask &) = delete;
114 };
115 
116 /// \class HdxRenderTaskParams
117 ///
118 /// RenderTask parameters (renderpass state).
119 ///
121 {
123  // Global Params
124  : overrideColor(0.0)
125  , wireframeColor(0.0)
126  , pointColor(GfVec4f(0,0,0,1))
127  , pointSize(3.0)
128  , enableLighting(false)
129  , alphaThreshold(0.0)
130  , enableSceneMaterials(true)
131  , enableSceneLights(true)
132  , enableClipping(true)
133  // Selection/Masking params
134  , maskColor(1.0f, 0.0f, 0.0f, 1.0f)
135  , indicatorColor(0.0f, 1.0f, 0.0f, 1.0f)
136  , pointSelectedSize(3.0)
137  // Storm render pipeline state
138  , depthBiasUseDefault(true)
139  , depthBiasEnable(false)
141  , depthBiasSlopeFactor(1.0f)
143  , depthMaskEnable(true)
145  , stencilRef(0)
146  , stencilMask(~0)
150  , stencilEnable(false)
157  , blendConstantColor(0.0f, 0.0f, 0.0f, 0.0f)
158  , blendEnable(false)
159  , enableAlphaToCoverage(true)
160  , useAovMultiSample(true)
161  , resolveAovMultiSample(true)
162  // Camera framing and viewer state
163  , viewport(0.0)
165  {}
166 
167  // ---------------------------------------------------------------------- //
168  // Application rendering state
169  // XXX: Several of the parameters below are specific to (or work only with)
170  // Storm and stem from its integration in Presto and usdview.
171  // ---------------------------------------------------------------------- //
172  // "Global" parameters while rendering.
176  float pointSize;
182 
183  // Selection/Masking params
187 
188  // AOVs to render to
189  // XXX: As a transitional API, if this is empty it indicates the renderer
190  // should write color and depth to the GL framebuffer.
193 
194  // ---------------------------------------------------------------------- //
195  // Render pipeline state for rasterizers.
196  // XXX: These are relevant only for Storm.
197  // ---------------------------------------------------------------------- //
198  bool depthBiasUseDefault; // inherit application GL state
202 
205 
206  // Stencil
214 
215  // Blending
224 
225  // AlphaToCoverage
227 
228  // If true (default), render into the multi-sampled AOVs (rather than
229  // the resolved AOVs).
231 
232  // If true (default), multi-sampled AOVs will be resolved at the end of a
233  // render pass.
235 
236  // ---------------------------------------------------------------------- //
237  // Viewer & Camera Framing state
238  // ---------------------------------------------------------------------- //
241  // Only used if framing is invalid.
244  std::optional<CameraUtilConformWindowPolicy> overrideWindowPolicy;
245 };
246 
247 // VtValue requirements
248 HDX_API
249 std::ostream& operator<<(std::ostream& out, const HdxRenderTaskParams& pv);
250 HDX_API
251 bool operator==(const HdxRenderTaskParams& lhs, const HdxRenderTaskParams& rhs);
252 HDX_API
253 bool operator!=(const HdxRenderTaskParams& lhs, const HdxRenderTaskParams& rhs);
254 
255 
257 
258 #endif //PXR_IMAGING_HDX_RENDER_SETUP_TASK_H
HdBlendFactor blendAlphaDstFactor
HdStencilOp stencilZFailOp
std::shared_ptr< class HdRenderPassState > HdRenderPassStateSharedPtr
Definition: engine.h:25
HdCompareFunction
Definition: enums.h:19
std::shared_ptr< class HdStShaderCode > HdStShaderCodeSharedPtr
HdCullStyle
Definition: enums.h:105
std::shared_ptr< class HdResourceRegistry > HdResourceRegistrySharedPtr
HDX_API void Sync(HdSceneDelegate *delegate, HdTaskContext *ctx, HdDirtyBits *dirtyBits) override
Sync the render pass resources.
HdBlendFactor blendAlphaSrcFactor
uint32_t HdDirtyBits
Definition: types.h:143
HdRenderPassAovBindingVector aovInputBindings
HdCompareFunction stencilFunc
HdStencilOp stencilFailOp
Definition: vec4d.h:45
HdBlendFactor
Definition: enums.h:70
#define HDX_API
Definition: api.h:23
GLenum const GLfloat * params
Definition: glcorearb.h:105
HDX_API void Execute(HdTaskContext *ctx) override
Execute render pass task.
HdStencilOp stencilZPassOp
GLfloat f
Definition: glcorearb.h:1926
bool operator!=(const Mat3< T0 > &m0, const Mat3< T1 > &m1)
Inequality operator, does exact floating point comparisons.
Definition: Mat3.h:556
CameraUtilFraming framing
Definition: task.h:43
Definition: path.h:273
HdStencilOp
Definition: enums.h:37
HDX_API void SyncParams(HdSceneDelegate *delegate, HdxRenderTaskParams const &params)
std::unordered_map< TfToken, VtValue, TfToken::HashFunctor > HdTaskContext
Definition: renderIndex.h:61
std::shared_ptr< class HdStRenderPassShader > HdStRenderPassShaderSharedPtr
Definition: vec4f.h:45
std::optional< CameraUtilConformWindowPolicy > overrideWindowPolicy
PXR_NAMESPACE_CLOSE_SCOPE PXR_NAMESPACE_OPEN_SCOPE
Definition: path.h:1425
HdRenderPassStateSharedPtr const & GetRenderPassState() const
std::shared_ptr< class HdxRenderSetupTask > HdxRenderSetupTaskSharedPtr
#define PXR_NAMESPACE_CLOSE_SCOPE
Definition: pxr.h:74
HDX_API std::ostream & operator<<(std::ostream &out, const HdxRenderTaskParams &pv)
HdBlendFactor blendColorSrcFactor
HDX_API void PrepareCamera(HdRenderIndex *renderIndex)
HdRenderPassAovBindingVector aovBindings
HdBlendOp
Definition: enums.h:55
std::vector< HdRenderPassAovBinding > HdRenderPassAovBindingVector
Definition: aov.h:137
HdCompareFunction depthFunc
HdBlendFactor blendColorDstFactor
HDX_API void Prepare(HdTaskContext *ctx, HdRenderIndex *renderIndex) override
Prepare the tasks resources.
bool operator==(const Mat3< T0 > &m0, const Mat3< T1 > &m1)
Equality operator, does exact floating point comparisons.
Definition: Mat3.h:542
HDX_API ~HdxRenderSetupTask() override