DNA_view3d_types.h

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2001-2002 NaN Holding BV. All rights reserved.
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#pragma once
 
struct BoundBox;
struct Object;
struct ViewRender;
struct SmoothView3DStore;
struct SpaceLink;
struct bGPdata;
struct wmTimer;
 
#ifdef __cplusplus
#  include "BLI_math_matrix_types.hh"
#  include "BLI_math_quaternion_types.hh"
#endif
 
#include "DNA_defs.h"
#include "DNA_image_types.h"
#include "DNA_listBase.h"
#include "DNA_movieclip_types.h"
#include "DNA_object_types.h"
#include "DNA_view3d_enums.h"
#include "DNA_viewer_path_types.h"
 
typedef struct RegionView3D {
 
  float winmat[4][4];
  float viewmat[4][4];
  float viewinv[4][4];
  float persmat[4][4];
  float persinv[4][4];
  float viewcamtexcofac[4];
 
  float viewmatob[4][4];
  float persmatob[4][4];
 
  float clip[6][4];
  float clip_local[6][4];
  struct BoundBox *clipbb;
 
  struct RegionView3D *localvd;
  struct ViewRender *view_render;
 
  struct SmoothView3DStore *sms;
  struct wmTimer *smooth_timer;
 
  float twmat[4][4];
  float tw_axis_min[3], tw_axis_max[3];
  float tw_axis_matrix[3][3];
 
  float gridview DNA_DEPRECATED;
 
  float viewquat[4];
  float dist;
  float camdx, camdy;
  float pixsize;
  float ofs[3];
  float camzoom;
  char is_persp;
  char persp;
  char view;
  char view_axis_roll;
  char viewlock; /* Should usually be accessed with RV3D_LOCK_FLAGS()! */
  char runtime_viewlock; /* Should usually be accessed with RV3D_LOCK_FLAGS()! */
  char viewlock_quad;
  char _pad[1];
  float ofs_lock[2];
 
  short twdrawflag;
  short rflag;
 
  float lviewquat[4];
  char lpersp;
  char lview;
  char lview_axis_roll;
  char _pad8[1];
 
  float rot_angle;
  float rot_axis[3];
} RegionView3D;
 
typedef struct View3DCursor {
  float location[3];
 
  float rotation_quaternion[4];
  float rotation_euler[3];
  float rotation_axis[3], rotation_angle;
  short rotation_mode;
 
  char _pad[6];
 
#ifdef __cplusplus
  template<typename T> T matrix() const;
  blender::math::Quaternion rotation() const;
 
  void set_rotation(const blender::math::Quaternion &quat, bool use_compat);
  void set_matrix(const blender::float3x3 &mat, bool use_compat);
  void set_matrix(const blender::float4x4 &mat, bool use_compat);
#endif
} View3DCursor;
 
typedef struct View3DShading {
  char type;
  char prev_type;
  char prev_type_wire;
 
  char color_type;
  short flag;
 
  char light;
  char background_type;
  char cavity_type;
  char wire_color_type;
 
  char use_compositor;
 
  char _pad;
 
  char studio_light[256];
  char lookdev_light[256];
  char matcap[256];
 
  float shadow_intensity;
  float single_color[3];
 
  float studiolight_rot_z;
  float studiolight_background;
  float studiolight_intensity;
  float studiolight_blur;
 
  float object_outline_color[3];
  float xray_alpha;
  float xray_alpha_wire;
 
  float cavity_valley_factor;
  float cavity_ridge_factor;
 
  float background_color[3];
 
  float curvature_ridge_factor;
  float curvature_valley_factor;
 
  /* Render pass displayed in the viewport. Is an `eScenePassType` where one bit is set */
  int render_pass;
  char aov_name[64];
 
  struct IDProperty *prop;
  void *_pad2;
} View3DShading;
 
