void
glw_scroll_layout(glw_scroll_control_t *gsc, glw_t *w, int height)
{
const int max_value =
MAX(0, gsc->total_size - gsc->page_size + gsc->scroll_threshold_post);
if(w->glw_root->gr_pointer_grab == w) {
gsc->filtered_pos = gsc->target_pos;
gsc->filtered_pos = GLW_CLAMP(gsc->filtered_pos, 0, max_value);
} else if(gsc->kinetic_scroll) {
gsc->filtered_pos += gsc->kinetic_scroll;
gsc->target_pos = gsc->filtered_pos;
gsc->kinetic_scroll *= 0.95;
gsc->filtered_pos = GLW_CLAMP(gsc->filtered_pos, 0, max_value);
} else {
gsc->target_pos = GLW_CLAMP(gsc->target_pos, 0, max_value);
if(fabsf(gsc->target_pos - gsc->filtered_pos) > height * 2) {
gsc->filtered_pos = gsc->target_pos;
} else {
glw_lp(&gsc->filtered_pos, w->glw_root, gsc->target_pos, 0.25);
}
}
gsc->rounded_pos = gsc->filtered_pos;
}
static void
glw_slider_layout(glw_t *w, const glw_rctx_t *rc)
{
glw_slider_t *s = (glw_slider_t *)w;
glw_t *c;
glw_rctx_t rc0;
int f;
if((c = TAILQ_FIRST(&w->glw_childs)) == NULL ||
rc->rc_width == 0 || rc->rc_height == 0)
return;
f = glw_filter_constraints(c);
if(s->fixed_knob_size) {
if(w->glw_class == &glw_slider_x) {
s->knob_size_px = s->knob_size_fixed * rc->rc_width;
} else {
s->knob_size_px = s->knob_size_fixed * rc->rc_height;
}
} else if(f & GLW_CONSTRAINT_X && w->glw_class == &glw_slider_x) {
s->knob_size_px = c->glw_req_size_x;
} else if(f & GLW_CONSTRAINT_Y && w->glw_class == &glw_slider_y) {
s->knob_size_px = c->glw_req_size_y;
} else if(w->glw_class == &glw_slider_x) {
s->knob_size_px = rc->rc_height;
} else {
s->knob_size_px = rc->rc_width;
}
int p;
rc0 = *rc;
if(w->glw_class == &glw_slider_x) {
p = s->value * (rc->rc_width - s->knob_size_px) + s->knob_size_px / 2;
rc0.rc_width = s->knob_size_px;
s->slider_size_px = rc->rc_width;
} else {
p = (1 - s->value) *
(rc->rc_height - s->knob_size_px) + s->knob_size_px / 2;
rc0.rc_height = s->knob_size_px;
s->slider_size_px = rc->rc_height;
}
if(s->interpolate)
glw_lp(&s->knob_pos_px, w->glw_root, p, 0.25);
else
s->knob_pos_px = p;
glw_layout0(c, &rc0);
}
void
glw_scroll_layout(glw_scroll_control_t *gsc, glw_t *w, int height)
{
const int max_value =
MAX(0, gsc->total_size - gsc->page_size + gsc->scroll_threshold_post);
if(w->glw_root->gr_pointer_grab_scroll == w) {
gsc->filtered_pos = gsc->target_pos;
gsc->filtered_pos = GLW_CLAMP(gsc->filtered_pos, 0, max_value);
} else if(fabsf(gsc->kinetic_scroll) > 0.5) {
gsc->filtered_pos += gsc->kinetic_scroll;
if(gsc->target_pos != gsc->filtered_pos) {
gsc->target_pos = gsc->filtered_pos;
glw_need_refresh(w->glw_root, 0);
}
gsc->kinetic_scroll *= 0.95;
gsc->bottom_anchored = 0;
gsc->filtered_pos = GLW_CLAMP(gsc->filtered_pos, 0, max_value);
} else {
gsc->kinetic_scroll = 0;
if(gsc->bottom_gravity) {
if(gsc->target_pos == max_value) {
gsc->bottom_anchored = 1;
}
if(gsc->bottom_anchored) {
if(gsc->target_pos != max_value) {
w->glw_flags |= GLW_UPDATE_METRICS;
}
gsc->target_pos = max_value;
}
}
gsc->target_pos = GLW_CLAMP(gsc->target_pos, 0, max_value);
if(fabsf(gsc->target_pos - gsc->filtered_pos) > height * 2) {
gsc->filtered_pos = gsc->target_pos;
} else {
glw_lp(&gsc->filtered_pos, w->glw_root, gsc->target_pos, 0.25);
}
}
gsc->rounded_pos = rintf(gsc->filtered_pos * 5.0f) / 5.0f;
}
static void
glw_segway_layout(glw_t *w, const glw_rctx_t *rc)
{
glw_segway_t *s = (glw_segway_t *)w;
glw_t *c;
if((c = TAILQ_FIRST(&w->glw_childs)) == NULL)
return;
s->req_width = 0;
int f = glw_filter_constraints(c);
if(f & GLW_CONSTRAINT_X) {
s->req_width = glw_req_width(c);
} else if(f & GLW_CONSTRAINT_W && c->glw_req_weight < 0) {
s->req_width = rc->rc_height * -c->glw_req_weight;
}
glw_rctx_t rc0 = *rc;
float alpha;
if(s->req_width == 0 || !s->direction) {
rc0.rc_width = w->glw_root->gr_width;
rc0.rc_segwayed = 1;
alpha = 0;
} else {
rc0.rc_width = s->req_width;
alpha = 1;
}
glw_lp(&s->alpha, w->glw_root, alpha, 0.25);
glw_lp(&s->actual_width, w->glw_root, s->req_width, 0.25);
s->actual_width_rounded = rintf(s->actual_width);
rc0.rc_alpha *= s->alpha;
glw_layout0(c, &rc0);
glw_set_constraints(w, s->actual_width_rounded, 0, 0, GLW_CONSTRAINT_X);
}
static void
render_focus_widget(glw_t *w, glw_cursor_t *gc, const 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) {
gc->gc_mtx = x;
gc->gc_initialized = 1;
} else {
for(int r = 0; r < 4; r++) {
for(int c = 0; c < 4; c++) {
glw_lp(&gc->gc_mtx.r[r][c], gr, x.r[r][c], 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);
}
static void
drawFrame(glw_ps3_t *gp, int buffer, int with_universe)
{
extern int browser_visible;
gcmContextData *ctx = gp->gr.gr_be.be_ctx;
realityViewportTranslate(ctx,
gp->res.width/2, gp->res.height/2, 0.0, 0.0);
realityViewportScale(ctx,
gp->res.width/2, -gp->res.height/2, 1.0, 0.0);
realityZControl(ctx, 0, 1, 1); // disable viewport culling
// Enable alpha blending.
realityBlendFunc(ctx,
NV30_3D_BLEND_FUNC_SRC_RGB_SRC_ALPHA |
NV30_3D_BLEND_FUNC_SRC_ALPHA_SRC_ALPHA,
NV30_3D_BLEND_FUNC_DST_RGB_ONE_MINUS_SRC_ALPHA |
NV30_3D_BLEND_FUNC_DST_ALPHA_ZERO);
realityBlendEquation(ctx, NV40_3D_BLEND_EQUATION_RGB_FUNC_ADD |
NV40_3D_BLEND_EQUATION_ALPHA_FUNC_ADD);
realityBlendEnable(ctx, 1);
realityViewport(ctx, gp->res.width, gp->res.height);
setupRenderTarget(gp, buffer);
// set the clear color
realitySetClearColor(ctx, 0x00000000);
realitySetClearDepthValue(ctx, 0xffff);
// Clear the buffers
realityClearBuffers(ctx,
REALITY_CLEAR_BUFFERS_COLOR_R |
REALITY_CLEAR_BUFFERS_COLOR_G |
REALITY_CLEAR_BUFFERS_COLOR_B |
NV30_3D_CLEAR_BUFFERS_COLOR_A |
REALITY_CLEAR_BUFFERS_DEPTH);
// XMB may overwrite currently loaded shaders, so clear them out
gp->gr.gr_be.be_vp_current = NULL;
gp->gr.gr_be.be_fp_current = NULL;
realityCullEnable(ctx, 1);
realityFrontFace(ctx, REALITY_FRONT_FACE_CCW);
realityCullFace(ctx, REALITY_CULL_FACE_BACK);
if(!with_universe)
return;
glw_lock(&gp->gr);
glw_prepare_frame(&gp->gr, 0);
gp->gr.gr_width = gp->res.width;
gp->gr.gr_height = gp->res.height;
glw_rctx_t rc;
int zmax = 0;
glw_rctx_init(&rc, gp->gr.gr_width * gp->scale, gp->gr.gr_height, 1, &zmax);
glw_lp(&gp->gp_browser_alpha, &gp->gr, browser_visible, 0.1);
rc.rc_alpha = 1 - gp->gp_stop * 0.1 - gp->gp_browser_alpha * 0.8;
glw_layout0(gp->gr.gr_universe, &rc);
glw_render0(gp->gr.gr_universe, &rc);
glw_unlock(&gp->gr);
glw_post_scene(&gp->gr);
}
