Differential D10300 Diff 33525 source/blender/editors/space_view3d/view3d_gizmo_navigate_type.c

Changeset View

Standalone View

source/blender/editors/space_view3d/view3d_gizmo_navigate_type.c

Show All 34 Lines

#include "GPU_batch.h"		#include "GPU_batch.h"
#include "GPU_batch_presets.h"		#include "GPU_batch_presets.h"
#include "GPU_immediate.h"		#include "GPU_immediate.h"
#include "GPU_immediate_util.h"		#include "GPU_immediate_util.h"
#include "GPU_matrix.h"		#include "GPU_matrix.h"
#include "GPU_state.h"		#include "GPU_state.h"

		#include "BLF_api.h"

#include "RNA_access.h"		#include "RNA_access.h"
#include "RNA_define.h"		#include "RNA_define.h"

#include "UI_interface.h"		#include "UI_interface.h"
#include "UI_resources.h"		#include "UI_resources.h"

#include "WM_api.h"		#include "WM_api.h"
#include "WM_types.h"		#include "WM_types.h"

#include "ED_screen.h"		#include "ED_screen.h"

#include "view3d_intern.h"		#include "view3d_intern.h"

#define USE_AXIS_FONT		/* Radius of the entire background. */
#define USE_FADE_BACKGROUND		#define WIDGET_RADIUS ((U.gizmo_size_navigate_v3d / 2.0f) * UI_DPI_FAC)

#ifdef USE_AXIS_FONT
# include "BLF_api.h"
#endif

#define DIAL_RESOLUTION 32

/* Sizes of axis spheres containing XYZ characters. */
#define AXIS_HANDLE_SIZE_FG 0.19f
/* When pointing away from the view. */
#define AXIS_HANDLE_SIZE_BG 0.15f
/* How far axis handles are away from the center. */
#define AXIS_HANDLE_OFFSET (1.0f - AXIS_HANDLE_SIZE_FG)

struct AxisDrawInfo {
/* Matrix is needed for screen-aligned font drawing. */
#ifdef USE_AXIS_FONT
float matrix_final[4][4];
#endif
#ifdef USE_FADE_BACKGROUND
float color_bg[3];
#endif
};

