ED_view3d.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2008 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */

 
#pragma once
 
#include "BLI_bounds_types.hh"
#include "BLI_math_matrix_types.hh"
#include "BLI_math_vector_types.hh"
#include "BLI_utildefines.h"
 
#include "DNA_scene_types.h"
 
/* ********* exports for space_view3d/ module ********** */
struct ARegion;
struct BMEdge;
struct BMElem;
struct BMEditMesh;
struct BMFace;
struct BMVert;
struct BPoint;
struct Base;
struct BezTriple;
struct BoundBox;
struct Camera;
struct CustomData_MeshMasks;
struct Depsgraph;
struct EditBone;
struct GPUSelectBuffer;
struct ID;
struct Main;
struct MetaElem;
struct Nurb;
struct Object;
struct RV3DMatrixStore;
struct RegionView3D;
struct RenderEngineType;
struct Scene;
struct ScrArea;
struct View3D;
struct ViewContext;
struct ViewLayer;
struct ViewOpsData;
struct bContext;
struct bGPDlayer;
struct bPoseChannel;
struct bScreen;
struct rctf;
struct rcti;
struct wmEvent;
struct wmGizmo;
struct wmKeyMapItem;
struct wmOperator;
struct wmWindow;
struct wmWindowManager;
namespace blender::ed::transform {
struct SnapObjectContext;
}

struct ViewContext {
  bContext *C;
  Main *bmain;
  /* Dependency graph is uses for depth drawing, viewport camera matrix access, and also some areas
   * are re-using this to access evaluated entities.
   *
   * Moral of the story: assign to a fully evaluated state. */
  Depsgraph *depsgraph;
  Scene *scene;
  ViewLayer *view_layer;
  Object *obact;
  Object *obedit;
  ARegion *region;
  View3D *v3d;
  wmWindow *win;
  RegionView3D *rv3d;
  BMEditMesh *em;
  int mval[2];
};
 
struct ViewDepths {
  unsigned short w, h;
  /* only for temp use for sub-rectangles, added to `region->winx/winy`. */
  short x, y;
  float *depths;
  double depth_range[2];
};
 
/* Rotate 3D cursor on placement. */
enum eV3DCursorOrient {
  V3D_CURSOR_ORIENT_NONE = 0,
  V3D_CURSOR_ORIENT_VIEW,
  V3D_CURSOR_ORIENT_XFORM,
  V3D_CURSOR_ORIENT_GEOM,
};
 
void ED_view3d_background_color_get(const Scene *scene, const View3D *v3d, float r_color[3]);
void ED_view3d_text_colors_get(const Scene *scene,
                               const View3D *v3d,
                               float r_text_color[4],
                               float r_shadow_color[4]);
bool ED_view3d_has_workbench_in_texture_color(const Scene *scene,
                                              const Object *ob,
                                              const View3D *v3d);
void ED_view3d_cursor3d_position(bContext *C,
                                 const int mval[2],
                                 bool use_depth,
                                 float r_cursor_co[3]);
void ED_view3d_cursor3d_position_rotation(bContext *C,
                                          const int mval[2],
                                          bool use_depth,
                                          enum eV3DCursorOrient orientation,
                                          float r_cursor_co[3],
                                          float r_cursor_quat[4]);
void ED_view3d_cursor3d_update(bContext *C,
                               const int mval[2],
                               bool use_depth,
                               enum eV3DCursorOrient orientation);
 
Camera *ED_view3d_camera_data_get(View3D *v3d, RegionView3D *rv3d);

void ED_view3d_to_m4(float mat[4][4], const float ofs[3], const float quat[4], float dist);
void ED_view3d_from_m4(const float mat[4][4], float ofs[3], float quat[4], const float *dist);

void ED_view3d_from_object(
    const Object *ob, float ofs[3], float quat[4], const float *dist, float *lens);
void ED_view3d_to_object(
    const Depsgraph *depsgraph, Object *ob, const float ofs[3], const float quat[4], float dist);
 
bool ED_view3d_camera_to_view_selected(Main *bmain,
                                       Depsgraph *depsgraph,
                                       const Scene *scene,
                                       Object *camera_ob);
 
bool ED_view3d_camera_to_view_selected_with_set_clipping(Main *bmain,
                                                         Depsgraph *depsgraph,
                                                         const Scene *scene,
                                                         Object *camera_ob);