typedef struct View3DOverlay {
  int flag;
 
  int edit_flag;
  float normals_length;
  float normals_constant_screen_size;
 
  int paint_flag;
 
  int wpaint_flag;
 
  float texture_paint_mode_opacity;
  float vertex_paint_mode_opacity;
  float weight_paint_mode_opacity;
  float sculpt_mode_mask_opacity;
  float sculpt_mode_face_sets_opacity;
  float viewer_attribute_opacity;
 
  float xray_alpha_bone;
  float bone_wire_alpha;
 
  float fade_alpha;
 
  float wireframe_threshold;
  float wireframe_opacity;
  float retopology_offset;
 
  float gpencil_paper_opacity;
  float gpencil_grid_opacity;
  float gpencil_fade_layer;
 
  /* Grease Pencil canvas settings. */
  float gpencil_grid_color[3];
  float gpencil_grid_scale[2];
  float gpencil_grid_offset[2];
  int gpencil_grid_subdivisions;
 
  float gpencil_vertex_paint_opacity;
  int handle_display;
 
  float sculpt_curves_cage_opacity;
} View3DOverlay;
 
typedef enum eHandleDisplay {
  /* Display only selected points. */
  CURVE_HANDLE_SELECTED = 0,
  /* Display all handles. */
  CURVE_HANDLE_ALL = 1,
  /* No display handles. */
  CURVE_HANDLE_NONE = 2,
} eHandleDisplay;
 
typedef struct View3D_Runtime {
  void *properties_storage;
  void (*properties_storage_free)(void *properties_storage);
  int flag;
 
  char _pad1[4];
  /* Only used for overlay stats while in local-view. */
  struct SceneStats *local_stats;
} View3D_Runtime;
 
typedef struct View3D {
  DNA_DEFINE_CXX_METHODS(View3D)
 
  struct SpaceLink *next, *prev;
  ListBase regionbase;
  char spacetype;
  char link_flag;
  char _pad0[6];
  /* End 'SpaceLink' header. */
 
  float viewquat[4] DNA_DEPRECATED;
  float dist DNA_DEPRECATED;
 
  float bundle_size;
  char bundle_drawtype;
 
  char drawtype DNA_DEPRECATED;
 
  char _pad3[1];
 
  char multiview_eye;
 
  int object_type_exclude_viewport;
  int object_type_exclude_select;
 
  short persp DNA_DEPRECATED;
  short view DNA_DEPRECATED;
 
  struct Object *camera, *ob_center;
  rctf render_border;
 
  struct View3D *localvd;
 
  char ob_center_bone[64];
 
  unsigned short local_view_uid;
  char _pad6[2];
  int layact DNA_DEPRECATED;
  unsigned short local_collections_uid;
  short _pad7[2];
 
  short debug_flag;
 
  short ob_center_cursor;
  short scenelock;
  short gp_flag;
  short flag;
  int flag2;
 
  float lens, grid;
  float clip_start, clip_end;
  float ofs[3] DNA_DEPRECATED;
 
  char _pad[1];
 
  char gizmo_flag;
 
  char gizmo_show_object;
  char gizmo_show_armature;
  char gizmo_show_empty;
  char gizmo_show_light;
  char gizmo_show_camera;
 
  char gridflag;
 
  short gridlines;
  short gridsubdiv;
 
  float vertex_opacity;
 
  /* XXX deprecated? */
  struct bGPdata *gpd DNA_DEPRECATED;
 
  short stereo3d_flag;
  char stereo3d_camera;
  char _pad4;
  float stereo3d_convergence_factor;
  float stereo3d_volume_alpha;
  float stereo3d_convergence_alpha;
 
  View3DShading shading;
  View3DOverlay overlay;
 
  ViewerPath viewer_path;
 
  View3D_Runtime runtime;
} View3D;
 
enum {
  V3D_S3D_DISPCAMERAS = 1 << 0,
  V3D_S3D_DISPPLANE = 1 << 1,
  V3D_S3D_DISPVOLUME = 1 << 2,
};
 