#ifndef USE_AXIS_FONT
/**
* \param viewmat_local_unit: is typically the 'rv3d->viewmatob'
* copied into a 3x3 matrix and normalized.
*/
static void draw_xyz_wire(
uint pos_id, const float viewmat_local_unit[3][3], const float c[3], float size, int axis)
{
int line_type;
float buffer[4][3];
int n = 0;

float v1[3] = {0.0f, 0.0f, 0.0f}, v2[3] = {0.0f, 0.0f, 0.0f};
float dim = size * 0.1f;
float dx[3], dy[3];

dx[0] = dim;
dx[1] = 0.0f;
dx[2] = 0.0f;
dy[0] = 0.0f;
dy[1] = dim;
dy[2] = 0.0f;

switch (axis) {
case 0: /* x axis */
line_type = GPU_PRIM_LINES;

/* bottom left to top right */
negate_v3_v3(v1, dx);
sub_v3_v3(v1, dy);
copy_v3_v3(v2, dx);
add_v3_v3(v2, dy);

copy_v3_v3(buffer[n++], v1);
copy_v3_v3(buffer[n++], v2);

/* top left to bottom right */
mul_v3_fl(dy, 2.0f);
add_v3_v3(v1, dy);
sub_v3_v3(v2, dy);

copy_v3_v3(buffer[n++], v1);
copy_v3_v3(buffer[n++], v2);

break;
case 1: /* y axis */
line_type = GPU_PRIM_LINES;

/* bottom left to top right */
mul_v3_fl(dx, 0.75f);
negate_v3_v3(v1, dx);
sub_v3_v3(v1, dy);
copy_v3_v3(v2, dx);
add_v3_v3(v2, dy);

copy_v3_v3(buffer[n++], v1);
copy_v3_v3(buffer[n++], v2);

/* top left to center */
mul_v3_fl(dy, 2.0f);
add_v3_v3(v1, dy);
zero_v3(v2);

copy_v3_v3(buffer[n++], v1);
copy_v3_v3(buffer[n++], v2);

break;
case 2: /* z axis */
line_type = GPU_PRIM_LINE_STRIP;

/* start at top left */
negate_v3_v3(v1, dx);
add_v3_v3(v1, dy);

copy_v3_v3(buffer[n++], v1);

mul_v3_fl(dx, 2.0f);		/* Sizes of axis spheres containing XYZ characters in relation to above. */
add_v3_v3(v1, dx);		#define AXIS_HANDLE_SIZE 0.20f

copy_v3_v3(buffer[n++], v1);		#define AXIS_LINE_WIDTH ((U.gizmo_size_navigate_v3d / 40.0f) * U.pixelsize)
		#define AXIS_RING_WIDTH ((U.gizmo_size_navigate_v3d / 60.0f) * U.pixelsize)
		#define AXIS_TEXT_SIZE (WIDGET_RADIUS * AXIS_HANDLE_SIZE * 1.25f)

mul_v3_fl(dy, 2.0f);		/* distance within this from center is considered positive. */
sub_v3_v3(v1, dx);		#define AXIS_DEPTH_BIAS 0.01f
sub_v3_v3(v1, dy);

copy_v3_v3(buffer[n++], v1);		static void gizmo_axis_draw(const bContext C, wmGizmo gz)

add_v3_v3(v1, dx);

copy_v3_v3(buffer[n++], v1);

break;
default:
BLI_assert(0);
return;
}

for (int i = 0; i < n; i++) {
mul_transposed_m3_v3((float(*)[3])viewmat_local_unit, buffer[i]);
add_v3_v3(buffer[i], c);
}

immBegin(line_type, n);
for (int i = 0; i < n; i++) {
immVertex3fv(pos_id, buffer[i]);
}
immEnd();
}
#endif /* !USE_AXIS_FONT */

