HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
camera.h
Go to the documentation of this file.
1 //
2 // Copyright 2017 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_HD_CAMERA_H
8 #define PXR_IMAGING_HD_CAMERA_H
9 
10 #include "pxr/pxr.h"
11 #include "pxr/imaging/hd/api.h"
12 #include "pxr/imaging/hd/version.h"
13 #include "pxr/imaging/hd/sprim.h"
14 
16 
18 #include "pxr/base/gf/matrix4d.h"
19 #include "pxr/base/gf/range1f.h"
20 #include "pxr/base/gf/vec2f.h"
21 
22 #include <vector>
23 
25 
26 /// Camera state that can be requested from the scene delegate via
27 /// GetCameraParamValue(id, token). The parameters below mimic the
28 /// USD camera schema and GfCamera (with the exception of window
29 /// policy). All spatial units are in world units though and
30 /// projection is HdCamera::Projection rather than a token.
31 #define HD_CAMERA_TOKENS \
32  /* frustum */ \
33  (projection) \
34  (horizontalAperture) \
35  (verticalAperture) \
36  (horizontalApertureOffset) \
37  (verticalApertureOffset) \
38  (focalLength) \
39  (clippingRange) \
40  (clipPlanes) \
41  \
42  /* depth of field */ \
43  (fStop) \
44  (focusDistance) \
45  (focusOn) \
46  (dofAspect) \
47  ((splitDiopterCount, "splitDiopter:count")) \
48  ((splitDiopterAngle, "splitDiopter:angle")) \
49  ((splitDiopterOffset1, "splitDiopter:offset1")) \
50  ((splitDiopterWidth1, "splitDiopter:width1")) \
51  ((splitDiopterFocusDistance1, "splitDiopter:focusDistance1")) \
52  ((splitDiopterOffset2, "splitDiopter:offset2")) \
53  ((splitDiopterWidth2, "splitDiopter:width2")) \
54  ((splitDiopterFocusDistance2, "splitDiopter:focusDistance2")) \
55  \
56  /* shutter/lighting */ \
57  (shutterOpen) \
58  (shutterClose) \
59  (exposure) \
60  (exposureTime) \
61  (exposureIso) \
62  (exposureFStop) \
63  (exposureResponsivity) \
64  (linearExposureScale) \
65  \
66  /* how to match window with different aspect */ \
67  (windowPolicy) \
68  \
69  /* lens distortion */ \
70  (standard) \
71  (fisheye) \
72  ((lensDistortionType, "lensDistortion:type")) \
73  ((lensDistortionK1, "lensDistortion:k1")) \
74  ((lensDistortionK2, "lensDistortion:k2")) \
75  ((lensDistortionCenter, "lensDistortion:center")) \
76  ((lensDistortionAnaSq, "lensDistortion:anaSq")) \
77  ((lensDistortionAsym, "lensDistortion:asym")) \
78  ((lensDistortionScale, "lensDistortion:scale")) \
79  ((lensDistortionIor, "lensDistortion:ior"))
80 
81 
83 
84 /// \class HdCamera
85 ///
86 /// Hydra schema for a camera that pulls the params (see above) during
87 /// Sync.
88 /// Backends that use additional camera parameters can inherit from HdCamera and
89 /// pull on them.
90 ///
91 class HdCamera : public HdSprim
92 {
93 public:
94  using ClipPlanesVector = std::vector<GfVec4d>;
95 
96  HD_API
97  HdCamera(SdfPath const & id);
98  HD_API
99  ~HdCamera() override;
100 
101  // change tracking for HdCamera
103  {
104  Clean = 0,
105  DirtyTransform = 1 << 0,
106  DirtyParams = 1 << 1,
107  DirtyClipPlanes = 1 << 2,
110  |DirtyParams
113  };
114 
115  enum Projection {
118  };
119 
120  // ---------------------------------------------------------------------- //
121  /// Sprim API
122  // ---------------------------------------------------------------------- //
123 
124  /// Synchronizes state from the delegate to this object.
125  HD_API
126  void Sync(HdSceneDelegate *sceneDelegate,
127  HdRenderParam *renderParam,
128  HdDirtyBits *dirtyBits) override;
129 
130 
131  /// Returns the minimal set of dirty bits to place in the
132  /// change tracker for use in the first sync of this prim.
133  /// Typically this would be all dirty bits.
134  HD_API
135  HdDirtyBits GetInitialDirtyBitsMask() const override;
136 
137  // ---------------------------------------------------------------------- //
138  /// Camera parameters accessor API
139  // ---------------------------------------------------------------------- //
140 
141  /// Returns camera transform
142  GfMatrix4d const& GetTransform() const {
143  return _transform;
144  }
145 
146  /// Returns whether camera is orthographic and perspective
148  return _projection;
149  }
150 
151  /// Returns horizontal aperture in world units.
152  float GetHorizontalAperture() const {
153  return _horizontalAperture;
154  }
155 
156  /// Returns vertical aperture in world units.
157  float GetVerticalAperture() const {
158  return _verticalAperture;
159  }
160 
161  /// Returns horizontal aperture offset in world units.
164  }
165 
166  /// Returns vertical aperture offset in world units.
169  }
170 
171  /// Returns focal length in world units.
172  float GetFocalLength() const {
173  return _focalLength;
174  }
175 
176  /// Returns near and far plane in world units
177  GfRange1f const &GetClippingRange() const {
178  return _clippingRange;
179  }
180 
181  /// Returns any additional clipping planes defined in camera space.
182  std::vector<GfVec4d> const& GetClipPlanes() const {
183  return _clipPlanes;
184  }
185 
186  /// Returns fstop of camera
187  float GetFStop() const {
188  return _fStop;
189  }
190 
191  /// Returns focus distance in world units.
192  float GetFocusDistance() const {
193  return _focusDistance;
194  }
195 
196  bool GetFocusOn() const {
197  return _focusOn;
198  }
199 
200  float GetDofAspect() const {
201  return _dofAspect;
202  }
203 
204  int GetSplitDiopterCount() const {
205  return _splitDiopterCount;
206  }
207 
208  float GetSplitDiopterAngle() const {
209  return _splitDiopterAngle;
210  }
211 
212  float GetSplitDiopterOffset1() const {
213  return _splitDiopterOffset1;
214  }
215 
216  float GetSplitDiopterWidth1() const {
217  return _splitDiopterWidth1;
218  }
219 
222  }
223 
224  float GetSplitDiopterOffset2() const {
225  return _splitDiopterOffset2;
226  }
227 
228  float GetSplitDiopterWidth2() const {
229  return _splitDiopterWidth2;
230  }
231 
234  }
235 
236  double GetShutterOpen() const {
237  return _shutterOpen;
238  }
239 
240  double GetShutterClose() const {
241  return _shutterClose;
242  }
243 
244  /// Get the raw exposure exponent value.
245  ///
246  /// This the same as the value stored in the exposure attribute on the
247  /// underlying camera. Note that in most cases, you will want to use
248  /// GetLinearExposureScale() instead of this method, as it is the computed
249  /// end result of all related exposure attributes.
250  /// GetExposure() is retained as-is for backward compatibility.
251  float GetExposure() const {
252  return _exposure;
253  }
254 
255  /// Get the computed linear exposure scale from the underlying camera.
256  ///
257  /// Scaling the image brightness by this value will cause the various
258  /// exposure controls on \ref UsdGeomCamera to behave like those of a real
259  /// camera to control the exposure of the image.
260  float GetLinearExposureScale() const {
261  return _linearExposureScale;
262  }
263 
265  return _lensDistortionType;
266  }
267 
268  float GetLensDistortionK1() const {
269  return _lensDistortionK1;
270  }
271 
272  float GetLensDistortionK2() const {
273  return _lensDistortionK2;
274  }
275 
277  return _lensDistortionCenter;
278  }
279 
280  float GetLensDistortionAnaSq() const {
281  return _lensDistortionAnaSq;
282  }
283 
285  return _lensDistortionAsym;
286  }
287 
288  float GetLensDistortionScale() const {
289  return _lensDistortionScale;
290  }
291 
292  float GetLensDistortionIor() const {
293  return _lensDistortionIor;
294  }
295 
296  /// Returns the window policy of the camera. If no opinion is authored, we
297  /// default to "CameraUtilFit"
299  return _windowPolicy;
300  }
301 
302  // ---------------------------------------------------------------------- //
303  /// Convenience API for rasterizers
304  // ---------------------------------------------------------------------- //
305 
306  /// Computes the projection matrix for a camera from its physical
307  /// properties.
308  HD_API
310 
311 protected:
312  // frustum
321  std::vector<GfVec4d> _clipPlanes;
322 
323  // focus
324  float _fStop;
326  bool _focusOn;
327  float _dofAspect;
336 
337  // shutter
338  double _shutterOpen;
340 
341  // exposure
342  float _exposure;
348 
349  // lens distortion
358 
359  // Camera's opinion how it display in a window with
360  // a different aspect ratio
362 };
363 
365 
366 #endif // PXR_IMAGING_HD_CAMERA_H
DirtyBits
Definition: camera.h:102
float _splitDiopterOffset1
Definition: camera.h:330
float _exposureIso
Definition: camera.h:344
float GetSplitDiopterWidth2() const
Definition: camera.h:228
bool GetFocusOn() const
Definition: camera.h:196
TF_DECLARE_PUBLIC_TOKENS(HdCameraTokens, HD_API, HD_CAMERA_TOKENS)
Projection GetProjection() const
Returns whether camera is orthographic and perspective.
Definition: camera.h:147
float _dofAspect
Definition: camera.h:327
uint32_t HdDirtyBits
Definition: types.h:143
float GetSplitDiopterWidth1() const
Definition: camera.h:216
float _lensDistortionIor
Definition: camera.h:357
float GetLensDistortionK1() const
Definition: camera.h:268
float _splitDiopterOffset2
Definition: camera.h:333
GfMatrix4d const & GetTransform() const
Camera parameters accessor API.
Definition: camera.h:142
float GetLensDistortionAnaSq() const
Definition: camera.h:280
#define HD_API
Definition: api.h:23
float _fStop
Definition: camera.h:324
float GetHorizontalApertureOffset() const
Returns horizontal aperture offset in world units.
Definition: camera.h:162
float _exposureResponsivity
Definition: camera.h:346
float GetSplitDiopterFocusDistance1() const
Definition: camera.h:220
double GetShutterClose() const
Definition: camera.h:240
Projection
Definition: camera.h:115
GfVec2f _lensDistortionCenter
Definition: camera.h:353
GfRange1f _clippingRange
Definition: camera.h:320
float GetFocusDistance() const
Returns focus distance in world units.
Definition: camera.h:192
float _horizontalAperture
Definition: camera.h:315
float GetSplitDiopterOffset1() const
Definition: camera.h:212
double _shutterOpen
Definition: camera.h:338
GfVec2f _lensDistortionAsym
Definition: camera.h:355
CameraUtilConformWindowPolicy _windowPolicy
Definition: camera.h:361
const GfVec2f & GetLensDistortionCenter() const
Definition: camera.h:276
float _lensDistortionScale
Definition: camera.h:356
float GetDofAspect() const
Definition: camera.h:200
float GetSplitDiopterOffset2() const
Definition: camera.h:224
float _exposure
Definition: camera.h:342
float GetVerticalAperture() const
Returns vertical aperture in world units.
Definition: camera.h:157
float _exposureFStop
Definition: camera.h:345
Definition: token.h:70
GfRange1f const & GetClippingRange() const
Returns near and far plane in world units.
Definition: camera.h:177
std::vector< GfVec4d > _clipPlanes
Definition: camera.h:321
float GetExposure() const
Definition: camera.h:251
float GetFocalLength() const
Returns focal length in world units.
Definition: camera.h:172
TfToken _lensDistortionType
Definition: camera.h:350
Projection _projection
Definition: camera.h:314
GfMatrix4d _transform
Definition: camera.h:313
int _splitDiopterCount
Definition: camera.h:328
float GetHorizontalAperture() const
Returns horizontal aperture in world units.
Definition: camera.h:152
float _verticalApertureOffset
Definition: camera.h:318
float GetSplitDiopterAngle() const
Definition: camera.h:208
TfToken GetLensDistortionType() const
Definition: camera.h:264
float _lensDistortionAnaSq
Definition: camera.h:354
float _exposureTime
Definition: camera.h:343
Definition: path.h:273
float _lensDistortionK1
Definition: camera.h:351
CameraUtilConformWindowPolicy
Definition: conformWindow.h:27
Definition: sprim.h:34
HD_API HdCamera(SdfPath const &id)
double GetShutterOpen() const
Definition: camera.h:236
const GfVec2f & GetLensDistortionAsym() const
Definition: camera.h:284
PXR_NAMESPACE_CLOSE_SCOPE PXR_NAMESPACE_OPEN_SCOPE
Definition: path.h:1425
float _linearExposureScale
Definition: camera.h:347
HD_API HdDirtyBits GetInitialDirtyBitsMask() const override
float GetLensDistortionScale() const
Definition: camera.h:288
const CameraUtilConformWindowPolicy & GetWindowPolicy() const
Definition: camera.h:298
float _splitDiopterWidth2
Definition: camera.h:334
Definition: vec2f.h:45
HD_API GfMatrix4d ComputeProjectionMatrix() const
Convenience API for rasterizers.
float _verticalAperture
Definition: camera.h:316
#define PXR_NAMESPACE_CLOSE_SCOPE
Definition: pxr.h:74
float _splitDiopterFocusDistance2
Definition: camera.h:335
float _horizontalApertureOffset
Definition: camera.h:317
std::vector< GfVec4d > ClipPlanesVector
Definition: camera.h:94
std::vector< GfVec4d > const & GetClipPlanes() const
Returns any additional clipping planes defined in camera space.
Definition: camera.h:182
int GetSplitDiopterCount() const
Definition: camera.h:204
#define HD_CAMERA_TOKENS
Definition: camera.h:31
float GetVerticalApertureOffset() const
Returns vertical aperture offset in world units.
Definition: camera.h:167
float GetLinearExposureScale() const
Definition: camera.h:260
bool _focusOn
Definition: camera.h:326
HD_API ~HdCamera() override
float GetSplitDiopterFocusDistance2() const
Definition: camera.h:232
float _focalLength
Definition: camera.h:319
float _focusDistance
Definition: camera.h:325
float _lensDistortionK2
Definition: camera.h:352
double _shutterClose
Definition: camera.h:339
float _splitDiopterAngle
Definition: camera.h:329
float GetFStop() const
Returns fstop of camera.
Definition: camera.h:187
float _splitDiopterWidth1
Definition: camera.h:331
float GetLensDistortionIor() const
Definition: camera.h:292
float _splitDiopterFocusDistance1
Definition: camera.h:332
float GetLensDistortionK2() const
Definition: camera.h:272
HD_API void Sync(HdSceneDelegate *sceneDelegate, HdRenderParam *renderParam, HdDirtyBits *dirtyBits) override
Sprim API.