Blender V5.3
node_geo_camera_info.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2025 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
5#include "DNA_camera_types.h"
6
7#include "BKE_camera.h"
8#include "BKE_scene.hh"
9
11
12#include "COM_node_operation.hh"
13
14#include "node_geometry_util.hh"
15
17
19{
20 b.use_custom_socket_order();
21
22 b.add_output<decl::Matrix>("Projection Matrix"_ustr).description("Camera projection matrix");
23 b.add_output<decl::Float>("Focal Length"_ustr).description("Perspective camera focal length");
24 b.add_output<decl::Vector>("Sensor"_ustr).dimensions(2).description("Size of the camera sensor");
25 b.add_output<decl::Vector>("Shift"_ustr).dimensions(2).description("Camera shift");
26 b.add_output<decl::Float>("Clip Start"_ustr).description("Camera near clipping distance");
27 b.add_output<decl::Float>("Clip End"_ustr).description("Camera far clipping distance");
28 b.add_output<decl::Float>("Focus Distance"_ustr)
29 .description("Distance to the focus point for depth of field");
30 b.add_output<decl::Bool>("Is Orthographic"_ustr)
31 .description("Whether the camera is using orthographic projection");
32 b.add_output<decl::Float>("Orthographic Scale"_ustr)
33 .description("Orthographic camera scale (similar to zoom)");
34
35 b.add_input<decl::Object>("Camera"_ustr).optional_label();
36}
37
38static CameraParams get_camera_parameters(const Scene &scene, const Object &camera_object)
39{
40 CameraParams camera_params;
41 BKE_camera_params_init(&camera_params);
42 BKE_camera_params_from_object(&camera_params, &camera_object);
44 &camera_params, scene.r.xsch, scene.r.ysch, scene.r.xasp, scene.r.yasp);
46 return camera_params;
47}
48
49/* Computes the horizontal aspect ratio and effective sensor fit of the camera. */
51 const CameraParams &camera_parameters,
52 float &aspect_ratio,
53 eCamera_SensorFit &effective_sensor_fit)
54{
55 int2 resolution;
56 BKE_render_resolution(&scene.r, false, &resolution.x, &resolution.y);
57 const float2 aspect_corrected_resolution = float2(resolution) *
58 float2(scene.r.xasp, scene.r.yasp);
59
60 aspect_ratio = aspect_corrected_resolution.x / aspect_corrected_resolution.y;
61 effective_sensor_fit = eCamera_SensorFit(BKE_camera_sensor_fit(
62 camera_parameters.sensor_fit, aspect_corrected_resolution.x, aspect_corrected_resolution.y));
63}
64
65static float2 compute_sensor_size(const Scene &scene, const CameraParams &camera_parameters)
66{
67 float aspect_ratio;
68 eCamera_SensorFit effective_sensor_fit;
70 scene, camera_parameters, aspect_ratio, effective_sensor_fit);
71
72 const float sensor_size = BKE_camera_sensor_size(
73 camera_parameters.sensor_fit, camera_parameters.sensor_x, camera_parameters.sensor_y);
74
75 if (effective_sensor_fit == CAMERA_SENSOR_FIT_HOR) {
76 return float2(sensor_size, sensor_size / aspect_ratio);
77 }
78 return float2(sensor_size * aspect_ratio, sensor_size);
79}
80
81static float2 compute_lens_shift(const Scene &scene, const CameraParams &camera_parameters)
82{
83 float aspect_ratio;
84 eCamera_SensorFit effective_sensor_fit;
86 scene, camera_parameters, aspect_ratio, effective_sensor_fit);
87
88 if (effective_sensor_fit == CAMERA_SENSOR_FIT_HOR) {
89 return float2(camera_parameters.shiftx, camera_parameters.shifty * aspect_ratio);
90 }
91 return float2(camera_parameters.shiftx / aspect_ratio, camera_parameters.shifty);
92}
93
95{
96 const Scene *scene = DEG_get_evaluated_scene(params.depsgraph());
97 if (!scene) {
99 return;
100 }
101
102 const Object *camera_obj = params.extract_input<Object *>("Camera"_ustr);
103
104 if (!camera_obj) {
106 return;
107 }
108
109 if (camera_obj->type != OB_CAMERA) {
110 params.error_message_add(NodeWarningType::Error, TIP_("Object is not a camera"));
112 return;
113 }
114
115 Camera *camera = id_cast<Camera *>(camera_obj->data);
116 if (!camera) {
118 return;
119 }
120
121 const CameraParams camera_params = get_camera_parameters(*scene, *camera_obj);
122 const float4x4 projection_matrix(camera_params.winmat);
123 const float focus_distance = BKE_camera_object_dof_distance(camera_obj);
124 const float2 sensor_size = compute_sensor_size(*scene, camera_params);
125 const float2 lens_shift = compute_lens_shift(*scene, camera_params);
126
127 params.set_output("Projection Matrix"_ustr, projection_matrix);
128 params.set_output("Focal Length"_ustr, camera_params.lens);
129 params.set_output("Sensor"_ustr, float3{sensor_size, 0.0f});
130 params.set_output("Shift"_ustr, float3{lens_shift, 0.0f});
131 params.set_output("Clip Start"_ustr, camera_params.clip_start);
132 params.set_output("Clip End"_ustr, camera_params.clip_end);
133 params.set_output("Focus Distance"_ustr, focus_distance);
134 params.set_output("Is Orthographic"_ustr, camera_params.is_ortho);
135 params.set_output("Orthographic Scale"_ustr, camera_params.ortho_scale);
136}
137
138using namespace blender::compositor;
139
141 public:
143
144 void execute() override
145 {
146 const Object *camera_object = this->get_input("Camera").get_single_value<Object *>();
147 if (!camera_object) {
149 return;
150 }
151
152 if (camera_object->type != OB_CAMERA) {
153 this->add_warning(NodeWarningType::Error, TIP_("Object is not a camera"));
155 return;
156 }
157
158 const Camera *camera = id_cast<Camera *>(camera_object->data);
159 if (!camera) {
161 return;
162 }
163
164 const Scene &scene = this->context().get_scene();
165 const CameraParams camera_parameters = get_camera_parameters(scene, *camera_object);
166
167 Result &projection_matrix_result = this->get_result("Projection Matrix");
168 if (projection_matrix_result.should_compute()) {
169 projection_matrix_result.allocate_single_value();
170 projection_matrix_result.set_single_value(float4x4(camera_parameters.winmat));
171 }
172
173 Result &focal_length_result = this->get_result("Focal Length");
174 if (focal_length_result.should_compute()) {
175 focal_length_result.allocate_single_value();
176 focal_length_result.set_single_value(camera_parameters.lens);
177 }
178
179 const float2 sensor_size = compute_sensor_size(scene, camera_parameters);
180 Result &sensor_result = this->get_result("Sensor");
181 if (sensor_result.should_compute()) {
182 sensor_result.allocate_single_value();
183 sensor_result.set_single_value(sensor_size);
184 }
185
186 const float2 lens_shift = compute_lens_shift(scene, camera_parameters);
187 Result &shift_result = this->get_result("Shift");
188 if (shift_result.should_compute()) {
189 shift_result.allocate_single_value();
190 shift_result.set_single_value(lens_shift);
191 }
192
193 Result &clip_start_result = this->get_result("Clip Start");
194 if (clip_start_result.should_compute()) {
195 clip_start_result.allocate_single_value();
196 clip_start_result.set_single_value(camera_parameters.clip_start);
197 }
198
199 Result &clip_end_result = this->get_result("Clip End");
200 if (clip_end_result.should_compute()) {
201 clip_end_result.allocate_single_value();
202 clip_end_result.set_single_value(camera_parameters.clip_end);
203 }
204
205 Result &focus_distance_result = this->get_result("Focus Distance");
206 if (focus_distance_result.should_compute()) {
207 focus_distance_result.allocate_single_value();
208 const float focus_distance = BKE_camera_object_dof_distance(camera_object);
209 focus_distance_result.set_single_value(focus_distance);
210 }
211
212 Result &is_orthographic_result = this->get_result("Is Orthographic");
213 if (is_orthographic_result.should_compute()) {
214 is_orthographic_result.allocate_single_value();
215 is_orthographic_result.set_single_value(camera_parameters.is_ortho);
216 }
217
218 Result &orthographic_scale_result = this->get_result("Orthographic Scale");
219 if (orthographic_scale_result.should_compute()) {
220 orthographic_scale_result.allocate_single_value();
221 orthographic_scale_result.set_single_value(camera_parameters.ortho_scale);
222 }
223 }
224};
225
227{
228 return new CameraInfoOperation(context, node);
229}
230
231static void node_register()
232{
233 static bke::bNodeType ntype;
234
235 geo_cmp_node_type_base(&ntype, "GeometryNodeCameraInfo"_ustr);
236 ntype.ui_name = "Camera Info";
237 ntype.ui_description = "Retrieve information from a camera object";
238 ntype.nclass = NODE_CLASS_INPUT;
240 ntype.declare = node_declare;
243}
245
246} // namespace blender::nodes::node_geo_camera_info_cc
Camera data-block and utility functions.
#define NODE_CLASS_INPUT
Definition BKE_node.hh:478
#define TIP_(msgid)
#define NOD_REGISTER_NODE(REGISTER_FUNC)
virtual const Scene & get_scene() const =0
NodeOperation(Context &context, const bNode &node)
void add_warning(nodes::NodeWarningType type, std::string message)
Result & get_result(StringRef identifier)
Definition operation.cc:40
Context & context() const
Definition operation.cc:57
Result & get_input(StringRef identifier) const
Definition operation.cc:35
bool should_compute() const
Definition result.cc:1124
void set_single_value(const T &value)
const T & get_single_value() const
void error_message_add(const NodeWarningType type, StringRef message) const
T extract_input(const UString identifier)
const Depsgraph * depsgraph() const
void set_output(const UString identifier, T &&value)
void camera(KernelGlobals &kg, const ShadingData &sd, float3 &outview, float &outdepth, float &outdist)
void node_register_type(bNodeType &ntype)
Definition node.cc:2920
static NodeOperation * get_compositor_operation(Context &context, const bNode &node)
static void node_declare(NodeDeclarationBuilder &b)
static float2 compute_sensor_size(const Scene &scene, const CameraParams &camera_parameters)
static float2 compute_lens_shift(const Scene &scene, const CameraParams &camera_parameters)
static void compute_aspect_ratio_and_effective_sensor_fit(const Scene &scene, const CameraParams &camera_parameters, float &aspect_ratio, eCamera_SensorFit &effective_sensor_fit)
static CameraParams get_camera_parameters(const Scene &scene, const Object &camera_object)
static void node_geo_exec(GeoNodeExecParams params)
void BKE_camera_params_compute_viewplane(CameraParams *params, int winx, int winy, float aspx, float aspy)
@ CAMERA_SENSOR_FIT_HOR
void BKE_render_resolution(const RenderData *r, const bool use_crop, int *r_width, int *r_height)
Definition scene.cc:3168
void BKE_camera_params_compute_matrix(CameraParams *params)
float BKE_camera_object_dof_distance(const struct Object *ob)
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)
Scene * DEG_get_evaluated_scene(const Depsgraph *graph)
void geo_cmp_node_type_base(bke::bNodeType *ntype, UString idname, const std::optional< int16_t > legacy_type)
struct RenderData r
Defines a node type.
Definition BKE_node.hh:265
std::string ui_description
Definition BKE_node.hh:271
NodeGetCompositorOperationFunction get_compositor_operation
Definition BKE_node.hh:379
NodeGeometryExecFunction geometry_node_execute
Definition BKE_node.hh:385
NodeDeclareFunction declare
Definition BKE_node.hh:393