void compositor_3d_draw_bitmap(Drawable *stack, DrawAspect2D *asp, GF_TraverseState *tr_state, Fixed width, Fixed height, Fixed bmp_scale_x, Fixed bmp_scale_y)
{
u8 alpha;
#if !defined(GPAC_USE_OGL_ES) && !defined(GPAC_USE_TINYGL)
Fixed x, y;
Fixed sx, sy;
char *data;
u32 format;
#endif
GF_TextureHandler *txh;
GF_Compositor *compositor = tr_state->visual->compositor;
Bool use_texture = !compositor->bitmap_use_pixels;
if (!asp->fill_texture)
return;
txh = asp->fill_texture;
if (!txh || !txh->tx_io || !txh->width || !txh->height)
return;
if (((txh->pixelformat==GF_PIXEL_RGBD) || (txh->pixelformat==GF_PIXEL_YUVD))) {
if (compositor->depth_gl_type) {
if (txh->data && gf_sc_texture_convert(txh) )
visual_3d_point_sprite(tr_state->visual, stack, txh, tr_state);
return;
} else {
use_texture = 1;
}
}
alpha = GF_COL_A(asp->fill_color);
/*THIS IS A HACK, will not work when setting filled=0, transparency and XLineProps*/
if (!alpha) alpha = GF_COL_A(asp->line_color);
/*texture is available in hw, use it - if blending, force using texture*/
if (!gf_sc_texture_needs_reload(txh) || (alpha != 0xFF) || use_texture
#ifdef GF_SR_USE_DEPTH
|| tr_state->depth_offset
#endif
) {
visual_3d_set_state(tr_state->visual, V3D_STATE_LIGHT, 0);
visual_3d_enable_antialias(tr_state->visual, 0);
if (alpha && (alpha != 0xFF)) {
visual_3d_set_material_2d_argb(tr_state->visual, GF_COL_ARGB(alpha, 0xFF, 0xFF, 0xFF));
gf_sc_texture_set_blend_mode(txh, TX_MODULATE);
} else if (gf_sc_texture_is_transparent(txh)) {
gf_sc_texture_set_blend_mode(txh, TX_REPLACE);
} else {
visual_3d_set_state(tr_state->visual, V3D_STATE_BLEND, 0);
}
/*ignore texture transform for bitmap*/
tr_state->mesh_num_textures = gf_sc_texture_enable(txh, NULL);
if (tr_state->mesh_num_textures) {
/*we must check the w & h passed are correct because of bitmap node initialization*/
if (width && height) {
if (!stack->mesh) {
SFVec2f size;
size.x = width;
size.y = height;
stack->mesh = new_mesh();
mesh_new_rectangle(stack->mesh, size, NULL, 0);
}
}
if (stack->mesh) {
#ifdef GF_SR_USE_DEPTH
if (tr_state->depth_offset) {
GF_Matrix mx;
Fixed offset;
Fixed disp_depth = (compositor->display_depth<0) ? INT2FIX(tr_state->visual->height) : INT2FIX(compositor->display_depth);
if (disp_depth) {
if (!tr_state->pixel_metrics) disp_depth = gf_divfix(disp_depth, tr_state->min_hsize);
gf_mx_init(mx);
/*add recalibration by the scene*/
offset = tr_state->depth_offset;
if (tr_state->visual->depth_vp_range) {
offset = gf_divfix(offset, tr_state->visual->depth_vp_range/2);
}
gf_mx_add_translation(&mx, 0, 0, gf_mulfix(offset, disp_depth/2) );
visual_3d_matrix_push(tr_state->visual);
visual_3d_matrix_add(tr_state->visual, mx.m);
visual_3d_mesh_paint(tr_state, stack->mesh);
visual_3d_matrix_pop(tr_state->visual);
} else {
visual_3d_mesh_paint(tr_state, stack->mesh);
}
} else
#endif
visual_3d_mesh_paint(tr_state, stack->mesh);
}
gf_sc_texture_disable(txh);
tr_state->mesh_num_textures = 0;
return;
}
}
/*otherwise use glDrawPixels*/
#if !defined(GPAC_USE_OGL_ES) && !defined(GPAC_USE_TINYGL)
data = gf_sc_texture_get_data(txh, &format);
if (!data) return;
x = INT2FIX(txh->width) / -2;
y = INT2FIX(txh->height) / 2;
{
Fixed g[16];
sx = bmp_scale_x; if (sx<0) sx = FIX_ONE;
sy = bmp_scale_y; if (sy<0) sy = FIX_ONE;
#ifndef GPAC_DISABLE_VRML
compositor_adjust_scale(txh->owner, &sx, &sy);
#endif
/*add top level scale if any*/
sx = gf_mulfix(sx, compositor->scale_x);
sy = gf_mulfix(sy, compositor->scale_y);
/*get & apply current transform scale*/
visual_3d_matrix_get(tr_state->visual, V3D_MATRIX_MODELVIEW, g);
if (g[0]<0) g[0] *= -FIX_ONE;
if (g[5]<0) g[5] *= -FIX_ONE;
sx = gf_mulfix(sx, g[0]);
sy = gf_mulfix(sy, g[5]);
x = gf_mulfix(x, sx);
y = gf_mulfix(y, sy);
}
visual_3d_draw_image(tr_state->visual, x, y, txh->width, txh->height, format, data, sx, sy);
#endif
}
static void svg_recompute_viewport_transformation(GF_Node *node, SVGsvgStack *stack, GF_TraverseState *tr_state, SVGAllAttributes *atts)
{
GF_Matrix2D mx;
SVG_ViewBox ext_vb, *vb;
SVG_PreserveAspectRatio par;
Fixed scale, vp_w, vp_h;
Fixed parent_width, parent_height, doc_width, doc_height;
/*canvas size negociation has already been done when attaching the scene to the compositor*/
if (atts->width && (atts->width->type==SVG_NUMBER_PERCENTAGE) ) {
parent_width = gf_mulfix(tr_state->vp_size.x, atts->width->value/100);
doc_width = 0;
} else if (!stack->root_svg) {
doc_width = parent_width = atts->width ? atts->width->value : 0;
} else {
parent_width = tr_state->vp_size.x;
doc_width = atts->width ? atts->width->value : 0;
}
if (atts->height && (atts->height->type==SVG_NUMBER_PERCENTAGE) ) {
parent_height = gf_mulfix(tr_state->vp_size.y, atts->height->value/100);
doc_height = 0;
} else if (!stack->root_svg) {
doc_height = parent_height = atts->height ? atts->height->value : 0;
} else {
parent_height = tr_state->vp_size.y;
doc_height = atts->height ? atts->height->value : 0;
}
stack->vp = stack->parent_vp = tr_state->vp_size;
vb = atts->viewBox;
gf_mx2d_init(mx);
if (stack->root_svg) {
const char *frag_uri = gf_scene_get_fragment_uri(node);
if (frag_uri) {
/*SVGView*/
if (!strncmp(frag_uri, "svgView", 7)) {
if (!strncmp(frag_uri, "svgView(viewBox(", 16)) {
Float x, y, w, h;
sscanf(frag_uri, "svgView(viewBox(%f,%f,%f,%f))", &x, &y, &w, &h);
ext_vb.x = FLT2FIX(x);
ext_vb.y = FLT2FIX(y);
ext_vb.width = FLT2FIX(w);
ext_vb.height = FLT2FIX(h);
ext_vb.is_set = 1;
vb = &ext_vb;
}
else if (!strncmp(frag_uri, "svgView(transform(", 18)) {
Bool ret = gf_svg_parse_transformlist(&mx, (char *) frag_uri+18);
if (!ret) {
GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Error parsing SVG View transform component: %s\n", frag_uri+18));
}
}
}
/*fragID*/
else {
GF_Node *target = gf_sg_find_node_by_name(gf_node_get_graph(node), (char *) frag_uri);
if (target) {
GF_Matrix2D mx;
GF_TraverseState bounds_state;
memset(&bounds_state, 0, sizeof(bounds_state));
bounds_state.traversing_mode = TRAVERSE_GET_BOUNDS;
bounds_state.visual = tr_state->visual;
bounds_state.for_node = target;
bounds_state.svg_props = tr_state->svg_props;
gf_mx2d_init(bounds_state.transform);
gf_mx2d_init(bounds_state.mx_at_node);
gf_mx_init(tr_state->visual->compositor->hit_world_to_local);
gf_sc_get_nodes_bounds(node, ((GF_ParentNode *)node)->children, &bounds_state, NULL);
gf_mx2d_from_mx(&mx, &tr_state->visual->compositor->hit_world_to_local);
gf_mx2d_apply_rect(&mx, &bounds_state.bounds);
ext_vb.x = bounds_state.bounds.x;
ext_vb.y = bounds_state.bounds.y-bounds_state.bounds.height;
ext_vb.width = bounds_state.bounds.width;
ext_vb.height = bounds_state.bounds.height;
ext_vb.is_set = 1;
vb = &ext_vb;
}
}
}
}
gf_mx2d_init(stack->viewbox_mx);
if (!vb) {
if (!doc_width || !doc_height) {
gf_mx2d_copy(stack->viewbox_mx, mx);
return;
}
/*width/height were specified in the doc, use them to compute a dummy viewbox*/
ext_vb.x = 0;
ext_vb.y = 0;
ext_vb.width = doc_width;
ext_vb.height = doc_height;
ext_vb.is_set = 1;
vb = &ext_vb;
}
if ((vb->width<=0) || (vb->height<=0) ) {
gf_mx2d_copy(stack->viewbox_mx, mx);
return;
}
stack->vp.x = vb->width;
stack->vp.y = vb->height;
/*setup default*/
par.defer = 0;
par.meetOrSlice = SVG_MEETORSLICE_MEET;
par.align = SVG_PRESERVEASPECTRATIO_XMIDYMID;
/*use parent (animation, image) viewport settings*/
if (tr_state->parent_anim_atts) {
if (tr_state->parent_anim_atts->preserveAspectRatio) {
if (tr_state->parent_anim_atts->preserveAspectRatio->defer) {
if (atts->preserveAspectRatio)
par = *atts->preserveAspectRatio;
} else {
par = *tr_state->parent_anim_atts->preserveAspectRatio;
}
}
}
/*use current viewport settings*/
else if (atts->preserveAspectRatio) {
par = *atts->preserveAspectRatio;
}
if (par.meetOrSlice==SVG_MEETORSLICE_MEET) {
if (gf_divfix(parent_width, vb->width) > gf_divfix(parent_height, vb->height)) {
scale = gf_divfix(parent_height, vb->height);
vp_w = gf_mulfix(vb->width, scale);
vp_h = parent_height;
} else {
scale = gf_divfix(parent_width, vb->width);
vp_w = parent_width;
vp_h = gf_mulfix(vb->height, scale);
}
} else {
if (gf_divfix(parent_width, vb->width) < gf_divfix(parent_height, vb->height)) {
scale = gf_divfix(parent_height, vb->height);
vp_w = gf_mulfix(vb->width, scale);
vp_h = parent_height;
} else {
scale = gf_divfix(parent_width, vb->width);
vp_w = parent_width;
vp_h = gf_mulfix(vb->height, scale);
}
}
if (par.align==SVG_PRESERVEASPECTRATIO_NONE) {
stack->viewbox_mx.m[0] = gf_divfix(parent_width, vb->width);
stack->viewbox_mx.m[4] = gf_divfix(parent_height, vb->height);
stack->viewbox_mx.m[2] = - gf_muldiv(vb->x, parent_width, vb->width);
stack->viewbox_mx.m[5] = - gf_muldiv(vb->y, parent_height, vb->height);
} else {
Fixed dx, dy;
stack->viewbox_mx.m[0] = stack->viewbox_mx.m[4] = scale;
stack->viewbox_mx.m[2] = - gf_mulfix(vb->x, scale);
stack->viewbox_mx.m[5] = - gf_mulfix(vb->y, scale);
dx = dy = 0;
switch (par.align) {
case SVG_PRESERVEASPECTRATIO_XMINYMIN:
break;
case SVG_PRESERVEASPECTRATIO_XMIDYMIN:
dx = ( parent_width - vp_w) / 2;
break;
case SVG_PRESERVEASPECTRATIO_XMAXYMIN:
dx = parent_width - vp_w;
break;
case SVG_PRESERVEASPECTRATIO_XMINYMID:
dy = ( parent_height - vp_h) / 2;
break;
case SVG_PRESERVEASPECTRATIO_XMIDYMID:
dx = ( parent_width - vp_w) / 2;
dy = ( parent_height - vp_h) / 2;
break;
case SVG_PRESERVEASPECTRATIO_XMAXYMID:
dx = parent_width - vp_w;
dy = ( parent_height - vp_h) / 2;
break;
case SVG_PRESERVEASPECTRATIO_XMINYMAX:
dy = parent_height - vp_h;
break;
case SVG_PRESERVEASPECTRATIO_XMIDYMAX:
dx = (parent_width - vp_w) / 2;
dy = parent_height - vp_h;
break;
case SVG_PRESERVEASPECTRATIO_XMAXYMAX:
dx = parent_width - vp_w;
dy = parent_height - vp_h;
break;
}
gf_mx2d_add_translation(&stack->viewbox_mx, dx, dy);
stack->dx = dx;
stack->dy = dy;
stack->vpw = vp_w;
stack->vph = vp_h;
/*we need a clipper*/
if (stack->root_svg && !tr_state->parent_anim_atts && (par.meetOrSlice==SVG_MEETORSLICE_SLICE)) {
GF_Rect rc;
rc.width = parent_width;
rc.height = parent_height;
if (!stack->root_svg) {
rc.x = 0;
rc.y = parent_height;
gf_mx2d_apply_rect(&stack->viewbox_mx, &rc);
} else {
rc.x = dx;
rc.y = dy + parent_height;
}
// tr_state->visual->top_clipper = gf_rect_pixelize(&rc);
}
}
gf_mx2d_add_matrix(&stack->viewbox_mx, &mx);
}
static GF_Err swf_svg_define_text(SWFReader *read, SWFText *text)
{
Bool use_text;
u32 i;
u32 j;
SWFGlyphRec *gr;
SWFFont *ft;
use_text = (read->flags & GF_SM_SWF_NO_FONT) ? 1 : 0;
swf_svg_print(read, "<defs>\n");
swf_svg_print(read, "<g id=\"S%d\" ", text->ID);
swf_svg_print_matrix(read, &text->mat);
swf_svg_print(read, ">\n");
i=0;
while ((gr = (SWFGlyphRec*)gf_list_enum(text->text, &i)))
{
ft = NULL;
if (use_text) {
ft = swf_find_font(read, gr->fontID);
if (!ft->glyph_codes) {
use_text = 0;
swf_report(read, GF_BAD_PARAM, "Font glyphs are not defined, cannot reference extern font - Forcing glyph embedding");
}
}
if (use_text) {
/*restore back the font height in pixels (it's currently in SWF glyph design units)*/
swf_svg_print(read, "<text ");
swf_svg_print(read, "x=\"%g \" ", FIX2FLT(gr->orig_x));
swf_svg_print(read, "y=\"%g \" ", FIX2FLT(gr->orig_y));
swf_svg_print(read, "font-size=\"%d\" ", (u32)(gr->fontSize * SWF_TWIP_SCALE));
if (ft->fontName)
{
swf_svg_print(read, "font-family=\"%s\" ", ft->fontName);
}
if (ft->is_italic)
{
swf_svg_print(read, "font-style=\"italic\" ");
}
if (ft->is_bold)
{
swf_svg_print(read, "font-weight=\"bold\" ");
}
swf_svg_print(read, ">");
/*convert to UTF-8*/
{
size_t _len;
u16 *str_w;
u16 *widestr;
char *str;
str_w = (u16*)gf_malloc(sizeof(u16) * (gr->nbGlyphs+1));
for (j=0; j<gr->nbGlyphs; j++)
{
str_w[j] = ft->glyph_codes[gr->indexes[j]];
}
str_w[j] = 0;
str = (char*)gf_malloc(sizeof(char) * (gr->nbGlyphs+2));
widestr = str_w;
_len = gf_utf8_wcstombs(str, sizeof(u8) * (gr->nbGlyphs+1), (const unsigned short **) &widestr);
if (_len != (size_t) -1) {
str[(u32) _len] = 0;
swf_svg_print(read, "%s", str);
}
}
swf_svg_print(read, "</text>\n");
}
else
{
/*convert glyphs*/
Fixed dx;
swf_svg_print(read, "<g tranform=\"scale(1,-1) ");
swf_svg_print(read, "translate(%g, %g)\" >\n", FIX2FLT(gr->orig_x), FIX2FLT(gr->orig_y));
dx = 0;
for (j=0; j<gr->nbGlyphs; j++)
{
swf_svg_print(read, "<use xlink:href=\"#Font%d_Glyph%d\" transform=\"translate(%g)\" />\n", gr->fontID, gr->indexes[j], FIX2FLT(gf_divfix(dx, FLT2FIX(gr->fontSize * SWF_TEXT_SCALE))));
dx += gr->dx[j];
}
swf_svg_print(read, "</g>\n");
}
}
read->empty_frame = GF_FALSE;
swf_svg_print(read, "</g>\n");
swf_svg_print(read, "</defs>\n");
return GF_OK;
}
static void TraverseBackground(GF_Node *node, void *rs, Bool is_destroy)
{
M_Background *bck;
BackgroundStack *st;
SFColor bcol;
SFVec4f res;
Fixed scale;
Bool has_sky, has_ground, front_tx, back_tx, top_tx, bottom_tx, right_tx, left_tx;
GF_Matrix mx;
GF_Compositor *compositor;
GF_TraverseState *tr_state = (GF_TraverseState *)rs;
if (is_destroy) {
DestroyBackground(node);
return;
}
gf_node_dirty_clear(node, 0);
bck = (M_Background *)node;
st = (BackgroundStack *) gf_node_get_private(node);
compositor = (GF_Compositor*)st->compositor;
/*may happen in get_bounds*/
if (!tr_state->backgrounds) return;
/*first traverse, bound if needed*/
if (gf_list_find(tr_state->backgrounds, node) < 0) {
gf_list_add(tr_state->backgrounds, node);
assert(gf_list_find(st->reg_stacks, tr_state->backgrounds)==-1);
gf_list_add(st->reg_stacks, tr_state->backgrounds);
/*only bound if we're on top*/
if (gf_list_get(tr_state->backgrounds, 0) == bck) {
if (!bck->isBound) Bindable_SetIsBound(node, 1);
}
/*check streams*/
if (back_use_texture(&bck->frontUrl) && !st->txh_front.is_open) gf_sc_texture_play(&st->txh_front, &bck->frontUrl);
if (back_use_texture(&bck->bottomUrl) && !st->txh_bottom.is_open) gf_sc_texture_play(&st->txh_bottom, &bck->bottomUrl);
if (back_use_texture(&bck->backUrl) && !st->txh_back.is_open) gf_sc_texture_play(&st->txh_back, &bck->backUrl);
if (back_use_texture(&bck->topUrl) && !st->txh_top.is_open) gf_sc_texture_play(&st->txh_top, &bck->topUrl);
if (back_use_texture(&bck->rightUrl) && !st->txh_right.is_open) gf_sc_texture_play(&st->txh_right, &bck->rightUrl);
if (back_use_texture(&bck->leftUrl) && !st->txh_left.is_open) gf_sc_texture_play(&st->txh_left, &bck->leftUrl);
/*in any case don't draw the first time (since the background could have been declared last)*/
gf_sc_invalidate(st->compositor, NULL);
return;
}
if (!bck->isBound) return;
if (tr_state->traversing_mode != TRAVERSE_BINDABLE) {
if (tr_state->traversing_mode == TRAVERSE_SORT) {
gf_mx_copy(st->current_mx, tr_state->model_matrix);
}
return;
}
front_tx = back_gf_sc_texture_enabled(&bck->frontUrl, &st->txh_front);
back_tx = back_gf_sc_texture_enabled(&bck->backUrl, &st->txh_back);
top_tx = back_gf_sc_texture_enabled(&bck->topUrl, &st->txh_top);
bottom_tx = back_gf_sc_texture_enabled(&bck->bottomUrl, &st->txh_bottom);
right_tx = back_gf_sc_texture_enabled(&bck->rightUrl, &st->txh_right);
left_tx = back_gf_sc_texture_enabled(&bck->leftUrl, &st->txh_left);
has_sky = ((bck->skyColor.count>1) && bck->skyAngle.count) ? 1 : 0;
has_ground = ((bck->groundColor.count>1) && bck->groundAngle.count) ? 1 : 0;
bcol.red = bcol.green = bcol.blue = 0;
if (bck->skyColor.count) bcol = bck->skyColor.vals[0];
/*if we clear the main visual clear it entirely - ONLY IF NOT IN LAYER*/
if ((tr_state->visual == compositor->visual) && (tr_state->visual->back_stack == tr_state->backgrounds)) {
visual_3d_clear(tr_state->visual, bcol, FIX_ONE);
if (!has_sky && !has_ground && !front_tx && !back_tx && !top_tx && !bottom_tx && !left_tx && !right_tx) {
return;
}
}
/*undo translation*/
res.x = res.y = res.z = 0;
res.q = FIX_ONE;
gf_mx_apply_vec_4x4(&tr_state->camera->unprojection, &res);
assert(res.q);
res.x = gf_divfix(res.x, res.q);
res.y = gf_divfix(res.y, res.q);
res.z = gf_divfix(res.z, res.q);
/*NB: we don't support local rotation of the background ...*/
/*enable background state (turn off all quality options)*/
visual_3d_set_background_state(tr_state->visual, 1);
if (has_sky) {
GF_Matrix bck_mx;
gf_mx_copy(bck_mx, tr_state->model_matrix);
gf_mx_copy(tr_state->model_matrix, st->current_mx);
if (!st->sky_mesh) {
st->sky_mesh = new_mesh();
back_build_dome(st->sky_mesh, &bck->skyAngle, &bck->skyColor, 0);
}
gf_mx_init(mx);
gf_mx_add_translation(&mx, res.x, res.y, res.z);
/*CHECKME - not sure why, we need to scale less in fixed point otherwise z-far clipping occur - probably some
rounding issues...*/
#ifdef GPAC_FIXED_POINT
scale = (tr_state->camera->z_far/10)*8;
#else
scale = 9*tr_state->camera->z_far/10;
#endif
gf_mx_add_scale(&mx, scale, scale, scale);
gf_mx_add_matrix(&tr_state->model_matrix, &mx);
visual_3d_mesh_paint(tr_state, st->sky_mesh);
gf_mx_copy(tr_state->model_matrix, bck_mx);
}
if (has_ground) {
GF_Matrix bck_mx;
gf_mx_copy(bck_mx, tr_state->model_matrix);
gf_mx_copy(tr_state->model_matrix, st->current_mx);
if (!st->ground_mesh) {
st->ground_mesh = new_mesh();
back_build_dome(st->ground_mesh, &bck->groundAngle, &bck->groundColor, 1);
}
gf_mx_init(mx);
gf_mx_add_translation(&mx, res.x, res.y, res.z);
/*cf above*/
#ifdef GPAC_FIXED_POINT
scale = (tr_state->camera->z_far/100)*70;
#else
scale = 85*tr_state->camera->z_far/100;
#endif
gf_mx_add_scale(&mx, scale, -scale, scale);
gf_mx_add_matrix(&tr_state->model_matrix, &mx);
visual_3d_mesh_paint(tr_state, st->ground_mesh);
gf_mx_copy(tr_state->model_matrix, bck_mx);
}
if (front_tx || back_tx || left_tx || right_tx || top_tx || bottom_tx) {
GF_Matrix bck_mx;
gf_mx_copy(bck_mx, tr_state->model_matrix);
gf_mx_copy(tr_state->model_matrix, st->current_mx);
gf_mx_init(mx);
gf_mx_add_translation(&mx, res.x, res.y, res.z);
#ifdef GPAC_FIXED_POINT
scale = (tr_state->camera->z_far/100)*99;
gf_mx_add_scale(&mx, scale, scale, scale);
#else
gf_mx_add_scale(&mx, tr_state->camera->z_far, tr_state->camera->z_far, tr_state->camera->z_far);
#endif
visual_3d_enable_antialias(tr_state->visual, 1);
gf_mx_add_matrix(&tr_state->model_matrix, &mx);
if (front_tx) back_draw_texture(tr_state, &st->txh_front, st->front_mesh);
if (back_tx) back_draw_texture(tr_state, &st->txh_back, st->back_mesh);
if (top_tx) back_draw_texture(tr_state, &st->txh_top, st->top_mesh);
if (bottom_tx) back_draw_texture(tr_state, &st->txh_bottom, st->bottom_mesh);
if (left_tx) back_draw_texture(tr_state, &st->txh_left, st->left_mesh);
if (right_tx) back_draw_texture(tr_state, &st->txh_right, st->right_mesh);
gf_mx_copy(tr_state->model_matrix, bck_mx);
}
/*enable background state (turn off all quality options)*/
visual_3d_set_background_state(tr_state->visual, 0);
}
static void TraversePlanarExtrusion(GF_Node *node, void *rs, Bool is_destroy)
{
PlanarExtrusion plane_ext;
Drawable *stack_2d;
u32 i, j, k;
MFVec3f spine_vec;
SFVec3f d;
Fixed spine_len;
GF_Rect bounds;
GF_Path *geo, *spine;
GF_TraverseState *tr_state = (GF_TraverseState *)rs;
Drawable3D *stack = (Drawable3D *)gf_node_get_private(node);
if (is_destroy) {
drawable_3d_del(node);
return;
}
if (!PlanarExtrusion_GetNode(node, &plane_ext)) return;
if (!plane_ext.geometry || !plane_ext.spine) return;
if (gf_node_dirty_get(node)) {
u32 cur, nb_pts;
u32 mode = tr_state->traversing_mode;
geo = spine = NULL;
tr_state->traversing_mode = TRAVERSE_GET_BOUNDS;
gf_node_traverse(plane_ext.geometry, tr_state);
gf_node_traverse(plane_ext.spine, tr_state);
tr_state->traversing_mode = mode;
switch (gf_node_get_tag(plane_ext.geometry) ) {
case TAG_MPEG4_Circle:
case TAG_MPEG4_Ellipse:
case TAG_MPEG4_Rectangle:
case TAG_MPEG4_Curve2D:
case TAG_MPEG4_XCurve2D:
case TAG_MPEG4_IndexedFaceSet2D:
case TAG_MPEG4_IndexedLineSet2D:
stack_2d = (Drawable*)gf_node_get_private(plane_ext.geometry);
if (stack_2d) geo = stack_2d->path;
break;
default:
return;
}
switch (gf_node_get_tag(plane_ext.spine) ) {
case TAG_MPEG4_Circle:
case TAG_MPEG4_Ellipse:
case TAG_MPEG4_Rectangle:
case TAG_MPEG4_Curve2D:
case TAG_MPEG4_XCurve2D:
case TAG_MPEG4_IndexedFaceSet2D:
case TAG_MPEG4_IndexedLineSet2D:
stack_2d = (Drawable*)gf_node_get_private(plane_ext.spine);
if (stack_2d) spine = stack_2d->path;
break;
default:
return;
}
if (!geo || !spine) return;
mesh_reset(stack->mesh);
gf_path_flatten(spine);
gf_path_get_bounds(spine, &bounds);
gf_path_flatten(geo);
gf_path_get_bounds(geo, &bounds);
cur = 0;
for (i=0; i<spine->n_contours; i++) {
nb_pts = 1 + spine->contours[i] - cur;
spine_vec.vals = NULL;
gf_sg_vrml_mf_alloc(&spine_vec, GF_SG_VRML_MFVEC3F, nb_pts);
spine_len = 0;
for (j=cur; j<nb_pts; j++) {
spine_vec.vals[j].x = spine->points[j].x;
spine_vec.vals[j].y = spine->points[j].y;
spine_vec.vals[j].z = 0;
if (j) {
gf_vec_diff(d, spine_vec.vals[j], spine_vec.vals[j-1]);
spine_len += gf_vec_len(d);
}
}
cur += nb_pts;
if (!plane_ext.orientation->count && !plane_ext.scale->count) {
mesh_extrude_path_ext(stack->mesh, geo, &spine_vec, plane_ext.creaseAngle,
bounds.x, bounds.y-bounds.height, bounds.width, bounds.height,
plane_ext.beginCap, plane_ext.endCap, NULL, NULL, plane_ext.txAlongSpine);
}
/*interpolate orientation and scale along subpath line*/
else {
MFRotation ori;
MFVec2f scale;
Fixed cur_len, frac;
ori.vals = NULL;
gf_sg_vrml_mf_alloc(&ori, GF_SG_VRML_MFROTATION, nb_pts);
scale.vals = NULL;
gf_sg_vrml_mf_alloc(&scale, GF_SG_VRML_MFVEC2F, nb_pts);
cur_len = 0;
if (!plane_ext.orientation->count) ori.vals[0].y = FIX_ONE;
if (!plane_ext.scale->count) scale.vals[0].x = scale.vals[0].y = FIX_ONE;
for (j=0; j<nb_pts; j++) {
if (j) {
gf_vec_diff(d, spine_vec.vals[j], spine_vec.vals[j-1]);
cur_len += gf_vec_len(d);
ori.vals[j] = ori.vals[j-1];
scale.vals[j] = scale.vals[j-1];
}
if (plane_ext.orientation->count && (plane_ext.orientation->count == plane_ext.orientationKeys->count)) {
frac = gf_divfix(cur_len , spine_len);
if (frac < plane_ext.orientationKeys->vals[0]) ori.vals[j] = plane_ext.orientation->vals[0];
else if (frac >= plane_ext.orientationKeys->vals[plane_ext.orientationKeys->count-1]) ori.vals[j] = plane_ext.orientation->vals[plane_ext.orientationKeys->count-1];
else {
for (k=1; k<plane_ext.orientationKeys->count; k++) {
Fixed kDiff = plane_ext.orientationKeys->vals[k] - plane_ext.orientationKeys->vals[k-1];
if (!kDiff) continue;
if (frac < plane_ext.orientationKeys->vals[k-1]) continue;
if (frac > plane_ext.orientationKeys->vals[k]) continue;
frac = gf_divfix(frac - plane_ext.orientationKeys->vals[k-1], kDiff);
break;
}
ori.vals[j] = gf_sg_sfrotation_interpolate(plane_ext.orientation->vals[k-1], plane_ext.orientation->vals[k], frac);
}
}
if (plane_ext.scale->count == plane_ext.scaleKeys->count) {
frac = gf_divfix(cur_len , spine_len);
if (frac <= plane_ext.scaleKeys->vals[0]) scale.vals[j] = plane_ext.scale->vals[0];
else if (frac >= plane_ext.scaleKeys->vals[plane_ext.scaleKeys->count-1]) scale.vals[j] = plane_ext.scale->vals[plane_ext.scale->count-1];
else {
for (k=1; k<plane_ext.scaleKeys->count; k++) {
Fixed kDiff = plane_ext.scaleKeys->vals[k] - plane_ext.scaleKeys->vals[k-1];
if (!kDiff) continue;
if (frac < plane_ext.scaleKeys->vals[k-1]) continue;
if (frac > plane_ext.scaleKeys->vals[k]) continue;
frac = gf_divfix(frac - plane_ext.scaleKeys->vals[k-1], kDiff);
break;
}
scale.vals[j].x = gf_mulfix(plane_ext.scale->vals[k].x - plane_ext.scale->vals[k-1].x, frac) + plane_ext.scale->vals[k-1].x;
scale.vals[j].y = gf_mulfix(plane_ext.scale->vals[k].y - plane_ext.scale->vals[k-1].y, frac) + plane_ext.scale->vals[k-1].y;
}
}
}
mesh_extrude_path_ext(stack->mesh, geo, &spine_vec, plane_ext.creaseAngle,
bounds.x, bounds.y-bounds.height, bounds.width, bounds.height,
plane_ext.beginCap, plane_ext.endCap, &ori, &scale, plane_ext.txAlongSpine);
gf_sg_vrml_mf_reset(&ori, GF_SG_VRML_MFROTATION);
gf_sg_vrml_mf_reset(&scale, GF_SG_VRML_MFVEC2F);
}
gf_sg_vrml_mf_reset(&spine_vec, GF_SG_VRML_MFVEC3F);
}
mesh_update_bounds(stack->mesh);
gf_mesh_build_aabbtree(stack->mesh);
}
if (tr_state->traversing_mode==TRAVERSE_DRAW_3D) {
visual_3d_draw(tr_state, stack->mesh);
} else if (tr_state->traversing_mode==TRAVERSE_GET_BOUNDS) {
tr_state->bbox = stack->mesh->bounds;
}
}
static void TraverseLayer3D(GF_Node *node, void *rs, Bool is_destroy)
{
Bool prev_layer, changed = 0;
GF_List *oldb, *oldv, *oldf, *oldn;
GF_Rect rc;
u32 cur_lights;
GF_List *node_list_backup;
GF_BBox bbox_backup;
GF_Matrix model_backup;
GF_Matrix2D mx2d_backup;
GF_Camera *prev_cam;
GF_VisualManager *old_visual;
M_Layer3D *l = (M_Layer3D *)node;
Layer3DStack *st = (Layer3DStack *) gf_node_get_private(node);
GF_TraverseState *tr_state = (GF_TraverseState *) rs;
if (is_destroy) {
DestroyLayer3D(node);
return;
}
if (st->unsupported) return;
if (gf_node_dirty_get(node)) {
/*main visual in pixel metrics, use output width*/
if (tr_state->pixel_metrics && (tr_state->visual->compositor->visual==tr_state->visual)) {
st->clip.width = INT2FIX(tr_state->visual->compositor->vp_width);
st->clip.height = INT2FIX(tr_state->visual->compositor->vp_height);
} else {
visual_get_size_info(tr_state, &st->clip.width, &st->clip.height);
}
/*setup bounds in local coord system*/
if (l->size.x>=0) st->clip.width = l->size.x;
if (l->size.y>=0) st->clip.height = l->size.y;
st->clip = gf_rect_center(st->clip.width, st->clip.height);
changed = 1;
}
switch (tr_state->traversing_mode) {
case TRAVERSE_GET_BOUNDS:
if (!tr_state->for_node) {
tr_state->bounds = st->clip;
gf_bbox_from_rect(&tr_state->bbox, &st->clip);
return;
}
case TRAVERSE_PICK:
case TRAVERSE_SORT:
/*layers can only be used in a 2D context*/
if (tr_state->camera && tr_state->camera->is_3D) return;
break;
case TRAVERSE_DRAW_2D:
layer3d_draw_2d(node, tr_state);
return;
case TRAVERSE_DRAW_3D:
default:
return;
}
/*layer3D maintains its own stacks*/
oldb = tr_state->backgrounds;
oldv = tr_state->viewpoints;
oldf = tr_state->fogs;
oldn = tr_state->navigations;
tr_state->backgrounds = st->visual->back_stack;
tr_state->viewpoints = st->visual->view_stack;
tr_state->navigations = st->visual->navigation_stack;
tr_state->fogs = st->visual->fog_stack;
prev_layer = tr_state->is_layer;
tr_state->is_layer = 1;
prev_cam = tr_state->camera;
tr_state->camera = &st->visual->camera;
old_visual = tr_state->visual;
bbox_backup = tr_state->bbox;
gf_mx_copy(model_backup, tr_state->model_matrix);
gf_mx2d_copy(mx2d_backup, tr_state->transform);
/*compute viewport in visual coordinate*/
rc = st->clip;
if (prev_cam) {
gf_mx_apply_rect(&tr_state->model_matrix, &rc);
gf_mx_apply_rect(&prev_cam->modelview, &rc);
if (tr_state->camera->flags & CAM_HAS_VIEWPORT)
gf_mx_apply_rect(&prev_cam->viewport, &rc);
#if 0
if (tr_state->visual->compositor->visual==tr_state->visual) {
GF_Matrix mx;
gf_mx_init(mx);
gf_mx_add_scale(&mx, tr_state->visual->compositor->scale_x, tr_state->visual->compositor->scale_y, FIX_ONE);
gf_mx_apply_rect(&mx, &rc);
}
#endif
} else {
gf_mx2d_apply_rect(&tr_state->transform, &rc);
/* if (tr_state->visual->compositor->visual==tr_state->visual) {
gf_mx2d_init(mx2d_backup);
gf_mx2d_add_scale(&mx2d_backup, tr_state->visual->compositor->scale_x, tr_state->visual->compositor->scale_y);
gf_mx2d_apply_rect(&mx2d_backup, &rc);
}
*/
/*switch visual*/
tr_state->visual = st->visual;
}
/*check bindables*/
gf_mx_init(tr_state->model_matrix);
l3d_CheckBindables(node, tr_state, st->first);
if (prev_cam) gf_mx_copy(tr_state->model_matrix, model_backup);
/*drawing a layer means drawing all subelements as a whole (no depth sorting with parents)*/
if (tr_state->traversing_mode==TRAVERSE_SORT) {
u32 old_type_3d = tr_state->visual->type_3d;
if (gf_node_dirty_get(node)) changed = 1;
gf_node_dirty_clear(node, GF_SG_NODE_DIRTY|GF_SG_VRML_BINDABLE_DIRTY);
/*!! we were in a 2D mode, setup associated texture !!*/
if (!prev_cam) {
switch (layer3d_setup_offscreen(node, st, tr_state, rc.width, rc.height)) {
case 0:
goto l3d_exit;
case 2:
if (!changed && !(st->visual->camera.flags & CAM_IS_DIRTY) && !st->visual->camera.anim_len) {
GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPOSE, ("[Layer3D] No changes found , skipping 3D draw\n"));
goto layer3d_unchanged_2d;
}
default:
break;
}
#ifdef GPAC_USE_TINYGL
if (st->tgl_ctx) ostgl_make_current(st->tgl_ctx, 0);
#endif
/*note that we don't backup the state as a layer3D cannot be declared in a layer3D*/
tr_state->layer3d = node;
rc = st->vp;
/*setup GL*/
visual_3d_setup(tr_state->visual);
}
GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPOSE, ("[Layer3D] Redrawing\n"));
layer3d_setup_clip(st, tr_state, prev_cam ? 1 : 0, rc);
tr_state->visual->type_3d = 2;
visual_3d_clear_all_lights(tr_state->visual);
cur_lights = tr_state->visual->num_lights;
/*this will init projection. Note that we're binding the viewpoint in the current pixelMetrics context
even if the viewpoint was declared in an inline below
if no previous camera, we're using offscreen rendering, force clear */
visual_3d_init_draw(tr_state, prev_cam ? 1 : 2);
visual_3d_check_collisions(tr_state, l->children);
tr_state->traversing_mode = TRAVERSE_SORT;
/*shortcut node list*/
node_list_backup = tr_state->visual->alpha_nodes_to_draw;
tr_state->visual->alpha_nodes_to_draw = gf_list_new();
/*reset cull flag*/
tr_state->cull_flag = 0;
group_3d_traverse(node, (GroupingNode *)st, tr_state);
visual_3d_flush_contexts(tr_state->visual, tr_state);
gf_list_del(tr_state->visual->alpha_nodes_to_draw);
tr_state->visual->alpha_nodes_to_draw = node_list_backup;
while (cur_lights < tr_state->visual->num_lights) {
visual_3d_remove_last_light(tr_state->visual);
}
tr_state->traversing_mode = TRAVERSE_SORT;
tr_state->visual->type_3d = old_type_3d;
//reload previous projection matrix
if (prev_cam) {
visual_3d_projection_matrix_modified(tr_state->visual);
}
/*!! we were in a 2D mode, create drawable context!!*/
if (!prev_cam) {
DrawableContext *ctx;
/*with TinyGL we draw directly to the offscreen buffer*/
#ifndef GPAC_USE_TINYGL
gf_sc_copy_to_stencil(&st->txh);
#else
if (st->txh.pixelformat==GF_PIXEL_RGBDS)
gf_get_tinygl_depth(&st->txh);
#endif
if (tr_state->visual->compositor->rasterizer->stencil_texture_modified)
tr_state->visual->compositor->rasterizer->stencil_texture_modified(gf_sc_texture_get_stencil(&st->txh) );
gf_sc_texture_set_stencil(&st->txh, gf_sc_texture_get_stencil(&st->txh) );
changed = 1;
layer3d_unchanged_2d:
/*restore visual*/
tr_state->visual = old_visual;
tr_state->layer3d = NULL;
tr_state->appear = NULL;
// tr_state->camera = prev_cam;
ctx = drawable_init_context_mpeg4(st->drawable, tr_state);
if (!ctx) return;
ctx->aspect.fill_texture = &st->txh;
ctx->flags |= CTX_NO_ANTIALIAS;
if (changed) ctx->flags |= CTX_APP_DIRTY;
if (st->txh.transparent) ctx->flags |= CTX_IS_TRANSPARENT;
drawable_finalize_sort(ctx, tr_state, NULL);
}
}
/*check picking - we must fall in our 2D clipper except when mvt is grabbed on layer*/
else if (!gf_node_dirty_get(node) && (tr_state->traversing_mode==TRAVERSE_PICK)) {
GF_Ray prev_r;
SFVec3f start, end;
SFVec4f res;
Fixed in_x, in_y;
Bool do_pick = 0;
if (!prev_cam) rc = st->vp;
layer3d_setup_clip(st, tr_state, prev_cam ? 1 : 0, rc);
if (tr_state->visual->compositor->active_layer==node) {
do_pick = (tr_state->visual->compositor->grabbed_sensor || tr_state->visual->compositor->navigation_state) ? 1 : 0;
}
if (!prev_cam) gf_mx_from_mx2d(&tr_state->model_matrix, &tr_state->transform);
if (!do_pick && !gf_list_count(tr_state->visual->compositor->sensors))
do_pick = gf_sc_pick_in_clipper(tr_state, &st->clip);
if (!do_pick) goto l3d_exit;
prev_r = tr_state->ray;
compositor_get_2d_plane_intersection(&tr_state->ray, &start);
gf_mx_inverse(&tr_state->model_matrix);
gf_mx_apply_vec(&tr_state->model_matrix, &start);
if (tr_state->visual->compositor->visual==tr_state->visual) {
start.x = gf_mulfix(start.x, tr_state->visual->compositor->scale_x);
start.y = gf_mulfix(start.y, tr_state->visual->compositor->scale_y);
} else if (!prev_cam) {
start.x = gf_muldiv(start.x, st->visual->camera.width, st->clip.width);
start.y = gf_muldiv(start.y, st->visual->camera.height, st->clip.height);
}
visual_3d_setup_projection(tr_state, 1);
in_x = 2 * gf_divfix(start.x, st->visual->camera.width);
in_y = 2 * gf_divfix(start.y, st->visual->camera.height);
res.x = in_x;
res.y = in_y;
res.z = -FIX_ONE;
res.q = FIX_ONE;
gf_mx_apply_vec_4x4(&st->visual->camera.unprojection, &res);
if (!res.q) goto l3d_exit;
start.x = gf_divfix(res.x, res.q);
start.y = gf_divfix(res.y, res.q);
start.z = gf_divfix(res.z, res.q);
res.x = in_x;
res.y = in_y;
res.z = FIX_ONE;
res.q = FIX_ONE;
gf_mx_apply_vec_4x4(&st->visual->camera.unprojection, &res);
if (!res.q) goto l3d_exit;
end.x = gf_divfix(res.x, res.q);
end.y = gf_divfix(res.y, res.q);
end.z = gf_divfix(res.z, res.q);
tr_state->ray = gf_ray(start, end);
GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPOSE, ("[Layer3D] Picking: cast ray\n\tOrigin %.4f %.4f %.4f - End %.4f %.4f %.4f\n\tDir %.4f %.4f %.4f\n",
FIX2FLT(tr_state->ray.orig.x), FIX2FLT(tr_state->ray.orig.y), FIX2FLT(tr_state->ray.orig.z),
FIX2FLT(end.x), FIX2FLT(end.y), FIX2FLT(end.z),
FIX2FLT(tr_state->ray.dir.x), FIX2FLT(tr_state->ray.dir.y), FIX2FLT(tr_state->ray.dir.z)));
group_3d_traverse(node, (GroupingNode *)st, tr_state);
tr_state->ray = prev_r;
/*store info if navigation allowed - we just override any layer3D picked first since we are picking 2D
objects*/
if (tr_state->camera->navigate_mode || (tr_state->camera->navigation_flags & NAV_ANY))
tr_state->layer3d = node;
tr_state->traversing_mode = TRAVERSE_PICK;
}
l3d_exit:
/*restore camera*/
tr_state->camera = prev_cam;
if (prev_cam) visual_3d_set_viewport(tr_state->visual, tr_state->camera->vp);
tr_state->visual = old_visual;
/*restore traversing state*/
tr_state->backgrounds = oldb;
tr_state->viewpoints = oldv;
tr_state->fogs = oldf;
tr_state->navigations = oldn;
tr_state->bbox = bbox_backup;
tr_state->is_layer = prev_layer;
gf_mx_copy(tr_state->model_matrix, model_backup);
gf_mx2d_copy(tr_state->transform, mx2d_backup);
/*in case we missed bindables*/
if (st->first) {
st->first = 0;
gf_node_dirty_set(node, 0, 0);
gf_sc_invalidate(tr_state->visual->compositor, NULL);
}
}
static void back_build_dome(GF_Mesh *mesh, MFFloat *angles, MFColor *color, Bool ground_dome)
{
u32 i, j, last_idx, ang_idx, new_idx;
Bool pad;
u32 step_div_h;
GF_Vertex vx;
SFColorRGBA start_col, end_col, fcol;
Fixed start_angle, next_angle, angle, r, frac, first_angle;
start_angle = 0;
mesh_reset(mesh);
start_col.red = start_col.green = start_col.blue = 0;
end_col = start_col;
if (color->count) {
COL_TO_RGBA(start_col, color->vals[0]);
end_col = start_col;
if (color->count>1) COL_TO_RGBA(end_col, color->vals[1]);
}
start_col.alpha = end_col.alpha = FIX_ONE;
vx.texcoords.x = vx.texcoords.y = 0;
vx.color = MESH_MAKE_COL(start_col);
vx.pos.x = vx.pos.z = 0;
vx.pos.y = FIX_ONE;
vx.normal.x = vx.normal.z = 0;
vx.normal.y = -MESH_NORMAL_UNIT;
mesh_set_vertex_vx(mesh, &vx);
last_idx = 0;
ang_idx = 0;
pad = 1;
next_angle = first_angle = 0;
if (angles->count) {
next_angle = angles->vals[0];
first_angle = 7*next_angle/8;
pad = 0;
}
step_div_h = DOME_STEP_H;
i=0;
if (ground_dome) {
step_div_h *= 2;
i=1;
}
for (; i<DOME_STEP_V; i++) {
if (ground_dome) {
angle = first_angle + (i * (GF_PI2-first_angle) / DOME_STEP_V);
} else {
angle = (i * GF_PI / DOME_STEP_V);
}
/*switch cols*/
if (angle >= next_angle) {
if (ang_idx+1<=angles->count) {
start_angle = next_angle;
next_angle = angles->vals[ang_idx+1];
if (next_angle>GF_PI) next_angle=GF_PI;
start_col = end_col;
ang_idx++;
if (ang_idx+1<color->count) {
COL_TO_RGBA(end_col, color->vals[ang_idx+1]);
} else {
pad = 1;
}
} else {
if (ground_dome) break;
pad = 1;
}
}
if (pad) {
fcol = end_col;
} else {
frac = gf_divfix(angle - start_angle, next_angle - start_angle) ;
fcol.red = gf_mulfix(end_col.red - start_col.red, frac) + start_col.red;
fcol.green = gf_mulfix(end_col.green - start_col.green, frac) + start_col.green;
fcol.blue = gf_mulfix(end_col.blue - start_col.blue, frac) + start_col.blue;
fcol.alpha = FIX_ONE;
}
vx.color = MESH_MAKE_COL(fcol);
vx.pos.y = gf_sin(GF_PI2 - angle);
r = gf_sqrt(FIX_ONE - gf_mulfix(vx.pos.y, vx.pos.y));
new_idx = mesh->v_count;
for (j = 0; j < step_div_h; j++) {
SFVec3f n;
Fixed lon = 2 * GF_PI * j / step_div_h;
vx.pos.x = gf_mulfix(gf_sin(lon), r);
vx.pos.z = gf_mulfix(gf_cos(lon), r);
n = gf_vec_scale(vx.pos, FIX_ONE /*-FIX_ONE*/);
gf_vec_norm(&n);
MESH_SET_NORMAL(vx, n);
mesh_set_vertex_vx(mesh, &vx);
if (j) {
if (i>1) {
mesh_set_triangle(mesh, last_idx+j, new_idx+j, new_idx+j-1);
mesh_set_triangle(mesh, last_idx+j, new_idx+j-1, last_idx+j-1);
} else {
mesh_set_triangle(mesh, 0, new_idx+j, new_idx+j-1);
}
}
}
if (i>1) {
mesh_set_triangle(mesh, last_idx, new_idx, new_idx+step_div_h-1);
mesh_set_triangle(mesh, last_idx, new_idx+step_div_h-1, last_idx+step_div_h-1);
} else {
mesh_set_triangle(mesh, 0, new_idx, new_idx+step_div_h-1);
}
last_idx = new_idx;
}
if (!ground_dome) {
new_idx = mesh->v_count;
vx.pos.x = vx.pos.z = 0;
vx.pos.y = -FIX_ONE;
vx.normal.x = vx.normal.z = 0;
vx.normal.y = MESH_NORMAL_UNIT;
mesh_set_vertex_vx(mesh, &vx);
for (j=1; j < step_div_h; j++) {
mesh_set_triangle(mesh, last_idx+j-1, last_idx+j, new_idx);
}
mesh_set_triangle(mesh, last_idx+step_div_h-1, last_idx, new_idx);
}
mesh->flags |= MESH_HAS_COLOR | MESH_NO_TEXTURE;
mesh_update_bounds(mesh);
}
static void build_text_split(TextStack *st, M_Text *txt, GF_TraverseState *tr_state)
{
u32 i, j, k, len, styles, idx, first_char;
Bool split_words = 0;
GF_Font *font;
GF_TextSpan *tspan;
GF_FontManager *ft_mgr = tr_state->visual->compositor->font_manager;
Fixed fontSize, start_y;
M_FontStyle *fs = (M_FontStyle *)txt->fontStyle;
fontSize = FSSIZE;
if (fontSize <= 0) {
fontSize = INT2FIX(12);
if (!tr_state->pixel_metrics) fontSize = gf_divfix(fontSize, tr_state->visual->compositor->output_width);
}
styles = 0;
if (fs && fs->style.buffer) {
if (strstr(fs->style.buffer, "BOLD") || strstr(fs->style.buffer, "bold")) styles |= GF_FONT_WEIGHT_BOLD;
if (strstr(fs->style.buffer, "ITALIC") || strstr(fs->style.buffer, "italic")) styles |= GF_FONT_ITALIC;
if (strstr(fs->style.buffer, "UNDERLINED") || strstr(fs->style.buffer, "underlined")) styles |= GF_FONT_UNDERLINED;
}
font = gf_font_manager_set_font(ft_mgr, fs ? fs->family.vals : NULL, fs ? fs->family.count : 0, styles);
if (!font) return;
st->ascent = (fontSize*font->ascent) / font->em_size;
st->descent = -(fontSize*font->descent) / font->em_size;
if (!strcmp(FSMINOR, "MIDDLE")) {
start_y = (st->descent + st->ascent)/2;
}
else if (!strcmp(FSMINOR, "BEGIN")) {
start_y = st->descent;
}
else if (!strcmp(FSMINOR, "END")) {
start_y = st->descent + st->ascent;
}
else {
start_y = st->ascent;
}
st->bounds.width = st->bounds.x = st->bounds.height = 0;
idx = 0;
split_words = (tr_state->text_split_mode==1) ? 1 : 0;
for (i=0; i < txt->string.count; i++) {
char *str = txt->string.vals[i];
if (!str || !strlen(str)) continue;
tspan = gf_font_manager_create_span(ft_mgr, font, str, fontSize, 0, 0, 0, NULL, 0, styles, (GF_Node*)txt);
if (!tspan) continue;
len = tspan->nb_glyphs;
tspan->flags |= GF_TEXT_SPAN_HORIZONTAL;
first_char = 0;
for (j=0; j<len; j++) {
u32 is_space = 0;
GF_TextSpan *span;
if (!tspan->glyphs[j]) continue;
/*we currently only split sentences at spaces*/
if (tspan->glyphs[j]->utf_name == (unsigned short) ' ') is_space = 1;
else if (tspan->glyphs[j]->utf_name == (unsigned short) '\n')
is_space = 2;
if (split_words && (j+1!=len) && !is_space)
continue;
span = (GF_TextSpan*) gf_malloc(sizeof(GF_TextSpan));
memcpy(span, tspan, sizeof(GF_TextSpan));
span->nb_glyphs = split_words ? (j - first_char) : 1;
if (split_words && !is_space) span->nb_glyphs++;
span->glyphs = gf_malloc(sizeof(void *)*span->nb_glyphs);
span->bounds.height = st->ascent + st->descent;
span->bounds.y = start_y;
span->bounds.x = 0;
span->bounds.width = 0;
if (split_words) {
for (k=0; k<span->nb_glyphs; k++) {
span->glyphs[k] = tspan->glyphs[FSLTR ? (first_char+k) : (len - first_char - k - 1)];
span->bounds.width += tspan->font_scale * (span->glyphs[k] ? span->glyphs[k]->horiz_advance : tspan->font->max_advance_h);
}
} else {
span->glyphs[0] = tspan->glyphs[FSLTR ? j : (len - j - 1) ];
span->glyphs[0] = tspan->glyphs[j];
span->bounds.width = tspan->font_scale * (span->glyphs[0] ? span->glyphs[0]->horiz_advance : tspan->font->max_advance_h);
}
gf_list_add(st->spans, span);
/*request a context (first one is always valid when entering sort phase)*/
if (idx) parent_node_start_group(tr_state->parent, NULL, 0);
idx++;
parent_node_end_text_group(tr_state->parent, &span->bounds, st->ascent, st->descent, idx);
if (is_space && split_words) {
span = (GF_TextSpan*) gf_malloc(sizeof(GF_TextSpan));
memcpy(span, tspan, sizeof(GF_TextSpan));
span->nb_glyphs = 1;
span->glyphs = gf_malloc(sizeof(void *));
gf_list_add(st->spans, span);
span->bounds.height = st->ascent + st->descent;
span->bounds.y = start_y;
span->bounds.x = 0;
k = (j - first_char);
span->glyphs[0] = tspan->glyphs[FSLTR ? (first_char+k) : (len - first_char - k - 1)];
span->bounds.width = tspan->font_scale * (span->glyphs[0] ? span->glyphs[0]->horiz_advance : tspan->font->max_advance_h);
parent_node_start_group(tr_state->parent, NULL, is_space);
idx++;
parent_node_end_text_group(tr_state->parent, &span->bounds, st->ascent, st->descent, idx);
}
first_char = j+1;
}
gf_font_manager_delete_span(ft_mgr, tspan);
}
}
void visual_2d_texture_path_text(GF_VisualManager *visual, DrawableContext *txt_ctx, GF_Path *path, GF_Rect *object_bounds, GF_TextureHandler *txh, GF_TraverseState *tr_state)
{
GF_STENCIL stencil;
Fixed sS, sT;
GF_Matrix2D gf_mx2d_txt;
GF_Rect orig_rc;
u8 alpha, r, g, b;
GF_ColorMatrix cmat;
GF_Raster2D *raster;
if (! visual->CheckAttached(visual) ) return;
raster = visual->compositor->rasterizer;
stencil = gf_sc_texture_get_stencil(txh);
if (!stencil) return;
visual_2d_set_options(visual->compositor, visual->raster_surface, 0, 1);
/*get original bounds*/
orig_rc = *object_bounds;
/*get scaling ratio so that active texture view is stretched to original bounds (std 2D shape texture mapping in MPEG4)*/
sS = gf_divfix(orig_rc.width, INT2FIX(txh->width));
sT = gf_divfix(orig_rc.height, INT2FIX(txh->height));
gf_mx2d_init(gf_mx2d_txt);
gf_mx2d_add_scale(&gf_mx2d_txt, sS, sT);
/*move to bottom-left corner of bounds */
gf_mx2d_add_translation(&gf_mx2d_txt, (orig_rc.x), (orig_rc.y - orig_rc.height));
/*move to final coordinate system*/
gf_mx2d_add_matrix(&gf_mx2d_txt, &txt_ctx->transform);
/*set path transform, except for background2D node which is directly build in the final coord system*/
raster->stencil_set_matrix(stencil, &gf_mx2d_txt);
alpha = GF_COL_A(txt_ctx->aspect.fill_color);
r = GF_COL_R(txt_ctx->aspect.fill_color);
g = GF_COL_G(txt_ctx->aspect.fill_color);
b = GF_COL_B(txt_ctx->aspect.fill_color);
/*if col do a cxmatrix*/
if (!r && !g && !b) {
raster->stencil_set_alpha(stencil, alpha);
} else {
raster->stencil_set_alpha(stencil, 0xFF);
memset(cmat.m, 0, sizeof(Fixed) * 20);
cmat.m[4] = INT2FIX(r)/255;
cmat.m[9] = INT2FIX(g)/255;
cmat.m[14] = INT2FIX(b)/255;
cmat.m[18] = INT2FIX(alpha)/255;
cmat.identity = 0;
raster->stencil_set_color_matrix(stencil, &cmat);
}
raster->surface_set_matrix(visual->raster_surface, &txt_ctx->transform);
txh->flags |= GF_SR_TEXTURE_USED;
/*push path*/
raster->surface_set_path(visual->raster_surface, path);
visual_2d_fill_path(visual, txt_ctx, stencil, tr_state, 0);
raster->surface_set_path(visual->raster_surface, NULL);
txt_ctx->flags |= CTX_PATH_FILLED;
}
static Bool OnPlaneSensor(GF_SensorHandler *sh, Bool is_over, Bool is_cancel, GF_Event *ev, GF_Compositor *compositor)
{
Bool is_mouse = (ev->type<=GF_EVENT_MOUSEWHEEL) ? 1 : 0;
M_PlaneSensor *ps = (M_PlaneSensor *)sh->sensor;
PSStack *stack = (PSStack *) gf_node_get_private(sh->sensor);
if (ps->isActive &&
( /*mouse*/((ev->type==GF_EVENT_MOUSEUP) && (ev->mouse.button==GF_MOUSE_LEFT))
|| /*keyboar*/(!is_mouse && (!is_over|| ((ev->type==GF_EVENT_KEYDOWN) && (ev->key.key_code==GF_KEY_ENTER))) )
) ) {
if (ps->autoOffset) {
ps->offset = ps->translation_changed;
if (!is_cancel) gf_node_event_out_str(sh->sensor, "offset");
}
ps->isActive = 0;
if (!is_cancel) gf_node_event_out_str(sh->sensor, "isActive");
sh->grabbed = 0;
return is_cancel ? 0 : 1;
}
/*mouse*/
else if (is_mouse) {
if (!ps->isActive && (ev->type==GF_EVENT_MOUSEDOWN) && (ev->mouse.button==GF_MOUSE_LEFT) ) {
gf_mx_copy(stack->initial_matrix, compositor->hit_local_to_world);
gf_vec_diff(stack->start_drag, compositor->hit_local_point, ps->offset);
stack->tracker.normal.x = stack->tracker.normal.y = 0; stack->tracker.normal.z = FIX_ONE;
stack->tracker.d = - gf_vec_dot(stack->start_drag, stack->tracker.normal);
ps->isActive = 1;
gf_node_event_out_str(sh->sensor, "isActive");
sh->grabbed = 1;
return 1;
}
else if (ps->isActive) {
GF_Ray loc_ray;
SFVec3f res;
loc_ray = compositor->hit_world_ray;
gf_mx_apply_ray(&stack->initial_matrix, &loc_ray);
gf_plane_intersect_line(&stack->tracker, &loc_ray.orig, &loc_ray.dir, &res);
ps->trackPoint_changed = res;
gf_node_event_out_str(sh->sensor, "trackPoint_changed");
gf_vec_diff(res, res, stack->start_drag);
/*clip*/
if (ps->minPosition.x <= ps->maxPosition.x) {
if (res.x < ps->minPosition.x) res.x = ps->minPosition.x;
if (res.x > ps->maxPosition.x) res.x = ps->maxPosition.x;
}
if (ps->minPosition.y <= ps->maxPosition.y) {
if (res.y < ps->minPosition.y) res.y = ps->minPosition.y;
if (res.y > ps->maxPosition.y) res.y = ps->maxPosition.y;
}
ps->translation_changed = res;
gf_node_event_out_str(sh->sensor, "translation_changed");
return 1;
}
} else {
if (!ps->isActive && is_over && (ev->type==GF_EVENT_KEYDOWN) && (ev->key.key_code==GF_KEY_ENTER)) {
ps->isActive = 1;
stack->start_drag = ps->offset;
gf_node_event_out_str(sh->sensor, "isActive");
return 1;
}
else if (ps->isActive && (ev->type==GF_EVENT_KEYDOWN)) {
SFVec3f res;
Fixed diff = (ev->key.flags & GF_KEY_MOD_SHIFT) ? 5*FIX_ONE : FIX_ONE;
if (!gf_sg_use_pixel_metrics(gf_node_get_graph(sh->sensor)))
diff = gf_divfix(diff, compositor->vp_width/2);
res = stack->start_drag;
switch (ev->key.key_code) {
case GF_KEY_LEFT: res.x -= diff; break;
case GF_KEY_RIGHT: res.x += diff; break;
case GF_KEY_UP: res.y += diff; break;
case GF_KEY_DOWN: res.y -= diff; break;
case GF_KEY_HOME: res = ps->offset; break;
default:
return 0;
}
/*clip*/
if (ps->minPosition.x <= ps->maxPosition.x) {
if (res.x < ps->minPosition.x) res.x = ps->minPosition.x;
if (res.x > ps->maxPosition.x) res.x = ps->maxPosition.x;
}
if (ps->minPosition.y <= ps->maxPosition.y) {
if (res.y < ps->minPosition.y) res.y = ps->minPosition.y;
if (res.y > ps->maxPosition.y) res.y = ps->maxPosition.y;
}
stack->start_drag = res;
ps->translation_changed = res;
gf_node_event_out_str(sh->sensor, "translation_changed");
return 1;
}
}
return 0;
}
static void build_text(TextStack *st, M_Text *txt, GF_TraverseState *tr_state)
{
u32 i, j, int_major, k, styles, count;
Fixed fontSize, start_x, start_y, line_spacing, tot_width, tot_height, max_scale, maxExtent;
u32 size, trim_size;
GF_Font *font;
Bool horizontal;
GF_TextSpan *trim_tspan = NULL;
GF_FontManager *ft_mgr = tr_state->visual->compositor->font_manager;
M_FontStyle *fs = (M_FontStyle *)txt->fontStyle;
fontSize = FSSIZE;
if (fontSize <= 0) {
fontSize = INT2FIX(12);
if (!tr_state->pixel_metrics) fontSize = gf_divfix(fontSize, tr_state->visual->compositor->output_width);
}
horizontal = FSHORIZ;
start_x = start_y = 0;
styles = 0;
if (fs && fs->style.buffer) {
if (strstr(fs->style.buffer, "BOLD") || strstr(fs->style.buffer, "bold")) styles |= GF_FONT_WEIGHT_BOLD;
if (strstr(fs->style.buffer, "ITALIC") || strstr(fs->style.buffer, "italic")) styles |= GF_FONT_ITALIC;
if (strstr(fs->style.buffer, "UNDERLINED") || strstr(fs->style.buffer, "underlined")) styles |= GF_FONT_UNDERLINED;
}
font = gf_font_manager_set_font(ft_mgr, fs ? fs->family.vals : NULL, fs ? fs->family.count : 0, styles);
if (!font) return;
/*NOTA: we could use integer maths here but we have a risk of overflow with large fonts, so use fixed maths*/
st->ascent = gf_muldiv(fontSize, INT2FIX(font->ascent), INT2FIX(font->em_size));
st->descent = -gf_muldiv(fontSize, INT2FIX(font->descent), INT2FIX(font->em_size));
line_spacing = gf_mulfix(FSSPACE, fontSize);
maxExtent = txt->maxExtent;
trim_size = 0;
if (maxExtent<0) {
trim_tspan = gf_font_manager_create_span(ft_mgr, font, "...", fontSize, 0, 0, 0, NULL, 0, styles, (GF_Node*)txt);
for (i=0; i<trim_tspan->nb_glyphs; i++) {
if (horizontal) {
trim_size += trim_tspan->glyphs[i] ? trim_tspan->glyphs[i]->horiz_advance : trim_tspan->font->max_advance_h;
} else {
trim_size += trim_tspan->glyphs[i] ? trim_tspan->glyphs[i]->vert_advance : trim_tspan->font->max_advance_v;
}
}
}
tot_width = tot_height = 0;
for (i=0; i < txt->string.count; i++) {
GF_TextSpan *tspan;
char *str = txt->string.vals[i];
if (!str) continue;
tspan = gf_font_manager_create_span(ft_mgr, font, txt->string.vals[i], fontSize, 0, 0, 0, NULL, 0, styles, (GF_Node*)txt);
if (!tspan) continue;
if (horizontal) tspan->flags |= GF_TEXT_SPAN_HORIZONTAL;
size = 0;
if (trim_size) {
for (j=0; j<tspan->nb_glyphs; j++) {
if (horizontal) {
size += tspan->glyphs[j] ? tspan->glyphs[j]->horiz_advance : tspan->font->max_advance_h;
} else {
size += tspan->glyphs[j] ? tspan->glyphs[j]->vert_advance : tspan->font->max_advance_v;
}
/*word is bigger than allowed extent, rewrite 3 previous chars*/
if ((s32)size*tspan->font_scale >= -maxExtent) {
u32 k;
u32 nb_chars = (j<2) ? j : 3;
for (k=0; k<nb_chars; k++) {
u32 idx = nb_chars-k-1;
if (horizontal) {
size -= tspan->glyphs[j-k] ? tspan->glyphs[j-k]->horiz_advance : tspan->font->max_advance_h;
size += trim_tspan->glyphs[idx] ? trim_tspan->glyphs[idx]->horiz_advance : tspan->font->max_advance_h;
} else {
size -= tspan->glyphs[j-k] ? tspan->glyphs[j-k]->vert_advance : tspan->font->max_advance_v;
size += trim_tspan->glyphs[idx] ? trim_tspan->glyphs[idx]->vert_advance : tspan->font->max_advance_v;
}
tspan->glyphs[j-k] = trim_tspan->glyphs[idx];
}
tspan->nb_glyphs = j+1;
break;
}
}
}
if ((horizontal && !FSLTR) || (!horizontal && !FSTTB)) {
for (k=0; k<tspan->nb_glyphs/2; k++) {
GF_Glyph *g = tspan->glyphs[k];
tspan->glyphs[k] = tspan->glyphs[tspan->nb_glyphs-1-k];
tspan->glyphs[tspan->nb_glyphs-k-1] = g;
}
}
if (!size) {
for (j=0; j<tspan->nb_glyphs; j++) {
if (horizontal) {
size += tspan->glyphs[j] ? tspan->glyphs[j]->horiz_advance : tspan->font->max_advance_h;
} else {
size += tspan->glyphs[j] ? tspan->glyphs[j]->vert_advance : tspan->font->max_advance_v;
}
}
}
gf_list_add(st->spans, tspan);
if (horizontal) {
tspan->bounds.width = tspan->font_scale * size;
/*apply length*/
if ((txt->length.count>i) && (txt->length.vals[i]>0)) {
tspan->x_scale = gf_divfix(txt->length.vals[i], tspan->bounds.width);
tspan->bounds.width = txt->length.vals[i];
}
if (tot_width < tspan->bounds.width ) tot_width = tspan->bounds.width;
} else {
tspan->bounds.height = tspan->font_scale * size;
/*apply length*/
if ((txt->length.count>i) && (txt->length.vals[i]>0)) {
tspan->y_scale = gf_divfix(txt->length.vals[i], tspan->bounds.height);
tspan->bounds.height = txt->length.vals[i];
}
if (tot_height < tspan->bounds.height) tot_height = tspan->bounds.height;
}
}
if (trim_tspan) gf_font_manager_delete_span(ft_mgr, trim_tspan);
max_scale = FIX_ONE;
if (horizontal) {
if ((maxExtent > 0) && (tot_width>maxExtent)) {
max_scale = gf_divfix(maxExtent, tot_width);
tot_width = maxExtent;
}
tot_height = (txt->string.count-1) * line_spacing + (st->ascent + st->descent);
st->bounds.height = tot_height;
if (!strcmp(FSMINOR, "MIDDLE")) {
if (FSTTB) {
start_y = tot_height/2;
st->bounds.y = start_y;
} else {
start_y = st->descent + st->ascent - tot_height/2;
st->bounds.y = tot_height/2;
}
}
else if (!strcmp(FSMINOR, "BEGIN")) {
if (FSTTB) {
start_y = st->descent;
start_y = 0;
st->bounds.y = start_y;
} else {
st->bounds.y = st->bounds.height;
start_y = st->descent + st->ascent;
}
}
else if (!strcmp(FSMINOR, "END")) {
if (FSTTB) {
start_y = tot_height;
st->bounds.y = start_y;
} else {
start_y = -tot_height + 2*st->descent + st->ascent;
st->bounds.y = start_y - (st->descent + st->ascent) + tot_height;
}
}
else {
start_y = st->ascent;
st->bounds.y = FSTTB ? start_y : (tot_height - st->descent);
}
} else {
if ((maxExtent > 0) && (tot_height>maxExtent) ) {
max_scale = gf_divfix(maxExtent, tot_height);
tot_height = maxExtent;
}
tot_width = txt->string.count * line_spacing;
st->bounds.width = tot_width;
if (!strcmp(FSMINOR, "MIDDLE")) {
if (FSLTR) {
start_x = -tot_width/2;
st->bounds.x = start_x;
} else {
start_x = tot_width/2 - line_spacing;
st->bounds.x = - tot_width + line_spacing;
}
}
else if (!strcmp(FSMINOR, "END")) {
if (FSLTR) {
start_x = -tot_width;
st->bounds.x = start_x;
} else {
start_x = tot_width-line_spacing;
st->bounds.x = 0;
}
}
else {
if (FSLTR) {
start_x = 0;
st->bounds.x = start_x;
} else {
start_x = -line_spacing;
st->bounds.x = -tot_width;
}
}
}
/*major-justification*/
if (!strcmp(FSMAJOR, "MIDDLE") ) {
int_major = 0;
} else if (!strcmp(FSMAJOR, "END") ) {
int_major = 1;
} else {
int_major = 2;
}
st->bounds.width = st->bounds.height = 0;
count = gf_list_count(st->spans);
for (i=0; i < count; i++) {
GF_TextSpan *span = gf_list_get(st->spans, i);
switch (int_major) {
/*major-justification MIDDLE*/
case 0:
if (horizontal) {
start_x = -span->bounds.width/2;
} else {
//start_y = FSTTB ? span->bounds.height/2 : (-span->bounds.height/2 + space);
start_y = span->bounds.height/2;
}
break;
/*major-justification END*/
case 1:
if (horizontal) {
start_x = (FSLTR) ? -span->bounds.width : 0;
} else {
//start_y = FSTTB ? span->bounds.height : (-span->bounds.height + space);
start_y = FSTTB ? span->bounds.height : 0;
}
break;
/*BEGIN, FIRST or default*/
default:
if (horizontal) {
start_x = (FSLTR) ? 0 : -span->bounds.width;
} else {
//start_y = FSTTB ? 0 : space;
start_y = FSTTB ? 0 : span->bounds.height;
}
break;
}
span->off_x = start_x;
span->bounds.x = start_x;
if (horizontal) {
span->off_y = start_y - st->ascent;
span->x_scale = gf_mulfix(span->x_scale, max_scale);
span->bounds.y = start_y;
} else {
span->y_scale = gf_mulfix(span->y_scale, max_scale);
span->off_y = start_y - gf_mulfix(st->ascent, span->y_scale);
span->bounds.y = start_y;
}
span->off_x = gf_mulfix(span->off_x, max_scale);
span->off_y = gf_mulfix(span->off_y, max_scale);
if (horizontal) {
start_y += FSTTB ? -line_spacing : line_spacing;
span->bounds.height = st->descent + st->ascent;
} else {
start_x += FSLTR ? line_spacing : -line_spacing;
span->bounds.width = line_spacing;
}
gf_rect_union(&st->bounds, &span->bounds);
}
}
GF_Err compositor_3d_set_aspect_ratio(GF_Compositor *compositor)
{
GF_Event evt;
Double ratio;
Fixed scaleX, scaleY;
if (!compositor->display_height || !compositor->display_width) return GF_OK;
compositor->visual->camera.flags |= CAM_IS_DIRTY;
compositor->output_width = compositor->vp_width = compositor->display_width;
compositor->output_height = compositor->vp_height = compositor->display_height;
compositor->vp_x = 0;
compositor->vp_y = 0;
scaleX = scaleY = FIX_ONE;
if (!compositor->has_size_info) {
compositor->visual->width = compositor->vp_width;
compositor->visual->height = compositor->vp_height;
} else {
switch (compositor->aspect_ratio) {
case GF_ASPECT_RATIO_FILL_SCREEN:
break;
case GF_ASPECT_RATIO_16_9:
compositor->vp_height = 9 * compositor->vp_width / 16;
break;
case GF_ASPECT_RATIO_4_3:
compositor->vp_height = 3 * compositor->vp_width / 4;
break;
default:
ratio = compositor->scene_height;
ratio /= compositor->scene_width;
if (compositor->vp_width * ratio > compositor->vp_height) {
compositor->vp_width = compositor->vp_height * compositor->scene_width;
compositor->vp_width /= compositor->scene_height;
}
else {
compositor->vp_height = compositor->vp_width * compositor->scene_height;
compositor->vp_height /= compositor->scene_width;
}
break;
}
compositor->vp_x = (compositor->display_width - compositor->vp_width) / 2;
compositor->vp_y = (compositor->display_height - compositor->vp_height) / 2;
/*update size info for main visual*/
if (compositor->visual) {
compositor->visual->width = compositor->scene_width;
compositor->visual->height = compositor->scene_height;
}
/*scaling is still needed for bitmap*/
scaleX = gf_divfix(INT2FIX(compositor->vp_width), INT2FIX(compositor->scene_width));
scaleY = gf_divfix(INT2FIX(compositor->vp_height), INT2FIX(compositor->scene_height));
}
if (compositor->has_size_info) {
compositor->traverse_state->vp_size.x = INT2FIX(compositor->scene_width);
compositor->traverse_state->vp_size.y = INT2FIX(compositor->scene_height);
} else {
compositor->traverse_state->vp_size.x = INT2FIX(compositor->output_width);
compositor->traverse_state->vp_size.y = INT2FIX(compositor->output_height);
}
compositor_set_ar_scale(compositor, scaleX, scaleY);
/*and resetup OpenGL*/
evt.type = GF_EVENT_VIDEO_SETUP;
evt.setup.width = compositor->display_width;
evt.setup.height = compositor->display_height;
evt.setup.back_buffer = 1;
#ifdef GPAC_USE_TINYGL
evt.setup.opengl_mode = 0;
#else
evt.setup.opengl_mode = 1;
#endif
if (compositor->video_out->ProcessEvent(compositor->video_out, &evt)<0) {
compositor->reset_graphics=1;
return GF_OK;
}
#if defined(GPAC_USE_TINYGL)
{
u32 bpp;
GF_VideoSurface bb;
GF_Err e = compositor->video_out->LockBackBuffer(compositor->video_out, &bb, 1);
if (e==GF_OK) {
switch (bb.pixel_format) {
case GF_PIXEL_RGB_32:
case GF_PIXEL_ARGB:
bpp = 32;
break;
case GF_PIXEL_RGB_24:
case GF_PIXEL_BGR_24:
bpp = 24;
break;
case GF_PIXEL_RGB_565:
case GF_PIXEL_RGB_555:
bpp = 16;
break;
default:
e = GF_NOT_SUPPORTED;
bpp = 0;
break;
}
if (e==GF_OK) {
compositor->tgl_ctx = ostgl_create_context(bb.width, bb.height, bpp, &bb.video_buffer, 1);
if (compositor->tgl_ctx) ostgl_make_current(compositor->tgl_ctx, 0);
}
compositor->video_out->LockBackBuffer(compositor->video_out, &bb, 0);
}
}
#endif
return GF_OK;
}
void camera_update(GF_Camera *cam, GF_Matrix2D *user_transform, Bool center_coords, Fixed horizontal_shift, Fixed nominal_view_distance, Fixed view_distance_offset, u32 camera_layout)
{
Fixed vlen, h, w, ar;
SFVec3f corner, center;
GF_Matrix post_model_view;
if (! (cam->flags & CAM_IS_DIRTY)) return;
ar = gf_divfix(cam->width, cam->height);
gf_mx_init(post_model_view);
if (cam->is_3D) {
/*setup perspective*/
if (camera_layout==GF_3D_CAMERA_OFFAXIS) {
Fixed left, right, top, bottom, shift, wd2, ndfl, viewing_distance;
SFVec3f eye, pos, tar, disp;
viewing_distance = (nominal_view_distance + view_distance_offset);
wd2 = cam->z_near * gf_tan(cam->fieldOfView/2);
ndfl = gf_divfix(cam->z_near, viewing_distance);
/*compute h displacement*/
shift = gf_mulfix(horizontal_shift, ndfl);
top = wd2;
bottom = -top;
left = -ar * wd2 - shift;
right = ar * wd2 - shift;
gf_mx_init(cam->projection);
cam->projection.m[0] = gf_divfix(2*cam->z_near, (right-left));
cam->projection.m[5] = gf_divfix(2*cam->z_near, (top-bottom));
cam->projection.m[8] = gf_divfix(right+left, right-left);
cam->projection.m[9] = gf_divfix(top+bottom, top-bottom);
cam->projection.m[10] = gf_divfix(cam->z_far+cam->z_near, cam->z_near-cam->z_far);
cam->projection.m[11] = -FIX_ONE;
cam->projection.m[14] = 2*gf_muldiv(cam->z_near, cam->z_far, cam->z_near-cam->z_far);
cam->projection.m[15] = 0;
gf_vec_diff(eye, cam->target, cam->position);
gf_vec_norm(&eye);
disp = gf_vec_cross(eye, cam->up);
gf_vec_norm(&disp);
gf_vec_diff(center, cam->world_bbox.center, cam->position);
vlen = gf_vec_len(center);
vlen += view_distance_offset * (vlen/nominal_view_distance);
shift = horizontal_shift * vlen / viewing_distance;
pos = gf_vec_scale(disp, shift);
gf_vec_add(pos, pos, cam->position);
gf_vec_add(tar, pos, eye);
/*setup modelview*/
gf_mx_lookat(&cam->modelview, pos, tar, cam->up);
} else {
gf_mx_perspective(&cam->projection, cam->fieldOfView, ar, cam->z_near, cam->z_far);
/*setup modelview*/
gf_mx_lookat(&cam->modelview, cam->position, cam->target, cam->up);
}
if (!center_coords) {
gf_mx_add_scale(&post_model_view, 1, -1, 1);
gf_mx_add_translation(&post_model_view, -cam->width / 2, -cam->height / 2, 0);
}
/*compute center and radius - CHECK ME!*/
vlen = cam->z_far - cam->z_near;
h = gf_mulfix(vlen , gf_tan(cam->fieldOfView / 2));
w = gf_mulfix(h, ar);
center.x = 0; center.y = 0; center.z = cam->z_near + vlen / 2;
corner.x = w; corner.y = h; corner.z = vlen;
gf_vec_diff(corner, corner, center);
cam->radius = gf_vec_len(corner);
gf_vec_diff(cam->center, cam->target, cam->position);
gf_vec_norm(&cam->center);
cam->center = gf_vec_scale(cam->center, cam->z_near + vlen/2);
gf_vec_add(cam->center, cam->center, cam->position);
} else {
GF_BBox b;
Fixed hw, hh;
hw = cam->width / 2;
hh = cam->height / 2;
cam->z_near = INT2FIX(NEAR_PLANE_2D);
cam->z_far = INT2FIX(FAR_PLANE_2D);
/*setup ortho*/
gf_mx_ortho(&cam->projection, -hw, hw, -hh, hh, cam->z_near, cam->z_far);
/*setup modelview*/
gf_mx_init(cam->modelview);
#ifdef FORCE_CAMERA_3D
if (! (cam->flags & CAM_NO_LOOKAT))
gf_mx_lookat(&cam->modelview, cam->position, cam->target, cam->up);
#endif
if (!center_coords) {
gf_mx_add_scale(&post_model_view, 1, -1, 1);
gf_mx_add_translation(&post_model_view, -hw, -hh, 0);
}
if (user_transform) {
#ifdef FORCE_CAMERA_3D
if (! (cam->flags & CAM_NO_LOOKAT)) {
GF_Matrix mx;
gf_mx_from_mx2d(&mx, user_transform);
mx.m[10] = mx.m[0];
gf_mx_add_matrix(&post_model_view, &mx);
} else
#endif
gf_mx_add_matrix_2d(&post_model_view, user_transform);
}
if (cam->end_zoom != FIX_ONE) gf_mx_add_scale(&post_model_view, cam->end_zoom, cam->end_zoom, cam->end_zoom);
if (cam->flags & CAM_HAS_VIEWPORT) gf_mx_add_matrix(&post_model_view, &cam->viewport);
/*compute center & radius*/
b.max_edge.x = hw;
b.max_edge.y = hh;
b.min_edge.x = -hw;
b.min_edge.y = -hh;
b.min_edge.z = b.max_edge.z = (cam->z_near+cam->z_far) / 2;
gf_bbox_refresh(&b);
cam->center = b.center;
cam->radius = b.radius;
if (camera_layout==GF_3D_CAMERA_OFFAXIS)
camera_layout=GF_3D_CAMERA_LINEAR;
}
if (camera_layout == GF_3D_CAMERA_CIRCULAR) {
GF_Matrix mx;
Fixed viewing_distance = nominal_view_distance + view_distance_offset;
SFVec3f pos, target;
Fixed angle;
gf_vec_diff(center, cam->world_bbox.center, cam->position);
vlen = gf_vec_len(center);
vlen += view_distance_offset * (vlen/nominal_view_distance);
gf_vec_diff(pos, cam->target, cam->position);
gf_vec_norm(&pos);
pos = gf_vec_scale(pos, vlen);
gf_vec_add(target, pos, cam->position);
gf_mx_init(mx);
gf_mx_add_translation(&mx, target.x, target.y, target.z);
angle = gf_atan2(horizontal_shift, viewing_distance);
gf_mx_add_rotation(&mx, angle, cam->up.x, cam->up.y, cam->up.z);
gf_mx_add_translation(&mx, -target.x, -target.y, -target.z);
pos = cam->position;
gf_mx_apply_vec(&mx, &pos);
gf_mx_lookat(&cam->modelview, pos, target, cam->up);
} else if (camera_layout == GF_3D_CAMERA_LINEAR) {
Fixed viewing_distance = nominal_view_distance + view_distance_offset;
GF_Vec eye, disp, pos, tar;
gf_vec_diff(center, cam->world_bbox.center, cam->position);
vlen = gf_vec_len(center);
vlen += view_distance_offset * (vlen/nominal_view_distance);
gf_vec_diff(eye, cam->target, cam->position);
gf_vec_norm(&eye);
tar = gf_vec_scale(eye, vlen);
gf_vec_add(tar, tar, cam->position);
disp = gf_vec_cross(eye, cam->up);
gf_vec_norm(&disp);
disp= gf_vec_scale(disp, vlen*horizontal_shift/viewing_distance);
gf_vec_add(pos, cam->position, disp);
gf_mx_lookat(&cam->modelview, pos, tar, cam->up);
}
gf_mx_add_matrix(&cam->modelview, &post_model_view);
/*compute frustum planes*/
gf_mx_copy(cam->unprojection, cam->projection);
gf_mx_add_matrix_4x4(&cam->unprojection, &cam->modelview);
camera_frustum_from_matrix(cam, &cam->unprojection);
/*also compute reverse PM for unprojections*/
gf_mx_inverse_4x4(&cam->unprojection);
cam->flags &= ~CAM_IS_DIRTY;
}
static Bool compositor_handle_navigation_3d(GF_Compositor *compositor, GF_Event *ev)
{
Fixed x, y, trans_scale;
Fixed dx, dy, key_trans, key_pan, key_exam;
s32 key_inv;
u32 keys;
Bool is_pixel_metrics;
GF_Camera *cam;
Fixed zoom = compositor->zoom;
cam = NULL;
if (compositor->active_layer) {
#ifndef GPAC_DISABLE_VRML
cam = compositor_layer3d_get_camera(compositor->active_layer);
is_pixel_metrics = gf_sg_use_pixel_metrics(gf_node_get_graph(compositor->active_layer));
#endif
}
if (!cam) {
cam = &compositor->visual->camera;
assert(compositor);
assert(compositor->scene);
is_pixel_metrics = compositor->traverse_state->pixel_metrics;
}
keys = compositor->key_states;
if (!cam->navigate_mode && !(keys & GF_KEY_MOD_ALT) ) return 0;
x = y = 0;
/*renorm between -1, 1*/
if (ev->type<=GF_EVENT_MOUSEWHEEL) {
x = gf_divfix( INT2FIX(ev->mouse.x + (s32) compositor->visual->width/2), INT2FIX(compositor->visual->width));
y = gf_divfix( INT2FIX(ev->mouse.y + (s32) compositor->visual->height/2), INT2FIX(compositor->visual->height));
}
dx = (x - compositor->grab_x);
dy = (compositor->grab_y - y);
/* trans_scale = is_pixel_metrics ? cam->width/2 : INT2FIX(10);
key_trans = is_pixel_metrics ? INT2FIX(10) : cam->avatar_size.x;
*/
trans_scale = cam->width/20;
key_trans = cam->avatar_size.x;
if (cam->world_bbox.is_set && (key_trans*5 > cam->world_bbox.radius)) {
key_trans = cam->world_bbox.radius / 10;
}
key_pan = FIX_ONE/25;
key_exam = FIX_ONE/10;
key_inv = 1;
if (keys & GF_KEY_MOD_SHIFT) {
dx *= 4;
dy *= 4;
key_pan *= 4;
key_exam *= 4;
key_trans*=4;
}
switch (ev->type) {
case GF_EVENT_MOUSEDOWN:
/*left*/
if (ev->mouse.button==GF_MOUSE_LEFT) {
compositor->grab_x = x;
compositor->grab_y = y;
compositor->navigation_state = 1;
/*change vp and examine center to current location*/
if ((keys & GF_KEY_MOD_CTRL) && compositor->hit_square_dist) {
cam->vp_position = cam->position;
cam->vp_orientation = camera_get_orientation(cam->position, cam->target, cam->up);
cam->vp_fov = cam->fieldOfView;
cam->examine_center = compositor->hit_world_point;
camera_changed(compositor, cam);
return 1;
}
}
/*right*/
else if (ev->mouse.button==GF_MOUSE_RIGHT) {
if (compositor->navigation_state && (cam->navigate_mode==GF_NAVIGATE_WALK)) {
camera_jump(cam);
gf_sc_invalidate(compositor, NULL);
return 1;
}
else if (keys & GF_KEY_MOD_CTRL) gf_sc_fit_world_to_screen(compositor);
}
break;
/* note: shortcuts are mostly the same as blaxxun contact, I don't feel like remembering 2 sets...*/
case GF_EVENT_MOUSEMOVE:
if (!compositor->navigation_state) {
if (cam->navigate_mode==GF_NAVIGATE_GAME) {
/*init mode*/
compositor->grab_x = x;
compositor->grab_y = y;
compositor->navigation_state = 1;
}
return 0;
}
compositor->navigation_state++;
switch (cam->navigate_mode) {
/*FIXME- we'll likely need a "step" value for walk at some point*/
case GF_NAVIGATE_WALK:
case GF_NAVIGATE_FLY:
view_pan_x(compositor, cam, -dx);
if (keys & GF_KEY_MOD_CTRL) view_pan_y(compositor, cam, dy);
else view_translate_z(compositor, cam, gf_mulfix(dy, trans_scale));
break;
case GF_NAVIGATE_VR:
view_pan_x(compositor, cam, -dx);
if (keys & GF_KEY_MOD_CTRL) view_zoom(compositor, cam, dy);
else view_pan_y(compositor, cam, dy);
break;
case GF_NAVIGATE_PAN:
view_pan_x(compositor, cam, -dx);
if (keys & GF_KEY_MOD_CTRL) view_translate_z(compositor, cam, gf_mulfix(dy, trans_scale));
else view_pan_y(compositor, cam, dy);
break;
case GF_NAVIGATE_SLIDE:
view_translate_x(compositor, cam, gf_mulfix(dx, trans_scale));
if (keys & GF_KEY_MOD_CTRL) view_translate_z(compositor, cam, gf_mulfix(dy, trans_scale));
else view_translate_y(compositor, cam, gf_mulfix(dy, trans_scale));
break;
case GF_NAVIGATE_EXAMINE:
if (keys & GF_KEY_MOD_CTRL) {
view_translate_z(compositor, cam, gf_mulfix(dy, trans_scale));
view_roll(compositor, cam, gf_mulfix(dx, trans_scale));
} else {
view_exam_x(compositor, cam, -gf_mulfix(GF_PI, dx));
view_exam_y(compositor, cam, gf_mulfix(GF_PI, dy));
}
break;
case GF_NAVIGATE_ORBIT:
if (keys & GF_KEY_MOD_CTRL) {
view_translate_z(compositor, cam, gf_mulfix(dy, trans_scale));
} else {
view_orbit_x(compositor, cam, -gf_mulfix(GF_PI, dx));
view_orbit_y(compositor, cam, gf_mulfix(GF_PI, dy));
}
break;
case GF_NAVIGATE_GAME:
view_pan_x(compositor, cam, -dx);
view_pan_y(compositor, cam, dy);
break;
}
compositor->grab_x = x;
compositor->grab_y = y;
return 1;
case GF_EVENT_MOUSEWHEEL:
switch (cam->navigate_mode) {
/*FIXME- we'll likely need a "step" value for walk at some point*/
case GF_NAVIGATE_WALK:
case GF_NAVIGATE_FLY:
view_pan_y(compositor, cam, gf_mulfix(key_pan, ev->mouse.wheel_pos));
break;
case GF_NAVIGATE_VR:
view_zoom(compositor, cam, gf_mulfix(key_pan, ev->mouse.wheel_pos));
break;
case GF_NAVIGATE_SLIDE:
case GF_NAVIGATE_EXAMINE:
case GF_NAVIGATE_ORBIT:
case GF_NAVIGATE_PAN:
if (cam->is_3D) {
view_translate_z(compositor, cam, gf_mulfix(trans_scale, ev->mouse.wheel_pos) * ((keys & GF_KEY_MOD_SHIFT) ? 4 : 1));
} else {
nav_set_zoom_trans_2d(compositor->visual, zoom + INT2FIX(ev->mouse.wheel_pos)/10, 0, 0);
}
}
return 1;
case GF_EVENT_MOUSEUP:
if (ev->mouse.button==GF_MOUSE_LEFT) compositor->navigation_state = 0;
break;
case GF_EVENT_KEYDOWN:
switch (ev->key.key_code) {
case GF_KEY_BACKSPACE:
gf_sc_reset_graphics(compositor);
return 1;
case GF_KEY_C:
compositor->collide_mode = compositor->collide_mode ? GF_COLLISION_NONE : GF_COLLISION_DISPLACEMENT;
return 1;
case GF_KEY_J:
if (cam->navigate_mode==GF_NAVIGATE_WALK) {
camera_jump(cam);
gf_sc_invalidate(compositor, NULL);
return 1;
}
break;
case GF_KEY_HOME:
if (!compositor->navigation_state) {
compositor->visual->camera.start_zoom = compositor->zoom;
compositor->zoom = FIX_ONE;
compositor->interoccular_offset = 0;
compositor->view_distance_offset = 0;
compositor->interoccular_offset = 0;
compositor->view_distance_offset = 0;
compositor_3d_reset_camera(compositor);
}
break;
case GF_KEY_END:
if (cam->navigate_mode==GF_NAVIGATE_GAME) {
cam->navigate_mode = GF_NAVIGATE_WALK;
compositor->navigation_state = 0;
return 1;
}
break;
case GF_KEY_LEFT: key_inv = -1;
case GF_KEY_RIGHT:
if (keys & GF_KEY_MOD_ALT) {
if ( (keys & GF_KEY_MOD_SHIFT) && (compositor->visual->nb_views > 1) ) {
compositor->view_distance_offset += key_inv * (is_pixel_metrics ? INT2FIX(1) : FLT2FIX(0.1));
cam->flags |= CAM_IS_DIRTY;
fprintf(stdout, "AutoStereo view distance %f\n", FIX2FLT(compositor->view_distance_offset + compositor->video_out->view_distance)/100);
gf_sc_invalidate(compositor, NULL);
return 1;
}
return 0;
}
switch (cam->navigate_mode) {
case GF_NAVIGATE_SLIDE:
if (keys & GF_KEY_MOD_CTRL) view_pan_x(compositor, cam, key_inv * key_pan);
else view_translate_x(compositor, cam, key_inv * key_trans);
break;
case GF_NAVIGATE_EXAMINE:
if (keys & GF_KEY_MOD_CTRL) view_roll(compositor, cam, gf_mulfix(dx, trans_scale));
else view_exam_x(compositor, cam, -key_inv * key_exam);
break;
case GF_NAVIGATE_ORBIT:
if (keys & GF_KEY_MOD_CTRL) view_translate_x(compositor, cam, key_inv * key_trans);
else view_orbit_x(compositor, cam, -key_inv * key_exam);
break;
case GF_NAVIGATE_GAME: view_translate_x(compositor, cam, key_inv * key_trans); break;
case GF_NAVIGATE_VR: view_pan_x(compositor, cam, -key_inv * key_pan); break;
/*walk/fly/pan*/
default:
if (keys & GF_KEY_MOD_CTRL) view_translate_x(compositor, cam, key_inv * key_trans);
else view_pan_x(compositor, cam, -key_inv * key_pan);
break;
}
return 1;
case GF_KEY_DOWN: key_inv = -1;
case GF_KEY_UP:
if (keys & GF_KEY_MOD_ALT) {
if ( (keys & GF_KEY_MOD_SHIFT) && (compositor->visual->nb_views > 1) ) {
compositor->interoccular_offset += FLT2FIX(0.5) * key_inv;
fprintf(stdout, "AutoStereo interoccular distance %f\n", FIX2FLT(compositor->interoccular_offset)+6.8);
cam->flags |= CAM_IS_DIRTY;
gf_sc_invalidate(compositor, NULL);
return 1;
}
return 0;
}
switch (cam->navigate_mode) {
case GF_NAVIGATE_SLIDE:
if (keys & GF_KEY_MOD_CTRL) view_translate_z(compositor, cam, key_inv * key_trans);
else view_translate_y(compositor, cam, key_inv * key_trans);
break;
case GF_NAVIGATE_EXAMINE:
if (keys & GF_KEY_MOD_CTRL) view_translate_z(compositor, cam, key_inv * key_trans);
else view_exam_y(compositor, cam, -key_inv * key_exam);
break;
case GF_NAVIGATE_ORBIT:
if (keys & GF_KEY_MOD_CTRL) view_translate_y(compositor, cam, key_inv * key_trans);
else view_orbit_y(compositor, cam, -key_inv * key_exam);
break;
case GF_NAVIGATE_PAN:
if (keys & GF_KEY_MOD_CTRL) view_translate_y(compositor, cam, key_inv * key_trans);
else view_pan_y(compositor, cam, key_inv * key_pan);
break;
case GF_NAVIGATE_GAME: view_translate_z(compositor, cam, key_inv * key_trans); break;
case GF_NAVIGATE_VR:
if (keys & GF_KEY_MOD_CTRL) view_zoom(compositor, cam, key_inv * key_pan);
else view_pan_y(compositor, cam, key_inv * key_pan);
break;
/*walk/fly*/
default:
if (keys & GF_KEY_MOD_CTRL) view_pan_y(compositor, cam, key_inv * key_pan);
else view_translate_z(compositor, cam, key_inv * key_trans);
break;
}
return 1;
case GF_KEY_PAGEDOWN:
if (keys & GF_KEY_MOD_CTRL) { view_zoom(compositor, cam, FIX_ONE/10); return 1; }
break;
case GF_KEY_PAGEUP:
if (keys & GF_KEY_MOD_CTRL) { view_zoom(compositor, cam, -FIX_ONE/10); return 1; }
break;
}
break;
}
return 0;
}
Bool gf_sc_fit_world_to_screen(GF_Compositor *compositor)
{
GF_TraverseState tr_state;
SFVec3f pos, diff;
Fixed dist, d;
GF_Camera *cam;
GF_Node *top;
#ifndef GPAC_DISABLE_VRML
// if (gf_list_count(compositor->visual->back_stack)) return;
if (gf_list_count(compositor->visual->view_stack)) return 0;
#endif
gf_mx_p(compositor->mx);
top = gf_sg_get_root_node(compositor->scene);
if (!top) {
gf_mx_v(compositor->mx);
return 0;
}
memset(&tr_state, 0, sizeof(GF_TraverseState));
tr_state.traversing_mode = TRAVERSE_GET_BOUNDS;
tr_state.visual = compositor->visual;
gf_node_traverse(top, &tr_state);
if (gf_node_dirty_get(top)) {
tr_state.bbox.is_set = 0;
}
if (!tr_state.bbox.is_set) {
gf_mx_v(compositor->mx);
/*empty world ...*/
if (tr_state.bbox.radius==-1) return 1;
/*2D world with 3D camera forced*/
if (tr_state.bounds.width&&tr_state.bounds.height) return 1;
return 0;
}
cam = &compositor->visual->camera;
cam->world_bbox = tr_state.bbox;
/*fit is based on bounding sphere*/
dist = gf_divfix(tr_state.bbox.radius, gf_sin(cam->fieldOfView/2) );
gf_vec_diff(diff, cam->center, tr_state.bbox.center);
/*do not update if camera is outside the scene bounding sphere and dist is too close*/
if (gf_vec_len(diff) > tr_state.bbox.radius + cam->radius) {
gf_vec_diff(diff, cam->vp_position, tr_state.bbox.center);
d = gf_vec_len(diff);
if (d<dist) {
gf_mx_v(compositor->mx);
return 1;
}
}
diff = gf_vec_scale(camera_get_pos_dir(cam), dist);
gf_vec_add(pos, tr_state.bbox.center, diff);
diff = cam->position;
camera_set_vectors(cam, pos, cam->vp_orientation, cam->fieldOfView);
cam->position = diff;
camera_move_to(cam, pos, cam->target, cam->up);
cam->examine_center = tr_state.bbox.center;
cam->flags |= CF_STORE_VP;
if (cam->z_far < dist) cam->z_far = 10*dist;
camera_changed(compositor, cam);
gf_mx_v(compositor->mx);
return 1;
}
static void NLD_Apply(M_NonLinearDeformer *nld, GF_Mesh *mesh)
{
u32 i;
GF_Matrix mx;
SFVec3f n;
Fixed param, z_min, z_max, v_min, v_max, f_min, f_max, frac, val, a_cos, a_sin;
Bool needs_transform = NLD_GetMatrix(nld, &mx);
param = nld->param;
if (!param) param = 1;
if (mesh->bounds.min_edge.z == mesh->bounds.max_edge.z) return;
z_min = FIX_MAX;
z_max = -FIX_MAX;
if (needs_transform) {
for (i=0; i<mesh->v_count; i++) {
gf_mx_apply_vec(&mx, &mesh->vertices[i].pos);
MESH_GET_NORMAL(n, mesh->vertices[i]);
gf_mx_rotate_vector(&mx, &n);
MESH_SET_NORMAL(mesh->vertices[i], n);
if (mesh->vertices[i].pos.z<z_min) z_min = mesh->vertices[i].pos.z;
if (mesh->vertices[i].pos.z>z_max) z_max = mesh->vertices[i].pos.z;
}
} else {
z_min = mesh->bounds.min_edge.z;
z_max = mesh->bounds.max_edge.z;
}
for (i=0; i<mesh->v_count; i++) {
SFVec3f old = mesh->vertices[i].pos;
frac = gf_divfix(old.z - z_min, z_max - z_min);
NLD_GetKey(nld, frac, &f_min, &v_min, &f_max, &v_max);
if (f_max == f_min) {
val = v_min;
} else {
frac = gf_divfix(frac-f_min, f_max - f_min);
val = gf_mulfix(v_max - v_min, frac) + v_min;
}
val = gf_mulfix(val, param);
switch (nld->type) {
/*taper*/
case 0:
mesh->vertices[i].pos.x = gf_mulfix(mesh->vertices[i].pos.x, val);
mesh->vertices[i].pos.y = gf_mulfix(mesh->vertices[i].pos.y, val);
MESH_GET_NORMAL(old, mesh->vertices[i]);
n=old;
n.x = gf_mulfix(n.x, val);
n.y = gf_mulfix(n.y, val);
gf_vec_norm(&n);
MESH_SET_NORMAL(mesh->vertices[i], n);
break;
/*twist*/
case 1:
a_cos = gf_cos(val);
a_sin = gf_sin(val);
mesh->vertices[i].pos.x = gf_mulfix(a_cos, old.x) - gf_mulfix(a_sin, old.y);
mesh->vertices[i].pos.y = gf_mulfix(a_sin, old.x) + gf_mulfix(a_cos, old.y);
MESH_GET_NORMAL(old, mesh->vertices[i]);
n=old;
n.x = gf_mulfix(a_cos, old.x) - gf_mulfix(a_sin, old.y);
n.y = gf_mulfix(a_sin, old.x) + gf_mulfix(a_cos, old.y);
gf_vec_norm(&n);
MESH_SET_NORMAL(mesh->vertices[i], n);
break;
/*bend*/
case 2:
a_cos = gf_cos(val);
a_sin = gf_sin(val);
mesh->vertices[i].pos.x = gf_mulfix(a_sin, old.z) + gf_mulfix(a_cos, old.x);
mesh->vertices[i].pos.z = gf_mulfix(a_cos, old.z) - gf_mulfix(a_sin, old.x);
MESH_GET_NORMAL(old, mesh->vertices[i]);
n=old;
n.x = gf_mulfix(a_sin, old.z) + gf_mulfix(a_cos, old.x);
n.z = gf_mulfix(a_cos, old.z) - gf_mulfix(a_sin, old.x);
gf_vec_norm(&n);
MESH_SET_NORMAL(mesh->vertices[i], n);
break;
/*pinch, not standard (taper on X dim only)*/
case 3:
mesh->vertices[i].pos.x = gf_mulfix(mesh->vertices[i].pos.x, val);
MESH_GET_NORMAL(old, mesh->vertices[i]);
n=old;
n.x = gf_mulfix(n.x, val);
gf_vec_norm(&n);
MESH_SET_NORMAL(mesh->vertices[i], n);
break;
}
}
if (needs_transform) {
gf_mx_inverse(&mx);
for (i=0; i<mesh->v_count; i++) {
gf_mx_apply_vec(&mx, &mesh->vertices[i].pos);
MESH_GET_NORMAL(n, mesh->vertices[i]);
gf_mx_rotate_vector(&mx, &n);
MESH_SET_NORMAL(mesh->vertices[i], n);
}
}
mesh_update_bounds(mesh);
gf_mesh_build_aabbtree(mesh);
}