enum {
  V3D_LOCAL_COLLECTIONS = 1 << 0,
  V3D_FLAG_UNUSED_1 = 1 << 1, /* cleared */
  V3D_HIDE_HELPLINES = 1 << 2,
  V3D_FLAG_UNUSED_2 = 1 << 3, /* cleared */
  V3D_XR_SESSION_MIRROR = 1 << 4,
  V3D_XR_SESSION_SURFACE = 1 << 5,
 
  V3D_FLAG_UNUSED_10 = 1 << 10, /* cleared */
  V3D_SELECT_OUTLINE = 1 << 11,
  V3D_FLAG_UNUSED_12 = 1 << 12, /* cleared */
  V3D_GLOBAL_STATS = 1 << 13,
  V3D_DRAW_CENTERS = 1 << 15,
};
 
enum {
  V3D_RUNTIME_XR_SESSION_ROOT = (1 << 0),
  V3D_RUNTIME_DEPTHBUF_OVERRIDDEN = (1 << 1),
  V3D_RUNTIME_LOCAL_MAYBE_EMPTY = (1 << 2),
};
 
enum {
  RV3D_ORTHO = 0,
  RV3D_PERSP = 1,
  RV3D_CAMOB = 2,
};
 
enum {
  RV3D_CLIPPING = 1 << 2,
  RV3D_NAVIGATING = 1 << 3,
  RV3D_GPULIGHT_UPDATE = 1 << 4,
  RV3D_PAINTING = 1 << 5,
  // RV3D_IS_GAME_ENGINE = 1 << 5, /* UNUSED */
  RV3D_ZOFFSET_DISABLED = 1 << 6,
};
 
enum {
  RV3D_LOCK_ROTATION = (1 << 0),
  RV3D_BOXVIEW = (1 << 1),
  RV3D_BOXCLIP = (1 << 2),
  RV3D_LOCK_LOCATION = (1 << 3),
  RV3D_LOCK_ZOOM_AND_DOLLY = (1 << 4),
 
  RV3D_LOCK_ANY_TRANSFORM = (RV3D_LOCK_LOCATION | RV3D_LOCK_ROTATION | RV3D_LOCK_ZOOM_AND_DOLLY),
};
 
#define RV3D_LOCK_FLAGS(rv3d) ((rv3d)->viewlock | ((rv3d)->runtime_viewlock))
 
enum {
  RV3D_VIEWLOCK_INIT = 1 << 7,
};
 
enum {
  RV3D_VIEW_USER = 0,
  RV3D_VIEW_FRONT = 1,
  RV3D_VIEW_BACK = 2,
  RV3D_VIEW_LEFT = 3,
  RV3D_VIEW_RIGHT = 4,
  RV3D_VIEW_TOP = 5,
  RV3D_VIEW_BOTTOM = 6,
  RV3D_VIEW_CAMERA = 8,
};
 
#define RV3D_VIEW_IS_AXIS(view) (((view) >= RV3D_VIEW_FRONT) && ((view) <= RV3D_VIEW_BOTTOM))
 
enum {
  RV3D_VIEW_AXIS_ROLL_0 = 0,
  RV3D_VIEW_AXIS_ROLL_90 = 1,
  RV3D_VIEW_AXIS_ROLL_180 = 2,
  RV3D_VIEW_AXIS_ROLL_270 = 3,
};
 
#define RV3D_CLIPPING_ENABLED(v3d, rv3d) \
  ((rv3d) && (v3d) && ((rv3d)->rflag & RV3D_CLIPPING) && \
   ELEM((v3d)->shading.type, OB_WIRE, OB_SOLID) && (rv3d)->clipbb)
 
