mpeg4_animators.c

一个用于智能手机的多媒体库适合S60 WinCE的跨平台开发库

			frac = do_bisection(frac, stack->a, stack->b, stack->c, stack->d);
			i = FIX2INT(gf_floor(frac*(nbVals-1)));
			frac = (frac - INT2FIX(i) / (nbVals-1) ) * (nbVals-1);
			break;
		default:
			return;
		}
		/*interpolate*/
		pa->value_changed.x = Interpolate(pa->keyValue.vals[i].x, pa->keyValue.vals[i+1].x, frac);
		pa->value_changed.y = Interpolate(pa->keyValue.vals[i].y, pa->keyValue.vals[i+1].y, frac);
		pa->value_changed.z = Interpolate(pa->keyValue.vals[i].z, pa->keyValue.vals[i+1].z, frac);
		break;
	/*bezier interpolate*/
	case ANIM_QUADRATIC:
	case ANIM_CUBIC:
	case ANIM_NURBS:
		if (!stack->anurbs.valid) return;
		/*compute frac*/
		switch (stack->anim_type) {
		case ANIM_DISCRETE:
			i = FIX2INT(gf_floor(frac*nbVals));
			frac = INT2FIX(i) / nbVals;
			break;
		case ANIM_LINEAR:
			i = FIX2INT(gf_floor(frac*(nbVals-1)));
			frac = (frac - INT2FIX(i) / (nbVals-1) ) * (nbVals-1);
			break;
		case ANIM_VELOCITY:
			frac = do_bisection(frac, stack->a, stack->b, stack->c, stack->d);
			break;
		/*nothing to do for this one here*/
		case ANIM_DEFAULT:
		/*not supported - use frac as is*/
		case ANIM_PACED: 
		default:
			break;
		}
		/*evaluate*/
		i = anurbs_find_span(&stack->anurbs, frac);
		anurbs_basis(&stack->anurbs, i, frac);
		pa->value_changed = anurbs_get_vec3f(&stack->anurbs, i, pa->keyValue.vals);
		break;
	/*not supported*/
	case ANIM_SPLINE: 
	default:
		return;
	}

	pa->value_changed.x += pa->offset.x;
	pa->value_changed.y += pa->offset.y;
	pa->value_changed.z += pa->offset.z;
	gf_node_event_out_str(node, "value_changed");
}

void PA_Modified(GF_Node *node, GF_FieldInfo *field)
{
	AnimatorStack *stack = (AnimatorStack *)gf_node_get_private(node);
	M_PositionAnimator *pa = (M_PositionAnimator *)node;

	if ( /*all fields impacting cached path len / nurbs*/
		(field->far_ptr == &pa->keyValue) 
		|| (field->far_ptr == &pa->keyValueType) 
		|| (field->far_ptr == &pa->key) 
		|| (field->far_ptr == &pa->keyType) 
		|| (field->far_ptr == &pa->keySpline) 
		|| (field->far_ptr == &pa->weight) 
		|| (field->far_ptr == &pa->key) 
		
		) stack->is_dirty = 1;
}
void PA_Init(GF_Node *n)
{
	M_PositionAnimator *sa = (M_PositionAnimator*)n;
	AnimatorStack *stack;
	GF_SAFEALLOC(stack, AnimatorStack);
	stack->is_dirty = 1;
	gf_node_set_private(n, stack);
	gf_node_set_callback_function(n, Anim_Destroy);
	sa->on_set_fraction = PA_SetFraction;
}