void ED_view3d_lastview_store(RegionView3D *rv3d);
 
/* Depth buffer */
enum eV3DDepthOverrideMode {
  V3D_DEPTH_ALL = 0,
  V3D_DEPTH_NO_GPENCIL,
  V3D_DEPTH_GPENCIL_ONLY,
  V3D_DEPTH_OBJECT_ONLY,
  V3D_DEPTH_SELECTED_ONLY,
 
};

void ED_view3d_depth_override(Depsgraph *depsgraph,
                              ARegion *region,
                              View3D *v3d,
                              Object *obact,
                              eV3DDepthOverrideMode mode,
                              bool use_overlay,
                              ViewDepths **r_depths);
void ED_view3d_depths_free(ViewDepths *depths);
bool ED_view3d_depth_read_cached(const ViewDepths *vd,
                                 const int mval[2],
                                 int margin,
                                 float *r_depth);
bool ED_view3d_depth_read_cached_normal(const ARegion *region,
                                        const ViewDepths *depths,
                                        const int mval[2],
                                        float r_normal[3]);
bool ED_view3d_depth_unproject_v3(const ARegion *region,
                                  const int mval[2],
                                  double depth,
                                  float r_location_world[3]);
 
bool ED_view3d_has_depth_buffer_updated(const Depsgraph *depsgraph, const View3D *v3d);

ViewOpsData *ED_view3d_navigation_init(bContext *C, const wmKeyMapItem *kmi_merge);
bool ED_view3d_navigation_do(bContext *C,
                             ViewOpsData *vod,
                             const wmEvent *event,
                             const float depth_loc_override[3]);
void ED_view3d_navigation_free(bContext *C, ViewOpsData *vod);
 
/* Projection */
#define IS_CLIPPED 12000
 
/* return values for ED_view3d_project_...() */
enum eV3DProjStatus {
  V3D_PROJ_RET_OK = 0,
  V3D_PROJ_RET_CLIP_NEAR = 1,
  V3D_PROJ_RET_CLIP_FAR = 2,
  V3D_PROJ_RET_CLIP_ZERO = 3,
  V3D_PROJ_RET_CLIP_BB = 4,
  V3D_PROJ_RET_CLIP_WIN = 5,
  V3D_PROJ_RET_OVERFLOW = 6,
};
ENUM_OPERATORS(eV3DProjStatus, V3D_PROJ_RET_OVERFLOW);
 
/* some clipping tests are optional */
enum eV3DProjTest {
  V3D_PROJ_TEST_NOP = 0,
  V3D_PROJ_TEST_CLIP_BB = (1 << 0),
  V3D_PROJ_TEST_CLIP_WIN = (1 << 1),
  V3D_PROJ_TEST_CLIP_NEAR = (1 << 2),
  V3D_PROJ_TEST_CLIP_FAR = (1 << 3),
  V3D_PROJ_TEST_CLIP_ZERO = (1 << 4),
  V3D_PROJ_TEST_CLIP_CONTENT = (1 << 5),
};
ENUM_OPERATORS(eV3DProjTest, V3D_PROJ_TEST_CLIP_CONTENT);
 
#define V3D_PROJ_TEST_CLIP_DEFAULT \
  (V3D_PROJ_TEST_CLIP_BB | V3D_PROJ_TEST_CLIP_WIN | V3D_PROJ_TEST_CLIP_NEAR)
#define V3D_PROJ_TEST_ALL \
  (V3D_PROJ_TEST_CLIP_DEFAULT | V3D_PROJ_TEST_CLIP_FAR | V3D_PROJ_TEST_CLIP_ZERO | \
   V3D_PROJ_TEST_CLIP_CONTENT)
 
#define V3D_PROJ_TEST_CLIP_CONTENT_DEFAULT \
  (V3D_PROJ_TEST_CLIP_CONTENT | V3D_PROJ_TEST_CLIP_NEAR | V3D_PROJ_TEST_CLIP_FAR | \
   V3D_PROJ_TEST_CLIP_WIN)
 
/* `view3d_snap.cc` */
 
bool ED_view3d_snap_selected_to_location(bContext *C,
                                         wmOperator *op,
                                         const float target_loc_global[3],
                                         int pivot_point);
 
/* `view3d_cursor_snap.cc` */
 
