static void
glw_cursor_render(glw_t *w, const glw_rctx_t *rc)
{
glw_root_t *gr = w->glw_root;
glw_cursor_t *gc = (glw_cursor_t *)w;
glw_rctx_t rc0;
int zmax = 0;
glw_t *c;
Mtx saved;
if(w->glw_alpha < 0.01)
return;
c = TAILQ_FIRST(&w->glw_childs);
if(c == NULL)
return;
glw_mtx_copy(saved, rc->rc_mtx);
rc0 = *rc;
rc0.rc_zmax = &zmax;
gc->gc_hover_set = 0;
glw_t *saved_cursor = gr->gr_current_cursor;
void (*saved_focus_tracker)(struct glw *w, const struct glw_rctx *rc,
struct glw *cursor) =
gr->gr_cursor_focus_tracker;
gr->gr_cursor_focus_tracker = glw_cursor_focus_tracker;
gr->gr_current_cursor = w;
glw_render0(c, &rc0);
gr->gr_cursor_focus_tracker = saved_focus_tracker;
gr->gr_current_cursor = saved_cursor;
glw_zinc(&rc0);
c = TAILQ_NEXT(c, glw_parent_link);
if(c != NULL) {
render_focus_widget(c, gc, saved, &rc0, rc, &zmax);
if(!gr->gr_keyboard_mode) {
c = TAILQ_NEXT(c, glw_parent_link);
if(c != NULL) {
render_hover_widget(c, gc, &rc0, rc, &zmax);
}
}
}
*rc->rc_zmax = MAX(*rc->rc_zmax, zmax);
}
static void
shader_render_delayed(struct glw_root *root,
const Mtx m,
const struct glw_backend_texture *t0,
const struct glw_backend_texture *t1,
const struct glw_rgb *rgb_mul,
const struct glw_rgb *rgb_off,
float alpha, float blur,
const float *vertices,
int num_vertices,
const uint16_t *indices,
int num_triangles,
int flags,
glw_program_t *p,
const glw_rctx_t *rc)
{
glw_backend_root_t *gbr = &root->gr_be;
if(gbr->gbr_num_render_jobs >= gbr->gbr_render_jobs_capacity) {
// Need more space
gbr->gbr_render_jobs_capacity = 100 + gbr->gbr_render_jobs_capacity * 2;
gbr->gbr_render_jobs = realloc(gbr->gbr_render_jobs,
sizeof(render_job_t) *
gbr->gbr_render_jobs_capacity);
}
struct render_job *rj = gbr->gbr_render_jobs + gbr->gbr_num_render_jobs;
if(m == NULL) {
rj->eyespace = 1;
} else {
rj->eyespace = 0;
glw_mtx_copy(rj->m, m);
}
rj->width = rc->rc_width;
rj->height = rc->rc_height;
rj->up = p;
rj->t0 = t0;
rj->t1 = t1;
switch(gbr->gbr_blendmode) {
case GLW_BLEND_NORMAL:
rj->rgb_mul = *rgb_mul;
rj->alpha = alpha;
break;
case GLW_BLEND_ADDITIVE:
rj->rgb_mul.r = rgb_mul->r * alpha;
rj->rgb_mul.g = rgb_mul->g * alpha;
rj->rgb_mul.b = rgb_mul->b * alpha;
rj->alpha = 1;
break;
}
if(rgb_off != NULL) {
rj->rgb_off = *rgb_off;
flags |= GLW_RENDER_COLOR_OFFSET;
} else {
rj->rgb_off.r = 0;
rj->rgb_off.g = 0;
rj->rgb_off.b = 0;
}
rj->blur = blur;
rj->blendmode = gbr->gbr_blendmode;
rj->frontface = gbr->gbr_frontface;
int vnum = indices ? num_triangles * 3 : num_vertices;
if(gbr->gbr_vertex_offset + vnum > gbr->gbr_vertex_buffer_capacity) {
gbr->gbr_vertex_buffer_capacity = 100 + vnum +
gbr->gbr_vertex_buffer_capacity * 2;
gbr->gbr_vertex_buffer = realloc(gbr->gbr_vertex_buffer,
sizeof(float) * VERTEX_SIZE *
gbr->gbr_vertex_buffer_capacity);
}
float *vdst = gbr->gbr_vertex_buffer + gbr->gbr_vertex_offset * VERTEX_SIZE;
if(indices != NULL) {
int i;
for(i = 0; i < num_triangles * 3; i++) {
const float *v = &vertices[indices[i] * VERTEX_SIZE];
memcpy(vdst, v, VERTEX_SIZE * sizeof(float));
vdst += VERTEX_SIZE;
}
} else {
memcpy(vdst, vertices, num_vertices * VERTEX_SIZE * sizeof(float));
}
rj->flags = flags;
rj->vertex_offset = gbr->gbr_vertex_offset;
rj->num_vertices = vnum;
gbr->gbr_vertex_offset += vnum;
gbr->gbr_num_render_jobs++;
}
static void
render_focus_widget(glw_t *w, glw_cursor_t *gc, Mtx saved,
glw_rctx_t *rc0, const glw_rctx_t *rc,
int *zmax)
{
glw_root_t *gr = w->glw_root;
if(!(gc->w.glw_flags & GLW_IN_FOCUS_PATH))
return;
glw_t *f = gr->gr_current_focus;
if(f->glw_matrix != NULL) {
Mtx a_inv;
glw_mtx_invert(a_inv, saved);
Mtx *b = f->glw_matrix;
if(0) {
glw_rect_t focus_rect;
glw_project_matrix(&focus_rect, *b, gr);
printf("Current focus: %d,%d - %d,%d\n",
focus_rect.x1, focus_rect.y1,
focus_rect.x2, focus_rect.y2);
}
Mtx x;
glw_mtx_mul(x, a_inv, *b);
if (!gc->gc_initialized) {
glw_mtx_copy(gc->gc_mtx, x);
gc->gc_initialized = 1;
} else {
for(int i = 0; i < 16; i++) {
glw_lp(&gc->gc_mtx[i], gr, x[i], 0.75);
/* printf("%2.3f%c", gc->gc_mtx[i], (i+1) & 3 ? '\t' : '\n'); */
}
}
glw_mtx_mul(gc->gc_cursor_rctx.rc_mtx, saved, gc->gc_mtx);
}
glw_rect_t cursor_rect;
glw_project(&cursor_rect, &gc->gc_cursor_rctx, gr);
gc->gc_cursor_rctx.rc_width = cursor_rect.x2 - cursor_rect.x1;
gc->gc_cursor_rctx.rc_height = cursor_rect.y2 - cursor_rect.y1;
if(gc->gc_cursor_rctx.rc_width <= 0)
return;
if(gc->gc_cursor_rctx.rc_height <= 0)
return;
gc->gc_cursor_rctx.rc_alpha = 1.0f;
gc->gc_cursor_rctx.rc_sharpness = 1.0f;
glw_layout0(w, &gc->gc_cursor_rctx);
rc0->rc_zindex = MAX(*zmax, rc->rc_zindex);
gc->gc_cursor_rctx.rc_zmax = rc0->rc_zmax;
gc->gc_cursor_rctx.rc_zindex = rc0->rc_zindex;
glw_render0(w, &gc->gc_cursor_rctx);
}