enum {
  V3D_HIDE_OVERLAYS = 1 << 2,
  V3D_SHOW_VIEWER = 1 << 3,
  V3D_SHOW_ANNOTATION = 1 << 4,
  V3D_LOCK_CAMERA = 1 << 5,
  V3D_FLAG2_UNUSED_6 = 1 << 6, /* cleared */
  V3D_SHOW_RECONSTRUCTION = 1 << 7,
  V3D_SHOW_CAMERAPATH = 1 << 8,
  V3D_SHOW_BUNDLENAME = 1 << 9,
  V3D_FLAG2_UNUSED_10 = 1 << 10, /* cleared */
  V3D_RENDER_BORDER = 1 << 11,
  V3D_FLAG2_UNUSED_12 = 1 << 12, /* cleared */
  V3D_FLAG2_UNUSED_13 = 1 << 13, /* cleared */
  V3D_FLAG2_UNUSED_14 = 1 << 14, /* cleared */
  V3D_FLAG2_UNUSED_15 = 1 << 15, /* cleared */
  V3D_XR_SHOW_CONTROLLERS = 1 << 16,
  V3D_XR_SHOW_CUSTOM_OVERLAYS = 1 << 17,
  V3D_SHOW_CAMERA_GUIDES = (1 << 18),
  V3D_SHOW_CAMERA_PASSEPARTOUT = (1 << 19),
  V3D_XR_SHOW_PASSTHROUGH = 1 << 20,
};
 
enum {
  V3D_GP_FADE_OBJECTS = 1 << 0,
  V3D_GP_SHOW_GRID = 1 << 1,
  V3D_GP_SHOW_EDIT_LINES = 1 << 2,
  V3D_GP_SHOW_MULTIEDIT_LINES = 1 << 3,
  V3D_GP_SHOW_ONION_SKIN = 1 << 4,
  V3D_GP_FADE_NOACTIVE_LAYERS = 1 << 5,
  V3D_GP_FADE_NOACTIVE_GPENCIL = 1 << 6,
  V3D_GP_SHOW_STROKE_DIRECTION = 1 << 7,
  V3D_GP_SHOW_MATERIAL_NAME = 1 << 8,
  V3D_GP_SHOW_GRID_XRAY = 1 << 9,
};
 
enum {
  V3D_SHADING_OBJECT_OUTLINE = (1 << 0),
  V3D_SHADING_XRAY = (1 << 1),
  V3D_SHADING_SHADOW = (1 << 2),
  V3D_SHADING_SCENE_LIGHTS = (1 << 3),
  V3D_SHADING_SPECULAR_HIGHLIGHT = (1 << 4),
  V3D_SHADING_CAVITY = (1 << 5),
  V3D_SHADING_MATCAP_FLIP_X = (1 << 6),
  V3D_SHADING_SCENE_WORLD = (1 << 7),
  V3D_SHADING_XRAY_WIREFRAME = (1 << 8),
  V3D_SHADING_WORLD_ORIENTATION = (1 << 9),
  V3D_SHADING_BACKFACE_CULLING = (1 << 10),
  V3D_SHADING_DEPTH_OF_FIELD = (1 << 11),
  V3D_SHADING_SCENE_LIGHTS_RENDER = (1 << 12),
  V3D_SHADING_SCENE_WORLD_RENDER = (1 << 13),
  V3D_SHADING_STUDIOLIGHT_VIEW_ROTATION = (1 << 14),
};
 
enum {
  V3D_DEBUG_FREEZE_CULLING = (1 << 0),
};
 
#define V3D_USES_SCENE_LIGHTS(v3d) \
  ((((v3d)->shading.type == OB_MATERIAL) && ((v3d)->shading.flag & V3D_SHADING_SCENE_LIGHTS)) || \
   (((v3d)->shading.type == OB_RENDER) && \
    ((v3d)->shading.flag & V3D_SHADING_SCENE_LIGHTS_RENDER)))
 
#define V3D_USES_SCENE_WORLD(v3d) \
  ((((v3d)->shading.type == OB_MATERIAL) && ((v3d)->shading.flag & V3D_SHADING_SCENE_WORLD)) || \
   (((v3d)->shading.type == OB_RENDER) && \
    ((v3d)->shading.flag & V3D_SHADING_SCENE_WORLD_RENDER)))
 