#define USE_SNAP_DETECT_FROM_KEYMAP_HACK
enum eV3DSnapCursor {
  V3D_SNAPCURSOR_TOGGLE_ALWAYS_TRUE = 1 << 0,
  V3D_SNAPCURSOR_OCCLUSION_ALWAYS_TRUE = 1 << 1,
  V3D_SNAPCURSOR_OCCLUSION_ALWAYS_FALSE = 1 << 2, /* TODO. */
  V3D_SNAPCURSOR_SNAP_EDIT_GEOM_FINAL = 1 << 3,
  V3D_SNAPCURSOR_SNAP_EDIT_GEOM_CAGE = 1 << 4,
};
ENUM_OPERATORS(eV3DSnapCursor, V3D_SNAPCURSOR_SNAP_EDIT_GEOM_CAGE)
 
struct V3DSnapCursorData {
  eSnapMode type_source;
  eSnapMode type_target;
  float loc[3];
  float nor[3];
  float obmat[4][4];
  int elem_index[3];
  float plane_omat[3][3];
  bool is_snap_invert;

  bool is_enabled;
};
 
struct V3DSnapCursorState {
  /* Setup. */
  eV3DSnapCursor flag;
  uchar source_color[4];
  uchar target_color[4];
  uchar color_box[4];
  float *prevpoint;
  float box_dimensions[3];
  bool draw_point;
  bool draw_plane;
  bool draw_box;
 
  bool (*poll)(ARegion *region, void *custom_poll_data);
  void *poll_data;
};
 
void ED_view3d_cursor_snap_state_default_set(V3DSnapCursorState *state);
V3DSnapCursorState *ED_view3d_cursor_snap_state_active_get();
void ED_view3d_cursor_snap_state_active_set(V3DSnapCursorState *state);
V3DSnapCursorState *ED_view3d_cursor_snap_state_create();
void ED_view3d_cursor_snap_state_free(V3DSnapCursorState *state);
void ED_view3d_cursor_snap_state_prevpoint_set(V3DSnapCursorState *state,
                                               const float prev_point[3]);
void ED_view3d_cursor_snap_data_update(V3DSnapCursorState *state,
                                       const bContext *C,
                                       const ARegion *region,
                                       const blender::int2 &mval);
V3DSnapCursorData *ED_view3d_cursor_snap_data_get();
blender::ed::transform::SnapObjectContext *ED_view3d_cursor_snap_context_ensure(Scene *scene);
void ED_view3d_cursor_snap_draw_util(RegionView3D *rv3d,
                                     const float source_loc[3],
                                     const float target_loc[3],
                                     const eSnapMode source_type,
                                     const eSnapMode target_type,
                                     const uchar source_color[4],
                                     const uchar target_color[4]);
 
/* `view3d_iterators.cc` */
 
/* foreach iterators */
 
void meshobject_foreachScreenVert(const ViewContext *vc,
                                  void (*func)(void *user_data,
                                               const float screen_co[2],
                                               int index),
                                  void *user_data,
                                  eV3DProjTest clip_flag);
void mesh_foreachScreenVert(
    const ViewContext *vc,
    void (*func)(void *user_data, BMVert *eve, const float screen_co[2], int index),
    void *user_data,
    eV3DProjTest clip_flag);
void mesh_foreachScreenEdge(const ViewContext *vc,
                            void (*func)(void *user_data,
                                         BMEdge *eed,
                                         const float screen_co_a[2],
                                         const float screen_co_b[2],
                                         int index),
                            void *user_data,
                            eV3DProjTest clip_flag);

void mesh_foreachScreenEdge_clip_bb_segment(const ViewContext *vc,
                                            void (*func)(void *user_data,
                                                         BMEdge *eed,
                                                         const float screen_co_a[2],
                                                         const float screen_co_b[2],
                                                         int index),
                                            void *user_data,
                                            eV3DProjTest clip_flag);
 
void mesh_foreachScreenFace(
    const ViewContext *vc,
    void (*func)(void *user_data, BMFace *efa, const float screen_co[2], int index),
    void *user_data,
    eV3DProjTest clip_flag);
void nurbs_foreachScreenVert(const ViewContext *vc,
                             void (*func)(void *user_data,
                                          Nurb *nu,
                                          BPoint *bp,
                                          BezTriple *bezt,
                                          int beztindex,
                                          bool handle_visible,
                                          const float screen_co[2]),
                             void *user_data,
                             eV3DProjTest clip_flag);
