Draw Manager: Remove unused function
Signed-off-by: fclem
This commit is contained in:
parent
ffbe5985c6
commit
44f04b5f53
|
|
@ -77,486 +77,6 @@ void DRW_draw_region_info(void)
|
|||
}
|
||||
}
|
||||
|
||||
/* ************************* Grid ************************** */
|
||||
|
||||
static void gridline_range(double x0, double dx, double max, int *r_first, int *r_len)
|
||||
{
|
||||
/* determine range of gridlines that appear in this Area -- similar calc but separate ranges for x & y
|
||||
* x0 is gridline 0, the axis in screen space
|
||||
* Area covers [0 .. max) pixels */
|
||||
|
||||
int first = (int)ceil(-x0 / dx);
|
||||
int last = (int)floor((max - x0) / dx);
|
||||
|
||||
if (first <= last) {
|
||||
*r_first = first;
|
||||
*r_len = last - first + 1;
|
||||
}
|
||||
else {
|
||||
*r_first = 0;
|
||||
*r_len = 0;
|
||||
}
|
||||
}
|
||||
|
||||
static int gridline_count(ARegion *ar, double x0, double y0, double dx)
|
||||
{
|
||||
/* x0 & y0 establish the "phase" of the grid within this 2D region
|
||||
* dx is the frequency, shared by x & y directions
|
||||
* pass in dx of smallest (highest precision) grid we want to draw */
|
||||
|
||||
int first, x_len, y_len;
|
||||
|
||||
gridline_range(x0, dx, ar->winx, &first, &x_len);
|
||||
gridline_range(y0, dx, ar->winy, &first, &y_len);
|
||||
|
||||
int total_len = x_len + y_len;
|
||||
|
||||
return total_len;
|
||||
}
|
||||
|
||||
static bool drawgrid_draw(
|
||||
ARegion *ar, double x0, double y0, double dx, int skip_mod,
|
||||
uint pos, uint col, GLubyte col_value[3])
|
||||
{
|
||||
/* skip every skip_mod lines relative to each axis; they will be overlaid by another drawgrid_draw
|
||||
* always skip exact x0 & y0 axes; they will be drawn later in color
|
||||
*
|
||||
* set grid color once, just before the first line is drawn
|
||||
* it's harmless to set same color for every line, or every vertex
|
||||
* but if no lines are drawn, color must not be set! */
|
||||
|
||||
const float x_max = (float)ar->winx;
|
||||
const float y_max = (float)ar->winy;
|
||||
|
||||
int first, ct;
|
||||
int x_len = 0, y_len = 0; /* count of lines actually drawn */
|
||||
int lines_skipped_for_next_unit = 0;
|
||||
|
||||
/* draw vertical lines */
|
||||
gridline_range(x0, dx, x_max, &first, &ct);
|
||||
|
||||
for (int i = first; i < first + ct; ++i) {
|
||||
if (i == 0)
|
||||
continue;
|
||||
else if (skip_mod && (i % skip_mod) == 0) {
|
||||
++lines_skipped_for_next_unit;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (x_len == 0)
|
||||
immAttrib3ub(col, col_value[0], col_value[1], col_value[2]);
|
||||
|
||||
float x = (float)(x0 + i * dx);
|
||||
immVertex2f(pos, x, 0.0f);
|
||||
immVertex2f(pos, x, y_max);
|
||||
++x_len;
|
||||
}
|
||||
|
||||
/* draw horizontal lines */
|
||||
gridline_range(y0, dx, y_max, &first, &ct);
|
||||
|
||||
for (int i = first; i < first + ct; ++i) {
|
||||
if (i == 0)
|
||||
continue;
|
||||
else if (skip_mod && (i % skip_mod) == 0) {
|
||||
++lines_skipped_for_next_unit;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (x_len + y_len == 0)
|
||||
immAttrib3ub(col, col_value[0], col_value[1], col_value[2]);
|
||||
|
||||
float y = (float)(y0 + i * dx);
|
||||
immVertex2f(pos, 0.0f, y);
|
||||
immVertex2f(pos, x_max, y);
|
||||
++y_len;
|
||||
}
|
||||
|
||||
return lines_skipped_for_next_unit > 0;
|
||||
}
|
||||
|
||||
#define GRID_MIN_PX_D 6.0
|
||||
#define GRID_MIN_PX_F 6.0f
|
||||
|
||||
static void drawgrid(UnitSettings *unit, ARegion *ar, View3D *v3d, const char **grid_unit)
|
||||
{
|
||||
RegionView3D *rv3d = ar->regiondata;
|
||||
|
||||
double fx = rv3d->persmat[3][0];
|
||||
double fy = rv3d->persmat[3][1];
|
||||
double fw = rv3d->persmat[3][3];
|
||||
|
||||
const double wx = 0.5 * ar->winx; /* use double precision to avoid rounding errors */
|
||||
const double wy = 0.5 * ar->winy;
|
||||
|
||||
double x = wx * fx / fw;
|
||||
double y = wy * fy / fw;
|
||||
|
||||
double vec4[4] = { v3d->grid, v3d->grid, 0.0, 1.0 };
|
||||
mul_m4_v4d(rv3d->persmat, vec4);
|
||||
fx = vec4[0];
|
||||
fy = vec4[1];
|
||||
fw = vec4[3];
|
||||
|
||||
double dx = fabs(x - wx * fx / fw);
|
||||
if (dx == 0) dx = fabs(y - wy * fy / fw);
|
||||
|
||||
x += wx;
|
||||
y += wy;
|
||||
|
||||
/* now x, y, and dx have their final values
|
||||
* (x,y) is the world origin (0,0,0) mapped to Area-relative screen space
|
||||
* dx is the distance in pixels between grid lines -- same for horiz or vert grid lines */
|
||||
|
||||
glLineWidth(1.0f);
|
||||
|
||||
#if 0 /* TODO: write to UI/widget depth buffer, not scene depth */
|
||||
glDepthMask(GL_FALSE); /* disable write in zbuffer */
|
||||
#endif
|
||||
|
||||
GPUVertFormat *format = immVertexFormat();
|
||||
uint pos = GPU_vertformat_attr_add(format, "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
|
||||
uint color = GPU_vertformat_attr_add(format, "color", GPU_COMP_U8, 3, GPU_FETCH_INT_TO_FLOAT_UNIT);
|
||||
|
||||
immBindBuiltinProgram(GPU_SHADER_2D_FLAT_COLOR);
|
||||
|
||||
uchar col[3], col2[3];
|
||||
UI_GetThemeColor3ubv(TH_GRID, col);
|
||||
|
||||
if (unit->system) {
|
||||
const void *usys;
|
||||
int len;
|
||||
|
||||
bUnit_GetSystem(unit->system, B_UNIT_LENGTH, &usys, &len);
|
||||
|
||||
bool first = true;
|
||||
|
||||
if (usys) {
|
||||
int i = len;
|
||||
while (i--) {
|
||||
double scalar = bUnit_GetScaler(usys, i);
|
||||
|
||||
double dx_scalar = dx * scalar / (double)unit->scale_length;
|
||||
if (dx_scalar < (GRID_MIN_PX_D * 2.0)) {
|
||||
/* very very small grid items are less useful when dealing with units */
|
||||
continue;
|
||||
}
|
||||
|
||||
if (first) {
|
||||
first = false;
|
||||
|
||||
/* Store the smallest drawn grid size units name so users know how big each grid cell is */
|
||||
*grid_unit = bUnit_GetNameDisplay(usys, i);
|
||||
rv3d->gridview = (float)((scalar * (double)v3d->grid) / (double)unit->scale_length);
|
||||
|
||||
int gridline_len = gridline_count(ar, x, y, dx_scalar);
|
||||
if (gridline_len == 0)
|
||||
goto drawgrid_cleanup; /* nothing to draw */
|
||||
|
||||
immBegin(GPU_PRIM_LINES, gridline_len * 2);
|
||||
}
|
||||
|
||||
float blend_fac = 1.0f - ((GRID_MIN_PX_F * 2.0f) / (float)dx_scalar);
|
||||
/* tweak to have the fade a bit nicer */
|
||||
blend_fac = (blend_fac * blend_fac) * 2.0f;
|
||||
CLAMP(blend_fac, 0.3f, 1.0f);
|
||||
|
||||
UI_GetThemeColorBlend3ubv(TH_HIGH_GRAD, TH_GRID, blend_fac, col2);
|
||||
|
||||
const int skip_mod = (i == 0) ? 0 : (int)round(bUnit_GetScaler(usys, i - 1) / scalar);
|
||||
if (!drawgrid_draw(ar, x, y, dx_scalar, skip_mod, pos, color, col2))
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
const double sublines = v3d->gridsubdiv;
|
||||
const float sublines_fl = v3d->gridsubdiv;
|
||||
|
||||
int grids_to_draw = 2; /* first the faint fine grid, then the bold coarse grid */
|
||||
|
||||
if (dx < GRID_MIN_PX_D) {
|
||||
rv3d->gridview *= sublines_fl;
|
||||
dx *= sublines;
|
||||
if (dx < GRID_MIN_PX_D) {
|
||||
rv3d->gridview *= sublines_fl;
|
||||
dx *= sublines;
|
||||
if (dx < GRID_MIN_PX_D) {
|
||||
rv3d->gridview *= sublines_fl;
|
||||
dx *= sublines;
|
||||
grids_to_draw = (dx < GRID_MIN_PX_D) ? 0 : 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
if (dx > (GRID_MIN_PX_D * 10.0)) { /* start blending in */
|
||||
rv3d->gridview /= sublines_fl;
|
||||
dx /= sublines;
|
||||
if (dx > (GRID_MIN_PX_D * 10.0)) { /* start blending in */
|
||||
rv3d->gridview /= sublines_fl;
|
||||
dx /= sublines;
|
||||
if (dx > (GRID_MIN_PX_D * 10.0)) {
|
||||
grids_to_draw = 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int gridline_len = gridline_count(ar, x, y, dx);
|
||||
if (gridline_len == 0)
|
||||
goto drawgrid_cleanup; /* nothing to draw */
|
||||
|
||||
immBegin(GPU_PRIM_LINES, gridline_len * 2);
|
||||
|
||||
if (grids_to_draw == 2) {
|
||||
UI_GetThemeColorBlend3ubv(TH_HIGH_GRAD, TH_GRID, dx / (GRID_MIN_PX_D * 6.0), col2);
|
||||
if (drawgrid_draw(ar, x, y, dx, v3d->gridsubdiv, pos, color, col2)) {
|
||||
drawgrid_draw(ar, x, y, dx * sublines, 0, pos, color, col);
|
||||
}
|
||||
}
|
||||
else if (grids_to_draw == 1) {
|
||||
drawgrid_draw(ar, x, y, dx, 0, pos, color, col);
|
||||
}
|
||||
}
|
||||
|
||||
/* draw visible axes */
|
||||
/* horizontal line */
|
||||
if (0 <= y && y < ar->winy) {
|
||||
UI_make_axis_color(col, col2, ELEM(rv3d->view, RV3D_VIEW_RIGHT, RV3D_VIEW_LEFT) ? 'Y' : 'X');
|
||||
immAttrib3ub(color, col2[0], col2[1], col2[2]);
|
||||
immVertex2f(pos, 0.0f, y);
|
||||
immVertex2f(pos, (float)ar->winx, y);
|
||||
}
|
||||
|
||||
/* vertical line */
|
||||
if (0 <= x && x < ar->winx) {
|
||||
UI_make_axis_color(col, col2, ELEM(rv3d->view, RV3D_VIEW_TOP, RV3D_VIEW_BOTTOM) ? 'Y' : 'Z');
|
||||
immAttrib3ub(color, col2[0], col2[1], col2[2]);
|
||||
immVertex2f(pos, x, 0.0f);
|
||||
immVertex2f(pos, x, (float)ar->winy);
|
||||
}
|
||||
|
||||
immEnd();
|
||||
|
||||
drawgrid_cleanup:
|
||||
immUnbindProgram();
|
||||
|
||||
#if 0 /* depth write is left enabled above */
|
||||
glDepthMask(GL_TRUE); /* enable write in zbuffer */
|
||||
#endif
|
||||
}
|
||||
|
||||
#undef DEBUG_GRID
|
||||
#undef GRID_MIN_PX_D
|
||||
#undef GRID_MIN_PX_F
|
||||
|
||||
static void drawfloor(Scene *scene, View3D *v3d, const char **grid_unit)
|
||||
{
|
||||
/* draw only if there is something to draw */
|
||||
if (v3d->gridflag & (V3D_SHOW_FLOOR | V3D_SHOW_X | V3D_SHOW_Y | V3D_SHOW_Z)) {
|
||||
/* draw how many lines?
|
||||
* trunc(v3d->gridlines / 2) * 4
|
||||
* + 2 for xy axes (possibly with special colors)
|
||||
* + 1 for z axis (the only line not in xy plane)
|
||||
* even v3d->gridlines are honored, odd rounded down */
|
||||
const int gridlines = v3d->gridlines / 2;
|
||||
const float grid_scale = ED_view3d_grid_scale(scene, v3d, grid_unit);
|
||||
const float grid = gridlines * grid_scale;
|
||||
|
||||
const bool show_floor = (v3d->gridflag & V3D_SHOW_FLOOR) && gridlines >= 1;
|
||||
|
||||
bool show_axis_x = (v3d->gridflag & V3D_SHOW_X) != 0;
|
||||
bool show_axis_y = (v3d->gridflag & V3D_SHOW_Y) != 0;
|
||||
bool show_axis_z = (v3d->gridflag & V3D_SHOW_Z) != 0;
|
||||
|
||||
uchar col_grid[3], col_axis[3];
|
||||
|
||||
glLineWidth(1.0f);
|
||||
|
||||
UI_GetThemeColor3ubv(TH_GRID, col_grid);
|
||||
|
||||
if (show_floor) {
|
||||
const uint vertex_len = 2 * (gridlines * 4 + 2);
|
||||
const int sublines = v3d->gridsubdiv;
|
||||
|
||||
uchar col_bg[3], col_grid_emphasise[3], col_grid_light[3];
|
||||
|
||||
GPUVertFormat *format = immVertexFormat();
|
||||
uint pos = GPU_vertformat_attr_add(format, "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
|
||||
uint color = GPU_vertformat_attr_add(format, "color", GPU_COMP_U8, 3, GPU_FETCH_INT_TO_FLOAT_UNIT);
|
||||
|
||||
immBindBuiltinProgram(GPU_SHADER_3D_FLAT_COLOR);
|
||||
|
||||
immBegin(GPU_PRIM_LINES, vertex_len);
|
||||
|
||||
/* draw normal grid lines */
|
||||
UI_GetColorPtrShade3ubv(col_grid, col_grid_light, 10);
|
||||
|
||||
for (int a = 1; a <= gridlines; a++) {
|
||||
/* skip emphasised divider lines */
|
||||
if (a % sublines != 0) {
|
||||
const float line = a * grid_scale;
|
||||
|
||||
immAttrib3ubv(color, col_grid_light);
|
||||
|
||||
immVertex2f(pos, -grid, -line);
|
||||
immVertex2f(pos, +grid, -line);
|
||||
immVertex2f(pos, -grid, +line);
|
||||
immVertex2f(pos, +grid, +line);
|
||||
|
||||
immVertex2f(pos, -line, -grid);
|
||||
immVertex2f(pos, -line, +grid);
|
||||
immVertex2f(pos, +line, -grid);
|
||||
immVertex2f(pos, +line, +grid);
|
||||
}
|
||||
}
|
||||
|
||||
/* draw emphasised grid lines */
|
||||
UI_GetThemeColor3ubv(TH_BACK, col_bg);
|
||||
/* emphasise division lines lighter instead of darker, if background is darker than grid */
|
||||
UI_GetColorPtrShade3ubv(col_grid, col_grid_emphasise,
|
||||
(col_grid[0] + col_grid[1] + col_grid[2] + 30 >
|
||||
col_bg[0] + col_bg[1] + col_bg[2]) ? 20 : -10);
|
||||
|
||||
if (sublines <= gridlines) {
|
||||
immAttrib3ubv(color, col_grid_emphasise);
|
||||
|
||||
for (int a = sublines; a <= gridlines; a += sublines) {
|
||||
const float line = a * grid_scale;
|
||||
|
||||
immVertex2f(pos, -grid, -line);
|
||||
immVertex2f(pos, +grid, -line);
|
||||
immVertex2f(pos, -grid, +line);
|
||||
immVertex2f(pos, +grid, +line);
|
||||
|
||||
immVertex2f(pos, -line, -grid);
|
||||
immVertex2f(pos, -line, +grid);
|
||||
immVertex2f(pos, +line, -grid);
|
||||
immVertex2f(pos, +line, +grid);
|
||||
}
|
||||
}
|
||||
|
||||
/* draw X axis */
|
||||
if (show_axis_x) {
|
||||
show_axis_x = false; /* drawing now, won't need to draw later */
|
||||
UI_make_axis_color(col_grid, col_axis, 'X');
|
||||
immAttrib3ubv(color, col_axis);
|
||||
}
|
||||
else
|
||||
immAttrib3ubv(color, col_grid_emphasise);
|
||||
|
||||
immVertex2f(pos, -grid, 0.0f);
|
||||
immVertex2f(pos, +grid, 0.0f);
|
||||
|
||||
/* draw Y axis */
|
||||
if (show_axis_y) {
|
||||
show_axis_y = false; /* drawing now, won't need to draw later */
|
||||
UI_make_axis_color(col_grid, col_axis, 'Y');
|
||||
immAttrib3ubv(color, col_axis);
|
||||
}
|
||||
else
|
||||
immAttrib3ubv(color, col_grid_emphasise);
|
||||
|
||||
immVertex2f(pos, 0.0f, -grid);
|
||||
immVertex2f(pos, 0.0f, +grid);
|
||||
|
||||
immEnd();
|
||||
immUnbindProgram();
|
||||
|
||||
/* done with XY plane */
|
||||
}
|
||||
|
||||
if (show_axis_x || show_axis_y || show_axis_z) {
|
||||
/* draw axis lines -- sometimes grid floor is off, other times we still need to draw the Z axis */
|
||||
|
||||
GPUVertFormat *format = immVertexFormat();
|
||||
uint pos = GPU_vertformat_attr_add(format, "pos", GPU_COMP_F32, 3, GPU_FETCH_FLOAT);
|
||||
uint color = GPU_vertformat_attr_add(format, "color", GPU_COMP_U8, 3, GPU_FETCH_INT_TO_FLOAT_UNIT);
|
||||
|
||||
immBindBuiltinProgram(GPU_SHADER_3D_FLAT_COLOR);
|
||||
immBegin(GPU_PRIM_LINES, (show_axis_x + show_axis_y + show_axis_z) * 2);
|
||||
|
||||
if (show_axis_x) {
|
||||
UI_make_axis_color(col_grid, col_axis, 'X');
|
||||
immAttrib3ubv(color, col_axis);
|
||||
immVertex3f(pos, -grid, 0.0f, 0.0f);
|
||||
immVertex3f(pos, +grid, 0.0f, 0.0f);
|
||||
}
|
||||
|
||||
if (show_axis_y) {
|
||||
UI_make_axis_color(col_grid, col_axis, 'Y');
|
||||
immAttrib3ubv(color, col_axis);
|
||||
immVertex3f(pos, 0.0f, -grid, 0.0f);
|
||||
immVertex3f(pos, 0.0f, +grid, 0.0f);
|
||||
}
|
||||
|
||||
if (show_axis_z) {
|
||||
UI_make_axis_color(col_grid, col_axis, 'Z');
|
||||
immAttrib3ubv(color, col_axis);
|
||||
immVertex3f(pos, 0.0f, 0.0f, -grid);
|
||||
immVertex3f(pos, 0.0f, 0.0f, +grid);
|
||||
}
|
||||
|
||||
immEnd();
|
||||
immUnbindProgram();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void DRW_draw_grid(void)
|
||||
{
|
||||
/* TODO viewport
|
||||
* Missing is the flags to check whether to draw it
|
||||
* for now now we are using the flags in v3d itself.
|
||||
*
|
||||
* Also for now always assume depth is there, so we
|
||||
* draw on top of it.
|
||||
*/
|
||||
/**
|
||||
* Calculate pixel-size factor once, is used for lamps and object centers.
|
||||
* Used by #ED_view3d_pixel_size and typically not accessed directly.
|
||||
*
|
||||
* \note #BKE_camera_params_compute_viewplane' also calculates a pixel-size value,
|
||||
* passed to #RE_SetPixelSize, in ortho mode this is compatible with this value,
|
||||
* but in perspective mode its offset by the near-clip.
|
||||
*
|
||||
* 'RegionView3D.pixsize' is used for viewport drawing, not rendering.
|
||||
*/
|
||||
const DRWContextState *draw_ctx = DRW_context_state_get();
|
||||
Scene *scene = draw_ctx->scene;
|
||||
View3D *v3d = draw_ctx->v3d;
|
||||
ARegion *ar = draw_ctx->ar;
|
||||
RegionView3D *rv3d = draw_ctx->rv3d;
|
||||
|
||||
const bool draw_floor = (rv3d->view == RV3D_VIEW_USER) || (rv3d->persp != RV3D_ORTHO);
|
||||
const char *grid_unit = NULL;
|
||||
|
||||
/* ortho grid goes first, does not write to depth buffer and doesn't need depth test so it will override
|
||||
* objects if done last
|
||||
* needs to be done always, gridview is adjusted in drawgrid() now, but only for ortho views.
|
||||
*/
|
||||
rv3d->gridview = ED_view3d_grid_scale(scene, v3d, &grid_unit);
|
||||
|
||||
glEnable(GL_DEPTH_TEST);
|
||||
glDepthFunc(GL_LESS);
|
||||
|
||||
if (!draw_floor) {
|
||||
/* Do not get in front of overlays */
|
||||
glDepthMask(GL_FALSE);
|
||||
|
||||
ED_region_pixelspace(ar);
|
||||
*(&grid_unit) = NULL; /* drawgrid need this to detect/affect smallest valid unit... */
|
||||
drawgrid(&scene->unit, ar, v3d, &grid_unit);
|
||||
|
||||
GPU_matrix_projection_set(rv3d->winmat);
|
||||
GPU_matrix_set(rv3d->viewmat);
|
||||
}
|
||||
else {
|
||||
glDepthMask(GL_TRUE);
|
||||
drawfloor(scene, v3d, &grid_unit);
|
||||
}
|
||||
}
|
||||
|
||||
/* ************************* Background ************************** */
|
||||
|
||||
void DRW_draw_background(void)
|
||||
|
|
|
|||
|
|
@ -26,7 +26,6 @@
|
|||
#ifndef __DRAW_VIEW_H__
|
||||
#define __DRAW_VIEW_H__
|
||||
|
||||
void DRW_draw_grid(void);
|
||||
void DRW_draw_region_info(void);
|
||||
void DRW_draw_background(void);
|
||||
void DRW_draw_cursor(void);
|
||||
|
|
|
|||
Loading…
Reference in New Issue