enum {
  V3D_SHADING_CAVITY_SSAO = 0,
  V3D_SHADING_CAVITY_CURVATURE = 1,
  V3D_SHADING_CAVITY_BOTH = 2,
};
 
typedef enum View3DShadingUseCompositor {
  V3D_SHADING_USE_COMPOSITOR_DISABLED = 0,
  V3D_SHADING_USE_COMPOSITOR_CAMERA = 1,
  V3D_SHADING_USE_COMPOSITOR_ALWAYS = 2,
} View3DShadingUseCompositor;
 
enum {
  V3D_OVERLAY_FACE_ORIENTATION = (1 << 0),
  V3D_OVERLAY_HIDE_CURSOR = (1 << 1),
  V3D_OVERLAY_BONE_SELECT = (1 << 2),
  V3D_OVERLAY_LOOK_DEV = (1 << 3),
  V3D_OVERLAY_WIREFRAMES = (1 << 4),
  V3D_OVERLAY_HIDE_TEXT = (1 << 5),
  V3D_OVERLAY_HIDE_MOTION_PATHS = (1 << 6),
  V3D_OVERLAY_ONION_SKINS = (1 << 7),
  V3D_OVERLAY_HIDE_BONES = (1 << 8),
  V3D_OVERLAY_HIDE_OBJECT_XTRAS = (1 << 9),
  V3D_OVERLAY_HIDE_OBJECT_ORIGINS = (1 << 10),
  V3D_OVERLAY_STATS = (1 << 11),
  V3D_OVERLAY_FADE_INACTIVE = (1 << 12),
  V3D_OVERLAY_VIEWER_ATTRIBUTE = (1 << 13),
  V3D_OVERLAY_SCULPT_SHOW_MASK = (1 << 14),
  V3D_OVERLAY_SCULPT_SHOW_FACE_SETS = (1 << 15),
  V3D_OVERLAY_SCULPT_CURVES_CAGE = (1 << 16),
  V3D_OVERLAY_SHOW_LIGHT_COLORS = (1 << 17),
  V3D_OVERLAY_VIEWER_ATTRIBUTE_TEXT = (1 << 18),
};
 
enum {
  V3D_OVERLAY_EDIT_VERT_NORMALS = (1 << 0),
  V3D_OVERLAY_EDIT_LOOP_NORMALS = (1 << 1),
  V3D_OVERLAY_EDIT_FACE_NORMALS = (1 << 2),
 
  V3D_OVERLAY_EDIT_RETOPOLOGY = (1 << 3),
 
  V3D_OVERLAY_EDIT_WEIGHT = (1 << 4),
 
  V3D_OVERLAY_EDIT_EDGES_DEPRECATED = (1 << 5),
  V3D_OVERLAY_EDIT_FACES = (1 << 6),
  V3D_OVERLAY_EDIT_FACE_DOT = (1 << 7),
 
  V3D_OVERLAY_EDIT_SEAMS = (1 << 8),
  V3D_OVERLAY_EDIT_SHARP = (1 << 9),
  V3D_OVERLAY_EDIT_CREASES = (1 << 10),
  V3D_OVERLAY_EDIT_BWEIGHTS = (1 << 11),
 
  V3D_OVERLAY_EDIT_FREESTYLE_EDGE = (1 << 12),
  V3D_OVERLAY_EDIT_FREESTYLE_FACE = (1 << 13),
 
  V3D_OVERLAY_EDIT_STATVIS = (1 << 14),
  V3D_OVERLAY_EDIT_EDGE_LEN = (1 << 15),
  V3D_OVERLAY_EDIT_EDGE_ANG = (1 << 16),
  V3D_OVERLAY_EDIT_FACE_ANG = (1 << 17),
  V3D_OVERLAY_EDIT_FACE_AREA = (1 << 18),
  V3D_OVERLAY_EDIT_INDICES = (1 << 19),
 
  /* Deprecated. */
  // V3D_OVERLAY_EDIT_CU_HANDLES = (1 << 20),
 