void mball_foreachScreenElem(const ViewContext *vc,
                             void (*func)(void *user_data, MetaElem *ml, const float screen_co[2]),
                             void *user_data,
                             eV3DProjTest clip_flag);
void lattice_foreachScreenVert(const ViewContext *vc,
                               void (*func)(void *user_data, BPoint *bp, const float screen_co[2]),
                               void *user_data,
                               eV3DProjTest clip_flag);
void armature_foreachScreenBone(const ViewContext *vc,
                                void (*func)(void *user_data,
                                             EditBone *ebone,
                                             const float screen_co_a[2],
                                             const float screen_co_b[2]),
                                void *user_data,
                                eV3DProjTest clip_flag);

void pose_foreachScreenBone(const ViewContext *vc,
                            void (*func)(void *user_data,
                                         bPoseChannel *pchan,
                                         const float screen_co_a[2],
                                         const float screen_co_b[2]),
                            void *user_data,
                            eV3DProjTest clip_flag);
/* *** end iterators *** */
 
/* `view3d_project.cc` */

blender::float2 ED_view3d_project_float_v2_m4(const ARegion *region,
                                              const float co[3],
                                              const blender::float4x4 &mat);
void ED_view3d_project_float_v3_m4(const ARegion *region,
                                   const float co[3],
                                   float r_co[3],
                                   const float mat[4][4]);
 
eV3DProjStatus ED_view3d_project_base(const ARegion *region, Base *base, float r_co[2]);
 
/* *** short *** */
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);
/* --- short --- */
eV3DProjStatus ED_view3d_project_short_global(const ARegion *region,
                                              const float co[3],
                                              short r_co[2],
                                              eV3DProjTest flag);
/* object space, use ED_view3d_init_mats_rv3d before calling */
eV3DProjStatus ED_view3d_project_short_object(const ARegion *region,
                                              const float co[3],
                                              short r_co[2],
                                              eV3DProjTest flag);
 
/* *** int *** */
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);
/* --- int --- */
eV3DProjStatus ED_view3d_project_int_global(const ARegion *region,
                                            const float co[3],
                                            int r_co[2],
                                            eV3DProjTest flag);
/* object space, use ED_view3d_init_mats_rv3d before calling */
eV3DProjStatus ED_view3d_project_int_object(const ARegion *region,
                                            const float co[3],
                                            int r_co[2],
                                            eV3DProjTest flag);
 
/* *** float *** */
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);
/* --- float --- */
eV3DProjStatus ED_view3d_project_float_global(const ARegion *region,
                                              const float co[3],
                                              float r_co[2],
                                              eV3DProjTest flag);
eV3DProjStatus ED_view3d_project_float_object(const ARegion *region,
                                              const float co[3],
                                              float r_co[2],
                                              eV3DProjTest flag);
 
float ED_view3d_pixel_size(const RegionView3D *rv3d, const float co[3]);
float ED_view3d_pixel_size_no_ui_scale(const RegionView3D *rv3d, const float co[3]);

float ED_view3d_calc_zfac_ex(const RegionView3D *rv3d, const float co[3], bool *r_flip);
float ED_view3d_calc_zfac(const RegionView3D *rv3d, const float co[3]);
float ED_view3d_calc_depth_for_comparison(const RegionView3D *rv3d, const float co[3]);
 
bool ED_view3d_clip_segment(const RegionView3D *rv3d, float ray_start[3], float ray_end[3]);
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);
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 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_global_to_vector(const RegionView3D *rv3d, const float coord[3], float r_out[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]);
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]);
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]);
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]);
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]);
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]);
void ED_view3d_win_to_delta(const ARegion *region,
                            const float xy_delta[2],
                            float zfac,
                            float r_out[3],
                            bool precise = false);
