static void
glw_slideshow_render(glw_t *w, const glw_rctx_t *rc)
{
glw_t *c, *p, *n;
glw_rctx_t rc0;
if((c = w->glw_focused) == NULL)
return;
p = glw_prev_widget(c);
if(p == NULL)
p = glw_last_widget(w);
if(p != NULL && p != c) {
if(p->glw_parent_alpha > 0.01) {
rc0 = *rc;
rc0.rc_alpha *= p->glw_parent_alpha;
glw_render0(p, &rc0);
}
}
rc0 = *rc;
rc0.rc_alpha *= c->glw_parent_alpha;
glw_render0(c, &rc0);
n = glw_next_widget(c);
if(n == NULL)
n = glw_first_widget(w);
if(n != NULL && n != c) {
if(n->glw_parent_alpha > 0.01) {
rc0 = *rc;
rc0.rc_alpha *= n->glw_parent_alpha;
glw_render0(n, &rc0);
}
}
}
static void
glw_mirror_render(glw_t *w, const glw_rctx_t *rc)
{
glw_t *c;
glw_rctx_t rc0;
int b;
if((c = TAILQ_FIRST(&w->glw_childs)) == NULL)
return;
b = glw_clip_enable(w->glw_root, rc, GLW_CLIP_BOTTOM, 0);
glw_render0(c, rc);
glw_clip_disable(w->glw_root, b);
rc0 = *rc;
glw_Translatef(&rc0, 0, -1, 0);
glw_Scalef(&rc0, 1.0, -1.0, 1.0);
glw_Translatef(&rc0, 0, 1, 0);
glw_frontface(w->glw_root, GLW_CW);
rc0.rc_alpha *= w->glw_alpha;
rc0.rc_inhibit_matrix_store = 1;
b = glw_clip_enable(w->glw_root, &rc0, GLW_CLIP_BOTTOM, 0);
glw_render0(c, &rc0);
glw_clip_disable(w->glw_root, b);
glw_frontface(w->glw_root, GLW_CCW);
}
static void
glw_segway_render(glw_t *w, const glw_rctx_t *rc)
{
glw_t *c;
glw_rctx_t rc0;
glw_segway_t *s = (glw_segway_t *)w;
if((c = TAILQ_FIRST(&w->glw_childs)) == NULL)
return;
if(s->req_width == 0 || s->direction == 0)
return;
rc0 = *rc;
int displacement = s->req_width - s->actual_width_rounded;
switch(s->direction) {
case SEGWAY_DIRECTION_LEFT:
glw_reposition(&rc0, -displacement, rc->rc_height,
rc->rc_width, 0);
break;
case SEGWAY_DIRECTION_RIGHT:
glw_reposition(&rc0, displacement * 0, rc->rc_height,
rc->rc_width + 1 * displacement, 0);
break;
}
rc0.rc_width = s->req_width;
rc0.rc_alpha *= s->alpha;
glw_render0(c, &rc0);
}
static void
glw_freefloat_render(glw_t *w, const glw_rctx_t *rc)
{
glw_freefloat_t *ff = (glw_freefloat_t *)w;
glw_t *c;
int i;
float a;
glw_rctx_t rc0;
for(i = 0; i < ff->num_visible; i++) {
if((c = ff->visible[i]) == NULL)
continue;
rc0 = *rc;
a = (1 - fabs(-1 + (GLW_MAX(0, -0.1 + c->glw_parent_v * 2.1))));
rc0.rc_alpha *= a;
glw_Translatef(&rc0,
c->glw_parent_x,
c->glw_parent_y,
-5 + c->glw_parent_v * 5);
glw_Rotatef(&rc0,
-30 + c->glw_parent_v * 60,
fabsf(sin(c->glw_parent_a)),
fabsf(cos(c->glw_parent_a)),
0.0);
glw_render0(c, &rc0);
}
}
static void
drawFrame(glw_ps3_t *gp, int buffer)
{
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);
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;
glw_rctx_init(&rc, gp->gr.gr_width, gp->gr.gr_height);
glw_layout0(gp->gr.gr_universe, &rc);
glw_render0(gp->gr.gr_universe, &rc);
glw_unlock(&gp->gr);
}
static void
glw_keyintercept_render(glw_t *w, glw_rctx_t *rc)
{
glw_t *c;
if((c = TAILQ_FIRST(&w->glw_childs)) != NULL)
glw_render0(c, rc);
}
static void
popup_render(glw_t *w, const glw_rctx_t *rc)
{
glw_rctx_t rc0;
glw_popup_t *p = (glw_popup_t *)w;
glw_store_matrix(w, rc);
rc0 = *rc;
rc0.rc_alpha *= w->glw_alpha;
if(rc0.rc_alpha < GLW_ALPHA_EPSILON)
return;
glw_t *c = TAILQ_FIRST(&w->glw_childs);
if(c == NULL || c->glw_flags & GLW_HIDDEN)
return;
Vec3 point, dir;
glw_vec3_copy(point, glw_vec3_make(p->screen_x, p->screen_y, -2.41));
glw_vec3_sub(dir, point, glw_vec3_make(p->screen_x * 42.38,
p->screen_y * 42.38,
-100));
float x, y;
glw_widget_unproject(w->glw_matrix, &x, &y, point, dir);
int x1, y1;
if(p->screen_cord_set) {
x1 = (x + 1.0f) * 0.5f * rc->rc_width;
y1 = (y + 1.0f) * 0.5f * rc->rc_height - p->height;
} else {
x1 = rc->rc_width / 2 - p->width / 2;
y1 = rc->rc_height / 2 - p->height / 2;
}
int x2 = x1 + p->width;
int y2 = y1 + p->height;
if(x2 > rc->rc_width) {
int spill = x2 - rc->rc_width;
x1 -= spill;
x2 -= spill;
}
if(y1 < 0) {
y2 -= y1;
y1 -= y1;
}
glw_reposition(&rc0, x1, y2, x2, y1);
glw_render0(c, &rc0);
}
static void
glw_bloom_render(glw_t *w, const glw_rctx_t *rc)
{
glw_bloom_t *b = (void *)w;
float a = rc->rc_alpha * w->glw_alpha;
glw_rctx_t rc0;
glw_t *c;
rc0 = *rc;
rc0.rc_alpha = a;
TAILQ_FOREACH(c, &w->glw_childs, glw_parent_link)
glw_render0(c, &rc0);
if(b->b_glow < 0.01)
return;
b->b_need_render = a > 0.01;
if(!b->b_need_render)
return;
if(glw_is_focusable(w))
glw_store_matrix(w, rc);
rc0 = *rc;
glw_Scalef(&rc0,
1.0 + EDGE_SIZE / rc->rc_width,
1.0 + EDGE_SIZE / rc->rc_height,
1.0);
#if 0
glw_render(&b->b_render, w->glw_root, &rc0,
GLW_RENDER_MODE_QUADS, GLW_RENDER_ATTRIBS_TEX,
&glw_rtt_texture(&b->b_rtt[0]), 1, 1, 1, a);
#endif
a *= b->b_glow;
glw_blendmode(w->glw_root, GLW_BLEND_ADDITIVE);
glw_renderer_draw(&b->b_render, w->glw_root, &rc0,
&glw_rtt_texture(&b->b_rtt[0]),
NULL, NULL, a * 0.50, 0, NULL);
glw_renderer_draw(&b->b_render, w->glw_root, &rc0,
&glw_rtt_texture(&b->b_rtt[1]),
NULL, NULL, a * 0.44, 0, NULL);
glw_renderer_draw(&b->b_render, w->glw_root, &rc0,
&glw_rtt_texture(&b->b_rtt[2]),
NULL, NULL, a * 0.33, 0, NULL);
glw_blendmode(w->glw_root, GLW_BLEND_NORMAL);
}
static void
render_child_simple(glw_t *w, glw_rctx_t *rc)
{
glw_rctx_t rc0 = *rc;
glw_t *c;
if((c = TAILQ_FIRST(&w->glw_childs)) != NULL) {
rc0.rc_alpha = rc->rc_alpha * w->glw_alpha;
glw_render0(c, &rc0);
}
}
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 < GLW_ALPHA_EPSILON)
return;
c = TAILQ_FIRST(&w->glw_childs);
if(c == NULL)
return;
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
glw_slideshow_render(glw_t *w, const glw_rctx_t *rc)
{
glw_t *c, *p, *n;
glw_rctx_t rc0;
float sa = w->glw_alpha;
if((c = w->glw_focused) == NULL)
return;
p = glw_prev_widget(c);
if(p == NULL)
p = glw_last_widget(w);
if(p != NULL && p != c) {
float a = sa * glw_parent_data(p, glw_slideshow_item_t)->alpha;
if(a > GLW_ALPHA_EPSILON) {
rc0 = *rc;
rc0.rc_alpha *= a;
glw_render0(p, &rc0);
}
}
rc0 = *rc;
rc0.rc_alpha *= sa * glw_parent_data(c, glw_slideshow_item_t)->alpha;
glw_render0(c, &rc0);
n = glw_next_widget(c);
if(n == NULL)
n = glw_first_widget(w);
if(n != NULL && n != c) {
float a = sa * glw_parent_data(n, glw_slideshow_item_t)->alpha;
if(a > GLW_ALPHA_EPSILON) {
rc0 = *rc;
rc0.rc_alpha *= a;
glw_render0(n, &rc0);
}
}
}
static void
render_child_autocentered(glw_image_t *gi, const glw_rctx_t *rc)
{
glw_t *c;
glw_rctx_t rc0;
if((c = TAILQ_FIRST(&gi->w.glw_childs)) == NULL)
return;
rc0 = *rc;
glw_reposition(&rc0, gi->gi_box_left, rc->rc_height - gi->gi_box_top,
rc->rc_width - gi->gi_box_right, gi->gi_box_bottom);
rc0.rc_alpha *= gi->w.glw_alpha;
glw_render0(c, &rc0);
}
static void
glw_detachable_render(glw_t *w, const glw_rctx_t *rc)
{
glw_detachable_t *gd = (glw_detachable_t *)w;
glw_t *c;
glw_store_matrix(w, rc);
gd->width = rc->rc_width;
gd->height = rc->rc_height;
if(gd->on)
return;
if((c = TAILQ_FIRST(&w->glw_childs)) == NULL)
return;
glw_render0(c, rc);
}
static void
glw_rotator_render(glw_t *w, glw_rctx_t *rc)
{
glw_rotator_t *gr = (glw_rotator_t *)w;
glw_t *c;
glw_rctx_t rc0;
if((c = TAILQ_FIRST(&w->glw_childs)) == NULL)
return;
rc0 = *rc;
glw_Scalef(&rc0, 0.8, 0.8, 0.8);
glw_scale_to_aspect(&rc0, 1.0f);
glw_Rotatef(&rc0, gr->theta, 0.0, 0.0f, 1.0f);
glw_render0(c, &rc0);
}
static void
glw_displacement_render(glw_t *w, const glw_rctx_t *rc)
{
glw_displacement_t *gd = (glw_displacement_t *)w;
glw_t *c;
glw_rctx_t rc0 = *rc;
rc0.rc_alpha = rc->rc_alpha * w->glw_alpha;
if(rc0.rc_alpha < 0.01)
return;
if((c = TAILQ_FIRST(&w->glw_childs)) == NULL)
return;
glw_Translatef(&rc0,
gd->gd_translate_x,
gd->gd_translate_y,
gd->gd_translate_z);
glw_Scalef(&rc0,
gd->gd_scale_x,
gd->gd_scale_y,
gd->gd_scale_z);
if(gd->gd_rotate_a)
glw_Rotatef(&rc0,
gd->gd_rotate_a,
gd->gd_rotate_x,
gd->gd_rotate_y,
gd->gd_rotate_z);
glw_repositionf(&rc0,
gd->gd_padding_left,
rc->rc_height - gd->gd_padding_top,
rc->rc_width - gd->gd_padding_right,
gd->gd_padding_bottom);
if(glw_is_focusable(w))
glw_store_matrix(w, &rc0);
glw_render0(c, &rc0);
}
static void
render_hover_widget(glw_t *w, glw_cursor_t *gc,
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_HOVER_PATH))
return;
gc->gc_hover_rctx.rc_alpha = 1.0f;
gc->gc_hover_rctx.rc_sharpness = 1.0f;
glw_layout0(w, &gc->gc_hover_rctx);
rc0->rc_zindex = MAX(*zmax, rc->rc_zindex);
gc->gc_hover_rctx.rc_zmax = rc0->rc_zmax;
gc->gc_hover_rctx.rc_zindex = rc0->rc_zindex;
glw_render0(w, &gc->gc_hover_rctx);
}
JNIEXPORT void JNICALL
Java_com_showtimemediacenter_showtime_STCore_glwStep(JNIEnv *env,
jobject obj,
jint id)
{
android_glw_root_t *agr = (android_glw_root_t *)id;
glw_root_t *gr = &agr->gr;
glw_lock(gr);
gr->gr_can_externalize = 1;
gr->gr_externalize_cnt = 0;
glViewport(0, 0, gr->gr_width, gr->gr_height);
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
glw_prepare_frame(gr, 0);
glw_rctx_t rc;
glw_rctx_init(&rc, gr->gr_width, gr->gr_height, 1);
glw_layout0(gr->gr_universe, &rc);
glw_render0(gr->gr_universe, &rc);
glw_unlock(gr);
glw_post_scene(gr);
}
static void
glw_slider_render_y(glw_t *w, const glw_rctx_t *rc)
{
glw_slider_t *s = (glw_slider_t *)w;
glw_t *c;
glw_rctx_t rc0;
if(glw_is_focusable_or_clickable(w))
glw_store_matrix(w, rc);
if((c = TAILQ_FIRST(&w->glw_childs)) == NULL)
return;
rc0 = *rc;
rc0.rc_alpha *= w->glw_alpha;
glw_reposition(&rc0,
0,
s->knob_pos_px + s->knob_size_px / 2,
rc->rc_width,
s->knob_pos_px - s->knob_size_px / 2);
glw_render0(c, &rc0);
}
static void
glw_bloom_layout(glw_t *w, glw_rctx_t *rc)
{
glw_bloom_t *b = (void *)w;
glw_root_t *gr = w->glw_root;
glw_rctx_t rc0;
glw_t *c;
int x, y, i, sizx, sizy;
TAILQ_FOREACH(c, &w->glw_childs, glw_parent_link)
glw_layout0(c, rc);
if(b->b_glow < 0.01) {
if(b->b_width || b->b_height)
bloom_destroy_rtt(gr, b);
return;
}
sizx = rc->rc_width + EDGE_SIZE;
sizy = rc->rc_height + EDGE_SIZE;
if(b->b_width != sizx || b->b_height != sizy) {
if(b->b_width || b->b_height)
bloom_destroy_rtt(gr, b);
b->b_width = sizx;
b->b_height = sizy;
if(b->b_width || b->b_height) {
for(i = 0; i < BLOOM_COUNT; i++) {
x = b->b_width / (2 << i);
y = b->b_height / (2 << i);
glw_rtt_init(gr, &b->b_rtt[i], x, y, 1);
}
}
}
// Initialize output texture
if(!b->b_render_initialized) {
float xs = gr->gr_normalized_texture_coords ? 1.0 : b->b_width;
float ys = gr->gr_normalized_texture_coords ? 1.0 : b->b_height;
glw_renderer_init_quad(&b->b_render);
glw_renderer_vtx_pos(&b->b_render, 0, -1.0, -1.0, 0.0);
glw_renderer_vtx_st (&b->b_render, 0, 0.0, 0);
glw_renderer_vtx_pos(&b->b_render, 1, 1.0, -1.0, 0.0);
glw_renderer_vtx_st (&b->b_render, 1, xs, 0);
glw_renderer_vtx_pos(&b->b_render, 2, 1.0, 1.0, 0.0);
glw_renderer_vtx_st (&b->b_render, 2, xs, ys);
glw_renderer_vtx_pos(&b->b_render, 3, -1.0, 1.0, 0.0);
glw_renderer_vtx_st (&b->b_render, 3, 0.0, ys);
}
memset(&rc0, 0, sizeof(glw_rctx_t));
rc0.rc_alpha = 1;
rc0.rc_width = b->b_width - EDGE_SIZE;
rc0.rc_height = b->b_height - EDGE_SIZE;
rc0.rc_inhibit_shadows = 1;
if(!b->b_need_render)
return;
for(i = 0; i < BLOOM_COUNT; i++) {
glw_rtt_enter(gr, &b->b_rtt[i], &rc0);
rc0.rc_width = b->b_width - EDGE_SIZE;
rc0.rc_height = b->b_height - EDGE_SIZE;
glw_Scalef(&rc0,
1.0 - EDGE_SIZE / b->b_width,
1.0 - EDGE_SIZE / b->b_height,
1.0);
TAILQ_FOREACH(c, &w->glw_childs, glw_parent_link)
glw_render0(c, &rc0);
glw_rtt_restore(gr, &b->b_rtt[i]);
}
}
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);
}