/**
* \param draw_info: Extra data needed for drawing.
*/
static void axis_geom_draw(const wmGizmo *gz,
const float color[4],
const bool select,
const struct AxisDrawInfo *draw_info)
{		{
float viewport[4];
GPU_viewport_size_get_f(viewport);

GPUVertFormat *format = immVertexFormat();
const uint pos_id = GPU_vertformat_attr_add(format, "pos", GPU_COMP_F32, 3, GPU_FETCH_FLOAT);
immBindBuiltinProgram(GPU_SHADER_3D_UNIFORM_COLOR);

struct {		struct {
float depth;		float depth;
char index;		char index;
char axis;		char axis;
		char axis_opposite;
bool is_pos;		bool is_pos;
} axis_order[6] = {		} axis_order[6] = {
{-gz->matrix_offset[0][2], 0, 0, false},		{-gz->matrix_offset[0][2], 0, 0, 1, false},
{+gz->matrix_offset[0][2], 1, 0, true},		{+gz->matrix_offset[0][2], 1, 0, 0, true},
{-gz->matrix_offset[1][2], 2, 1, false},		{-gz->matrix_offset[1][2], 2, 1, 3, false},
{+gz->matrix_offset[1][2], 3, 1, true},		{+gz->matrix_offset[1][2], 3, 1, 2, true},
{-gz->matrix_offset[2][2], 4, 2, false},		{-gz->matrix_offset[2][2], 4, 2, 5, false},
{+gz->matrix_offset[2][2], 5, 2, true},		{+gz->matrix_offset[2][2], 5, 2, 4, true},
};		};

int axis_align = -1;		int axis_align = -1;
for (int axis = 0; axis < 3; axis++) {		for (int axis = 0; axis < 3; axis++) {
if (len_squared_v2(gz->matrix_offset[axis]) < 1e-6f) {		if (len_squared_v2(gz->matrix_offset[axis]) < 1e-6f) {
axis_align = axis;		axis_align = axis;
break;		break;
}		}
}		}

/* Show backwards pointing highlight on-top (else we can't see it at all). */
if ((select == false) && (gz->highlight_part > 0) && (axis_align != -1)) {
if (axis_order[gz->highlight_part - 1].is_pos == false) {
axis_order[gz->highlight_part - 1].depth = FLT_MAX;
}
}

qsort(&axis_order, ARRAY_SIZE(axis_order), sizeof(axis_order[0]), BLI_sortutil_cmp_float);		qsort(&axis_order, ARRAY_SIZE(axis_order), sizeof(axis_order[0]), BLI_sortutil_cmp_float);

static const float axis_highlight[4] = {1, 1, 1, 1};		/* When the cursor is over any of the gizmos (show circle backdrop). */
static const float axis_black[4] = {0, 0, 0, 1};		const bool is_active = ((gz->state & WM_GIZMO_STATE_HIGHLIGHT) != 0);
static float axis_color[3][4];

const float axis_depth_bias = 0.01f;		/* Background color of the View3D, used to mix colors. */
const float sphere_scale = 1.15f;		float view_color[4];
/* TODO(fclem): Is there a way to get the widget radius? */		ED_view3d_background_color_get(CTX_data_scene(C), CTX_wm_view3d(C), view_color);
const float widget_pix_size = 40.0f * U.dpi_fac;		view_color[3] = 1.0f;

		float matrix_screen[4][4];
		float matrix_unit[4][4];
		unit_m4(matrix_unit);
		WM_gizmo_calc_matrix_final_params(gz,
		&((struct WM_GizmoMatrixParams){
		.matrix_offset = matrix_unit,
		}),
		matrix_screen);
		GPU_matrix_push();
		GPU_matrix_mul(matrix_screen);

		GPUVertFormat *format = immVertexFormat();
		const uint pos_id = GPU_vertformat_attr_add(format, "pos", GPU_COMP_F32, 3, GPU_FETCH_FLOAT);
		const uint color_id = GPU_vertformat_attr_add(format, "color", GPU_COMP_F32, 4, GPU_FETCH_FLOAT);
		float viewport_size[4];
		GPU_viewport_size_get_f(viewport_size);

		static float axis_color[3][4];

#ifdef USE_AXIS_FONT
struct {		struct {
float matrix[4][4];		float matrix[4][4];
float matrix_m3[3][3];		float matrix_m3[3][3];
float matrix_m3_invert[3][3];		float matrix_m3_invert[3][3];
int id;		int id;
} font;		} font;

if (select == false) {		font.id = BLF_default();
font.id = blf_mono_font;
BLF_disable(font.id, BLF_ROTATION \| BLF_SHADOW \| BLF_MATRIX \| BLF_ASPECT \| BLF_WORD_WRAP);		BLF_disable(font.id, BLF_ROTATION \| BLF_SHADOW \| BLF_MATRIX \| BLF_ASPECT \| BLF_WORD_WRAP);
BLF_color4fv(font.id, axis_black);		BLF_enable(font.id, BLF_BOLD);
BLF_size(font.id, 12 * U.dpi_fac, 72);		BLF_size(font.id, AXIS_TEXT_SIZE, 72);

/* The view matrix is used to position the text. */
BLF_position(font.id, 0, 0, 0);		BLF_position(font.id, 0, 0, 0);

/* Calculate the inverse of the (matrix_final * matrix_offset).		/* Calculate the inverse of the (matrix_final * matrix_offset).
* This allows us to use the final location, while reversing the rotation so fonts		* This allows us to use the final location, while reversing the rotation so fonts
* show without any rotation. */		* show without any rotation. */
float m3[3][3];		float m3[3][3];
float m3_offset[3][3];		float m3_offset[3][3];
copy_m3_m4(m3, draw_info->matrix_final);		copy_m3_m4(m3, matrix_screen);
copy_m3_m4(m3_offset, gz->matrix_offset);		copy_m3_m4(m3_offset, gz->matrix_offset);
mul_m3_m3m3(m3, m3, m3_offset);		mul_m3_m3m3(m3, m3, m3_offset);
copy_m3_m3(font.matrix_m3_invert, m3);		copy_m3_m3(font.matrix_m3_invert, m3);
invert_m3(m3);		invert_m3(m3);
copy_m3_m3(font.matrix_m3, m3);		copy_m3_m3(font.matrix_m3, m3);
copy_m4_m3(font.matrix, m3);		copy_m4_m3(font.matrix, m3);
}
#endif

/* When the cursor is over any of the gizmos (show circle backdrop). */
const bool is_active = (color[3] != 0.0f);

const float clip_range = gz->scale_final * sphere_scale;		bool use_project_matrix = (gz->scale_final >= -GPU_MATRIX_ORTHO_CLIP_NEAR_DEFAULT);
bool use_project_matrix = (clip_range >= -GPU_MATRIX_ORTHO_CLIP_NEAR_DEFAULT);
if (use_project_matrix) {		if (use_project_matrix) {
GPU_matrix_push_projection();		GPU_matrix_push_projection();
GPU_matrix_ortho_set_z(-clip_range, clip_range);		GPU_matrix_ortho_set_z(-gz->scale_final, gz->scale_final);
}		}

UI_draw_roundbox_corner_set(UI_CNR_ALL);		UI_draw_roundbox_corner_set(UI_CNR_ALL);
GPU_polygon_smooth(false);		GPU_polygon_smooth(false);

/* Circle defining active area. */		/* Circle defining active area. */
if (is_active) {		if (is_active) {
immUnbindProgram();		const float rad = WIDGET_RADIUS;

float rad = widget_pix_size;
GPU_matrix_push();		GPU_matrix_push();
GPU_matrix_scale_1f(1.0f / rad);		GPU_matrix_scale_1f(1.0f / rad);
		UI_draw_roundbox_4fv(
UI_draw_roundbox_4fv(true, -rad, -rad, rad, rad, rad, color);		&(const rctf){
		.xmin = -rad,
		.xmax = rad,
		.ymin = -rad,
		.ymax = rad,
		},
		true,
		rad,
		gz->color_hi);
GPU_matrix_pop();		GPU_matrix_pop();

immBindBuiltinProgram(GPU_SHADER_3D_UNIFORM_COLOR);
}		}

GPU_matrix_push();
GPU_matrix_mul(gz->matrix_offset);		GPU_matrix_mul(gz->matrix_offset);

for (int axis_index = 0; axis_index < ARRAY_SIZE(axis_order); axis_index++) {		for (int axis_index = 0; axis_index < ARRAY_SIZE(axis_order); axis_index++) {
const int index = axis_order[axis_index].index;		const int index = axis_order[axis_index].index;
const int axis = axis_order[axis_index].axis;		const int axis = axis_order[axis_index].axis;
const bool is_pos = axis_order[axis_index].is_pos;		const bool is_pos = axis_order[axis_index].is_pos;
const bool is_highlight = index + 1 == gz->highlight_part;		const float depth = axis_order[axis_index].depth;
		const bool is_behind = (depth <= (AXIS_DEPTH_BIAS * (is_pos ? -1 : 1)));
		bool is_aligned_front = (axis_align != -1 && axis_align == axis && !is_behind);
		bool is_aligned_back = (axis_align != -1 && axis_align == axis && is_behind);

		const float v[3] = {0, 0, (1.0f - AXIS_HANDLE_SIZE) * (is_pos ? 1 : -1)};
		const float v_final[3] = {v[(axis + 2) % 3], v[(axis + 1) % 3], v[axis]};

		bool is_highlight = index + 1 == gz->highlight_part;
		/* Check if highlight part is the other side when axis aligned. */
		if (is_aligned_front && (axis_order[axis_index].axis_opposite + 1 == gz->highlight_part)) {
		is_highlight = true;
		}

UI_GetThemeColor3fv(TH_AXIS_X + axis, axis_color[axis]);		UI_GetThemeColor3fv(TH_AXIS_X + axis, axis_color[axis]);
axis_color[axis][3] = 1.0f;		axis_color[axis][3] = 1.0f;

const int index_z = axis;		/* Color that is full at front, but 50% view background when in back. */
const int index_y = (axis + 1) % 3;		float fading_color[4];
const int index_x = (axis + 2) % 3;		interp_v4_v4v4(fading_color, view_color, axis_color[axis], ((depth + 1) * 0.25) + 0.5);

bool ok = true;		/* Color that is midway between front and back. */
		float middle_color[4];
/* Skip view align axis when selecting (allows to switch to opposite side). */		interp_v4_v4v4(middle_color, view_color, axis_color[axis], 0.75f);
if (select && ((axis_align == axis) && (gz->matrix_offset[axis][2] > 0.0f) == is_pos)) {
ok = false;
}
if (ok) {
/* Check aligned, since the front axis won't display in this case,
* and we want to make sure all 3 axes have a character at all times. */
const bool show_axis_char = (is_pos \|\| (axis == axis_align));
const float v[3] = {0, 0, AXIS_HANDLE_OFFSET * (is_pos ? 1 : -1)};
const float v_final[3] = {v[index_x], v[index_y], v[index_z]};
const float *color_current = is_highlight ? axis_highlight : axis_color[axis];
float color_current_fade[4];

/* Flip the faded state when axis aligned, since we're hiding the front-mode axis
* otherwise we see the color for the back-most axis, which is useful for
* click-to-rotate 180d but not useful to visualize.
*
* Use depth bias so axis-aligned views show the positive axis as being in-front.
* This is a detail so primary axes show as dominant.
*/
const bool is_pos_color = (axis_order[axis_index].depth >
(axis_depth_bias * (is_pos ? -1 : 1)));

if (select == false) {
#ifdef USE_FADE_BACKGROUND
interp_v3_v3v3(
color_current_fade, draw_info->color_bg, color_current, is_highlight ? 1.0 : 0.5f);
color_current_fade[3] = color_current[3];
#else
copy_v4_v4(color_current_fade, color_current);
color_current_fade[3] *= 0.2;
#endif
}
else {
copy_v4_fl(color_current_fade, 1.0f);
}

/* Axis Line. */
if (is_pos) {
float v_start[3];
immUnbindProgram();

GPU_blend(GPU_BLEND_ALPHA);		GPU_blend(GPU_BLEND_ALPHA);

immBindBuiltinProgram(GPU_SHADER_3D_POLYLINE_UNIFORM_COLOR);		/* Axis Line. */
immUniform2fv("viewportSize", &viewport[2]);		if (is_pos \|\| axis_align != -1) {
immUniform1f("lineWidth", 2.0f * U.pixelsize);
immUniformColor4fv(is_pos_color ? color_current : color_current_fade);

		/* Extend slightly to meet better at the center. */
		float v_start[3] = {0.0f, 0.0f, 0.0f};
		mul_v3_v3fl(v_start, v_final, -(AXIS_LINE_WIDTH / WIDGET_RADIUS * 0.66f));

		/* Decrease length of line by ball radius. */
		float v_end[3] = {0.0f, 0.0f, 0.0f};
		mul_v3_v3fl(v_end, v_final, 1.0f - AXIS_HANDLE_SIZE);

		immBindBuiltinProgram(GPU_SHADER_3D_POLYLINE_SMOOTH_COLOR);
		immUniform2fv("viewportSize", &viewport_size[2]);
		immUniform1f("lineWidth", AXIS_LINE_WIDTH);
immBegin(GPU_PRIM_LINES, 2);		immBegin(GPU_PRIM_LINES, 2);
if (axis_align == -1) {		immAttr4fv(color_id, middle_color);
zero_v3(v_start);
}
else {
/* When axis aligned we don't draw the front most axis
* (allowing us to switch to the opposite side).
* In this case don't draw lines over axis pointing away from us
* because it obscures character and looks noisy.
*/
mul_v3_v3fl(v_start, v_final, 0.3f);
}
immVertex3fv(pos_id, v_start);		immVertex3fv(pos_id, v_start);
immVertex3fv(pos_id, v_final);		immAttr4fv(color_id, fading_color);
		immVertex3fv(pos_id, v_end);
immEnd();		immEnd();

immUnbindProgram();		immUnbindProgram();

immBindBuiltinProgram(GPU_SHADER_3D_UNIFORM_COLOR);
}		}

/* Axis Ball. */		/* Axis Ball. */
#ifdef USE_AXIS_FONT		if (!is_aligned_back) {
if (select == false) {		float *inner_color = fading_color;
immUnbindProgram();		float *outline_color = fading_color;
		float negative_color[4];
GPU_matrix_push();		if (!is_pos) {
GPU_matrix_translate_3fv(v_final);		if (is_aligned_front) {
GPU_matrix_mul(font.matrix);		interp_v4_v4v4(
		negative_color, (float[4]){1.0f, 1.0f, 1.0f, 1.0f}, axis_color[axis], 0.5f);
float rad = widget_pix_size * (is_pos ? AXIS_HANDLE_SIZE_FG : AXIS_HANDLE_SIZE_BG);		negative_color[3] = MIN2(depth + 1, 1.0f);
		outline_color = negative_color;
/* Black outlines for negative axis balls, otherwise they can be hard to see since
* they use a faded color which can be similar to the circle backdrop in tone. */
if (is_active && !is_highlight && !is_pos && !select && !(axis_align == axis)) {
static const float axis_black_faded[4] = {0.0f, 0.0f, 0.0f, 0.2f};
float outline = rad * sphere_scale;
UI_draw_roundbox_4fv(
true, -outline, -outline, outline, outline, outline, axis_black_faded);
}		}
		else {
const float *col = is_pos_color ? color_current : color_current_fade;		interp_v4_v4v4(negative_color, view_color, axis_color[axis], 0.25f);
UI_draw_roundbox_4fv(true, -rad, -rad, rad, rad, rad, col);		negative_color[3] = MIN2(depth + 1, 1.0f);
		inner_color = negative_color;
GPU_matrix_pop();

immBindBuiltinProgram(GPU_SHADER_3D_UNIFORM_COLOR);
}		}
else		}
#endif
{
GPU_matrix_push();		GPU_matrix_push();
GPU_matrix_translate_3fv(v_final);		GPU_matrix_translate_3fv(v_final);
GPU_matrix_scale_1f(is_pos ? AXIS_HANDLE_SIZE_FG : AXIS_HANDLE_SIZE_BG);		GPU_matrix_mul(font.matrix);
		/* Size change from back to front: 0.92f - 1.08f. */
GPUBatch *sphere = GPU_batch_preset_sphere(0);		float scale = ((depth + 1) * 0.08f) + 0.92f;
GPU_batch_program_set_builtin(sphere, GPU_SHADER_3D_UNIFORM_COLOR);		const float rad = WIDGET_RADIUS * AXIS_HANDLE_SIZE * scale;
		UI_draw_roundbox_4fv_ex(
/* Black outlines for negative axis balls, otherwise they can be hard to see since		&(const rctf){
* they use a faded color which can be similar to the circle backdrop in tone. */		.xmin = -rad,
if (is_active && !is_highlight && !is_pos && !select && !(axis_align == axis)) {		.xmax = rad,
static const float axis_black_faded[4] = {0, 0, 0, 0.2f};		.ymin = -rad,
GPU_matrix_scale_1f(sphere_scale);		.ymax = rad,
GPU_batch_uniform_4fv(sphere, "color", axis_black_faded);		},
GPU_batch_draw(sphere);		inner_color,
GPU_matrix_scale_1f(1.0 / sphere_scale);		NULL,
}		0.0f,
		outline_color,
GPU_batch_program_set_builtin(sphere, GPU_SHADER_3D_UNIFORM_COLOR);		AXIS_RING_WIDTH,
GPU_batch_uniform_4fv(sphere, "color", is_pos_color ? color_current : color_current_fade);		rad);
GPU_batch_draw(sphere);
GPU_matrix_pop();		GPU_matrix_pop();
}		}

/* Axis XYZ Character. */		/* Axis XYZ Character. */
if (show_axis_char && (select == false)) {		if ((is_pos \|\| is_highlight \|\| (axis == axis_align)) && !is_aligned_back) {
#ifdef USE_AXIS_FONT		float axis_str_width, axis_string_height;
float axis_str_size[2] = {0};		char axis_str[3] = {'X' + axis, 0, 0};
const char axis_str[2] = {'X' + axis, 0};		if (!is_pos) {
BLF_width_and_height(font.id, axis_str, 2, &axis_str_size[0], &axis_str_size[1]);		axis_str[0] = '-';
		axis_str[1] = 'X' + axis;
		}
		BLF_width_and_height(font.id, axis_str, 3, &axis_str_width, &axis_string_height);

/* Calculate pixel aligned location, without this text draws fuzzy. */		/* Calculate pixel-aligned location, without this text draws fuzzy. */
float v_final_px[3];		float v_final_px[3];
mul_v3_m3v3(v_final_px, font.matrix_m3_invert, v_final);		mul_v3_m3v3(v_final_px, font.matrix_m3_invert, v_final);
/* Center the test and pixel align, it's important to round once		/* Center the text and pixel align, it's important to round once
* otherwise the characters are noticeably not-centered.		* otherwise the characters are noticeably not-centered.
* If this wasn't an issue we could use #BLF_position to place the text. */		* If this wasn't an issue we could use #BLF_position to place the text. */
v_final_px[0] = roundf(v_final_px[0] - (axis_str_size[0] / 2.0f));		v_final_px[0] = roundf(v_final_px[0] - (axis_str_width * (is_pos ? 0.5f : 0.55f)));
v_final_px[1] = roundf(v_final_px[1] - (axis_str_size[1] / 2.0f));		v_final_px[1] = roundf(v_final_px[1] - (axis_string_height / 2.0f));
mul_m3_v3(font.matrix_m3, v_final_px);		mul_m3_v3(font.matrix_m3, v_final_px);

immUnbindProgram();

GPU_matrix_push();		GPU_matrix_push();
GPU_matrix_translate_3fv(v_final_px);		GPU_matrix_translate_3fv(v_final_px);
GPU_matrix_mul(font.matrix);		GPU_matrix_mul(font.matrix);
		float text_color[4] = {1.0f, 1.0f, 1.0f, 1.0f};
		if (!is_highlight) {
		zero_v4(text_color);
		text_color[3] = is_active ? 1.0f : 0.9f;
		}
		BLF_color4fv(font.id, text_color);
BLF_draw_ascii(font.id, axis_str, 2);		BLF_draw_ascii(font.id, axis_str, 2);
GPU_blend(GPU_BLEND_ALPHA); /* XXX, blf disables */
GPU_matrix_pop();		GPU_matrix_pop();

immBindBuiltinProgram(GPU_SHADER_3D_UNIFORM_COLOR);
#else
immUnbindProgram();
immBindBuiltinProgram(GPU_SHADER_3D_UNIFORM_COLOR);
GPU_line_width(1.0f);
float m3[3][3];
copy_m3_m4(m3, gz->matrix_offset);
immUniformColor4fv(axis_black);
draw_xyz_wire(pos_id, m3, v_final, 1.0, axis);
immUnbindProgram();
#endif
}		}
}		}
}