void ED_view3d_win_to_origin(const ARegion *region, const float mval[2], float r_out[3]);
void ED_view3d_win_to_vector(const ARegion *region, const float mval[2], float r_out[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);
blender::float4x4 ED_view3d_ob_project_mat_get(const RegionView3D *rv3d, const Object *ob);
blender::float4x4 ED_view3d_ob_project_mat_get_from_obmat(const RegionView3D *rv3d,
                                                          const blender::float4x4 &obmat);

void ED_view3d_project_v3(const ARegion *region, const float world[3], float r_region_co[3]);
void ED_view3d_project_v2(const ARegion *region, const float world[3], float r_region_co[2]);
bool ED_view3d_unproject_v3(
    const ARegion *region, float regionx, float regiony, float regionz, float world[3]);
 
/* end */

blender::Bounds<float> ED_view3d_dist_soft_range_get(const View3D *v3d, bool use_persp_range);

float ED_view3d_dist_soft_min_get(const View3D *v3d, bool use_persp_range);

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);
bool ED_view3d_viewplane_get(const Depsgraph *depsgraph,
                             const View3D *v3d,
                             const RegionView3D *rv3d,
                             int winx,
                             int winy,
                             rctf *r_viewplane,
                             float *r_clip_start,
                             float *r_clip_end,
                             float *r_pixsize);

void ED_view3d_polygon_offset(const RegionView3D *rv3d, float dist);
 
void ED_view3d_calc_camera_border(const Scene *scene,
                                  const Depsgraph *depsgraph,
                                  const ARegion *region,
                                  const View3D *v3d,
                                  const RegionView3D *rv3d,
                                  bool no_shift,
                                  rctf *r_viewborder);
void ED_view3d_calc_camera_border_size(const Scene *scene,
                                       Depsgraph *depsgraph,
                                       const ARegion *region,
                                       const View3D *v3d,
                                       const RegionView3D *rv3d,
                                       float r_size[2]);
bool ED_view3d_calc_render_border(
    const Scene *scene, Depsgraph *depsgraph, View3D *v3d, ARegion *region, rcti *r_rect);
 
void ED_view3d_clipping_calc_from_boundbox(float clip[4][4], const BoundBox *bb, bool is_flip);
void ED_view3d_clipping_calc(
    BoundBox *bb, float planes[4][4], const ARegion *region, const Object *ob, const rcti *rect);
bool ED_view3d_clipping_clamp_minmax(const RegionView3D *rv3d, float min[3], float max[3]);
 
void ED_view3d_clipping_local(RegionView3D *rv3d, const float mat[4][4]);
bool ED_view3d_clipping_test(const RegionView3D *rv3d, const float co[3], bool is_local);
 
float ED_view3d_radius_to_dist_persp(float angle, float radius);
float ED_view3d_radius_to_dist_ortho(float lens, float radius);
float ED_view3d_radius_to_dist(const View3D *v3d,
                               const ARegion *region,
                               const Depsgraph *depsgraph,
                               char persp,
                               bool use_aspect,
                               float radius);

int ED_view3d_backbuf_sample_size_clamp(ARegion *region, float dist);
 
void ED_view3d_select_id_validate(const ViewContext *vc);

bool ED_view3d_autodist_last_check(wmWindow *win, const wmEvent *event);
bool ED_view3d_autodist_last_get(wmWindow *win, float r_ofs[3]);
void ED_view3d_autodist_last_set(wmWindow *win,
                                 const wmEvent *event,
                                 const float ofs[3],
                                 const bool has_depth);
void ED_view3d_autodist_last_clear(wmWindow *win);

bool ED_view3d_autodist(ARegion *region,
                        View3D *v3d,
                        const int mval[2],
                        float mouse_worldloc[3],
                        const float fallback_depth_pt[3]);

bool ED_view3d_autodist_simple(ARegion *region,
                               const int mval[2],
                               float mouse_worldloc[3],
                               int margin,
                               const float *force_depth);
bool ED_view3d_depth_read_cached_seg(const ViewDepths *vd,
                                     const int mval_sta[2],
                                     const int mval_end[2],
                                     int margin,
                                     float *r_depth);

class ViewportColorSampleSession {
  blender::gpu::Texture *tex = nullptr;
  blender::ushort4 *data = nullptr;
  int tex_w, tex_h;
  rcti valid_rect;
 
 public:
  ViewportColorSampleSession() = default;
  ~ViewportColorSampleSession();
 
  bool init(ARegion *region);
  bool sample(const int mval[2], float r_col[3]);
};
 
enum eV3DSelectMode {
  /* all elements in the region, ignore depth */
  VIEW3D_SELECT_ALL = 0,
  /* pick also depth sorts (only for small regions!) */
  VIEW3D_SELECT_PICK_ALL = 1,
  /* sorts and only returns visible objects (only for small regions!) */
  VIEW3D_SELECT_PICK_NEAREST = 2,
};
 