static void PA2D_Update(M_PositionAnimator2D *pa, AnimatorStack *stack)
{
	u32 i;
	Fixed dx, dy;
	stack->is_dirty = 0;
	stack->anim_type = pa->keyType;
	/*if empty key and default anim switch to linear*/
	if (!pa->key.count && !stack->anim_type) stack->anim_type = ANIM_LINEAR;

	if (stack->anim_type == ANIM_PACED) {
		stack->length = 0;
		for (i=0; i<pa->keyValue.count-1; i++) {
			dx = pa->keyValue.vals[i+1].x - pa->keyValue.vals[i].x;
			dy = pa->keyValue.vals[i+1].y - pa->keyValue.vals[i].y;
			stack->length += gf_sqrt(gf_mulfix(dx, dx) + gf_mulfix(dy, dy));
		}
	} 
	Animator_Update(stack, pa->keyValueType, pa->keyValue.count, &pa->keySpline, pa->weight.count, pa->weight.vals);
}
static void PA2D_SetFraction(GF_Node *node)
{
	Fixed frac;
	u32 nbKeys, nbVals, i;
	Fixed dx, dy;
	Fixed len, dlen, dist;
	M_PositionAnimator2D *pa = (M_PositionAnimator2D *)node;
	AnimatorStack *stack = (AnimatorStack *)gf_node_get_private(node);

	frac = pa->set_fraction;
	if (!anim_check_frac(frac, &pa->fromTo)) return;

	if (stack->is_dirty) PA2D_Update(pa, stack);

	nbKeys = pa->key.count;
	nbVals = pa->keyValue.count;

	i=0;
	switch (pa->keyValueType) {
	/*linear interpolate*/
	case ANIM_LINE:
		/*compute frac and segment start index*/
		switch (stack->anim_type) {
		case ANIM_DEFAULT:
			if (nbKeys != nbVals) return;
			if (frac<pa->key.vals[0]) { i=0; frac = 0; }
			else if (frac>pa->key.vals[nbKeys-1]) { i=nbVals-2; frac=FIX_ONE; }
			else {
				for (i=0; i<nbKeys-1; i++) {
					if ((frac>=pa->key.vals[i]) && (frac<pa->key.vals[i+1])) break;
				}
				frac = GetInterpolateFraction(pa->key.vals[i], pa->key.vals[i+1], frac);
			}
			break;
		case ANIM_DISCRETE:
			i = FIX2INT(gf_floor(frac*nbVals));
			frac = 0;
			break;
		case ANIM_LINEAR:
			i = FIX2INT(gf_floor(frac*(nbVals-1)));
			frac = (frac - INT2FIX(i)/ (nbVals-1) ) * (nbVals-1);
			break;
		case ANIM_PACED:
			/*at cst speed, this is the length done*/
			dist = gf_mulfix(frac, stack->length);
			/*then figure out in which seg we are*/
			len = 0;
			dlen = 0;
			for (i=0; i<nbVals-1; i++) {
				dx = pa->keyValue.vals[i+1].x - pa->keyValue.vals[i].x;
				dy = pa->keyValue.vals[i+1].y - pa->keyValue.vals[i].y;
				dlen = gf_sqrt(gf_mulfix(dx,dx) + gf_mulfix(dy,dy));
				if (len+dlen>dist) break;
				len += dlen;
			}
			/*that's our fraction inside the seg*/
			frac = gf_divfix(dist-len, dlen);
			break;
		case ANIM_SPLINE:
			frac = do_bisection(frac, stack->a, stack->b, stack->c, stack->d);
			i = FIX2INT(gf_floor(frac * (nbVals-1)));
			frac = (frac - INT2FIX(i) / (nbVals-1) ) * (nbVals-1);
			break;
		default:
			return;
		}
		/*interpolate*/
		pa->value_changed.x = Interpolate(pa->keyValue.vals[i].x, pa->keyValue.vals[i+1].x, frac);
		pa->value_changed.y = Interpolate(pa->keyValue.vals[i].y, pa->keyValue.vals[i+1].y, frac);
		break;
	/*bezier interpolate*/
	case ANIM_QUADRATIC:
	case ANIM_CUBIC:
	case ANIM_NURBS:
		if (!stack->anurbs.valid) return;
		/*compute frac*/
		switch (stack->anim_type) {
		case ANIM_DISCRETE:
			i = FIX2INT(gf_floor(frac*nbVals));
			frac = INT2FIX(i) / nbVals;
			break;
		case ANIM_LINEAR:
			i = FIX2INT(gf_floor(frac*(nbVals-1)));
			frac = (frac - INT2FIX(i) / (nbVals-1) ) * (nbVals-1);
			break;
		case ANIM_VELOCITY:
			frac = do_bisection(frac, stack->a, stack->b, stack->c, stack->d);
			break;
		/*nothing to do for this one here*/
		case ANIM_DEFAULT:
		/*not supported - use frac as is*/
		case ANIM_PACED: 
		default:
			break;
		}
		/*evaluate*/
		i = anurbs_find_span(&stack->anurbs, frac);
		anurbs_basis(&stack->anurbs, i, frac);
		pa->value_changed = anurbs_get_vec2f(&stack->anurbs, i, pa->keyValue.vals);
		break;
	/*not supported*/
	case ANIM_SPLINE: 
	default:
		return;
	}

	pa->value_changed.x += pa->offset.x;
	pa->value_changed.y += pa->offset.y;
	gf_node_event_out_str(node, "value_changed");
}