GPU_matrix_pop();
immUnbindProgram();

if (use_project_matrix) {		if (use_project_matrix) {
GPU_matrix_pop_projection();		GPU_matrix_pop_projection();
}		}
}

static void axis3d_draw_intern(const bContext *C,
wmGizmo *gz,
const bool select,
const bool highlight)
{
const float *color = highlight ? gz->color_hi : gz->color;
float matrix_final[4][4];
float matrix_unit[4][4];

unit_m4(matrix_unit);

WM_gizmo_calc_matrix_final_params(gz,
&((struct WM_GizmoMatrixParams){
.matrix_offset = matrix_unit,
}),
matrix_final);

GPU_matrix_push();
GPU_matrix_mul(matrix_final);

struct AxisDrawInfo draw_info;
#ifdef USE_AXIS_FONT
if (select == false) {
copy_m4_m4(draw_info.matrix_final, matrix_final);
}
#endif

#ifdef USE_FADE_BACKGROUND
if (select == false) {
ED_view3d_background_color_get(CTX_data_scene(C), CTX_wm_view3d(C), draw_info.color_bg);
}
#else
UNUSED_VARS(C);
#endif

GPU_blend(GPU_BLEND_ALPHA);
axis_geom_draw(gz, color, select, &draw_info);
GPU_blend(GPU_BLEND_NONE);		GPU_blend(GPU_BLEND_NONE);
		BLF_disable(font.id, BLF_BOLD);
GPU_matrix_pop();		GPU_matrix_pop();
}		}

