GF_Node *CT2D_PickNode(GF_TextureHandler *txh, DrawableContext *ctx, Fixed x, Fixed y)
{
GF_Rect orig;
GF_Matrix2D mat, tx_trans;
Fixed width, height;
Composite2DStack *st = (Composite2DStack *) gf_node_get_private(txh->owner);
assert(st->surf);
orig = ctx->bi->unclip;
gf_mx2d_copy(mat, ctx->transform);
gf_mx2d_inverse(&mat);
gf_mx2d_apply_rect(&mat, &orig);
gf_mx2d_init(mat);
gf_mx2d_add_scale(&mat, orig.width / st->width, orig.height / st->height);
get_gf_sr_texture_transform(ctx->appear, &st->txh, &tx_trans, (ctx->h_texture==&st->txh) ? 0 : 1, INT2FIX(orig.width), INT2FIX(orig.height));
gf_mx2d_add_matrix(&mat, &tx_trans);
gf_mx2d_add_translation(&mat, (orig.x), (orig.y - orig.height));
gf_mx2d_add_matrix(&mat, &ctx->transform);
gf_mx2d_inverse(&mat);
gf_mx2d_apply_coords(&mat, &x, &y);
width = INT2FIX(st->width);
height = INT2FIX(st->height);
while (x>width) x -= width;
while (x < 0) x += width;
while (y>height) y -= height;
while (y < 0) y += height;
x -= width / 2;
y -= height / 2;
return VS2D_PickNode(st->surf, x, y);
}
void get_gf_sr_texture_transform(GF_Node *__appear, GF_TextureHandler *txh, GF_Matrix2D *mat, Bool line_texture, Fixed final_width, Fixed final_height)
{
u32 node_tag;
M_Appearance *appear;
GF_Node *txtrans = NULL;
gf_mx2d_init(*mat);
if (!__appear || !txh) return;
appear = (M_Appearance *)__appear;
if (!line_texture) {
if (!appear->textureTransform) return;
txtrans = appear->textureTransform;
} else {
if (gf_node_get_tag(appear->material) != TAG_MPEG4_Material2D) return;
if (gf_node_get_tag(((M_Material2D *)appear->material)->lineProps) != TAG_MPEG4_XLineProperties) return;
txtrans = ((M_XLineProperties *) ((M_Material2D *)appear->material)->lineProps)->textureTransform;
}
if (!txtrans) return;
/*gradient doesn't need bounds info in texture transform*/
if (txh->compute_gradient_matrix) {
final_width = final_height = FIX_ONE;
}
node_tag = gf_node_get_tag(txtrans);
if (node_tag==TAG_MPEG4_TextureTransform) {
/*VRML: Tc' = -C × S × R × C × T × Tc*/
M_TextureTransform *txt = (M_TextureTransform *) txtrans;
SFVec2f scale = txt->scale;
if (!scale.x) scale.x = FIX_ONE/100;
if (!scale.y) scale.y = FIX_ONE/100;
gf_mx2d_add_translation(mat, -txt->center.x * final_width, -txt->center.y * final_height);
gf_mx2d_add_scale(mat, scale.x, scale.y);
gf_mx2d_add_rotation(mat, 0, 0, txt->rotation);
gf_mx2d_add_translation(mat, txt->center.x * final_width, txt->center.y * final_height);
gf_mx2d_add_translation(mat, txt->translation.x * final_width, txt->translation.y * final_height);
/*and inverse the matrix (this is texture transform, cf VRML)*/
gf_mx2d_inverse(mat);
return;
}
if (node_tag==TAG_MPEG4_TransformMatrix2D) {
TM2D_GetMatrix((GF_Node *) txtrans, mat);
mat->m[2] *= final_width;
mat->m[5] *= final_height;
gf_mx2d_inverse(mat);
return;
}
}
GF_EXPORT
GF_Err gf_path_add_arc_to(GF_Path *gp, Fixed end_x, Fixed end_y, Fixed fa_x, Fixed fa_y, Fixed fb_x, Fixed fb_y, Bool cw)
{
GF_Matrix2D mat, inv;
Fixed angle, start_angle, end_angle, sweep, axis_w, axis_h, tmp, cx, cy, _vx, _vy, start_x, start_y;
s32 i, num_steps;
if (!gp->n_points) return GF_BAD_PARAM;
start_x = gp->points[gp->n_points-1].x;
start_y = gp->points[gp->n_points-1].y;
cx = (fb_x + fa_x)/2;
cy = (fb_y + fa_y)/2;
angle = gf_atan2(fb_y-fa_y, fb_x-fa_x);
gf_mx2d_init(mat);
gf_mx2d_add_rotation(&mat, 0, 0, angle);
gf_mx2d_add_translation(&mat, cx, cy);
gf_mx2d_copy(inv, mat);
gf_mx2d_inverse(&inv);
gf_mx2d_apply_coords(&inv, &start_x, &start_y);
gf_mx2d_apply_coords(&inv, &end_x, &end_y);
gf_mx2d_apply_coords(&inv, &fa_x, &fa_y);
gf_mx2d_apply_coords(&inv, &fb_x, &fb_y);
//start angle and end angle
start_angle = gf_atan2(start_y, start_x);
end_angle = gf_atan2(end_y, end_x);
tmp = gf_mulfix((start_x - fa_x), (start_x - fa_x)) + gf_mulfix((start_y - fa_y), (start_y - fa_y));
axis_w = gf_sqrt(tmp);
tmp = gf_mulfix((start_x - fb_x) , (start_x - fb_x)) + gf_mulfix((start_y - fb_y), (start_y - fb_y));
axis_w += gf_sqrt(tmp);
axis_w /= 2;
axis_h = gf_sqrt(gf_mulfix(axis_w, axis_w) - gf_mulfix(fa_x,fa_x));
sweep = end_angle - start_angle;
if (cw) {
if (sweep>0) sweep -= 2*GF_PI;
} else {
if (sweep<0) sweep += 2*GF_PI;
}
num_steps = GF_2D_DEFAULT_RES/2;
for (i=1; i<=num_steps; i++) {
angle = start_angle + sweep*i/num_steps;
_vx = gf_mulfix(axis_w, gf_cos(angle));
_vy = gf_mulfix(axis_h, gf_sin(angle));
/*re-invert*/
gf_mx2d_apply_coords(&mat, &_vx, &_vy);
gf_path_add_line_to(gp, _vx, _vy);
}
return GF_OK;
}
GF_Err evg_surface_fill(GF_SURFACE _this, GF_STENCIL stencil)
{
GF_Rect rc;
GF_Matrix2D mat, st_mat;
Bool restore_filter;
EVGSurface *surf = (EVGSurface *)_this;
EVGStencil *sten = (EVGStencil *)stencil;
if (!surf || !stencil) return GF_BAD_PARAM;
if (!surf->ftoutline.n_points) return GF_OK;
surf->sten = sten;
/*setup ft raster calllbacks*/
if (!setup_grey_callback(surf)) return GF_OK;
/* surf->ftparams.gray_spans = gray_spans_stub; */
get_surface_world_matrix(surf, &mat);
restore_filter = 0;
/*get path frame for texture convertion */
if (sten->type != GF_STENCIL_SOLID) {
rc = surf->path_bounds;
gf_mx2d_apply_rect(&mat, &rc);
rc.x = rc.y = 0;
/*assign target frame and matrix*/
sten->frame = rc;
gf_mx2d_copy(sten->pmat, surf->mat);
gf_mx2d_inverse(&sten->pmat);
gf_mx2d_copy(st_mat, sten->smat);
gf_mx2d_init(sten->smat);
switch (sten->type) {
case GF_STENCIL_TEXTURE:
if (! ((EVG_Texture *)sten)->pixels) return GF_BAD_PARAM;
if (((EVG_Texture *)sten)->mod & GF_TEXTURE_FLIP) {
if (!surf->center_coords) gf_mx2d_add_scale(&sten->smat, FIX_ONE, -FIX_ONE);
} else {
if (surf->center_coords) gf_mx2d_add_scale(&sten->smat, FIX_ONE, -FIX_ONE);
}
evg_set_texture_active(sten);
gf_mx2d_add_matrix(&sten->smat, &st_mat);
gf_mx2d_add_matrix(&sten->smat, &mat);
gf_mx2d_inverse(&sten->smat);
evg_bmp_init(sten);
if (((EVG_Texture *)sten)->filter == GF_TEXTURE_FILTER_DEFAULT) {
restore_filter = 1;
((EVG_Texture *)sten)->filter = surf->texture_filter;
}
break;
case GF_STENCIL_LINEAR_GRADIENT:
{
EVG_LinearGradient *lin = (EVG_LinearGradient *)sten;
gf_mx2d_add_matrix(&sten->smat, &st_mat);
gf_mx2d_add_matrix(&sten->smat, &mat);
gf_mx2d_inverse(&sten->smat);
/*and finalize matrix in gradient coord system*/
gf_mx2d_add_matrix(&sten->smat, &lin->vecmat);
gf_mx2d_add_scale(&sten->smat, INT2FIX(1<<EVGGRADIENTBITS), INT2FIX(1<<EVGGRADIENTBITS));
}
break;
case GF_STENCIL_RADIAL_GRADIENT:
{
EVG_RadialGradient *rad = (EVG_RadialGradient*)sten;
gf_mx2d_copy(sten->smat, st_mat);
gf_mx2d_add_matrix(&sten->smat, &mat);
gf_mx2d_inverse(&sten->smat);
gf_mx2d_add_translation(&sten->smat, -rad->center.x, -rad->center.y);
gf_mx2d_add_scale(&sten->smat, gf_invfix(rad->radius.x), gf_invfix(rad->radius.y));
rad->d_f.x = gf_divfix(rad->focus.x - rad->center.x, rad->radius.x);
rad->d_f.y = gf_divfix(rad->focus.y - rad->center.y, rad->radius.y);
/*init*/
evg_radial_init(rad);
}
break;
}
}
if (surf->useClipper) {
surf->ftparams.clip_xMin = surf->clipper.x;
surf->ftparams.clip_yMin = surf->clipper.y;
surf->ftparams.clip_xMax = (surf->clipper.x + surf->clipper.width);
surf->ftparams.clip_yMax = (surf->clipper.y + surf->clipper.height);
} else {
surf->ftparams.clip_xMin = 0;
surf->ftparams.clip_yMin = 0;
surf->ftparams.clip_xMax = (surf->width);
surf->ftparams.clip_yMax = (surf->height);
}
/*and call the raster*/
evg_raster_render(surf->raster, &surf->ftparams);
/*restore stencil matrix*/
if (sten->type != GF_STENCIL_SOLID) {
gf_mx2d_copy(sten->smat, st_mat);
if (restore_filter) ((EVG_Texture *)sten)->filter = GF_TEXTURE_FILTER_DEFAULT;
}
surf->sten = 0L;
return GF_OK;
}
void svg_drawable_pick(GF_Node *node, Drawable *drawable, GF_TraverseState *tr_state)
{
DrawAspect2D asp;
GF_Matrix2D inv_2d;
Fixed x, y;
Bool picked = 0;
GF_Compositor *compositor = tr_state->visual->compositor;
SVGPropertiesPointers backup_props;
GF_Matrix2D backup_matrix;
GF_Matrix mx_3d;
SVGAllAttributes all_atts;
if (!drawable->path) return;
gf_svg_flatten_attributes((SVG_Element *)node, &all_atts);
memcpy(&backup_props, tr_state->svg_props, sizeof(SVGPropertiesPointers));
gf_svg_apply_inheritance(&all_atts, tr_state->svg_props);
if (compositor_svg_is_display_off(tr_state->svg_props)) return;
compositor_svg_apply_local_transformation(tr_state, &all_atts, &backup_matrix, &mx_3d);
memset(&asp, 0, sizeof(DrawAspect2D));
drawable_get_aspect_2d_svg(node, &asp, tr_state);
#ifndef GPAC_DISABLE_3D
if (tr_state->visual->type_3d) {
svg_drawable_3d_pick(drawable, tr_state, &asp);
compositor_svg_restore_parent_transformation(tr_state, &backup_matrix, &mx_3d);
memcpy(tr_state->svg_props, &backup_props, sizeof(SVGPropertiesPointers));
return;
}
#endif
gf_mx2d_copy(inv_2d, tr_state->transform);
gf_mx2d_inverse(&inv_2d);
x = tr_state->ray.orig.x;
y = tr_state->ray.orig.y;
gf_mx2d_apply_coords(&inv_2d, &x, &y);
picked = svg_drawable_is_over(drawable, x, y, &asp, tr_state, NULL);
if (picked) {
u32 count, i;
compositor->hit_local_point.x = x;
compositor->hit_local_point.y = y;
compositor->hit_local_point.z = 0;
gf_mx_from_mx2d(&compositor->hit_world_to_local, &tr_state->transform);
gf_mx_from_mx2d(&compositor->hit_local_to_world, &inv_2d);
compositor->hit_node = drawable->node;
compositor->hit_use_dom_events = 1;
compositor->hit_normal.x = compositor->hit_normal.y = 0; compositor->hit_normal.z = FIX_ONE;
compositor->hit_texcoords.x = gf_divfix(x, drawable->path->bbox.width) + FIX_ONE/2;
compositor->hit_texcoords.y = gf_divfix(y, drawable->path->bbox.height) + FIX_ONE/2;
svg_clone_use_stack(compositor, tr_state);
/*not use in SVG patterns*/
compositor->hit_appear = NULL;
/*also stack any VRML sensors present at the current level. If the event is not catched
by a listener in the SVG tree, the event will be forwarded to the VRML tree*/
gf_list_reset(tr_state->visual->compositor->sensors);
count = gf_list_count(tr_state->vrml_sensors);
for (i=0; i<count; i++) {
gf_list_add(tr_state->visual->compositor->sensors, gf_list_get(tr_state->vrml_sensors, i));
}
GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPOSE, ("[SVG Picking] node %s is under mouse - hit %g %g 0\n", gf_node_get_log_name(drawable->node), FIX2FLT(x), FIX2FLT(y)));
}
compositor_svg_restore_parent_transformation(tr_state, &backup_matrix, &mx_3d);
memcpy(tr_state->svg_props, &backup_props, sizeof(SVGPropertiesPointers));
}