void PA2D_Modified(GF_Node *node, GF_FieldInfo *field)
{
	AnimatorStack *stack = (AnimatorStack *)gf_node_get_private(node);
	M_PositionAnimator2D *pa = (M_PositionAnimator2D *)node;

	if ( /*all fields impacting cached path len / nurbs*/
		(field->far_ptr == &pa->keyValue) 
		|| (field->far_ptr == &pa->keyValueType) 
		|| (field->far_ptr == &pa->key) 
		|| (field->far_ptr == &pa->keyType) 
		|| (field->far_ptr == &pa->keySpline) 
		|| (field->far_ptr == &pa->weight) 
		|| (field->far_ptr == &pa->key) 
		
		) stack->is_dirty = 1;
}
void PA2D_Init(GF_Node *n)
{
	M_PositionAnimator2D *sa = (M_PositionAnimator2D *)n;
	AnimatorStack *stack;
	GF_SAFEALLOC(stack, AnimatorStack);
	stack->is_dirty = 1;
	gf_node_set_private(n, stack);
	gf_node_set_callback_function(n, Anim_Destroy);
	sa->on_set_fraction = PA2D_SetFraction;
}

static void SA_Update(M_ScalarAnimator *sa, AnimatorStack *stack)
{
	u32 i;
	Fixed len;
	stack->is_dirty = 0;
	stack->anim_type = sa->keyType;
	/*if empty key and default anim switch to linear*/
	if (!sa->key.count && !stack->anim_type) stack->anim_type = ANIM_LINEAR;

	if (stack->anim_type == ANIM_PACED) {
		stack->length = 0;
		for (i=0; i<sa->keyValue.count-1; i++) {
			len = sa->keyValue.vals[i+1] - sa->keyValue.vals[i];
			stack->length += ABS(len);
		}
	} 
	Animator_Update(stack, sa->keyValueType, sa->keyValue.count, &sa->keySpline, sa->weight.count, sa->weight.vals);
}