static void gizmo_axis_draw(const bContext C, wmGizmo gz)
{
const bool is_modal = gz->state & WM_GIZMO_STATE_MODAL;
const bool is_highlight = (gz->state & WM_GIZMO_STATE_HIGHLIGHT) != 0;

(void)is_modal;

GPU_blend(GPU_BLEND_ALPHA);
axis3d_draw_intern(C, gz, false, is_highlight);
GPU_blend(GPU_BLEND_NONE);
}

static int gizmo_axis_test_select(bContext UNUSED(C), wmGizmo gz, const int mval[2])		static int gizmo_axis_test_select(bContext UNUSED(C), wmGizmo gz, const int mval[2])
{		{
float point_local[2] = {UNPACK2(mval)};		float point_local[2] = {UNPACK2(mval)};
sub_v2_v2(point_local, gz->matrix_basis[3]);		sub_v2_v2(point_local, gz->matrix_basis[3]);
mul_v2_fl(point_local, 1.0f / gz->scale_final);		mul_v2_fl(point_local, 1.0f / gz->scale_final);

const float len_sq = len_squared_v2(point_local);		const float len_sq = len_squared_v2(point_local);
if (len_sq > 1.0) {		if (len_sq > 1.0) {
Show All 37 Lines	static int gizmo_axis_test_select(bContext UNUSED(C), wmGizmo gz, const int mval[2])
/* The 'gz->scale_final' is already applied when projecting. */		/* The 'gz->scale_final' is already applied when projecting. */
if (len_sq < 1.0f) {		if (len_sq < 1.0f) {
return 0;		return 0;
}		}

return -1;		return -1;
}		}

static int gizmo_axis_cursor_get(wmGizmo *gz)		static int gizmo_axis_cursor_get(wmGizmo *UNUSED(gz))
{		{
if (gz->highlight_part > 0) {		return WM_CURSOR_DEFAULT;
return WM_CURSOR_EDIT;
}		}
return WM_CURSOR_NSEW_SCROLL;
		static void gizmo_axis_screen_bounds_get(bContext C, wmGizmo gz, rcti *r_bounding_box)
		{
		ScrArea *area = CTX_wm_area(C);
		const float rad = WIDGET_RADIUS;
		r_bounding_box->xmin = gz->matrix_basis[3][0] + area->totrct.xmin - rad;
		r_bounding_box->ymin = gz->matrix_basis[3][1] + area->totrct.ymin - rad;
		r_bounding_box->xmax = r_bounding_box->xmin + rad;
		r_bounding_box->ymax = r_bounding_box->ymin + rad;
}		}

void VIEW3D_GT_navigate_rotate(wmGizmoType *gzt)		void VIEW3D_GT_navigate_rotate(wmGizmoType *gzt)
{		{
/* identifiers */		/* identifiers */
gzt->idname = "VIEW3D_GT_navigate_rotate";		gzt->idname = "VIEW3D_GT_navigate_rotate";

/* api callbacks */		/* api callbacks */
gzt->draw = gizmo_axis_draw;		gzt->draw = gizmo_axis_draw;
gzt->test_select = gizmo_axis_test_select;		gzt->test_select = gizmo_axis_test_select;
gzt->cursor_get = gizmo_axis_cursor_get;		gzt->cursor_get = gizmo_axis_cursor_get;
		gzt->screen_bounds_get = gizmo_axis_screen_bounds_get;

gzt->struct_size = sizeof(wmGizmo);		gzt->struct_size = sizeof(wmGizmo);
}		}