Blender V5.3
blender/camera.cpp
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2011-2022 Blender Foundation
2 *
3 * SPDX-License-Identifier: Apache-2.0 */
4
5#include "scene/camera.h"
6#include "scene/bake.h"
7#include "scene/osl.h"
8#include "scene/scene.h"
9
10#include "blender/sync.h"
11#include "blender/util.h"
12
13#include "util/log.h"
14
15#include "BKE_action.hh"
16#include "BKE_camera.h"
17#include "BKE_scene.hh"
19#include "DNA_camera_types.h"
20#include "DNA_light_types.h"
21#include "RE_engine.h"
22
24
25/* Blender Camera Intermediate: we first convert both the offline and 3d view
26 * render camera to this, and from there convert to our native camera format. */
27
29 public:
30 explicit BlenderCamera(const blender::RenderData &b_render)
31 {
32 full_width = render_width = render_resolution_x(b_render);
33 full_height = render_height = render_resolution_y(b_render);
34 };
35
40
41 float nearclip = 1e-5f;
42 float farclip = 1e5f;
43
45 float ortho_scale = 1.0f;
46
47 float lens = 50.0f;
48 float shuttertime = 1.0f;
51
54
55 float aperturesize = 0.0f;
57 float aperturerotation = 0.0f;
58 float focaldistance = 10.0f;
59
62 float zoom = 1.0f;
63
65 float roll = 0.0f;
67 bool is_flipped_x = false;
68
70
71 bool use_aspect_override = false;
72 float aspect_override = 0.0f;
73
74 float aperture_ratio = 1.0f;
75
78 float fisheye_lens = 10.5f;
84 float interocular_distance = 0.065f;
85 float convergence_distance = 30.0f * 0.065f;
86 bool use_pole_merge = false;
87 float pole_merge_angle_from = (60.0f * M_PI_F / 180.0f);
88 float pole_merge_angle_to = (75.0f * M_PI_F / 180.0f);
89
95
101
103 float sensor_width = 36.0f;
104 float sensor_height = 24.0f;
105
106 int full_width = 0;
107 int full_height = 0;
108
111
115 float pano_aspectratio = 0.0f;
116
118
120
122};
123
125 blender::Object &b_ob,
126 blender::Camera &b_camera,
127 BlenderCamera *bcam)
128{
129 blender::Object *b_dof_object = b_camera.dof.focus_object;
130
131 if (!b_dof_object) {
132 return b_camera.dof.focus_distance;
133 }
134
135 Transform dofmat = get_transform(b_dof_object->object_to_world());
136
137 const string focus_subtarget = b_camera.dof.focus_subtarget;
138 if (b_dof_object->pose && !focus_subtarget.empty()) {
139 if (blender::bPoseChannel *pchan = BKE_pose_channel_find_name(b_dof_object->pose,
140 focus_subtarget.c_str()))
141 {
142 dofmat = dofmat * get_transform(blender::float4x4(pchan->pose_mat));
143 }
144 }
145
146 /* for dof object, return distance along camera Z direction */
147 blender::float4x4 b_ob_matrix;
148 RE_engine_get_camera_model_matrix(
149 &b_engine, &b_ob, bcam->use_spherical_stereo, b_ob_matrix.base_ptr());
150 const Transform obmat = transform_clear_scale(get_transform(b_ob_matrix));
151 const float3 view_dir = normalize(transform_get_column(&obmat, 2));
152 const float3 dof_dir = transform_get_column(&obmat, 3) - transform_get_column(&dofmat, 3);
153 return fabsf(dot(view_dir, dof_dir));
154}
155
177
178/* Cycles equivalent of view3d_stereo3d_active(). */
180 const blender::View3D *b_v3d,
181 const blender::RegionView3D *b_rv3d)
182{
183 if ((b_render.scemode & blender::R_MULTIVIEW) == 0) {
184 return false;
185 }
186
187 if (!b_v3d || !b_rv3d) {
188 return false;
189 }
190
191 if ((b_v3d->camera == nullptr) || (b_v3d->camera->type != blender::OB_CAMERA) ||
192 b_rv3d->persp != blender::RV3D_CAMOB)
193 {
194 return false;
195 }
196
197 switch (b_v3d->stereo3d_camera) {
199 return false;
200
202 /* Cycles does not have access to window to check WM_stereo3d_enabled(), so assume it is
203 * enabled. */
204 if (((b_render.views_format & blender::SCE_VIEWS_FORMAT_MULTIVIEW) != 0) &&
205 !BKE_scene_multiview_is_stereo3d(&b_render))
206 {
207 return false;
208 }
209 return true;
210
213 return true;
214 }
215
216 return false;
217}
218
220 blender::RenderEngine &b_engine,
221 const blender::RenderData &b_render,
222 blender::View3D *b_v3d,
223 blender::RegionView3D *b_rv3d,
224 blender::Object &b_ob,
225 blender::Main &b_data,
226 bool skip_panorama = false)
227{
228 bcam->motion_steps = object_motion_steps(b_ob, b_ob);
229
230 /* A blender local camera can be an Empty even, which has no object data. */
231 blender::ID *b_ob_data = static_cast<blender::ID *>(b_ob.data);
232
233 if (b_ob_data && b_ob_data->id_type() == blender::ID_CA) {
234 blender::Camera &b_camera = blender::id_cast<blender::Camera &>(*b_ob_data);
235
236 bcam->nearclip = b_camera.clip_start;
237 bcam->farclip = b_camera.clip_end;
238
239 switch (b_camera.type) {
242 break;
244 bcam->type = skip_panorama ? CAMERA_PERSPECTIVE : CAMERA_CUSTOM;
245 break;
247 bcam->type = skip_panorama ? CAMERA_PERSPECTIVE : CAMERA_PANORAMA;
248 break;
250 default:
251 bcam->type = CAMERA_PERSPECTIVE;
252 break;
253 }
254
255 bcam->panorama_type = blender_panorama_type_to_cycles(b_camera.panorama_type);
256 bcam->fisheye_fov = b_camera.fisheye_fov;
257 bcam->fisheye_lens = b_camera.fisheye_lens;
258 bcam->latitude_min = b_camera.latitude_min;
259 bcam->latitude_max = b_camera.latitude_max;
260 bcam->longitude_min = b_camera.longitude_min;
261 bcam->longitude_max = b_camera.longitude_max;
262
263 bcam->fisheye_polynomial_k0 = b_camera.fisheye_polynomial_k0;
264 bcam->fisheye_polynomial_k1 = b_camera.fisheye_polynomial_k1;
265 bcam->fisheye_polynomial_k2 = b_camera.fisheye_polynomial_k2;
266 bcam->fisheye_polynomial_k3 = b_camera.fisheye_polynomial_k3;
267 bcam->fisheye_polynomial_k4 = b_camera.fisheye_polynomial_k4;
268
269 bcam->central_cylindrical_range_u_min = b_camera.central_cylindrical_range_u_min;
270 bcam->central_cylindrical_range_u_max = b_camera.central_cylindrical_range_u_max;
271 bcam->central_cylindrical_range_v_min = b_camera.central_cylindrical_range_v_min;
272 bcam->central_cylindrical_range_v_max = b_camera.central_cylindrical_range_v_max;
273 bcam->central_cylindrical_radius = b_camera.central_cylindrical_radius;
274
275 bcam->interocular_distance = b_camera.stereo.interocular_distance;
276 if (b_camera.stereo.convergence_mode == blender::CAM_S3D_PARALLEL) {
278 }
279 else {
280 bcam->convergence_distance = b_camera.stereo.convergence_distance;
281 }
282 bcam->use_spherical_stereo = RE_engine_get_spherical_stereo(&b_engine, &b_ob);
283
284 bcam->use_pole_merge = b_camera.stereo.flag & blender::CAM_S3D_POLE_MERGE;
285 bcam->pole_merge_angle_from = b_camera.stereo.pole_merge_angle_from;
286 bcam->pole_merge_angle_to = b_camera.stereo.pole_merge_angle_to;
287
288 bcam->ortho_scale = b_camera.ortho_scale;
289
290 bcam->lens = b_camera.lens;
291
292 if (b_camera.dof.flag & blender::CAM_DOF_ENABLED) {
293 /* allow f/stop number to change aperture_size but still
294 * give manual control over aperture radius */
295 float fstop = b_camera.dof.aperture_fstop;
296 fstop = max(fstop, 1e-5f);
297
298 if (bcam->type == CAMERA_ORTHOGRAPHIC || bcam->type == CAMERA_CUSTOM) {
299 bcam->aperturesize = 1.0f / (2.0f * fstop);
300 }
301 else {
302 bcam->aperturesize = (bcam->lens * 1e-3f) / (2.0f * fstop);
303 }
304
305 bcam->apertureblades = b_camera.dof.aperture_blades;
306 bcam->aperturerotation = b_camera.dof.aperture_rotation;
307 bcam->focaldistance = blender_camera_focal_distance(b_engine, b_ob, b_camera, bcam);
308 bcam->aperture_ratio = b_camera.dof.aperture_ratio;
309 }
310 else {
311 /* DOF is turned of for the camera. */
312 bcam->aperturesize = 0.0f;
313 bcam->apertureblades = 0;
314 bcam->aperturerotation = 0.0f;
315 bcam->focaldistance = 0.0f;
316 bcam->aperture_ratio = 1.0f;
317 }
318
319 if (is_viewport_stereo3d_active(b_render, b_v3d, b_rv3d)) {
320 /* Cycles equivalent of view3d_stereo3d_setup(). */
321 using eStereoViews = blender::eStereoViews;
322 const eStereoViews multiview_eye = b_v3d->stereo3d_camera != blender::STEREO_3D_ID ?
323 eStereoViews(b_v3d->stereo3d_camera) :
324 eStereoViews(b_v3d->multiview_eye);
325
326 const bool is_left = multiview_eye == blender::STEREO_LEFT_ID;
327 const char *viewname = is_left ? STEREO_LEFT_NAME : STEREO_RIGHT_NAME;
328 bcam->shift.x = BKE_camera_multiview_shift_x(&b_render, &b_ob, viewname);
329 }
330 else {
331 bcam->shift.x = RE_engine_get_camera_shift_x(&b_engine, &b_ob, bcam->use_spherical_stereo);
332 }
333 bcam->shift.y = b_camera.shifty;
334
335 bcam->sensor_width = b_camera.sensor_x;
336 bcam->sensor_height = b_camera.sensor_y;
337
338 if (b_camera.sensor_fit == blender::CAMERA_SENSOR_FIT_AUTO) {
340 }
341 else if (b_camera.sensor_fit == blender::CAMERA_SENSOR_FIT_HOR) {
343 }
344 else {
346 }
347
348 if (bcam->type == CAMERA_CUSTOM) {
349 blender::PointerRNA camera_rna_ptr = RNA_id_pointer_create(&b_camera.id);
350 bcam->custom_props = RNA_pointer_get(&camera_rna_ptr, "cycles_custom");
351 bcam->custom_bytecode_hash = b_camera.custom_bytecode_hash;
352 if (!bcam->custom_bytecode_hash.empty()) {
353 bcam->custom_bytecode = b_camera.custom_bytecode;
354 }
355 else {
356 bcam->custom_filepath = blender_absolute_path(
357 b_data, &b_camera.id, b_camera.custom_filepath);
358 }
359 }
360 }
361 else if (b_ob_data && b_ob_data->id_type() == blender::ID_LA) {
362 /* Can also look through spot light. */
363 const blender::Light &b_light = reinterpret_cast<const blender::Light &>(*b_ob_data);
364 const float lens = 16.0f / tanf(b_light.spotsize * 0.5f);
365 if (lens > 0.0f) {
366 bcam->lens = lens;
367 }
368 }
369 else {
370 /* Like Blender, fall back to 35mm for other object types. */
371 bcam->lens = 35.0f;
372 }
373}
374
376 const CameraType type,
377 const PanoramaType panorama_type)
378{
379 Transform result;
380
381 if (type == CAMERA_PANORAMA) {
382 if (panorama_type == PANORAMA_MIRRORBALL) {
383 /* Mirror ball camera is looking into the negative Y direction
384 * which matches texture mirror ball mapping.
385 */
386 result = tfm * make_transform(
387 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
388 }
389 else {
390 /* Make it so environment camera needs to be pointed in the direction
391 * of the positive x-axis to match an environment texture, this way
392 * it is looking at the center of the texture
393 */
394 result = tfm * make_transform(
395 0.0f, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f);
396 }
397 }
398 else {
399 /* Note the blender camera points along the negative z-axis. */
400 result = tfm * transform_scale(1.0f, 1.0f, -1.0f);
401 }
402
403 return transform_clear_scale(result);
404}
405
407 const int width,
408 const int height)
409{
410 if (bcam->sensor_fit == BlenderCamera::AUTO) {
411 const float xratio = (float)width * bcam->pixelaspect.x;
412 const float yratio = (float)height * bcam->pixelaspect.y;
413 return bcam->use_aspect_override ? (bcam->aspect_override <= 1.0f) : (xratio > yratio);
414 }
415
417}
418
419static float blender_camera_frame_fit(const BlenderCamera *bcam, const int width, const int height)
420{
421 const float frame_aspect = bcam->use_aspect_override ? bcam->aspect_override :
422 float(height) / float(width);
423 const blender::float2 frame_size = blender::BKE_camera_frame_size(width, height, frame_aspect);
424
425 return blender_camera_horizontal_fit(bcam, width, height) ? width / frame_size.x :
426 height / frame_size.y;
427}
428
430 const int width,
431 const int height,
432 BoundBox2D &viewplane,
433 float &aspectratio,
434 float &sensor_size)
435{
436 /* dimensions */
437 const float xratio = (float)width * bcam->pixelaspect.x;
438 const float yratio = (float)height * bcam->pixelaspect.y;
439
440 /* compute x/y aspect and ratio */
441 float2 aspect;
442 bool horizontal_fit = blender_camera_horizontal_fit(bcam, width, height);
443
444 /* sensor fitting */
446 sensor_size = bcam->sensor_width;
447 }
448 else {
449 sensor_size = bcam->sensor_height;
450 }
451
452 if (horizontal_fit) {
453 aspectratio = xratio / yratio;
454 aspect = make_float2(aspectratio, 1.0f);
455 }
456 else {
457 aspectratio = yratio / xratio;
458 aspect = make_float2(1.0f, aspectratio);
459 }
460
461 /* modify aspect for orthographic scale */
462 if (bcam->type == CAMERA_ORTHOGRAPHIC) {
463 aspect *= bcam->ortho_scale / (aspectratio * 2.0f);
464 aspectratio = bcam->ortho_scale / 2.0f;
465 }
466
467 if (bcam->type == CAMERA_PANORAMA || bcam->type == CAMERA_CUSTOM) {
468 /* Account for camera shift. */
469 float2 dv = bcam->shift;
470 if (bcam->pano_aspectratio != 0.0f) {
471 dv *= aspectratio / bcam->pano_aspectratio;
472 }
473
474 /* Set viewplane for panoramic or custom camera. */
475 viewplane = bcam->pano_viewplane.offset(dv);
476 }
477 else {
478 /* Account for camera shift and 3d camera view offset. */
479 const float2 shift = 2.0f * (aspectratio * bcam->shift + bcam->offset * aspect * 2.0f);
481 bcam->roll, bcam->is_flipped_x, blender::float2(shift.x, shift.y));
482
483 /* Set viewplane for perspective or orthographic camera. */
484 viewplane = (BoundBox2D(aspect) * bcam->zoom).offset(make_float2(dv.x, dv.y));
485 }
486}
487
489 public:
490 BlenderCameraParamQuery(blender::PointerRNA custom_props) : custom_props(custom_props) {}
491 ~BlenderCameraParamQuery() override = default;
492
493 bool get_float(ustring name, vector<float> &data) override
494 {
495 blender::PropertyRNA *prop = get_prop(name);
496 if (!prop) {
497 return false;
498 }
499 if (RNA_property_array_check(prop)) {
500 data.resize(RNA_property_array_length(&custom_props, prop));
501 RNA_property_float_get_array(&custom_props, prop, data.data());
502 }
503 else {
504 data.resize(1);
505 data[0] = RNA_property_float_get(&custom_props, prop);
506 }
507 return true;
508 }
509
510 bool get_int(ustring name, vector<int> &data) override
511 {
512 blender::PropertyRNA *prop = get_prop(name);
513 if (!prop) {
514 return false;
515 }
516 int array_len = 0;
517 if (RNA_property_array_check(prop)) {
518 array_len = RNA_property_array_length(&custom_props, prop);
519 }
520
521 /* OSL represents booleans as integers, but we represent them as boolean-type
522 * properties in RNA, so convert here. */
523 if (RNA_property_type(prop) == blender::PROP_BOOLEAN) {
524 if (array_len > 0) {
525 /* Can't use std::vector<bool> here since it's a weird special case. */
526 array<bool> bool_data(array_len);
527 RNA_property_boolean_get_array(&custom_props, prop, bool_data.data());
528 std::copy(bool_data.begin(), bool_data.end(), std::back_inserter(data));
529 }
530 else {
531 data.push_back(RNA_property_boolean_get(&custom_props, prop));
532 }
533 }
534 else if (RNA_property_type(prop) == blender::PROP_ENUM) {
535 const char *identifier = "";
536 const int value = RNA_property_enum_get(&custom_props, prop);
537 if (RNA_property_enum_identifier(nullptr, &custom_props, prop, value, &identifier)) {
538 data.push_back(atoi(identifier));
539 }
540 else {
541 data.push_back(value);
542 }
543 }
544 else {
545 if (array_len > 0) {
546 data.resize(array_len);
547 RNA_property_int_get_array(&custom_props, prop, data.data());
548 }
549 else {
550 data.push_back(RNA_property_int_get(&custom_props, prop));
551 }
552 }
553 return true;
554 }
555
556 bool get_string(ustring name, string &data) override
557 {
558 blender::PropertyRNA *prop = get_prop(name);
559 if (!prop) {
560 return false;
561 }
562 data = RNA_property_string_get(&custom_props, prop);
563 return true;
564 }
565
566 private:
567 blender::PointerRNA custom_props;
568
569 blender::PropertyRNA *get_prop(ustring param)
570 {
571 string name = string_printf("[\"%s\"]", param.c_str());
572 return RNA_struct_find_property(&custom_props, name.c_str());
573 }
574};
575
577 Scene *scene,
578 BlenderCamera *bcam,
579 const int width,
580 const int height,
581 const char *viewname,
582 blender::PointerRNA *cscene)
583{
584 float aspectratio;
585 float sensor_size;
586
587 /* viewplane */
588 BoundBox2D viewplane;
589 blender_camera_viewplane(bcam, width, height, viewplane, aspectratio, sensor_size);
590
591 cam->set_viewplane_left(viewplane.left);
592 cam->set_viewplane_right(viewplane.right);
593 cam->set_viewplane_top(viewplane.top);
594 cam->set_viewplane_bottom(viewplane.bottom);
595
596 cam->set_full_width(width);
597 cam->set_full_height(height);
598
599 /* Set panorama or custom sensor. */
600 if ((bcam->type == CAMERA_PANORAMA &&
603 bcam->type == CAMERA_CUSTOM)
604 {
605 const float fit_xratio = (float)bcam->render_width * bcam->pixelaspect.x;
606 const float fit_yratio = (float)bcam->render_height * bcam->pixelaspect.y;
607 bool horizontal_fit;
608 float sensor_size;
609
610 if (bcam->sensor_fit == BlenderCamera::AUTO) {
611 horizontal_fit = (fit_xratio > fit_yratio);
612 sensor_size = bcam->sensor_width;
613 }
614 else if (bcam->sensor_fit == BlenderCamera::HORIZONTAL) {
615 horizontal_fit = true;
616 sensor_size = bcam->sensor_width;
617 }
618 else { /* vertical */
619 horizontal_fit = false;
620 sensor_size = bcam->sensor_height;
621 }
622
623 if (horizontal_fit) {
624 cam->set_sensorwidth(sensor_size);
625 cam->set_sensorheight(sensor_size * fit_yratio / fit_xratio);
626 }
627 else {
628 cam->set_sensorwidth(sensor_size * fit_xratio / fit_yratio);
629 cam->set_sensorheight(sensor_size);
630 }
631 }
632
633 /* Sync custom camera parameters. */
634 if (scene != nullptr) {
635 if (bcam->type == CAMERA_CUSTOM) {
637 cam->set_osl_camera(
638 scene, params, bcam->custom_filepath, bcam->custom_bytecode_hash, bcam->custom_bytecode);
639 }
640 else {
641 cam->clear_osl_camera(scene);
642 }
643 }
644
645 /* clipping distances */
646 cam->set_nearclip(bcam->nearclip);
647 cam->set_farclip(bcam->farclip);
648
649 /* type */
650 cam->set_camera_type(bcam->type);
651
652 /* panorama */
653 cam->set_panorama_type(bcam->panorama_type);
654 cam->set_fisheye_fov(bcam->fisheye_fov);
655 cam->set_fisheye_lens(bcam->fisheye_lens);
656 cam->set_latitude_min(bcam->latitude_min);
657 cam->set_latitude_max(bcam->latitude_max);
658
659 cam->set_fisheye_polynomial_k0(bcam->fisheye_polynomial_k0);
660 cam->set_fisheye_polynomial_k1(bcam->fisheye_polynomial_k1);
661 cam->set_fisheye_polynomial_k2(bcam->fisheye_polynomial_k2);
662 cam->set_fisheye_polynomial_k3(bcam->fisheye_polynomial_k3);
663 cam->set_fisheye_polynomial_k4(bcam->fisheye_polynomial_k4);
664
665 cam->set_longitude_min(bcam->longitude_min);
666 cam->set_longitude_max(bcam->longitude_max);
667
668 cam->set_central_cylindrical_range_u_min(bcam->central_cylindrical_range_u_min);
669 cam->set_central_cylindrical_range_u_max(bcam->central_cylindrical_range_u_max);
670 cam->set_central_cylindrical_range_v_min(bcam->central_cylindrical_range_v_min /
672 cam->set_central_cylindrical_range_v_max(bcam->central_cylindrical_range_v_max /
674
675 /* panorama stereo */
676 cam->set_interocular_distance(bcam->interocular_distance);
677 cam->set_convergence_distance(bcam->convergence_distance);
678 cam->set_use_spherical_stereo(bcam->use_spherical_stereo);
679
680 if (cam->get_use_spherical_stereo()) {
681 if (strcmp(viewname, "left") == 0) {
682 cam->set_stereo_eye(Camera::STEREO_LEFT);
683 }
684 else if (strcmp(viewname, "right") == 0) {
685 cam->set_stereo_eye(Camera::STEREO_RIGHT);
686 }
687 else {
688 cam->set_stereo_eye(Camera::STEREO_NONE);
689 }
690 }
691
692 cam->set_use_pole_merge(bcam->use_pole_merge);
693 cam->set_pole_merge_angle_from(bcam->pole_merge_angle_from);
694 cam->set_pole_merge_angle_to(bcam->pole_merge_angle_to);
695
696 /* anamorphic lens bokeh */
697 cam->set_aperture_ratio(bcam->aperture_ratio);
698
699 /* perspective */
700 cam->set_fov(2.0f * atanf((0.5f * sensor_size) / bcam->lens / aspectratio));
701 cam->set_focaldistance(bcam->focaldistance);
702 cam->set_aperturesize(bcam->aperturesize);
703 cam->set_blades(bcam->apertureblades);
704 cam->set_bladesrotation(bcam->aperturerotation);
705
706 /* transform */
707 cam->set_matrix(blender_camera_matrix(bcam->matrix, bcam->type, bcam->panorama_type));
708
709 array<Transform> motion = cam->get_motion();
710 motion.resize(bcam->motion_steps, cam->get_matrix());
711 if (bcam->motion_steps != 0) {
712 motion[bcam->motion_steps / 2] = cam->get_matrix();
713 }
714 cam->set_motion(motion);
715 cam->set_use_perspective_motion(false);
716
717 cam->set_shuttertime(bcam->shuttertime);
718 cam->set_fov_pre(cam->get_fov());
719 cam->set_fov_post(cam->get_fov());
720 cam->set_motion_position(bcam->motion_position);
721
722 cam->set_rolling_shutter_type(bcam->rolling_shutter_type);
723 cam->set_rolling_shutter_duration(bcam->rolling_shutter_duration);
724
725 cam->set_shutter_curve(bcam->shutter_curve);
726
727 /* border */
728 cam->set_border_left(bcam->border.left);
729 cam->set_border_right(bcam->border.right);
730 cam->set_border_top(bcam->border.top);
731 cam->set_border_bottom(bcam->border.bottom);
732
733 cam->set_viewport_camera_border_left(bcam->viewport_camera_border.left);
734 cam->set_viewport_camera_border_right(bcam->viewport_camera_border.right);
735 cam->set_viewport_camera_border_top(bcam->viewport_camera_border.top);
736 cam->set_viewport_camera_border_bottom(bcam->viewport_camera_border.bottom);
737
738 bcam->offscreen_dicing_scale = RNA_float_get(cscene, "offscreen_dicing_scale");
739 cam->set_offscreen_dicing_scale(bcam->offscreen_dicing_scale);
740}
741
742/* Sync Render Camera */
743
745{
746 switch (type) {
752 return MOTION_POSITION_END;
753 }
754 /* Could happen if loading a newer file that has an unsupported type. */
756}
757
759 const int width,
760 const int height,
761 const char *viewname)
762{
763 BlenderCamera bcam(b_render);
764
765 /* pixel aspect */
766 bcam.pixelaspect.x = b_render.xasp;
767 bcam.pixelaspect.y = b_render.yasp;
768 bcam.shuttertime = b_render.motion_blur_shutter;
770 b_render.motion_blur_position);
771
772 const blender::CurveMapping &b_shutter_curve = b_render.mblur_shutter_curve;
773 curvemapping_to_array(b_shutter_curve, bcam.shutter_curve, RAMP_TABLE_SIZE);
774
775 blender::PointerRNA scene_rna_ptr = RNA_id_pointer_create(&b_scene->id);
776 blender::PointerRNA cscene = RNA_pointer_get(&scene_rna_ptr, "cycles");
778 cscene,
779 "rolling_shutter_type",
782 bcam.rolling_shutter_duration = RNA_float_get(&cscene, "rolling_shutter_duration");
783
784 /* border */
785 if (b_render.mode & blender::R_BORDER) {
786 bcam.border.left = b_render.border.xmin;
787 bcam.border.right = b_render.border.xmax;
788 bcam.border.bottom = b_render.border.ymin;
789 bcam.border.top = b_render.border.ymax;
790 }
791
792 /* camera object */
793 blender::Object *b_ob = get_camera_object(nullptr, nullptr);
794
795 if (b_ob) {
796 blender::float4x4 b_ob_matrix;
797 blender_camera_from_object(&bcam, *b_engine, b_render, nullptr, nullptr, *b_ob, *b_data);
798 RE_engine_get_camera_model_matrix(
799 b_engine, b_ob, bcam.use_spherical_stereo, b_ob_matrix.base_ptr());
800 bcam.matrix = get_transform(b_ob_matrix);
801 scene->bake_manager->set_use_camera(b_render.bake.view_from ==
803 }
804 else {
805 scene->bake_manager->set_use_camera(false);
806 }
807
808 /* sync */
809 Camera *cam = scene->camera;
810 blender_camera_sync(cam, scene, &bcam, width, height, viewname, &cscene);
811
812 /* dicing camera */
813 b_ob = RNA_pointer_get(&cscene, "dicing_camera").data_as<blender::Object>();
814 if (b_ob) {
815 blender::float4x4 b_ob_matrix;
816 blender_camera_from_object(&bcam, *b_engine, b_render, nullptr, nullptr, *b_ob, *b_data);
817 RE_engine_get_camera_model_matrix(
818 b_engine, b_ob, bcam.use_spherical_stereo, b_ob_matrix.base_ptr());
819 bcam.matrix = get_transform(b_ob_matrix);
820
821 blender_camera_sync(scene->dicing_camera, nullptr, &bcam, width, height, viewname, &cscene);
822 }
823 else {
824 *scene->dicing_camera = *cam;
825 }
826}
827
828/* See #rna_RenderEngine_camera_override_get. */
830{
831 /* TODO(sergey): Shouldn't engine point to an evaluated datablocks already? */
832 if (engine->re) {
833 blender::Object *cam = RE_GetCamera(engine->re);
834 blender::Object *cam_eval = DEG_get_evaluated(engine->depsgraph, cam);
835 return cam_eval;
836 }
837 return engine->camera_override;
838}
839
840blender::Object *BlenderSync::get_camera_object(blender::View3D *b_v3d,
841 blender::RegionView3D *b_rv3d)
842{
843 /* TODO(sergey): Shouldn't engine point to an evaluated datablocks already? */
844 blender::Object *b_camera_override = camera_override_get(b_engine);
845 if (b_camera_override) {
846 return b_camera_override;
847 }
848
849 if (b_v3d && b_rv3d && b_rv3d->persp == blender::RV3D_CAMOB && !b_v3d->scenelock) {
850 return b_v3d->camera;
851 }
852
853 return b_scene->camera;
854}
855
856blender::Object *BlenderSync::get_dicing_camera_object(blender::View3D *b_v3d,
857 blender::RegionView3D *b_rv3d)
858{
859 blender::PointerRNA scene_rna_ptr = RNA_id_pointer_create(&b_scene->id);
860 blender::PointerRNA cscene = RNA_pointer_get(&scene_rna_ptr, "cycles");
861 blender::Object *b_ob = RNA_pointer_get(&cscene, "dicing_camera").data_as<blender::Object>();
862 if (b_ob) {
863 return b_ob;
864 }
865
866 return get_camera_object(b_v3d, b_rv3d);
867}
868
869void BlenderSync::sync_camera_motion(const blender::RenderData &b_render,
870 blender::Object *b_ob,
871 const int width,
872 const int height,
873 const float motion_time)
874{
875 if (!b_ob) {
876 return;
877 }
878
879 Camera *cam = scene->camera;
880 blender::float4x4 b_ob_matrix;
882 b_engine, b_ob, cam->get_use_spherical_stereo(), b_ob_matrix.base_ptr());
883 Transform tfm = get_transform(b_ob_matrix);
884 tfm = blender_camera_matrix(tfm, cam->get_camera_type(), cam->get_panorama_type());
885
886 if (motion_time == 0.0f) {
887 /* When motion blur is not centered in frame, cam->matrix gets reset. */
888 cam->set_matrix(tfm);
889 }
890
891 /* Set transform in motion array. */
892 const int motion_step = cam->motion_step(motion_time);
893 if (motion_step >= 0) {
894 array<Transform> motion = cam->get_motion();
895 motion[motion_step] = tfm;
896 cam->set_motion(motion);
897 }
898
899 if (cam->get_camera_type() == CAMERA_PERSPECTIVE) {
900 BlenderCamera bcam(b_render);
901
902 /* TODO(sergey): Consider making it a part of BlenderCamera(). */
903 bcam.pixelaspect.x = b_render.xasp;
904 bcam.pixelaspect.y = b_render.yasp;
905
906 blender_camera_from_object(&bcam, *b_engine, b_render, nullptr, nullptr, *b_ob, *b_data);
907
908 BoundBox2D viewplane;
909 float aspectratio;
910 float sensor_size;
911 blender_camera_viewplane(&bcam, width, height, viewplane, aspectratio, sensor_size);
912 /* TODO(sergey): De-duplicate calculation with camera sync. */
913 const float fov = 2.0f * atanf((0.5f * sensor_size) / bcam.lens / aspectratio);
914 if (fov != cam->get_fov()) {
915 LOG_DEBUG << "Camera " << BKE_id_name(b_ob->id) << " FOV change detected.";
916 if (motion_time == 0.0f) {
917 cam->set_fov(fov);
918 }
919 else if (motion_time == -1.0f) {
920 cam->set_fov_pre(fov);
921 cam->set_use_perspective_motion(true);
922 }
923 else if (motion_time == 1.0f) {
924 cam->set_fov_post(fov);
925 cam->set_use_perspective_motion(true);
926 }
927 }
928 }
929}
930
931/* Sync 3D View Camera */
932
934 const blender::RenderData &b_render,
935 blender::Scene &b_scene,
936 blender::Main &b_data,
937 blender::Object &b_ob,
938 blender::View3D *&b_v3d,
939 blender::RegionView3D *b_rv3d,
940 const int width,
941 const int height,
942 BoundBox2D &view_box,
943 BoundBox2D &cam_box,
944 float &view_aspect);
945
947 blender::RenderEngine &b_engine,
948 const blender::RenderData &b_render,
949 blender::Scene &b_scene,
950 blender::Main &b_data,
951 blender::View3D *&b_v3d,
952 blender::RegionView3D *b_rv3d,
953 const int width,
954 const int height,
955 bool skip_panorama = false)
956{
957 /* 3d view parameters */
958 bcam->nearclip = b_v3d->clip_start;
959 bcam->farclip = b_v3d->clip_end;
960 bcam->lens = b_v3d->lens;
961 bcam->shuttertime = b_scene.r.motion_blur_shutter;
962
963 blender::CurveMapping &b_shutter_curve = b_scene.r.mblur_shutter_curve;
964 curvemapping_to_array(b_shutter_curve, bcam->shutter_curve, RAMP_TABLE_SIZE);
965
966 if (b_rv3d->persp == blender::RV3D_CAMOB) {
967 /* camera view */
968 blender::Object *b_ob = (b_v3d->scenelock) ? b_scene.camera : b_v3d->camera;
969
970 if (b_ob) {
972 bcam, b_engine, b_render, b_v3d, b_rv3d, *b_ob, b_data, skip_panorama);
973
974 /* Override the aspect, so change in viewport framing is minimized when camera parameters
975 * change. */
976 bcam->use_aspect_override = true;
977 bcam->aspect_override = (float(b_render.ysch) * b_render.yasp) /
978 (float(b_render.xsch) * b_render.xasp);
979
980 if (!skip_panorama && (bcam->type == CAMERA_PANORAMA || bcam->type == CAMERA_CUSTOM)) {
981 /* in panorama or custom camera view, we map viewplane to camera border */
982 BoundBox2D view_box;
983 BoundBox2D cam_box;
984 float view_aspect;
985
987 b_scene.r,
988 b_scene,
989 b_data,
990 *b_ob,
991 b_v3d,
992 b_rv3d,
993 width,
994 height,
995 view_box,
996 cam_box,
997 view_aspect);
998
999 bcam->pano_viewplane = view_box.make_relative_to(cam_box);
1000 bcam->pano_aspectratio = view_aspect;
1001 }
1002 else {
1003 /* magic zoom formula */
1004 bcam->zoom = b_rv3d->camzoom;
1005 bcam->zoom = (1.41421f + bcam->zoom / 50.0f);
1006 bcam->zoom *= bcam->zoom;
1007 bcam->zoom = 2.0f / bcam->zoom;
1008
1009 /* offset */
1010 bcam->offset = make_float2(b_rv3d->camdx, b_rv3d->camdy);
1011 bcam->roll = b_rv3d->camroll;
1012 bcam->is_flipped_x = (b_rv3d->rflag & blender::RV3D_FLIP_X) != 0;
1013
1014 /* Zoom to fit the camera frame. */
1015 const float frame_fit = blender_camera_frame_fit(bcam, width, height);
1016 bcam->zoom *= frame_fit;
1017 bcam->offset *= frame_fit;
1018 }
1019 }
1020 }
1021 else if (b_rv3d->persp == blender::RV3D_ORTHO) {
1022 /* orthographic view */
1023 bcam->farclip *= 0.5f;
1024 bcam->nearclip = -bcam->farclip;
1025
1026 float sensor_size;
1027 if (bcam->sensor_fit == BlenderCamera::VERTICAL) {
1028 sensor_size = bcam->sensor_height;
1029 }
1030 else {
1031 sensor_size = bcam->sensor_width;
1032 }
1033
1034 bcam->type = CAMERA_ORTHOGRAPHIC;
1035 bcam->ortho_scale = b_rv3d->dist * sensor_size / b_v3d->lens;
1036 }
1037
1038 bcam->zoom *= 2.0f;
1039
1040 /* 3d view transform */
1041 bcam->matrix = transform_inverse(get_transform(blender::float4x4(b_rv3d->viewmat)));
1042
1043 /* dimensions */
1044 bcam->full_width = width;
1045 bcam->full_height = height;
1046}
1047
1049 const blender::RenderData &b_render,
1050 blender::Scene &b_scene,
1051 blender::Main &b_data,
1052 blender::Object &b_ob,
1053 blender::View3D *&b_v3d,
1054 blender::RegionView3D *b_rv3d,
1055 const int width,
1056 const int height,
1057 BoundBox2D &view_box,
1058 BoundBox2D &cam_box,
1059 float &view_aspect)
1060{
1061 BoundBox2D cam;
1062 BoundBox2D view;
1063 float cam_aspect;
1064 float sensor_size;
1065
1066 /* Get viewport viewplane. */
1067 BlenderCamera view_bcam(b_render);
1069 &view_bcam, b_engine, b_render, b_scene, b_data, b_v3d, b_rv3d, width, height, true);
1070
1071 blender_camera_viewplane(&view_bcam, width, height, view, view_aspect, sensor_size);
1072
1073 /* Get camera viewplane. */
1074 BlenderCamera cam_bcam(b_render);
1075 blender_camera_from_object(&cam_bcam, b_engine, b_render, b_v3d, b_rv3d, b_ob, b_data, true);
1076
1077 /* Camera border is affect by aspect, viewport is not. */
1078 cam_bcam.pixelaspect.x = b_render.xasp;
1079 cam_bcam.pixelaspect.y = b_render.yasp;
1080
1082 &cam_bcam, cam_bcam.full_width, cam_bcam.full_height, cam, cam_aspect, sensor_size);
1083
1084 /* Return */
1085 view_box = view * (1.0f / view_aspect);
1086 cam_box = cam * (1.0f / cam_aspect);
1087}
1088
1089/* Convert a border in viewport pixels to normalized viewport coordinates. */
1091 const int width,
1092 const int height)
1093{
1094 BoundBox2D result;
1095
1096 result.left = border.xmin / (float)width;
1097 result.right = border.xmax / (float)width;
1098 result.bottom = border.ymin / (float)height;
1099 result.top = border.ymax / (float)height;
1100
1101 return result;
1102}
1103
1105 const blender::Depsgraph *b_depsgraph,
1106 blender::Scene &b_scene,
1107 blender::View3D *b_v3d,
1108 blender::RegionView3D *b_rv3d,
1109 const int width,
1110 const int height)
1111{
1112 /* Determine camera border inside the viewport. */
1113 if (b_rv3d->persp == blender::RV3D_CAMOB && b_v3d->camera) {
1114 const blender::rctf camera_border = BKE_camera_view_border(
1115 &b_scene, b_depsgraph, b_v3d, b_rv3d, width, height, false, false, true);
1116 bcam->viewport_camera_border = blender_camera_border_normalized(camera_border, width, height);
1117 }
1118
1119 /* Determine border to render. */
1120 blender::rctf border;
1121 if (BKE_camera_view_render_border(
1122 &b_scene, b_depsgraph, b_v3d, b_rv3d, width, height, &border, nullptr))
1123 {
1124 bcam->border = blender_camera_border_normalized(border, width, height);
1125 bcam->border = bcam->border.clamp();
1126 }
1127}
1128
1129void BlenderSync::sync_view(const blender::Depsgraph *b_depsgraph,
1130 blender::View3D *b_v3d,
1131 blender::RegionView3D *b_rv3d,
1132 const int width,
1133 const int height)
1134{
1135 const blender::RenderData &b_render_settings = b_scene->r;
1136 BlenderCamera bcam(b_render_settings);
1138 &bcam, *b_engine, b_render_settings, *b_scene, *b_data, b_v3d, b_rv3d, width, height);
1139 blender_camera_border(&bcam, b_depsgraph, *b_scene, b_v3d, b_rv3d, width, height);
1140 bcam.motion_steps = scene->need_motion() == Scene::MOTION_PASS_INTERACTIVE ? 2 : 0;
1141 blender::PointerRNA scene_rna_ptr = RNA_id_pointer_create(&b_scene->id);
1142 blender::PointerRNA cscene = RNA_pointer_get(&scene_rna_ptr, "cycles");
1143 blender_camera_sync(scene->camera, scene, &bcam, width, height, "", &cscene);
1144
1145 /* dicing camera */
1146 blender::Object *b_ob = RNA_pointer_get(&cscene, "dicing_camera").data_as<blender::Object>();
1147 if (b_ob) {
1148 blender::float4x4 b_ob_matrix;
1150 &bcam, *b_engine, b_render_settings, nullptr, nullptr, *b_ob, *b_data);
1151 RE_engine_get_camera_model_matrix(
1152 b_engine, b_ob, bcam.use_spherical_stereo, b_ob_matrix.base_ptr());
1153 bcam.matrix = get_transform(b_ob_matrix);
1154
1155 blender_camera_sync(scene->dicing_camera, nullptr, &bcam, width, height, "", &cscene);
1156 }
1157 else {
1158 *scene->dicing_camera = *scene->camera;
1159 }
1160}
1161
1163 blender::RegionView3D *b_rv3d,
1164 Camera *cam,
1165 const int width,
1166 const int height)
1167{
1168 BufferParams params;
1169 bool use_border = false;
1170
1171 params.full_width = width;
1172 params.full_height = height;
1173
1174 if (b_v3d && b_rv3d && b_rv3d->persp != blender::RV3D_CAMOB) {
1175 use_border = b_v3d->flag2 & blender::V3D_RENDER_BORDER;
1176 }
1177 else {
1178 /* the camera can always have a passepartout */
1179 use_border = true;
1180 }
1181
1182 if (use_border) {
1183 /* border render */
1184 /* the viewport may offset the border outside the view */
1185 const BoundBox2D border = cam->border.clamp();
1186 params.full_x = (int)(border.left * (float)width);
1187 params.full_y = (int)(border.bottom * (float)height);
1188 params.width = (int)(border.right * (float)width) - params.full_x;
1189 params.height = (int)(border.top * (float)height) - params.full_y;
1190
1191 /* survive in case border goes out of view or becomes too small */
1192 params.width = max(params.width, 1);
1193 params.height = max(params.height, 1);
1194 }
1195 else {
1196 params.width = width;
1197 params.height = height;
1198 }
1199
1200 params.window_width = params.width;
1201 params.window_height = params.height;
1202
1203 return params;
1204}
1205
Blender kernel action and pose functionality.
Camera data-block and utility functions.
#define STEREO_LEFT_NAME
#define STEREO_RIGHT_NAME
static blender::Object * camera_override_get(blender::RenderEngine *engine)
static void blender_camera_from_view(BlenderCamera *bcam, blender::RenderEngine &b_engine, const blender::RenderData &b_render, blender::Scene &b_scene, blender::Main &b_data, blender::View3D *&b_v3d, blender::RegionView3D *b_rv3d, const int width, const int height, bool skip_panorama=false)
static void blender_camera_sync(Camera *cam, Scene *scene, BlenderCamera *bcam, const int width, const int height, const char *viewname, blender::PointerRNA *cscene)
static void blender_camera_from_object(BlenderCamera *bcam, blender::RenderEngine &b_engine, const blender::RenderData &b_render, blender::View3D *b_v3d, blender::RegionView3D *b_rv3d, blender::Object &b_ob, blender::Main &b_data, bool skip_panorama=false)
static float blender_camera_frame_fit(const BlenderCamera *bcam, const int width, const int height)
static void blender_camera_border(BlenderCamera *bcam, const blender::Depsgraph *b_depsgraph, blender::Scene &b_scene, blender::View3D *b_v3d, blender::RegionView3D *b_rv3d, const int width, const int height)
static float blender_camera_focal_distance(blender::RenderEngine &b_engine, blender::Object &b_ob, blender::Camera &b_camera, BlenderCamera *bcam)
static bool is_viewport_stereo3d_active(const blender::RenderData &b_render, const blender::View3D *b_v3d, const blender::RegionView3D *b_rv3d)
static void blender_camera_viewplane(BlenderCamera *bcam, const int width, const int height, BoundBox2D &viewplane, float &aspectratio, float &sensor_size)
static BoundBox2D blender_camera_border_normalized(const blender::rctf &border, const int width, const int height)
static MotionPosition blender_motion_blur_position_type_to_cycles(const int type)
static void blender_camera_view_subset(blender::RenderEngine &b_engine, const blender::RenderData &b_render, blender::Scene &b_scene, blender::Main &b_data, blender::Object &b_ob, blender::View3D *&b_v3d, blender::RegionView3D *b_rv3d, const int width, const int height, BoundBox2D &view_box, BoundBox2D &cam_box, float &view_aspect)
static Transform blender_camera_matrix(const Transform &tfm, const CameraType type, const PanoramaType panorama_type)
static PanoramaType blender_panorama_type_to_cycles(const int type)
static bool blender_camera_horizontal_fit(const BlenderCamera *bcam, const int width, const int height)
btScalar max
~BlenderCameraParamQuery() override=default
BlenderCameraParamQuery(blender::PointerRNA custom_props)
bool get_string(ustring name, string &data) override
bool get_float(ustring name, vector< float > &data) override
bool get_int(ustring name, vector< int > &data) override
float central_cylindrical_radius
float rolling_shutter_duration
float central_cylindrical_range_u_min
MotionPosition motion_position
enum BlenderCamera::@245243132277217025050234337126046075336211064127 sensor_fit
string custom_bytecode_hash
float fisheye_polynomial_k2
float fisheye_polynomial_k1
array< float > shutter_curve
float fisheye_polynomial_k0
float central_cylindrical_range_v_min
blender::PointerRNA custom_props
float fisheye_polynomial_k4
BoundBox2D pano_viewplane
Camera::RollingShutterType rolling_shutter_type
float central_cylindrical_range_v_max
float pole_merge_angle_from
float fisheye_polynomial_k3
PanoramaType panorama_type
float central_cylindrical_range_u_max
BlenderCamera(const blender::RenderData &b_render)
BoundBox2D viewport_camera_border
static BufferParams get_buffer_params(blender::View3D *b_v3d, blender::RegionView3D *b_rv3d, Camera *cam, const int width, const int height)
void sync_view(const blender::Depsgraph *b_depsgraph, blender::View3D *b_v3d, blender::RegionView3D *b_rv3d, const int width, const int height)
void sync_camera(const blender::RenderData &b_render, const int width, const int height, const char *viewname)
BoundBox2D clamp(const float mn=0.0f, const float mx=1.0f)
Definition boundbox.h:268
BoundBox2D make_relative_to(const BoundBox2D &other) const
Definition boundbox.h:256
BoundBox2D offset(const float2 offset) const
Definition boundbox.h:280
float bottom
Definition boundbox.h:198
float top
Definition boundbox.h:198
float right
Definition boundbox.h:198
float left
Definition boundbox.h:198
BoundBox2D()=default
int full_width
Definition buffers.h:85
int full_height
Definition buffers.h:86
int window_height
Definition buffers.h:80
int window_width
Definition buffers.h:79
NODE_DECLARE int width
Definition buffers.h:70
RollingShutterType
@ ROLLING_SHUTTER_NUM_TYPES
@ ROLLING_SHUTTER_NONE
BoundBox2D border
int motion_step(const float time) const
void clear_osl_camera(Scene *scene)
void set_osl_camera(Scene *scene, OSLCameraParamQuery &params, const std::string &filepath, const std::string &bytecode_hash="", const std::string &bytecode="")
@ STEREO_LEFT
@ STEREO_NONE
@ STEREO_RIGHT
OSLCameraParamQuery()=default
Definition scene.h:133
@ MOTION_PASS_INTERACTIVE
Definition scene.h:207
T * resize(const size_t newsize)
#define M_PI_2_F
#define RAMP_TABLE_SIZE
#define CCL_NAMESPACE_END
#define FLT_MAX
VecBase< float, D > normalize(VecOp< float, D >) RET
float dot(VecOp< float, D >, VecOp< float, D >) RET
MotionPosition
@ MOTION_POSITION_END
@ MOTION_POSITION_START
@ MOTION_POSITION_CENTER
PanoramaType
@ PANORAMA_MIRRORBALL
@ PANORAMA_FISHEYE_EQUISOLID
@ PANORAMA_CENTRAL_CYLINDRICAL
@ PANORAMA_EQUIANGULAR_CUBEMAP_FACE
@ PANORAMA_FISHEYE_EQUIDISTANT
@ PANORAMA_FISHEYE_LENS_POLYNOMIAL
@ PANORAMA_EQUIRECTANGULAR
CameraType
@ CAMERA_PERSPECTIVE
@ CAMERA_PANORAMA
@ CAMERA_CUSTOM
@ CAMERA_ORTHOGRAPHIC
#define LOG_DEBUG
Definition log.h:107
ccl_device_inline float2 one_float2()
Definition math_float2.h:18
CCL_NAMESPACE_BEGIN ccl_device_inline float2 zero_float2()
Definition math_float2.h:13
PointerRNA RNA_id_pointer_create(ID *id)
float2 BKE_camera_viewplane_offset_transform(float roll, bool is_flipped_x, float2 offset)
@ CAMERA_SENSOR_FIT_AUTO
@ CAMERA_SENSOR_FIT_HOR
MatBase< float, 4, 4 > float4x4
const char * BKE_id_name(const ID &id)
@ R_BAKE_VIEW_FROM_ACTIVE_CAMERA
float2 BKE_camera_frame_size(float winx, float winy, float frame_aspect)
@ CAM_PANORAMA_CENTRAL_CYLINDRICAL
@ CAM_PANORAMA_EQUIRECTANGULAR
@ CAM_PANORAMA_MIRRORBALL
@ CAM_PANORAMA_FISHEYE_EQUISOLID
@ CAM_PANORAMA_EQUIANGULAR_CUBEMAP_FACE
@ CAM_PANORAMA_FISHEYE_LENS_POLYNOMIAL
@ CAM_PANORAMA_FISHEYE_EQUIDISTANT
VecBase< float, 2 > float2
@ PROP_BOOLEAN
Definition RNA_types.hh:210
PointerRNA RNA_pointer_get(PointerRNA *ptr, const char *name)
void RE_engine_get_camera_model_matrix(RenderEngine *engine, Object *camera, bool use_spherical_stereo, float r_modelmat[16])
@ SCE_VIEWS_FORMAT_MULTIVIEW
#define fabsf
#define atanf
#define make_float2
#define tanf
#define M_PI_F
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
CCL_NAMESPACE_BEGIN string string_printf(const char *format,...)
Definition string.cpp:25
eBakeViewFrom view_from
const T * base_ptr() const
struct bPose * pose
T * data_as() const
Definition RNA_types.hh:139
eRegionView3D_Flag rflag
eRegionView3D_Persp persp
struct CurveMapping mblur_shutter_curve
eSceneViews_Format views_format
struct Depsgraph * depsgraph
Definition RE_engine.h:165
struct Render * re
Definition RE_engine.h:148
struct Object * camera_override
Definition RE_engine.h:145
struct Object * camera
struct RenderData r
eView3D_Flag2 flag2
struct Object * camera
float x
float y
ccl_device_inline float3 transform_get_column(const Transform *t, const int column)
Definition transform.h:387
ccl_device_inline Transform transform_identity()
Definition transform.h:355
ccl_device_inline Transform transform_scale(const float3 s)
Definition transform.h:313
ccl_device_inline Transform transform_inverse(const Transform tfm)
Definition transform.h:563
ccl_device_inline Transform make_transform(const float a, const float b, const float c, const float d, const float e, const float f, const float g, const float h, const float i, const float j, const float k, const float l)
Definition transform.h:185
ccl_device_inline Transform transform_clear_scale(const Transform &tfm)
Definition transform.h:438