enum eV3DSelectObjectFilter {
  VIEW3D_SELECT_FILTER_NOP = 0,
  VIEW3D_SELECT_FILTER_OBJECT_MODE_LOCK = 1,
  VIEW3D_SELECT_FILTER_WPAINT_POSE_MODE_LOCK = 2,
};
 
eV3DSelectObjectFilter ED_view3d_select_filter_from_mode(const Scene *scene, const Object *obact);

void view3d_gpu_select_cache_begin();
void view3d_gpu_select_cache_end();

int view3d_gpu_select_ex(const ViewContext *vc,
                         GPUSelectBuffer *buffer,
                         const rcti *input,
                         eV3DSelectMode select_mode,
                         eV3DSelectObjectFilter select_filter,
                         bool do_material_slot_selection);
int view3d_gpu_select(const ViewContext *vc,
                      GPUSelectBuffer *buffer,
                      const rcti *input,
                      eV3DSelectMode select_mode,
                      eV3DSelectObjectFilter select_filter);
int view3d_gpu_select_with_id_filter(const ViewContext *vc,
                                     GPUSelectBuffer *buffer,
                                     const rcti *input,
                                     eV3DSelectMode select_mode,
                                     eV3DSelectObjectFilter select_filter,
                                     uint select_id);
 
/* `view3d_select.cc` */
 
float ED_view3d_select_dist_px();
ViewContext ED_view3d_viewcontext_init(bContext *C, Depsgraph *depsgraph);

void ED_view3d_viewcontext_init_object(ViewContext *vc, Object *obact);
void view3d_operator_needs_gpu(const bContext *C);
void view3d_region_operator_needs_gpu(ARegion *region);

bool edge_inside_circle(const float cent[2],
                        float radius,
                        const float screen_co_a[2],
                        const float screen_co_b[2]);

RegionView3D *ED_view3d_context_rv3d(bContext *C);
bool ED_view3d_context_user_region(bContext *C, View3D **r_v3d, ARegion **r_region);
bool ED_view3d_area_user_region(const ScrArea *area, const View3D *v3d, ARegion **r_region);
bool ED_operator_rv3d_user_region_poll(bContext *C);

void ED_view3d_init_mats_rv3d(const Object *ob, RegionView3D *rv3d);
void ED_view3d_init_mats_rv3d_gl(const Object *ob, RegionView3D *rv3d);
#ifndef NDEBUG
void ED_view3d_clear_mats_rv3d(RegionView3D *rv3d);
void ED_view3d_check_mats_rv3d(RegionView3D *rv3d);
#else
#  define ED_view3d_clear_mats_rv3d(rv3d) (void)(rv3d)
#  define ED_view3d_check_mats_rv3d(rv3d) (void)(rv3d)
#endif
 
RV3DMatrixStore *ED_view3d_mats_rv3d_backup(RegionView3D *rv3d);
void ED_view3d_mats_rv3d_restore(RegionView3D *rv3d, RV3DMatrixStore *rv3dmat);
void ED_view3D_mats_rv3d_free(RV3DMatrixStore *rv3d_mat);
 
RenderEngineType *ED_view3d_engine_type(const Scene *scene, int drawtype);
 
bool ED_view3d_context_activate(bContext *C);
void ED_view3d_draw_setup_view(const wmWindowManager *wm,
                               wmWindow *win,
                               Depsgraph *depsgraph,
                               Scene *scene,
                               ARegion *region,
                               View3D *v3d,
                               const float viewmat[4][4],
                               const float winmat[4][4],
                               const rcti *rect);

Base *ED_view3d_give_base_under_cursor(bContext *C, const int mval[2]);
Object *ED_view3d_give_object_under_cursor(bContext *C, const int mval[2]);
Object *ED_view3d_give_material_slot_under_cursor(bContext *C,
                                                  const int mval[2],
                                                  int *r_material_slot);
bool ED_view3d_is_object_under_cursor(bContext *C, const int mval[2]);
void ED_view3d_quadview_update(ScrArea *area, ARegion *region, bool do_clip);
void ED_view3d_update_viewmat(const Depsgraph *depsgraph,
                              const Scene *scene,
                              View3D *v3d,
                              ARegion *region,
                              const float viewmat[4][4],
                              const float winmat[4][4],
                              const rcti *rect,
                              bool offscreen);
