Blender V5.3
hydra/camera.cpp
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2022 NVIDIA Corporation
2 * SPDX-FileCopyrightText: 2022 Blender Foundation
3 *
4 * SPDX-License-Identifier: Apache-2.0 */
5
6#include "hydra/camera.h"
7#include "hydra/session.h"
8#include "hydra/util.h"
9#include "scene/camera.h"
10
11#include <pxr/base/gf/frustum.h>
12#include <pxr/imaging/hd/cameraSchema.h>
13#include <pxr/imaging/hd/sceneDelegate.h>
14#include <pxr/imaging/hd/xformSchema.h>
15#include <pxr/usd/usdGeom/tokens.h>
16
18
19extern Transform convert_transform(const GfMatrix4d &matrix);
20static Transform convert_camera_transform(const GfMatrix4d &matrix, const float metersPerUnit)
21{
22 Transform t = convert_transform(matrix);
23 // Flip Z axis
24 t.x.z *= -1.0f;
25 t.y.z *= -1.0f;
26 t.z.z *= -1.0f;
27 // Scale translation
28 t.x.w *= metersPerUnit;
29 t.y.w *= metersPerUnit;
30 t.z.w *= metersPerUnit;
31 return t;
32}
33
34HdCyclesCamera::HdCyclesCamera(const SdfPath &sprimId) : HdCamera(sprimId)
35{
36 // Synchronize default values
37 _horizontalAperture = _data.GetHorizontalAperture() * GfCamera::APERTURE_UNIT;
38 _verticalAperture = _data.GetVerticalAperture() * GfCamera::APERTURE_UNIT;
39 _horizontalApertureOffset = _data.GetHorizontalApertureOffset() * GfCamera::APERTURE_UNIT;
40 _verticalApertureOffset = _data.GetVerticalApertureOffset() * GfCamera::APERTURE_UNIT;
41 _focalLength = _data.GetFocalLength() * GfCamera::FOCAL_LENGTH_UNIT;
42 _clippingRange = _data.GetClippingRange();
43 _fStop = _data.GetFStop();
44 _focusDistance = _data.GetFocusDistance();
45}
46
48
50{
51 return DirtyBits::AllDirty;
52}
53
54void HdCyclesCamera::Sync(HdSceneDelegate *sceneDelegate,
55 HdRenderParam * /*renderParam*/,
56 HdDirtyBits *dirtyBits)
57{
58 if (*dirtyBits == DirtyBits::Clean) {
59 return;
60 }
61
62 const SdfPath &id = GetId();
63 const HdSceneIndexPrim prim = GetPrim(sceneDelegate, id);
64 const HdContainerDataSourceHandle &primDs = prim.dataSource;
65
66 HdCameraSchema cameraSchema = HdCameraSchema::GetFromParent(primDs);
67 HdContainerDataSourceHandle cameraDs = cameraSchema.GetContainer();
68
69 /* Read the shutter window from the camera prim so animated transforms can
70 * be sampled across it for motion blur. */
71 float shutterOpen = 0.0f;
72 float shutterClose = 0.0f;
73 if (auto ds = cameraSchema.GetShutterOpen()) {
74 shutterOpen = float(ds->GetTypedValue(0.0f));
75 }
76 if (auto ds = cameraSchema.GetShutterClose()) {
77 shutterClose = float(ds->GetTypedValue(0.0f));
78 }
79
80 if (*dirtyBits & DirtyBits::DirtyTransform) {
81 HdXformSchema xformSchema = HdXformSchema::GetFromParent(primDs);
82 if (auto matrixDs = xformSchema.GetMatrix()) {
83 SampleTyped<GfMatrix4d, 2>(matrixDs, shutterOpen, shutterClose, &_transformSamples);
84 bool transform_found = false;
85 for (size_t i = 0; i < _transformSamples.count; ++i) {
86 if (_transformSamples.times[i] == 0.0f) {
87 _transform = _transformSamples.values[i];
88 _data.SetTransform(_transform);
89 transform_found = true;
90 break;
91 }
92 }
93 if (!transform_found && _transformSamples.count) {
94 _transform = _transformSamples.values[0];
95 _data.SetTransform(_transform);
96 }
97 }
98 }
99
100 if (*dirtyBits & DirtyBits::DirtyWindowPolicy) {
101 /* The window policy is not part of the camera schema; it lives on the
102 * legacy data source. Leave the default of `CameraUtilFit`. */
103 }
104
105 if (*dirtyBits & DirtyBits::DirtyClipPlanes) {
106 if (auto ds = cameraSchema.GetClippingPlanes()) {
107 const VtArray<GfVec4d> clipPlanes = ds->GetTypedValue(0.0f);
108 _clipPlanes.assign(clipPlanes.cbegin(), clipPlanes.cend());
109 }
110 }
111
112 if (*dirtyBits & DirtyBits::DirtyParams) {
113 if (auto ds = cameraSchema.GetProjection()) {
114 const TfToken projection = ds->GetTypedValue(0.0f);
115 _projection = (projection == HdCameraSchemaTokens->orthographic) ? Orthographic :
116 Perspective;
117 _data.SetProjection(_projection != Orthographic ? GfCamera::Perspective :
118 GfCamera::Orthographic);
119 }
120
121 if (auto ds = cameraSchema.GetHorizontalAperture()) {
122 const float horizontalAperture = ds->GetTypedValue(0.0f);
123 _horizontalAperture = horizontalAperture;
124 _data.SetHorizontalAperture(horizontalAperture / GfCamera::APERTURE_UNIT);
125 }
126
127 if (auto ds = cameraSchema.GetVerticalAperture()) {
128 const float verticalAperture = ds->GetTypedValue(0.0f);
129 _verticalAperture = verticalAperture;
130 _data.SetVerticalAperture(verticalAperture / GfCamera::APERTURE_UNIT);
131 }
132
133 if (auto ds = cameraSchema.GetHorizontalApertureOffset()) {
134 const float horizontalApertureOffset = ds->GetTypedValue(0.0f);
135 _horizontalApertureOffset = horizontalApertureOffset;
136 _data.SetHorizontalApertureOffset(horizontalApertureOffset / GfCamera::APERTURE_UNIT);
137 }
138
139 if (auto ds = cameraSchema.GetVerticalApertureOffset()) {
140 const float verticalApertureOffset = ds->GetTypedValue(0.0f);
141 _verticalApertureOffset = verticalApertureOffset;
142 _data.SetVerticalApertureOffset(verticalApertureOffset / GfCamera::APERTURE_UNIT);
143 }
144
145 if (auto ds = cameraSchema.GetFocalLength()) {
146 const float focalLength = ds->GetTypedValue(0.0f);
147 _focalLength = focalLength;
148 _data.SetFocalLength(focalLength / GfCamera::FOCAL_LENGTH_UNIT);
149 }
150
151 if (auto ds = cameraSchema.GetClippingRange()) {
152 const GfVec2f range = ds->GetTypedValue(0.0f);
153 const GfRange1f clippingRange(range[0], range[1]);
154 _clippingRange = clippingRange;
155 _data.SetClippingRange(clippingRange);
156 }
157
158 if (auto ds = cameraSchema.GetFStop()) {
159 const float fStop = ds->GetTypedValue(0.0f);
160 _fStop = fStop;
161 _data.SetFStop(fStop);
162 }
163
164 if (auto ds = cameraSchema.GetFocusDistance()) {
165 const float focusDistance = ds->GetTypedValue(0.0f);
166 _focusDistance = focusDistance;
167 _data.SetFocusDistance(focusDistance);
168 }
169 }
170
171 *dirtyBits = DirtyBits::Clean;
172}
173
174void HdCyclesCamera::Finalize(HdRenderParam *renderParam)
175{
176 HdCamera::Finalize(renderParam);
177}
178
179void HdCyclesCamera::ApplyCameraSettings(HdRenderParam *renderParam, Camera *cam) const
180{
181 ApplyCameraSettings(renderParam, _data, _windowPolicy, cam);
182
183 const float metersPerUnit = static_cast<HdCyclesSession *>(renderParam)->GetStageMetersPerUnit();
184
185 array<Transform> motion(_transformSamples.count);
186 for (size_t i = 0; i < _transformSamples.count; ++i) {
187 motion[i] = convert_camera_transform(_transformSamples.values[i], metersPerUnit);
188 }
189 cam->set_motion(motion);
190}
191
192void HdCyclesCamera::ApplyCameraSettings(HdRenderParam *renderParam,
193 const GfCamera &dataUnconformedWindow,
194 CameraUtilConformWindowPolicy windowPolicy,
195 Camera *cam)
196{
197 const float width = cam->get_full_width();
198 const float height = cam->get_full_height();
199
200 auto data = dataUnconformedWindow;
201 CameraUtilConformWindow(&data, windowPolicy, width / height);
202
203 if (data.GetProjection() == GfCamera::Orthographic) {
204 cam->set_camera_type(CAMERA_ORTHOGRAPHIC);
205 }
206 else {
207 cam->set_camera_type(CAMERA_PERSPECTIVE);
208 }
209
210 const float metersPerUnit = static_cast<HdCyclesSession *>(renderParam)->GetStageMetersPerUnit();
211
212 auto viewplane = data.GetFrustum().GetWindow();
213 auto focalLength = 1.0f;
214 if (data.GetProjection() == GfCamera::Perspective) {
215 viewplane *= 2.0 / viewplane.GetSize()[1]; // Normalize viewplane
216 focalLength = data.GetFocalLength() * GfCamera::FOCAL_LENGTH_UNIT * metersPerUnit;
217
218 cam->set_fov(GfDegreesToRadians(data.GetFieldOfView(GfCamera::FOVVertical)));
219 }
220
221 cam->set_sensorwidth(data.GetHorizontalAperture() * GfCamera::APERTURE_UNIT * metersPerUnit);
222 cam->set_sensorheight(data.GetVerticalAperture() * GfCamera::APERTURE_UNIT * metersPerUnit);
223
224 cam->set_nearclip(data.GetClippingRange().GetMin() * metersPerUnit);
225 cam->set_farclip(data.GetClippingRange().GetMax() * metersPerUnit);
226
227 cam->set_viewplane_left(viewplane.GetMin()[0]);
228 cam->set_viewplane_right(viewplane.GetMax()[0]);
229 cam->set_viewplane_bottom(viewplane.GetMin()[1]);
230 cam->set_viewplane_top(viewplane.GetMax()[1]);
231
232 if (data.GetFStop() != 0.0f) {
233 cam->set_focaldistance(data.GetFocusDistance() * metersPerUnit);
234 cam->set_aperturesize(focalLength / (2.0f * data.GetFStop()));
235 }
236
237 cam->set_matrix(convert_camera_transform(data.GetTransform(), metersPerUnit));
238}
239
240void HdCyclesCamera::ApplyCameraSettings(HdRenderParam *renderParam,
241 const GfMatrix4d &worldToViewMatrix,
242 const GfMatrix4d &projectionMatrix,
243 const std::vector<GfVec4d> & /*clipPlanes*/,
244 Camera *cam)
245{
246 GfCamera data;
247 data.SetFromViewAndProjectionMatrix(worldToViewMatrix, projectionMatrix);
248
249 ApplyCameraSettings(renderParam, data, CameraUtilFit, cam);
250}
251
PXR_NS::HdDirtyBits GetInitialDirtyBitsMask() const override
void Sync(PXR_NS::HdSceneDelegate *sceneDelegate, PXR_NS::HdRenderParam *renderParam, PXR_NS::HdDirtyBits *dirtyBits) override
HdCyclesCamera(const PXR_NS::SdfPath &sprimId)
void ApplyCameraSettings(PXR_NS::HdRenderParam *renderParam, CCL_NS::Camera *cam) const
void Finalize(PXR_NS::HdRenderParam *renderParam) override
~HdCyclesCamera() override
void SampleTyped(const typename PXR_NS::HdTypedSampledDataSource< T >::Handle &ds, float shutterOpen, float shutterClose, PXR_NS::HdTimeSampleArray< T, Capacity > *out)
static Transform convert_camera_transform(const GfMatrix4d &matrix, const float metersPerUnit)
HDCYCLES_NAMESPACE_OPEN_SCOPE Transform convert_transform(const GfMatrix4d &matrix)
#define HDCYCLES_NAMESPACE_CLOSE_SCOPE
HDCYCLES_NAMESPACE_OPEN_SCOPE HdSceneIndexPrim GetPrim(HdSceneDelegate *delegate, const SdfPath &id)
@ CAMERA_PERSPECTIVE
@ CAMERA_ORTHOGRAPHIC
BMesh const char void * data
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
float4 y
Definition transform.h:53
float4 x
Definition transform.h:53
float4 z
Definition transform.h:53
float z
Definition sky_math.h:225
float w
Definition sky_math.h:225