void SA_SetFraction(GF_Node *node)
{
	Fixed frac;
	u32 nbKeys, nbVals, i;
	Fixed len, dlen, dist;
	M_ScalarAnimator *sa = (M_ScalarAnimator *)node;
	AnimatorStack *stack = (AnimatorStack *)gf_node_get_private(node);

	frac = sa->set_fraction;
	if (!anim_check_frac(frac, &sa->fromTo)) return;

	if (stack->is_dirty) SA_Update(sa, stack);

	nbKeys = sa->key.count;
	nbVals = sa->keyValue.count;

	i = 0;
	switch (sa->keyValueType) {
	/*linear interpolate*/
	case ANIM_LINE:
		/*compute frac & segment start index*/
		switch (stack->anim_type) {
		case ANIM_DEFAULT:
			if (nbKeys != nbVals) return;
			if (frac<sa->key.vals[0]) { i=0; frac = 0; }
			else if (frac>sa->key.vals[nbKeys-1]) { i=nbVals-2; frac=FIX_ONE; }
			else {
				for (i=0; i<nbKeys-1; i++) {
					if ((frac>=sa->key.vals[i]) && (frac<sa->key.vals[i+1])) break;
				}
				frac = GetInterpolateFraction(sa->key.vals[i], sa->key.vals[i+1], frac);
			}
			break;
		case ANIM_DISCRETE:
			i = FIX2INT(gf_floor(frac*nbVals));
			frac = 0;
			break;
		case ANIM_LINEAR:
			i = FIX2INT(gf_floor(frac*(nbVals-1)));
			frac = (frac - INT2FIX(i)/ (nbVals-1) ) * (nbVals-1);
			break;
		case ANIM_PACED:
			/*at cst speed, this is the length done*/
			dist = gf_mulfix(frac, stack->length);
			/*then figure out in which seg we are*/
			len = 0;
			dlen = 0;
			for (i=0; i<nbVals-1; i++) {
				dlen = sa->keyValue.vals[i+1] - sa->keyValue.vals[i];
				if (dlen<0) dlen *= -1;
				if (len+dlen>dist) break;
				len += dlen;
			}
			/*that's our fraction inside the seg*/
			frac = gf_divfix(dist-len, dlen);
			break;
		case ANIM_SPLINE:
			frac = do_bisection(frac, stack->a, stack->b, stack->c, stack->d);
			i = FIX2INT(gf_floor(frac*(nbVals-1)));
			frac = (frac - INT2FIX(i) / (nbVals-1) ) * (nbVals-1);
			break;
		}
		/*interpolate*/
		sa->value_changed = Interpolate(sa->keyValue.vals[i], sa->keyValue.vals[i+1], frac);
		break;
	/*bezier interpolate*/
	case ANIM_QUADRATIC:
	case ANIM_CUBIC:
	case ANIM_NURBS:
		if (!stack->anurbs.valid) return;
		/*compute frac*/
		switch (stack->anim_type) {
		case ANIM_DISCRETE:
			i = FIX2INT(gf_floor(frac*nbVals));
			frac = INT2FIX(i) / nbVals;
			break;
		case ANIM_LINEAR:
			i = FIX2INT(gf_floor(frac*(nbVals-1)));
			frac = (frac - INT2FIX(i) / (nbVals-1) ) * (nbVals-1);
			break;
		case ANIM_VELOCITY:
			frac = do_bisection(frac, stack->a, stack->b, stack->c, stack->d);
			break;
		/*nothing to do for this one here*/
		case ANIM_DEFAULT:
		/*not supported - use frac as is*/
		case ANIM_PACED: 
		default:
			break;
		}
		/*evaluate nurbs*/
		i = anurbs_find_span(&stack->anurbs, frac);
		anurbs_basis(&stack->anurbs, i, frac);
		sa->value_changed = anurbs_get_float(&stack->anurbs, i, sa->keyValue.vals);
		break;
	/*not supported*/
	case ANIM_SPLINE: 
	default:
		return;
	}

	sa->value_changed += sa->offset;
	gf_node_event_out_str(node, "value_changed");
}

void SA_Modified(GF_Node *node, GF_FieldInfo *field)
{
	AnimatorStack *stack = (AnimatorStack *)gf_node_get_private(node);
	M_ScalarAnimator *sa = (M_ScalarAnimator *)node;

	if ( /*all fields impacting cached path len / nurbs*/
		(field->far_ptr == &sa->keyValue) 
		|| (field->far_ptr == &sa->keyValueType) 
		|| (field->far_ptr == &sa->key) 
		|| (field->far_ptr == &sa->keyType) 
		|| (field->far_ptr == &sa->keySpline) 
		|| (field->far_ptr == &sa->weight) 
		|| (field->far_ptr == &sa->key) 
		
		) stack->is_dirty = 1;
}

void SA_Init(GF_Node *n)
{
	M_ScalarAnimator *sa = (M_ScalarAnimator *)n;
	AnimatorStack *stack;
	GF_SAFEALLOC(stack, AnimatorStack);
	stack->is_dirty = 1;
	gf_node_set_private(n, stack);
	gf_node_set_callback_function(n, Anim_Destroy);
	sa->on_set_fraction = SA_SetFraction;
}