bool ED_view3d_quat_from_axis_view(char view, char view_axis_roll, float r_quat[4]);
bool ED_view3d_quat_to_axis_view(const float quat[4],
                                 float epsilon,
                                 char *r_view,
                                 char *r_view_axis_roll);
bool ED_view3d_quat_to_axis_view_and_reset_quat(float quat[4],
                                                float epsilon,
                                                char *r_view,
                                                char *r_view_axis_roll);
 
char ED_view3d_lock_view_from_index(int index);
char ED_view3d_axis_view_opposite(char view);
bool ED_view3d_lock(RegionView3D *rv3d);
 
void ED_view3d_datamask(const Scene *scene,
                        ViewLayer *view_layer,
                        const View3D *v3d,
                        CustomData_MeshMasks *r_cddata_masks);
void ED_view3d_screen_datamask(const Scene *scene,
                               ViewLayer *view_layer,
                               const bScreen *screen,
                               CustomData_MeshMasks *r_cddata_masks);
 
bool ED_view3d_offset_lock_check(const View3D *v3d, const RegionView3D *rv3d);
void ED_view3d_persp_switch_from_camera(const Depsgraph *depsgraph,
                                        View3D *v3d,
                                        RegionView3D *rv3d,
                                        char persp);
bool ED_view3d_persp_ensure(const Depsgraph *depsgraph, View3D *v3d, ARegion *region);
 
/* Camera view functions. */

bool ED_view3d_camera_view_zoom_scale(RegionView3D *rv3d, const float scale);
bool ED_view3d_camera_view_pan(ARegion *region, const float event_ofs[2]);
 
/* Camera lock functions */

bool ED_view3d_camera_lock_check(const View3D *v3d, const RegionView3D *rv3d);
void ED_view3d_camera_lock_init_ex(const Depsgraph *depsgraph,
                                   View3D *v3d,
                                   RegionView3D *rv3d,
                                   bool calc_dist);
void ED_view3d_camera_lock_init(const Depsgraph *depsgraph, View3D *v3d, RegionView3D *rv3d);
bool ED_view3d_camera_lock_sync(const Depsgraph *depsgraph, View3D *v3d, RegionView3D *rv3d);
 
bool ED_view3d_camera_autokey(
    const Scene *scene, ID *id_key, bContext *C, bool do_rotate, bool do_translate);
bool ED_view3d_camera_lock_autokey(
    View3D *v3d, RegionView3D *rv3d, bContext *C, bool do_rotate, bool do_translate);
 
void ED_view3d_lock_clear(View3D *v3d);

bool ED_view3d_camera_lock_undo_test(const View3D *v3d, const RegionView3D *rv3d, bContext *C);

bool ED_view3d_camera_lock_undo_push(const char *str,
                                     const View3D *v3d,
                                     const RegionView3D *rv3d,
                                     bContext *C);

bool ED_view3d_camera_lock_undo_grouped_push(const char *str,
                                             const View3D *v3d,
                                             const RegionView3D *rv3d,
                                             bContext *C);
 
#define VIEW3D_MARGIN 1.4f
#define VIEW3D_DIST_FALLBACK 1.0f

float ED_view3d_offset_distance(const float mat[4][4], const float ofs[3], float fallback_dist);
void ED_view3d_distance_set(RegionView3D *rv3d, float dist);
bool ED_view3d_distance_set_from_location(RegionView3D *rv3d,
                                          const float dist_co[3],
                                          float dist_min);

float ED_scene_grid_scale(const Scene *scene, const char **r_grid_unit);
float ED_view3d_grid_scale(const Scene *scene, const View3D *v3d, const char **r_grid_unit);
void ED_view3d_grid_steps(const Scene *scene,
                          const View3D *v3d,
                          const RegionView3D *rv3d,
                          float r_grid_steps[8]);
float ED_view3d_grid_view_scale(const Scene *scene,
                                const View3D *v3d,
                                const ARegion *region,
                                const char **r_grid_unit);

void ED_scene_draw_fps(const Scene *scene, int xoffset, int *yoffset);
 
/* Render */
 
