Blender V5.3
view3d_project.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2008 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include "DNA_layer_types.h"
10#include "DNA_object_types.h"
11#include "DNA_scene_types.h"
12#include "DNA_screen_types.h"
13#include "DNA_userdef_types.h"
14#include "DNA_view3d_types.h"
15
16#include "BLI_math_geom_c.hh"
17#include "BLI_math_matrix_c.hh"
19#include "BLI_math_vector_c.hh"
20
21#include "GPU_matrix.hh"
22
23#include "ED_view3d.hh" /* own include */
24
25namespace blender {
26
27#define BL_ZERO_CLIP 0.001
28
29/* Non Clipping Projection Functions
30 * ********************************* */
31
32float2 ED_view3d_project_float_v2_m4(const ARegion *region, const float co[3], const float4x4 &mat)
33{
34 float vec4[4];
35
36 copy_v3_v3(vec4, co);
37 vec4[3] = 1.0;
38 // co_region[0] = IS_CLIPPED; /* Always overwritten. */
39
40 mul_m4_v4(mat.ptr(), vec4);
41
42 float2 co_region;
43 if (vec4[3] > FLT_EPSILON) {
44 co_region[0] = float(region->winx / 2.0f) + (region->winx / 2.0f) * vec4[0] / vec4[3];
45 co_region[1] = float(region->winy / 2.0f) + (region->winy / 2.0f) * vec4[1] / vec4[3];
46 }
47 else {
48 zero_v2(co_region);
49 }
50 return co_region;
51}
52
54 const float co[3],
55 float r_co[3],
56 const float mat[4][4])
57{
58 float vec4[4];
59
60 copy_v3_v3(vec4, co);
61 vec4[3] = 1.0;
62 // r_co[0] = IS_CLIPPED; /* Always overwritten. */
63
64 mul_m4_v4(mat, vec4);
65
66 if (vec4[3] > FLT_EPSILON) {
67 r_co[0] = float(region->winx / 2.0f) + (region->winx / 2.0f) * vec4[0] / vec4[3];
68 r_co[1] = float(region->winy / 2.0f) + (region->winy / 2.0f) * vec4[1] / vec4[3];
69 r_co[2] = vec4[2] / vec4[3];
70 }
71 else {
72 zero_v3(r_co);
73 }
74}
75
76/* Clipping Projection Functions
77 * ***************************** */
78
79eV3DProjStatus ED_view3d_project_base(const ARegion *region, Base *base, float r_co[2])
80{
82 region, base->object->object_to_world().location(), r_co, V3D_PROJ_TEST_CLIP_DEFAULT);
83
84 /* Prevent uninitialized values when projection fails,
85 * although the callers should check the return value. */
86 if (ret != V3D_PROJ_RET_OK) {
87 r_co[0] = -1.0;
88 r_co[1] = -1.0;
89 }
90
91 return ret;
92}
93
100 const float perspmat[4][4],
101 const bool is_local, /* normally hidden */
102 const float co[3],
103 float r_co[2],
104 const eV3DProjTest flag)
105{
106 float vec4[4];
107
108 /* check for bad flags */
109 BLI_assert((flag & V3D_PROJ_TEST_ALL) == flag);
110
111 if (flag & V3D_PROJ_TEST_CLIP_BB) {
112 const RegionView3D *rv3d = static_cast<const RegionView3D *>(region->regiondata);
113 if ((rv3d->rflag & RV3D_CLIPPING) && (rv3d->clipbb != nullptr)) {
114 if (ED_view3d_clipping_test(rv3d, co, is_local)) {
116 }
117 }
118 }
119
120 copy_v3_v3(vec4, co);
121 vec4[3] = 1.0;
122 mul_m4_v4(perspmat, vec4);
123 const float w = fabsf(vec4[3]);
124
125 if ((flag & V3D_PROJ_TEST_CLIP_ZERO) && (w <= float(BL_ZERO_CLIP))) {
127 }
128
129 if ((flag & V3D_PROJ_TEST_CLIP_NEAR) && (vec4[2] <= -w)) {
131 }
132
133 if ((flag & V3D_PROJ_TEST_CLIP_FAR) && (vec4[2] >= w)) {
135 }
136
137 const float scalar = (w != 0.0f) ? (1.0f / w) : 0.0f;
138 const float fx = (float(region->winx) / 2.0f) * (1.0f + (vec4[0] * scalar));
139 const float fy = (float(region->winy) / 2.0f) * (1.0f + (vec4[1] * scalar));
140
141 if ((flag & V3D_PROJ_TEST_CLIP_WIN) &&
142 (fx <= 0.0f || fy <= 0.0f || fx >= float(region->winx) || fy >= float(region->winy)))
143 {
145 }
146
147 r_co[0] = fx;
148 r_co[1] = fy;
149
150 return V3D_PROJ_RET_OK;
151}
152
154 float perspmat[4][4],
155 const bool is_local,
156 const float co[3],
157 short r_co[2],
158 const eV3DProjTest flag)
159{
160 float tvec[2];
161 eV3DProjStatus ret = ed_view3d_project__internal(region, perspmat, is_local, co, tvec, flag);
162 if (ret == V3D_PROJ_RET_OK) {
163 if ((tvec[0] > -32700.0f && tvec[0] < 32700.0f) && (tvec[1] > -32700.0f && tvec[1] < 32700.0f))
164 {
165 r_co[0] = short(floorf(tvec[0]));
166 r_co[1] = short(floorf(tvec[1]));
167 }
168 else {
170 }
171 }
172 return ret;
173}
174
176 float perspmat[4][4],
177 const bool is_local,
178 const float co[3],
179 int r_co[2],
180 const eV3DProjTest flag)
181{
182 float tvec[2];
183 eV3DProjStatus ret = ed_view3d_project__internal(region, perspmat, is_local, co, tvec, flag);
184 if (ret == V3D_PROJ_RET_OK) {
185 if ((tvec[0] > -2140000000.0f && tvec[0] < 2140000000.0f) &&
186 (tvec[1] > -2140000000.0f && tvec[1] < 2140000000.0f))
187 {
188 r_co[0] = int(floorf(tvec[0]));
189 r_co[1] = int(floorf(tvec[1]));
190 }
191 else {
193 }
194 }
195 return ret;
196}
197
199 float perspmat[4][4],
200 const bool is_local,
201 const float co[3],
202 float r_co[2],
203 const eV3DProjTest flag)
204{
205 float tvec[2];
206 eV3DProjStatus ret = ed_view3d_project__internal(region, perspmat, is_local, co, tvec, flag);
207 if (ret == V3D_PROJ_RET_OK) {
208 if (isfinite(tvec[0]) && isfinite(tvec[1])) {
209 copy_v2_v2(r_co, tvec);
210 }
211 else {
213 }
214 }
215 return ret;
216}
217
219 const float co[3],
220 short r_co[2],
221 const eV3DProjTest flag)
222{
223 RegionView3D *rv3d = static_cast<RegionView3D *>(region->regiondata);
224 return ED_view3d_project_short_ex(region, rv3d->persmat, false, co, r_co, flag);
225}
227 const float co[3],
228 short r_co[2],
229 const eV3DProjTest flag)
230{
231 RegionView3D *rv3d = static_cast<RegionView3D *>(region->regiondata);
233 return ED_view3d_project_short_ex(region, rv3d->persmatob, true, co, r_co, flag);
234}
235
237 const float co[3],
238 int r_co[2],
239 const eV3DProjTest flag)
240{
241 RegionView3D *rv3d = static_cast<RegionView3D *>(region->regiondata);
242 return ED_view3d_project_int_ex(region, rv3d->persmat, false, co, r_co, flag);
243}
245 const float co[3],
246 int r_co[2],
247 const eV3DProjTest flag)
248{
249 RegionView3D *rv3d = static_cast<RegionView3D *>(region->regiondata);
251 return ED_view3d_project_int_ex(region, rv3d->persmatob, true, co, r_co, flag);
252}
253
255 const float co[3],
256 float r_co[2],
257 const eV3DProjTest flag)
258{
259 RegionView3D *rv3d = static_cast<RegionView3D *>(region->regiondata);
260 return ED_view3d_project_float_ex(region, rv3d->persmat, false, co, r_co, flag);
261}
263 const float co[3],
264 float r_co[2],
265 const eV3DProjTest flag)
266{
267 RegionView3D *rv3d = static_cast<RegionView3D *>(region->regiondata);
269 return ED_view3d_project_float_ex(region, rv3d->persmatob, true, co, r_co, flag);
270}
271
272/* More Generic Window/Ray/Vector projection functions
273 * *************************************************** */
274
275float ED_view3d_pixel_size(const RegionView3D *rv3d, const float co[3])
276{
277 return mul_project_m4_v3_zfac(rv3d->persmat, co) * rv3d->pixsize * U.pixelsize;
278}
279
280float ED_view3d_pixel_size_no_ui_scale(const RegionView3D *rv3d, const float co[3])
281{
282 return mul_project_m4_v3_zfac(rv3d->persmat, co) * rv3d->pixsize;
283}
284
285float ED_view3d_calc_zfac_ex(const RegionView3D *rv3d, const float co[3], bool *r_flip)
286{
287 float zfac = mul_project_m4_v3_zfac(rv3d->persmat, co);
288
289 if (r_flip) {
290 *r_flip = (zfac < 0.0f);
291 }
292
293 /* if x,y,z is exactly the viewport offset, zfac is 0 and we don't want that
294 * (accounting for near zero values) */
295 if (zfac < 1.e-6f && zfac > -1.e-6f) {
296 zfac = 1.0f;
297 }
298
299 /* Negative zfac means x, y, z was behind the camera (in perspective).
300 * This gives flipped directions, so revert back to ok default case. */
301 if (zfac < 0.0f) {
302 zfac = -zfac;
303 }
304
305 return zfac;
306}
307
308float ED_view3d_calc_zfac(const RegionView3D *rv3d, const float co[3])
309{
310 return ED_view3d_calc_zfac_ex(rv3d, co, nullptr);
311}
312
313float ED_view3d_calc_depth_for_comparison(const RegionView3D *rv3d, const float co[3])
314{
315 if (rv3d->is_persp) {
316 return mul_project_m4_v3_zfac(rv3d->persmat, co);
317 }
318 return -dot_v3v3(rv3d->viewinv[2], co);
319}
320
321static void view3d_win_to_ray_segment(const Depsgraph *depsgraph,
322 const ARegion *region,
323 const View3D *v3d,
324 const float mval[2],
325 float r_ray_co[3],
326 float r_ray_dir[3],
327 float r_ray_start[3],
328 float r_ray_end[3])
329{
330 const RegionView3D *rv3d = static_cast<const RegionView3D *>(region->regiondata);
331 float _ray_co[3], _ray_dir[3], start_offset, end_offset;
332
333 if (!r_ray_co) {
334 r_ray_co = _ray_co;
335 }
336 if (!r_ray_dir) {
337 r_ray_dir = _ray_dir;
338 }
339
340 ED_view3d_win_to_origin(region, mval, r_ray_co);
341 ED_view3d_win_to_vector(region, mval, r_ray_dir);
342
343 if ((rv3d->is_persp == false) && (rv3d->persp != RV3D_CAMOB)) {
344 end_offset = v3d->clip_end / 2.0f;
345 start_offset = -end_offset;
346 }
347 else {
348 ED_view3d_clip_range_get(depsgraph, v3d, rv3d, false, &start_offset, &end_offset);
349 }
350
351 if (r_ray_start) {
352 madd_v3_v3v3fl(r_ray_start, r_ray_co, r_ray_dir, start_offset);
353 }
354 if (r_ray_end) {
355 madd_v3_v3v3fl(r_ray_end, r_ray_co, r_ray_dir, end_offset);
356 }
357}
358
359bool ED_view3d_clip_segment(const RegionView3D *rv3d, float ray_start[3], float ray_end[3])
360{
361 if ((rv3d->rflag & RV3D_CLIPPING) && (rv3d->clipbb != nullptr) &&
362 (clip_segment_v3_plane_n(ray_start, ray_end, rv3d->clip, 6, ray_start, ray_end) == false))
363 {
364 return false;
365 }
366 return true;
367}
368
369bool ED_view3d_win_to_ray_clipped_ex(Depsgraph *depsgraph,
370 const ARegion *region,
371 const View3D *v3d,
372 const float mval[2],
373 const bool do_clip_planes,
374 float r_ray_co[3],
375 float r_ray_normal[3],
376 float r_ray_start[3],
377 float r_ray_end[3])
378{
380 depsgraph, region, v3d, mval, r_ray_co, r_ray_normal, r_ray_start, r_ray_end);
381
382 /* bounds clipping */
383 if (do_clip_planes) {
385 static_cast<const RegionView3D *>(region->regiondata), r_ray_start, r_ray_end);
386 }
387
388 return true;
389}
390
391bool ED_view3d_win_to_ray_clipped(Depsgraph *depsgraph,
392 const ARegion *region,
393 const View3D *v3d,
394 const float mval[2],
395 float r_ray_start[3],
396 float r_ray_normal[3],
397 const bool do_clip_planes)
398{
399 float ray_end_dummy[3];
400 return ED_view3d_win_to_ray_clipped_ex(depsgraph,
401 region,
402 v3d,
403 mval,
404 do_clip_planes,
405 nullptr,
406 r_ray_normal,
407 r_ray_start,
408 ray_end_dummy);
409}
410
411void ED_view3d_win_to_ray(const ARegion *region,
412 const float mval[2],
413 float r_ray_start[3],
414 float r_ray_normal[3])
415{
416 ED_view3d_win_to_origin(region, mval, r_ray_start);
417 ED_view3d_win_to_vector(region, mval, r_ray_normal);
418}
419
420void ED_view3d_global_to_vector(const RegionView3D *rv3d, const float coord[3], float r_out[3])
421{
422 if (rv3d->is_persp) {
423 float p1[4], p2[4];
424
425 copy_v3_v3(p1, coord);
426 p1[3] = 1.0f;
427 copy_v3_v3(p2, p1);
428 p2[3] = 1.0f;
429 mul_m4_v4(rv3d->viewmat, p2);
430
431 mul_v3_fl(p2, 2.0f);
432
433 mul_m4_v4(rv3d->viewinv, p2);
434
435 sub_v3_v3v3(r_out, p1, p2);
436 }
437 else {
438 copy_v3_v3(r_out, rv3d->viewinv[2]);
439 }
440 normalize_v3(r_out);
441}
442
443/* very similar to ED_view3d_win_to_3d() but has no advantage, de-duplicating */
444#if 0
445bool view3d_get_view_aligned_coordinate(ARegion *region,
446 float fp[3],
447 const int mval[2],
448 const bool do_fallback)
449{
450 RegionView3D *rv3d = region->regiondata;
451 float dvec[3];
452 int mval_cpy[2];
454
455 ret = ED_view3d_project_int_global(region, fp, mval_cpy, V3D_PROJ_TEST_NOP);
456
457 if (ret == V3D_PROJ_RET_OK) {
458 const float mval_f[2] = {float(mval_cpy[0] - mval[0]), float(mval_cpy[1] - mval[1])};
459 const float zfac = ED_view3d_calc_zfac(rv3d, fp);
460 ED_view3d_win_to_delta(region, mval_f, zfac, dvec);
461 sub_v3_v3(fp, dvec);
462
463 return true;
464 }
465 else {
466 /* fallback to the view center */
467 if (do_fallback) {
468 negate_v3_v3(fp, rv3d->ofs);
469 return view3d_get_view_aligned_coordinate(region, fp, mval, false);
470 }
471 else {
472 return false;
473 }
474 }
475}
476#endif
477
478void ED_view3d_win_to_3d(const View3D * /*v3d*/,
479 const ARegion *region,
480 const float depth_pt[3],
481 const float mval[2],
482 float r_out[3])
483{
484 RegionView3D *rv3d = static_cast<RegionView3D *>(region->regiondata);
485
486 float ray_origin[3];
487 float ray_direction[3];
488 float lambda;
489
490 if (rv3d->is_persp) {
491 copy_v3_v3(ray_origin, rv3d->viewinv[3]);
492 ED_view3d_win_to_vector(region, mval, ray_direction);
493
494 /* NOTE: we could use #isect_line_plane_v3()
495 * however we want the intersection to be in front of the view no matter what,
496 * so apply the unsigned factor instead. */
497 isect_ray_plane_v3_factor(ray_origin, ray_direction, depth_pt, rv3d->viewinv[2], &lambda);
498
499 lambda = fabsf(lambda);
500 }
501 else {
502 float dx = (2.0f * mval[0] / float(region->winx)) - 1.0f;
503 float dy = (2.0f * mval[1] / float(region->winy)) - 1.0f;
504
505 if (rv3d->persp == RV3D_CAMOB) {
506 /* Account for lens shift and pan, using the window matrix translation. */
507 dx -= rv3d->winmat[3][0];
508 dy -= rv3d->winmat[3][1];
509 }
510 ray_origin[0] = (rv3d->persinv[0][0] * dx) + (rv3d->persinv[1][0] * dy) + rv3d->viewinv[3][0];
511 ray_origin[1] = (rv3d->persinv[0][1] * dx) + (rv3d->persinv[1][1] * dy) + rv3d->viewinv[3][1];
512 ray_origin[2] = (rv3d->persinv[0][2] * dx) + (rv3d->persinv[1][2] * dy) + rv3d->viewinv[3][2];
513
514 copy_v3_v3(ray_direction, rv3d->viewinv[2]);
515 lambda = ray_point_factor_v3(depth_pt, ray_origin, ray_direction);
516 }
517
518 madd_v3_v3v3fl(r_out, ray_origin, ray_direction, lambda);
519}
520
522 const ARegion *region,
523 const float depth_pt[3],
524 const float mval[2],
525 float r_out[3])
526{
527 RegionView3D *rv3d = static_cast<RegionView3D *>(region->regiondata);
528
529 float ray_origin[3];
530 float ray_direction[3];
531 float lambda;
532
533 if (rv3d->is_persp) {
534 copy_v3_v3(ray_origin, rv3d->viewinv[3]);
535 ED_view3d_win_to_vector(region, mval, ray_direction);
536
537 /* NOTE: we could use #isect_line_plane_v3()
538 * however we want the intersection to be in front of the view no matter what,
539 * so apply the unsigned factor instead. */
540 isect_ray_plane_v3_factor(ray_origin, ray_direction, depth_pt, rv3d->viewinv[2], &lambda);
541
542 lambda = fabsf(lambda);
543 }
544 else {
545 float dx = (2.0f * mval[0] / float(region->winx)) - 1.0f;
546 float dy = (2.0f * mval[1] / float(region->winy)) - 1.0f;
547
548 if (rv3d->persp == RV3D_CAMOB) {
549 /* Account for lens shift and pan, using the window matrix translation. */
550 dx -= rv3d->winmat[3][0];
551 dy -= rv3d->winmat[3][1];
552 }
553 ray_origin[0] = (rv3d->persinv[0][0] * dx) + (rv3d->persinv[1][0] * dy) + rv3d->persinv[3][0];
554 ray_origin[1] = (rv3d->persinv[0][1] * dx) + (rv3d->persinv[1][1] * dy) + rv3d->persinv[3][1];
555 ray_origin[2] = (rv3d->persinv[0][2] * dx) + (rv3d->persinv[1][2] * dy) + rv3d->persinv[3][2];
556
557 copy_v3_v3(ray_direction, rv3d->viewinv[2]);
558 lambda = ray_point_factor_v3(depth_pt, ray_origin, ray_direction);
559 }
560
561 madd_v3_v3v3fl(r_out, ray_origin, ray_direction, lambda);
562}
563
565 const ARegion *region,
566 const float depth_pt[3],
567 const int mval[2],
568 float r_out[3])
569{
570 const float mval_fl[2] = {float(mval[0]), float(mval[1])};
571 ED_view3d_win_to_3d(v3d, region, depth_pt, mval_fl, r_out);
572}
573
575 const float plane[4],
576 const float mval[2],
577 const bool do_clip,
578 float r_out[3])
579{
580 const RegionView3D *rv3d = static_cast<const RegionView3D *>(region->regiondata);
581 const bool ray_co_is_centered = rv3d->is_persp == false && rv3d->persp != RV3D_CAMOB;
582 const bool do_clip_ray_plane = do_clip && !ray_co_is_centered;
583 float ray_co[3], ray_no[3];
584 ED_view3d_win_to_origin(region, mval, ray_co);
585 ED_view3d_win_to_vector(region, mval, ray_no);
586 float lambda;
587 if (isect_ray_plane_v3(ray_co, ray_no, plane, &lambda, do_clip_ray_plane)) {
588 madd_v3_v3v3fl(r_out, ray_co, ray_no, lambda);
589
590 /* Handle clipping with an orthographic view differently,
591 * check if the resulting point is behind the view instead of clipping the ray. */
592 if (do_clip && (do_clip_ray_plane == false)) {
593 /* The offset is unit length where over 1.0 is beyond the views clip-plane (near and far)
594 * as non-camera orthographic views only use far distance in both directions.
595 * Multiply `r_out` by `persmat` (with translation), and get it's Z value. */
596 const float z_offset = fabsf(dot_m4_v3_row_z(rv3d->persmat, r_out) + rv3d->persmat[3][2]);
597 if (z_offset > 1.0f) {
598 return false;
599 }
600 }
601 return true;
602 }
603 return false;
604}
605
607 const float plane[4],
608 const int mval[2],
609 const bool do_clip,
610 float r_out[3])
611{
612 const float mval_fl[2] = {float(mval[0]), float(mval[1])};
613 return ED_view3d_win_to_3d_on_plane(region, plane, mval_fl, do_clip, r_out);
614}
615
617 const float plane[4],
618 const float mval[2],
619 const bool do_clip,
620 const float plane_fallback[4],
621 float r_out[3])
622{
623 float isect_co[3], isect_no[3];
624 if (!isect_plane_plane_v3(plane, plane_fallback, isect_co, isect_no)) {
625 return false;
626 }
627 normalize_v3(isect_no);
628
629 /* Construct matrix to transform `plane_fallback` onto `plane`. */
630 float mat4[4][4];
631 {
632 float mat3[3][3];
633 rotation_between_vecs_to_mat3(mat3, plane, plane_fallback);
634 copy_m4_m3(mat4, mat3);
635 transform_pivot_set_m4(mat4, isect_co);
636 }
637
638 float co[3];
639 if (!ED_view3d_win_to_3d_on_plane(region, plane_fallback, mval, do_clip, co)) {
640 return false;
641 }
642 mul_m4_v3(mat4, co);
643
644 /* While the point is already on the plane, there may be some small in-precision
645 * so ensure the point is exactly on the plane. */
646 closest_to_plane_v3(r_out, plane, co);
647
648 return true;
649}
650
652 const ARegion *region, const float xy_delta[2], const float zfac, float r_out[3], bool precise)
653{
654 RegionView3D *rv3d = static_cast<RegionView3D *>(region->regiondata);
655 float dx, dy;
656
657 dx = 2.0f * xy_delta[0] * zfac / region->winx;
658 dy = 2.0f * xy_delta[1] * zfac / region->winy;
659
660 if (precise) {
661 /* Fix for operators that needs more precision. (see #103499) */
662 float wininv[4][4];
663 invert_m4_m4(wininv, rv3d->winmat);
664 r_out[0] = (wininv[0][0] * dx + wininv[1][0] * dy);
665 r_out[1] = (wininv[0][1] * dx + wininv[1][1] * dy);
666 r_out[2] = (wininv[0][2] * dx + wininv[1][2] * dy);
667 mul_mat3_m4_v3(rv3d->viewinv, r_out);
668 }
669 else {
670 r_out[0] = (rv3d->persinv[0][0] * dx + rv3d->persinv[1][0] * dy);
671 r_out[1] = (rv3d->persinv[0][1] * dx + rv3d->persinv[1][1] * dy);
672 r_out[2] = (rv3d->persinv[0][2] * dx + rv3d->persinv[1][2] * dy);
673 }
674}
675
676void ED_view3d_win_to_origin(const ARegion *region, const float mval[2], float r_out[3])
677{
678 RegionView3D *rv3d = static_cast<RegionView3D *>(region->regiondata);
679 if (rv3d->is_persp) {
680 copy_v3_v3(r_out, rv3d->viewinv[3]);
681 }
682 else {
683 r_out[0] = 2.0f * mval[0] / region->winx - 1.0f;
684 r_out[1] = 2.0f * mval[1] / region->winy - 1.0f;
685
686 if (rv3d->persp == RV3D_CAMOB) {
687 r_out[2] = -1.0f;
688 }
689 else {
690 r_out[2] = 0.0f;
691 }
692
693 mul_project_m4_v3(rv3d->persinv, r_out);
694 }
695}
696
697void ED_view3d_win_to_vector(const ARegion *region, const float mval[2], float r_out[3])
698{
699 RegionView3D *rv3d = static_cast<RegionView3D *>(region->regiondata);
700
701 if (rv3d->is_persp) {
702 r_out[0] = 2.0f * (mval[0] / region->winx) - 1.0f;
703 r_out[1] = 2.0f * (mval[1] / region->winy) - 1.0f;
704 r_out[2] = -0.5f;
705 mul_project_m4_v3(rv3d->persinv, r_out);
706 sub_v3_v3(r_out, rv3d->viewinv[3]);
707 }
708 else {
709 negate_v3_v3(r_out, rv3d->viewinv[2]);
710 }
711 normalize_v3(r_out);
712}
713
714bool ED_view3d_win_to_segment_clipped(const Depsgraph *depsgraph,
715 const ARegion *region,
716 const View3D *v3d,
717 const float mval[2],
718 float r_ray_start[3],
719 float r_ray_end[3],
720 const bool do_clip_planes)
721{
723 depsgraph, region, v3d, mval, nullptr, nullptr, r_ray_start, r_ray_end);
724
725 /* bounds clipping */
726 if (do_clip_planes) {
728 static_cast<RegionView3D *>(region->regiondata), r_ray_start, r_ray_end);
729 }
730
731 return true;
732}
733
734/* -------------------------------------------------------------------- */
737
739{
740 float vmat[4][4];
741 float4x4 pmat;
742
743 mul_m4_m4m4(vmat, rv3d->viewmat, ob->object_to_world().ptr());
744 mul_m4_m4m4(pmat.ptr(), rv3d->winmat, vmat);
745 return pmat;
746}
747
749{
750 return float4x4_view(rv3d->winmat) * float4x4_view(rv3d->viewmat) * obmat;
751}
752
753void ED_view3d_project_v3(const ARegion *region, const float world[3], float r_region_co[3])
754{
755 /* Viewport is set up to make coordinates relative to the region, not window. */
756 RegionView3D *rv3d = static_cast<RegionView3D *>(region->regiondata);
757 const int viewport[4] = {0, 0, region->winx, region->winy};
758 GPU_matrix_project_3fv(world, rv3d->viewmat, rv3d->winmat, viewport, r_region_co);
759}
760
761void ED_view3d_project_v2(const ARegion *region, const float world[3], float r_region_co[2])
762{
763 /* Viewport is set up to make coordinates relative to the region, not window. */
764 RegionView3D *rv3d = static_cast<RegionView3D *>(region->regiondata);
765 const int viewport[4] = {0, 0, region->winx, region->winy};
766 GPU_matrix_project_2fv(world, rv3d->viewmat, rv3d->winmat, viewport, r_region_co);
767}
768
770 const ARegion *region, float regionx, float regiony, float regionz, float world[3])
771{
772 RegionView3D *rv3d = static_cast<RegionView3D *>(region->regiondata);
773 const int viewport[4] = {0, 0, region->winx, region->winy};
774 const float region_co[3] = {regionx, regiony, regionz};
775
776 return GPU_matrix_unproject_3fv(region_co, rv3d->viewinv, rv3d->winmat, viewport, world);
777}
778
780
781} // namespace blender
Object is a sort of wrapper for general info.
#define V3D_PROJ_TEST_CLIP_DEFAULT
Definition ED_view3d.hh:325
#define V3D_PROJ_TEST_ALL
Definition ED_view3d.hh:327
SIMD_FORCE_INLINE const btScalar & w() const
Return the w value.
Definition btQuadWord.h:119
vec4(1.0f/vec2(textureSize(edges_tx, 0)), vec2(textureSize(edges_tx, 0)))") DEFINE_VALUE("SMAA_RT_METRICS"
#define FLT_EPSILON
BMesh Iterators.
bool isect_ray_plane_v3_factor(const float ray_origin[3], const float ray_direction[3], const float plane_co[3], const float plane_no[3], float *r_lambda)
static void view3d_win_to_ray_segment(const Depsgraph *depsgraph, const ARegion *region, const View3D *v3d, const float mval[2], float r_ray_co[3], float r_ray_dir[3], float r_ray_start[3], float r_ray_end[3])
eV3DProjStatus ED_view3d_project_int_global(const ARegion *region, const float co[3], int r_co[2], eV3DProjTest flag)
MINLINE void madd_v3_v3v3fl(float r[3], const float a[3], const float b[3], float f)
UserDef U
Definition blender.cc:58
MINLINE float dot_m4_v3_row_z(const float M[4][4], const float a[3]) ATTR_WARN_UNUSED_RESULT
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
void closest_to_plane_v3(float r_close[3], const float plane[4], const float pt[3])
Definition math_geom.cc:451
MINLINE void negate_v3_v3(float r[3], const float a[3])
bool isect_plane_plane_v3(const float plane_a[4], const float plane_b[4], float r_isect_co[3], float r_isect_no[3]) ATTR_WARN_UNUSED_RESULT
@ V3D_PROJ_RET_OVERFLOW
Definition ED_view3d.hh:290
@ V3D_PROJ_RET_CLIP_FAR
Definition ED_view3d.hh:277
@ V3D_PROJ_RET_CLIP_ZERO
Definition ED_view3d.hh:284
@ V3D_PROJ_RET_CLIP_BB
Definition ED_view3d.hh:286
@ V3D_PROJ_RET_CLIP_WIN
Definition ED_view3d.hh:288
@ V3D_PROJ_RET_OK
Definition ED_view3d.hh:273
@ V3D_PROJ_RET_CLIP_NEAR
Definition ED_view3d.hh:275
void ED_view3d_win_to_ray(const ARegion *region, const float mval[2], float r_ray_start[3], float r_ray_normal[3])
void ED_view3d_win_to_3d_with_shift(const View3D *v3d, const ARegion *region, const float depth_pt[3], const float mval[2], float r_out[3])
MINLINE void copy_v3_v3(float r[3], const float a[3])
void ED_view3d_win_to_origin(const ARegion *region, const float mval[2], float r_out[3])
void GPU_matrix_project_2fv(const float world[3], const float model[4][4], const float proj[4][4], const int view[4], float r_win[2])
bool ED_view3d_win_to_3d_on_plane_int(const ARegion *region, const float plane[4], const int mval[2], bool do_clip, float r_out[3])
bool isect_ray_plane_v3(const float ray_origin[3], const float ray_direction[3], const float plane[4], float *r_lambda, bool clip)
eV3DProjStatus ED_view3d_project_float_object(const ARegion *region, const float co[3], float r_co[2], eV3DProjTest flag)
void copy_m4_m3(float m1[4][4], const float m2[3][3])
float4x4 ED_view3d_ob_project_mat_get(const RegionView3D *rv3d, const Object *ob)
eV3DProjStatus ED_view3d_project_short_global(const ARegion *region, const float co[3], short r_co[2], eV3DProjTest flag)
MINLINE void copy_v2_v2(float r[2], const float a[2])
float ED_view3d_pixel_size(const RegionView3D *rv3d, const float co[3])
bool ED_view3d_win_to_ray_clipped_ex(Depsgraph *depsgraph, const ARegion *region, const View3D *v3d, const float mval[2], const bool do_clip_planes, float r_ray_co[3], float r_ray_normal[3], float r_ray_start[3], float r_ray_end[3])
void mul_project_m4_v3(const float mat[4][4], float vec[3])
MINLINE float mul_project_m4_v3_zfac(const float mat[4][4], const float co[3]) ATTR_WARN_UNUSED_RESULT
eV3DProjStatus ED_view3d_project_short_object(const ARegion *region, const float co[3], short r_co[2], eV3DProjTest flag)
bool invert_m4_m4(float inverse[4][4], const float mat[4][4])
float2 ED_view3d_project_float_v2_m4(const ARegion *region, const float co[3], const float4x4 &mat)
void mul_m4_m4m4(float R[4][4], const float A[4][4], const float B[4][4])
void ED_view3d_project_v2(const ARegion *region, const float world[3], float r_region_co[2])
MatBase< float, 4, 4 > float4x4
float ray_point_factor_v3(const float p[3], const float ray_origin[3], const float ray_direction[3])
void ED_view3d_global_to_vector(const RegionView3D *rv3d, const float coord[3], float r_out[3])
MINLINE void mul_v3_fl(float r[3], float f)
bool ED_view3d_unproject_v3(const ARegion *region, float regionx, float regiony, float regionz, float world[3])
MINLINE void sub_v3_v3(float r[3], const float a[3])
void mul_m4_v3(const float M[4][4], float r[3])
bool ED_view3d_clip_segment(const RegionView3D *rv3d, float ray_start[3], float ray_end[3])
MatView< float, 4, 4, 4, 4, 0, 0, alignof(float)> float4x4_view
eV3DProjStatus ED_view3d_project_base(const ARegion *region, Base *base, float r_co[2])
VecBase< float, 2 > float2
eV3DProjStatus ED_view3d_project_int_object(const ARegion *region, const float co[3], int r_co[2], eV3DProjTest flag)
bool ED_view3d_win_to_3d_on_plane(const ARegion *region, const float plane[4], const float mval[2], bool do_clip, float r_out[3])
eV3DProjStatus ED_view3d_project_int_ex(const ARegion *region, float perspmat[4][4], bool is_local, const float co[3], int r_co[2], eV3DProjTest flag)
void GPU_matrix_project_3fv(const float world[3], const float model[4][4], const float proj[4][4], const int view[4], float r_win[3])
eV3DProjStatus ED_view3d_project_float_global(const ARegion *region, const float co[3], float r_co[2], eV3DProjTest flag)
void ED_view3d_project_float_v3_m4(const ARegion *region, const float co[3], float r_co[3], const float mat[4][4])
void ED_view3d_win_to_vector(const ARegion *region, const float mval[2], float r_out[3])
float ED_view3d_calc_zfac(const RegionView3D *rv3d, const float co[3])
void transform_pivot_set_m4(float mat[4][4], const float pivot[3])
static eV3DProjStatus ed_view3d_project__internal(const ARegion *region, const float perspmat[4][4], const bool is_local, const float co[3], float r_co[2], const eV3DProjTest flag)
void ED_view3d_project_v3(const ARegion *region, const float world[3], float r_region_co[3])
eV3DProjStatus ED_view3d_project_short_ex(const ARegion *region, float perspmat[4][4], bool is_local, const float co[3], short r_co[2], eV3DProjTest flag)
MINLINE void zero_v3(float r[3])
void mul_m4_v4(const float mat[4][4], float r[4])
bool ED_view3d_clip_range_get(const Depsgraph *depsgraph, const View3D *v3d, const RegionView3D *rv3d, bool use_ortho_factor, float *r_clip_start, float *r_clip_end)
void mul_mat3_m4_v3(const float mat[4][4], float r[3])
MINLINE float normalize_v3(float n[3])
MINLINE void sub_v3_v3v3(float r[3], const float a[3], const float b[3])
eV3DProjStatus ED_view3d_project_float_ex(const ARegion *region, float perspmat[4][4], bool is_local, const float co[3], float r_co[2], eV3DProjTest flag)
bool ED_view3d_clipping_test(const RegionView3D *rv3d, const float co[3], bool is_local)
float ED_view3d_pixel_size_no_ui_scale(const RegionView3D *rv3d, const float co[3])
bool GPU_matrix_unproject_3fv(const float win[3], const float model_inverted[4][4], const float proj[4][4], const int view[4], float r_world[3])
bool ED_view3d_win_to_segment_clipped(const Depsgraph *depsgraph, const ARegion *region, const View3D *v3d, const float mval[2], float r_ray_start[3], float r_ray_end[3], bool do_clip_planes)
bool ED_view3d_win_to_ray_clipped(Depsgraph *depsgraph, const ARegion *region, const View3D *v3d, const float mval[2], float r_ray_start[3], float r_ray_normal[3], bool do_clip_planes)
float ED_view3d_calc_zfac_ex(const RegionView3D *rv3d, const float co[3], bool *r_flip)
@ V3D_PROJ_TEST_CLIP_FAR
Definition ED_view3d.hh:299
@ V3D_PROJ_TEST_CLIP_ZERO
Definition ED_view3d.hh:300
@ V3D_PROJ_TEST_NOP
Definition ED_view3d.hh:295
@ V3D_PROJ_TEST_CLIP_NEAR
Definition ED_view3d.hh:298
@ V3D_PROJ_TEST_CLIP_WIN
Definition ED_view3d.hh:297
@ V3D_PROJ_TEST_CLIP_BB
Definition ED_view3d.hh:296
float4x4 ED_view3d_ob_project_mat_get_from_obmat(const RegionView3D *rv3d, const float4x4 &obmat)
void ED_view3d_win_to_3d_int(const View3D *v3d, const ARegion *region, const float depth_pt[3], const int mval[2], float r_out[3])
bool ED_view3d_win_to_3d_on_plane_with_fallback(const ARegion *region, const float plane[4], const float mval[2], bool do_clip, const float plane_fallback[4], float r_out[3])
void ED_view3d_check_mats_rv3d(RegionView3D *rv3d)
bool clip_segment_v3_plane_n(const float p1[3], const float p2[3], const float plane_array[][4], int plane_num, float r_p1[3], float r_p2[3])
void ED_view3d_win_to_3d(const View3D *v3d, const ARegion *region, const float depth_pt[3], const float mval[2], float r_out[3])
MINLINE float dot_v3v3(const float a[3], const float b[3]) ATTR_WARN_UNUSED_RESULT
MINLINE void zero_v2(float r[2])
void ED_view3d_win_to_delta(const ARegion *region, const float xy_delta[2], float zfac, float r_out[3], bool precise=false)
void rotation_between_vecs_to_mat3(float m[3][3], const float v1[3], const float v2[3])
float ED_view3d_calc_depth_for_comparison(const RegionView3D *rv3d, const float co[3])
#define floorf
#define fabsf
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
struct Object * object
const c_style_mat & ptr() const
eRegionView3D_Flag rflag
struct BoundBox * clipbb
eRegionView3D_Persp persp
#define BL_ZERO_CLIP