Blender V5.3
render/hydra/camera.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2011-2022 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
5#include "camera.hh"
6
7#include "BKE_camera.h"
8
9#include "DNA_camera_types.h"
10#include "DNA_object_types.h"
11#include "DNA_screen_types.h"
12#include "DNA_view3d_types.h"
13
15
17
18static pxr::GfMatrix4d gf_matrix_from_transform(const float m[4][4])
19{
20 pxr::GfMatrix4d ret;
21 for (int i = 0; i < 4; i++) {
22 for (int j = 0; j < 4; j++) {
23 ret[i][j] = m[i][j];
24 }
25 }
26 return ret;
27}
28
29static void gf_camera_fill_dof_data(const Object *camera_obj, pxr::GfCamera *gf_camera)
30{
31 if (camera_obj == nullptr || camera_obj->type != OB_CAMERA) {
32 return;
33 }
34
35 const Camera *camera = id_cast<Camera *>(camera_obj->data);
36 if (!(camera->dof.flag & CAM_DOF_ENABLED)) {
37 return;
38 }
39
40 /* World units. Handles DoF object and value. Object takes precedence. */
41 const float focus_distance = BKE_camera_object_dof_distance(camera_obj);
42 gf_camera->SetFocusDistance(focus_distance);
43
44 /*
45 * F-stop is unit-less, however it's a ratio between focal length and aperture diameter.
46 * The aperture must be in the same unit for correctness.
47 * Focal length in GfCamera is defined in tenths of a world unit.
48 *
49 * Following the logic of USD camera data writer:
50 * tenth_unit_to_meters = 1 / 10
51 * tenth_unit_to_millimeters = 1000 * tenth_unit_to_meters = 100
52 * Scene's units scale is not used for camera's focal length.
53 */
54 gf_camera->SetFStop(camera->dof.aperture_fstop * 100.0);
55}
56
57static pxr::GfCamera gf_camera(const CameraParams &params,
58 const pxr::GfVec2i &res,
59 const pxr::GfVec4f &border)
60{
61 pxr::GfCamera camera;
62
63 camera.SetProjection(params.is_ortho ? pxr::GfCamera::Projection::Orthographic :
64 pxr::GfCamera::Projection::Perspective);
65 camera.SetClippingRange(pxr::GfRange1f(params.clip_start, params.clip_end));
66 camera.SetFocalLength(params.lens);
67
68 pxr::GfVec2f b_pos(border[0], border[1]), b_size(border[2], border[3]);
69 float sensor_size = BKE_camera_sensor_size(params.sensor_fit, params.sensor_x, params.sensor_y);
70
71 const float frame_aspect = params.use_aspect_override ? params.aspect_override :
72 float(res[1]) / float(res[0]);
73 const bool horizontal_fit = BKE_camera_sensor_fit(params.sensor_fit, 1.0f, frame_aspect) ==
75
76 const float2 frame_size = BKE_camera_frame_size(float(res[0]), float(res[1]), frame_aspect);
77 const float frame_fit = horizontal_fit ? float(res[0]) / frame_size.x :
78 float(res[1]) / frame_size.y;
79
80 pxr::GfVec2f sensor_scale = (horizontal_fit) ? pxr::GfVec2f(1.0f, float(res[1]) / res[0]) :
81 pxr::GfVec2f(float(res[0]) / res[1], 1.0f);
82
83 pxr::GfVec2f aperture = pxr::GfVec2f((params.is_ortho) ? params.ortho_scale : sensor_size);
84 aperture = pxr::GfCompMult(aperture, sensor_scale);
85 aperture = pxr::GfCompMult(aperture, b_size);
86 aperture *= params.zoom * frame_fit;
87 if (params.is_ortho) {
88 /* Use tenths of a world unit according to USD docs
89 * https://graphics.pixar.com/usd/docs/api/class_gf_camera.html */
90 aperture *= 10.0f;
91 }
92 camera.SetHorizontalAperture(aperture[0]);
93 camera.SetVerticalAperture(aperture[1]);
94
95 pxr::GfVec2f lens_shift = pxr::GfVec2f(params.shiftx, params.shifty) / frame_fit;
96 lens_shift = pxr::GfCompDiv(lens_shift, sensor_scale);
97 lens_shift += pxr::GfVec2f(params.offsetx, params.offsety);
98
99 /* Apply camera roll and flip in pixel units. */
100 float2 shift(lens_shift[0] * res[0], lens_shift[1] * res[1]);
101 shift = BKE_camera_viewplane_offset_transform(params.roll, params.is_flipped_x, shift);
102 lens_shift = pxr::GfVec2f(shift.x / res[0], shift.y / res[1]);
103
104 lens_shift += b_pos + b_size * 0.5f - pxr::GfVec2f(0.5f);
105 lens_shift = pxr::GfCompDiv(lens_shift, b_size);
106 camera.SetHorizontalApertureOffset(lens_shift[0] * aperture[0]);
107 camera.SetVerticalApertureOffset(lens_shift[1] * aperture[1]);
108
109 return camera;
110}
111
112pxr::GfCamera gf_camera(const Depsgraph *depsgraph,
113 const View3D *v3d,
114 const ARegion *region,
115 const pxr::GfVec4f &border)
116{
117 const RegionView3D *region_data = static_cast<const RegionView3D *>(region->regiondata);
118
119 CameraParams params;
120 BKE_camera_params_init(&params);
121 BKE_camera_params_from_view3d(&params, depsgraph, v3d, region_data);
122
123 pxr::GfCamera camera = gf_camera(params, pxr::GfVec2i(region->winx, region->winy), border);
124 camera.SetTransform(gf_matrix_from_transform(region_data->viewmat).GetInverse());
125
126 /* Ensure viewport is in active camera view mode. */
127 if (region_data->persp == RV3D_CAMOB && v3d->camera) {
129 }
130
131 return camera;
132}
133
134pxr::GfCamera gf_camera(const Object *camera_obj,
135 const pxr::GfVec2i &res,
136 const pxr::GfVec4f &border)
137{
138 CameraParams params;
139 BKE_camera_params_init(&params);
140 BKE_camera_params_from_object(&params, camera_obj);
141
142 pxr::GfCamera camera = gf_camera(params, res, border);
143 camera.SetTransform(gf_matrix_from_transform(camera_obj->object_to_world().ptr()));
144
145 gf_camera_fill_dof_data(camera_obj, &camera);
146
147 return camera;
148}
149
150} // namespace blender::render::hydra
Camera data-block and utility functions.
Object is a sort of wrapper for general info.
void camera(KernelGlobals &kg, const ShadingData &sd, float3 &outview, float &outdepth, float &outdist)
static void gf_camera_fill_dof_data(const Object *camera_obj, pxr::GfCamera *gf_camera)
static pxr::GfMatrix4d gf_matrix_from_transform(const float m[4][4])
static pxr::GfCamera gf_camera(const CameraParams &params, const pxr::GfVec2i &res, const pxr::GfVec4f &border)
float2 BKE_camera_viewplane_offset_transform(float roll, bool is_flipped_x, float2 offset)
@ CAMERA_SENSOR_FIT_HOR
float2 BKE_camera_frame_size(float winx, float winy, float frame_aspect)
float BKE_camera_object_dof_distance(const struct Object *ob)
VecBase< float, 2 > float2
void BKE_camera_params_from_view3d(CameraParams *params, const struct Depsgraph *depsgraph, const struct View3D *v3d, const struct RegionView3D *rv3d)
T * DEG_get_evaluated(const Depsgraph *depsgraph, T *id)
void BKE_camera_params_from_object(CameraParams *params, const struct Object *cam_ob)
int BKE_camera_sensor_fit(int sensor_fit, float sizex, float sizey)
float BKE_camera_sensor_size(int sensor_fit, float sensor_x, float sensor_y)
void BKE_camera_params_init(CameraParams *params)
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
eRegionView3D_Persp persp
struct Object * camera