67 PassMain background_ps_ = {
"background_ps_"};
70 PassMain foreground_ps_ = {
"foreground_ps_"};
73 PassMain background_scene_ps_ = {
"background_scene_ps_"};
75 PassMain foreground_scene_ps_ = {
"foreground_scene_ps_"};
79 CameraInstanceBuf distances_buf = {selection_type_,
"camera_distances_buf"};
80 CameraInstanceBuf frame_buf = {selection_type_,
"camera_frame_buf"};
81 CameraInstanceBuf tria_buf = {selection_type_,
"camera_tria_buf"};
82 CameraInstanceBuf tria_wire_buf = {selection_type_,
"camera_tria_wire_buf"};
83 CameraInstanceBuf volume_buf = {selection_type_,
"camera_volume_buf"};
84 CameraInstanceBuf volume_wire_buf = {selection_type_,
"camera_volume_wire_buf"};
85 CameraInstanceBuf sphere_solid_buf = {selection_type_,
"camera_sphere_solid_buf"};
86 LinePrimitiveBuf stereo_connect_lines = {selection_type_,
"camera_dashed_lines_buf"};
87 LinePrimitiveBuf tracking_path = {selection_type_,
"camera_tracking_path_buf"};
88 Empties::CallBuffers empties{selection_type_};
91 bool images_enabled_ =
false;
92 bool extras_enabled_ =
false;
93 bool motion_tracking_enabled_ =
false;
106 images_enabled_ =
enabled_ && !res.is_selection() && !
state.is_depth_only_drawing;
107 enabled_ = extras_enabled_ || images_enabled_ || motion_tracking_enabled_;
109 offset_data_ =
state.offset_data_get();
111 if (extras_enabled_ || motion_tracking_enabled_) {
112 call_buffers_.distances_buf.clear();
113 call_buffers_.frame_buf.clear();
114 call_buffers_.tria_buf.clear();
115 call_buffers_.tria_wire_buf.clear();
116 call_buffers_.volume_buf.clear();
117 call_buffers_.volume_wire_buf.clear();
118 call_buffers_.sphere_solid_buf.clear();
119 call_buffers_.stereo_connect_lines.clear();
120 call_buffers_.tracking_path.clear();
124 if (images_enabled_) {
129 pass.
shader_set(res.shaders->image_plane_depth_bias.get());
132 pass.
push_constant(
"depth_bias_winmat", &depth_bias_winmat_);
133 res.select_bind(pass);
138 init_pass(background_ps_, draw_state);
141 init_pass(background_scene_ps_, draw_state);
144 init_pass(foreground_ps_, draw_state);
145 init_pass(foreground_scene_ps_, draw_state);
158 const select::ID select_id = res.select_id(ob_ref);
160 object_sync_extras(ob_ref, select_id,
state, res);
162 object_sync_motion_paths(ob_ref, res,
state);
164 object_sync_images(ob_ref, select_id, manager,
state, res);
169 if (!extras_enabled_ && !motion_tracking_enabled_) {
176 res.select_bind(ps_);
182 state.clipping_plane_count);
183 sub_pass.
shader_set(res.shaders->extra_shape.get());
184 call_buffers_.volume_buf.end_sync(sub_pass, res.shapes.camera_volume.get());
190 state.clipping_plane_count);
191 sub_pass.
shader_set(res.shaders->extra_shape.get());
192 call_buffers_.volume_wire_buf.end_sync(sub_pass, res.shapes.camera_volume_wire.get());
199 state.clipping_plane_count);
200 sub_pass.
shader_set(res.shaders->extra_shape.get());
201 call_buffers_.distances_buf.end_sync(sub_pass, res.shapes.camera_distances.get());
202 call_buffers_.frame_buf.end_sync(sub_pass, res.shapes.camera_frame.get());
203 call_buffers_.tria_buf.end_sync(sub_pass, res.shapes.camera_tria.get());
204 call_buffers_.tria_wire_buf.end_sync(sub_pass, res.shapes.camera_tria_wire.get());
205 call_buffers_.sphere_solid_buf.end_sync(sub_pass, res.shapes.sphere_low_detail.get());
212 state.clipping_plane_count);
213 sub_pass.
shader_set(res.shaders->extra_wire.get());
214 call_buffers_.stereo_connect_lines.end_sync(sub_pass);
215 call_buffers_.tracking_path.end_sync(sub_pass);
224 if (!images_enabled_) {
228 manager.generate_commands(background_scene_ps_, view);
229 manager.generate_commands(foreground_scene_ps_, view);
230 manager.generate_commands(background_ps_, view);
231 manager.generate_commands(foreground_ps_, view);
233 depth_bias_winmat_ = offset_data_.winmat_polygon_offset(view.winmat(), -1.0f);
238 if (!extras_enabled_ && !motion_tracking_enabled_) {
243 manager.submit(ps_, view);
248 if (!images_enabled_) {
259 if (!images_enabled_) {
269 if (!images_enabled_) {
278 void object_sync_extras(
const ObjectRef &ob_ref,
283 if (!extras_enabled_) {
288 float4x4 mat = ob->object_to_world();
300 const bool is_active = (ob == camera_object);
301 const bool is_camera_view = (is_active && (rv3d->
persp ==
RV3D_CAMOB));
305 const bool is_stereo3d_display_extra = is_active && is_multiview && (!is_camera_view) &&
307 const bool is_selection_camera_stereo = is_select && is_camera_view && is_multiview &&
312 if (is_selection_camera_stereo) {
335 for (
int i = 0; i < 4; i++) {
338 mul_v2_fl(vecs[i], 1.0f / std::abs(vecs[i].
z));
342 const float2 center = (vecs[0].xy() + vecs[2].xy()) * 0.5f;
343 const float2 corner = vecs[0].xy() - center.xy();
344 data.corner_x = corner.
x;
345 data.corner_y = corner.
y;
346 data.center_x = center.
x;
347 data.center_y = center.
y;
348 data.depth = vecs[0].z;
350 if (is_camera_view) {
351 if (!
state.is_image_render) {
358 data.center_x += camera_offaxis_shiftx_get(scene, ob,
data.corner_x, is_right);
362 data.matrix[i][j] = mat[i][j];
367 call_buffers_.frame_buf.append(
data, select_id);
372 if (is_stereo3d_display_extra) {
373 sync_stereoscopy_extra(
377 call_buffers_.frame_buf.append(
data, select_id);
381 if (!is_camera_view) {
383 float tria_size = 0.7f * drawsize /
fabsf(
data.depth);
384 float tria_margin = 0.1f * drawsize /
fabsf(
data.depth);
385 data.center_x = center.
x;
386 data.center_y = center.
y +
data.corner_y + tria_margin + tria_size;
387 data.corner_x =
data.corner_y = -tria_size;
388 (is_active ? call_buffers_.tria_buf : call_buffers_.tria_wire_buf).append(
data, select_id);
393 data.matrix.x_axis() *= cam.drawsize;
394 data.matrix.y_axis() *= cam.drawsize;
396 data.dist_color_id = (is_active) ? 3 : 2;
398 data.clip_start = cam.clip_start;
399 data.clip_end = cam.clip_end;
400 call_buffers_.distances_buf.append(
data, select_id);
406 data.dist_color_id = (is_active) ? 1 : 0;
408 data.mist_start = world->miststa;
409 data.mist_end = world->miststa + world->mistdist;
410 call_buffers_.distances_buf.append(
data, select_id);
415 void object_sync_motion_paths(
const ObjectRef &ob_ref, Resources &res,
const State &
state)
417 if (!motion_tracking_enabled_) {
421 Object *ob = ob_ref.object;
422 const View3D *v3d =
state.v3d;
426 if (clip ==
nullptr) {
430 const float4 &color = res.object_wire_color(ob_ref,
state);
432 const bool is_selection = res.is_selection();
433 const bool is_solid_bundle = (v3d->bundle_drawtype ==
OB_EMPTY_SPHERE) &&
436 MovieTracking *tracking = &clip->tracking;
440 float4 bundle_color_custom;
441 float *bundle_color_solid = res.theme.colors.bundle_solid;
442 float *bundle_color_unselected = res.theme.colors.wire;
443 uchar4 text_color_selected, text_color_unselected;
453 for (MovieTrackingObject *tracking_object :
459 tracking_object_mat = camera_mat;
467 tracking, tracking_object, framenr, object_mat.
ptr());
472 for (MovieTrackingTrack *track :
482 const float *bundle_color;
487 bundle_color_custom[3] = 1.0;
489 bundle_color = bundle_color_custom;
491 else if (is_solid_bundle) {
492 bundle_color = bundle_color_solid;
494 else if (is_selected) {
495 bundle_color = color;
498 bundle_color = bundle_color_unselected;
501 const select::ID track_select_id = res.select_id(ob_ref, track_index++ << 16);
502 if (is_solid_bundle) {
507 v3d->bundle_drawtype,
509 call_buffers_.empties);
512 call_buffers_.sphere_solid_buf.append(
513 ExtraInstanceData{bundle_mat,
float4(
float3(bundle_color), 1.0f), v3d->bundle_size},
520 v3d->bundle_drawtype,
522 call_buffers_.empties);
533 is_selected ? text_color_selected : text_color_unselected);
540 const MovieTrackingReconstruction *reconstruction = &tracking_object->reconstruction;
542 if (reconstruction->camnr) {
543 const MovieReconstructedCamera *
camera = reconstruction->cameras;
545 for (
int a = 0; a < reconstruction->camnr; a++,
camera++) {
559 void object_sync_images(
const ObjectRef &ob_ref,
560 select::ID select_id,
565 Object *ob = ob_ref.object;
569 const bool is_active = ob_ref.object == camera_object;
570 const bool is_camera_view = (is_active && (
state.rv3d->persp ==
RV3D_CAMOB));
571 const bool show_image = (cam.flag &
CAM_SHOW_BG_IMAGE) && !cam.bg_images.is_empty();
574 if (!images_enabled_ || !is_camera_view || !show_image || !show_frame) {
589 bool use_alpha_premult;
590 bool use_view_transform =
false;
594 gpu::Texture *tex = image_camera_background_texture_get(
595 bgpic,
state, res, aspect, use_alpha_premult, use_view_transform);
598 image_camera_background_matrix_get(&cam, bgpic,
state, aspect, mat);
614 const float4 color_premult_alpha{1.0f, 1.0f, 1.0f, std::min(bgpic->alpha, 0.999999f)};
617 (use_view_transform ? foreground_scene_ps_ : foreground_ps_) :
618 (use_view_transform ? background_scene_ps_ : background_ps_);
619 pass.bind_texture(
"img_tx", tex);
620 pass.push_constant(
"img_premultiplied", use_alpha_premult);
621 pass.push_constant(
"img_alpha_blend",
true);
622 pass.push_constant(
"is_camera_background",
true);
623 pass.push_constant(
"depth_set",
true);
624 pass.push_constant(
"ucolor", color_premult_alpha);
625 ResourceHandleRange res_handle = manager.resource_handle(mat);
626 pass.draw(res.shapes.quad_solid.get(), res_handle, select_id.get());
631 static void image_camera_background_matrix_get(
const Camera *cam,
632 const CameraBGImage *bgpic,
634 const float image_aspect,
642 float cam_corners[4][3];
644 float cam_width =
fabsf(cam_corners[0][0] - cam_corners[3][0]);
645 float cam_height =
fabsf(cam_corners[0][1] - cam_corners[1][1]);
646 float cam_aspect = cam_width / cam_height;
650 if (image_aspect > cam_aspect) {
651 scale[0][0] *= cam_height * image_aspect;
652 scale[1][1] *= cam_height;
655 scale[0][0] *= cam_width;
656 scale[1][1] *= cam_width / image_aspect;
661 if (image_aspect > cam_aspect) {
662 scale[0][0] *= cam_width;
663 scale[1][1] *= cam_width / image_aspect;
666 scale[0][0] *= cam_height * image_aspect;
667 scale[1][1] *= cam_height;
672 scale[0][0] *= cam_width;
673 scale[1][1] *= cam_height;
685 translate[3][1] /=
max_ff(1.0f, cam_aspect) * (image_aspect / cam_aspect);
690 translate[3][0] += (cam_corners[0][0] + cam_corners[2][0]) * 0.5f;
691 translate[3][1] += (cam_corners[0][1] + cam_corners[2][1]) * 0.5f;
696 gpu::Texture *image_camera_background_texture_get(
const CameraBGImage *bgpic,
700 bool &r_use_alpha_premult,
701 bool &r_use_view_transform)
704 ImageUser *iuser =
const_cast<ImageUser *
>(&bgpic->iuser);
705 MovieClip *clip =
nullptr;
706 gpu::Texture *tex =
nullptr;
707 float aspect_x, aspect_y;
710 r_use_alpha_premult =
false;
711 r_use_view_transform =
false;
713 switch (bgpic->source) {
715 if (image ==
nullptr) {
729 iuser->scene =
const_cast<Scene *
>(
state.scene);
731 iuser->scene =
nullptr;
733 if (tex ==
nullptr) {
741 aspect_x = bgpic->ima->aspx;
742 aspect_y = bgpic->ima->aspy;
748 if (
state.scene->camera) {
757 if (clip ==
nullptr) {
763 if (tex ==
nullptr) {
767 aspect_x = clip->aspx;
768 aspect_y = clip->aspy;
769 r_use_view_transform =
true;
774 res.bg_movie_clips.append(clip);
783 r_aspect = (width * aspect_x) / (height * aspect_y);
791 void sync_stereoscopy_extra(
const Main &bmain,
792 const CameraInstanceData &instdata,
793 const select::ID cam_select_id,
799 CameraInstanceData stereodata = instdata;
807 const bool is_selection = res.is_selection();
809 if (!is_stereo3d_cameras) {
811 call_buffers_.frame_buf.append(instdata, cam_select_id);
818 stereodata.corner_x = instdata.corner_x;
819 stereodata.corner_y = instdata.corner_y;
820 stereodata.center_x = instdata.center_x;
821 stereodata.center_y = instdata.center_y;
822 stereodata.depth = instdata.depth;
824 stereodata.center_x += camera_offaxis_shiftx_get(scene, ob, instdata.corner_x, eye);
826 if (is_stereo3d_cameras) {
827 call_buffers_.frame_buf.append(stereodata, cam_select_id);
830 call_buffers_.stereo_connect_lines.append(stereodata.matrix.location(),
831 instdata.object_to_world.location(),
832 res.theme.colors.wire,
836 if (is_stereo3d_volume && !is_selection) {
837 float r = (eye == 1) ? 2.0f : 1.0f;
839 stereodata.volume_start = -cam.clip_start;
840 stereodata.volume_end = -cam.clip_end;
842 stereodata.color_.x = r + 0.15f;
843 stereodata.color_.y = 1.0f;
844 call_buffers_.volume_wire_buf.append(stereodata, cam_select_id);
846 if (v3d->stereo3d_volume_alpha > 0.0f) {
848 stereodata.color_.x = r + 0.999f;
849 stereodata.color_.y = v3d->stereo3d_volume_alpha;
850 call_buffers_.volume_buf.append(stereodata, cam_select_id);
853 stereodata.color_.x = instdata.color_.x;
854 stereodata.color_.y = instdata.color_.y;
855 stereodata.color_.z = instdata.color_.z;
859 if (is_stereo3d_plane && !is_selection) {
865 stereodata.matrix.z_axis() =
float3(0.0f);
866 stereodata.matrix.location() =
float3(0.0f);
871 stereodata.matrix.z_axis() += mat.
z_axis();
872 stereodata.matrix.location() += mat.
location() * 0.5f;
874 stereodata.matrix.z_axis() =
math::normalize(stereodata.matrix.z_axis());
875 stereodata.matrix.x_axis() =
math::cross(stereodata.matrix.y_axis(),
876 stereodata.matrix.z_axis());
880 stereodata.matrix.location() =
float3(0.0f);
884 stereodata.matrix.location() += mat.
location() * 0.5f;
890 stereodata.volume_start = -cam.stereo.convergence_distance;
891 stereodata.volume_end = -cam.stereo.convergence_distance;
893 stereodata.color_.x = 0.1f;
894 stereodata.color_.y = 1.0f;
895 call_buffers_.volume_wire_buf.append(stereodata, cam_select_id);
897 if (v3d->stereo3d_convergence_alpha > 0.0f) {
899 stereodata.color_.x = 0.0f;
900 stereodata.color_.y = v3d->stereo3d_convergence_alpha;
901 call_buffers_.volume_buf.append(stereodata, cam_select_id);
906 static float camera_offaxis_shiftx_get(
const Scene *scene,
915 const float delta_shiftx = shiftx - cam.shiftx;
916 const float width = corner_x * 2.0f;
917 return delta_shiftx * width;