  V3D_OVERLAY_EDIT_CU_NORMALS = (1 << 21),
  V3D_OVERLAY_EDIT_CONSTANT_SCREEN_SIZE_NORMALS = (1 << 22),
};
 
enum {
  V3D_OVERLAY_PAINT_WIRE = (1 << 0),
};
 
enum {
  V3D_OVERLAY_WPAINT_CONTOURS = (1 << 0),
};
 
enum {
  /* center of the bounding box */
  V3D_AROUND_CENTER_BOUNDS = 0,
  /* center from the sum of all points divided by the total */
  V3D_AROUND_CENTER_MEDIAN = 3,
  /* pivot around the 2D/3D cursor */
  V3D_AROUND_CURSOR = 1,
  /* pivot around each items own origin */
  V3D_AROUND_LOCAL_ORIGINS = 2,
  /* pivot around the active items origin */
  V3D_AROUND_ACTIVE = 4,
};
 
enum {
  V3D_SHOW_FLOOR = 1 << 0,
  V3D_SHOW_X = 1 << 1,
  V3D_SHOW_Y = 1 << 2,
  V3D_SHOW_Z = 1 << 3,
  V3D_SHOW_ORTHO_GRID = 1 << 4,
};
 
enum {
  V3D_ORIENT_GLOBAL = 0,
  V3D_ORIENT_LOCAL = 1,
  V3D_ORIENT_NORMAL = 2,
  V3D_ORIENT_VIEW = 3,
  V3D_ORIENT_GIMBAL = 4,
  V3D_ORIENT_CURSOR = 5,
  V3D_ORIENT_PARENT = 6,
  V3D_ORIENT_CUSTOM = 1024,
  V3D_ORIENT_CUSTOM_MATRIX = (V3D_ORIENT_CUSTOM - 1),
};
 
enum {
  V3D_GIZMO_HIDE = (1 << 0),
  V3D_GIZMO_HIDE_NAVIGATE = (1 << 1),
  V3D_GIZMO_HIDE_CONTEXT = (1 << 2),
  V3D_GIZMO_HIDE_TOOL = (1 << 3),
  V3D_GIZMO_HIDE_MODIFIER = (1 << 4),
};
 
enum {
  V3D_GIZMO_SHOW_OBJECT_TRANSLATE = (1 << 0),
  V3D_GIZMO_SHOW_OBJECT_ROTATE = (1 << 1),
  V3D_GIZMO_SHOW_OBJECT_SCALE = (1 << 2),
};
enum {
  V3D_GIZMO_SHOW_ARMATURE_BBONE = (1 << 0),
  V3D_GIZMO_SHOW_ARMATURE_ROLL = (1 << 1),
};
enum {
  V3D_GIZMO_SHOW_EMPTY_IMAGE = (1 << 0),
  V3D_GIZMO_SHOW_EMPTY_FORCE_FIELD = (1 << 1),
};
enum {
  V3D_GIZMO_SHOW_LIGHT_SIZE = (1 << 0),
  V3D_GIZMO_SHOW_LIGHT_LOOK_AT = (1 << 1),
};
enum {
  V3D_GIZMO_SHOW_CAMERA_LENS = (1 << 0),
  V3D_GIZMO_SHOW_CAMERA_DOF_DIST = (1 << 2),
};
 
typedef enum {
  V3D_PLACE_DEPTH_SURFACE = 0,
  V3D_PLACE_DEPTH_CURSOR_PLANE = 1,
  V3D_PLACE_DEPTH_CURSOR_VIEW = 2,
} eV3DPlaceDepth;
typedef enum {
  V3D_PLACE_ORIENT_SURFACE = 0,
  V3D_PLACE_ORIENT_DEFAULT = 1,
} eV3DPlaceOrient;
 
#define RV3D_CAMZOOM_MIN -30
#define RV3D_CAMZOOM_MAX 600
 
#define RV3D_CAMZOOM_MIN_FACTOR 0.1657359312880714853f
#define RV3D_CAMZOOM_MAX_FACTOR 44.9852813742385702928f