void ED_view3d_stop_render_preview(wmWindowManager *wm, ARegion *region);
void ED_view3d_shade_update(Main *bmain, View3D *v3d, ScrArea *area);
 
#define SHADING_XRAY_ALPHA(shading) \
  (((shading).type == OB_WIRE) ? (shading).xray_alpha_wire : (shading).xray_alpha)
#define SHADING_XRAY_FLAG(shading) \
  (((shading).type == OB_WIRE) ? V3D_SHADING_XRAY_WIREFRAME : V3D_SHADING_XRAY)
#define SHADING_XRAY_FLAG_ENABLED(shading) (((shading).flag & SHADING_XRAY_FLAG(shading)) != 0)
#define SHADING_XRAY_ENABLED(shading) \
  (SHADING_XRAY_FLAG_ENABLED(shading) && (SHADING_XRAY_ALPHA(shading) < 1.0f))
#define SHADING_XRAY_ACTIVE(shading) \
  (SHADING_XRAY_ENABLED(shading) && ((shading).type < OB_MATERIAL))
 
#define XRAY_ALPHA(v3d) SHADING_XRAY_ALPHA((v3d)->shading)
#define XRAY_FLAG(v3d) SHADING_XRAY_FLAG((v3d)->shading)
#define XRAY_FLAG_ENABLED(v3d) SHADING_XRAY_FLAG_ENABLED((v3d)->shading)
#define XRAY_ENABLED(v3d) SHADING_XRAY_ENABLED((v3d)->shading)
#define XRAY_ACTIVE(v3d) SHADING_XRAY_ACTIVE((v3d)->shading)
 
#define OVERLAY_RETOPOLOGY_ENABLED(overlay) \
  (((overlay).edit_flag & V3D_OVERLAY_EDIT_RETOPOLOGY) != 0)
#ifdef __APPLE__
/* Apple silicon tile depth test requires a higher value to reduce drawing artifacts. */
#  define OVERLAY_RETOPOLOGY_MIN_OFFSET 0.0015f
#else
#  define OVERLAY_RETOPOLOGY_MIN_OFFSET FLT_EPSILON
#endif
 
#define OVERLAY_RETOPOLOGY_OFFSET(overlay) \
  (OVERLAY_RETOPOLOGY_ENABLED(overlay) ? \
       max_ff((overlay).retopology_offset, OVERLAY_RETOPOLOGY_MIN_OFFSET) : \
       0.0f)
 
#define RETOPOLOGY_ENABLED(v3d) (OVERLAY_RETOPOLOGY_ENABLED((v3d)->overlay))
#define RETOPOLOGY_OFFSET(v3d) (OVERLAY_RETOPOLOGY_OFFSET((v3d)->overlay))
 
/* `view3d_gizmo_preselect_type.cc` */
 
void ED_view3d_gizmo_mesh_preselect_get_active(const bContext *C,
                                               const wmGizmo *gz,
                                               Base **r_base,
                                               BMElem **r_ele);
void ED_view3d_gizmo_mesh_preselect_clear(wmGizmo *gz);
 
/* view3d_gizmo_ruler.cc */

void ED_view3d_gizmo_ruler_remove_by_gpencil_layer(struct bContext *C, bGPDlayer *gpl);
 
/* `space_view3d.cc` */
 
void ED_view3d_buttons_region_layout_ex(const bContext *C,
                                        ARegion *region,
                                        const char *category_override);
 
/* `view3d_view.cc` */

bool ED_localview_exit_if_empty(const Depsgraph *depsgraph,
                                Scene *scene,
                                ViewLayer *view_layer,
                                wmWindowManager *wm,
                                wmWindow *win,
                                View3D *v3d,
                                ScrArea *area,
                                bool frame_selected = true,
                                int smooth_viewtx = 0);
bool ED_view3d_local_collections_set(const Main *bmain, View3D *v3d);
void ED_view3d_local_collections_reset(const bContext *C, bool reset_all);
 
#ifdef WITH_XR_OPENXR
void ED_view3d_xr_mirror_update(const ScrArea *area, const View3D *v3d, bool enable);
void ED_view3d_xr_shading_update(wmWindowManager *wm, const View3D *v3d, const Scene *scene);
bool ED_view3d_is_region_xr_mirror_active(const wmWindowManager *wm,
                                          const View3D *v3d,
                                          const ARegion *region);
#endif