vrml_interpolators.c

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

			} else { 
				newa += GF_2PI; 
			}
		}
	}
	if (stzero || endzero) {
		res.x = stzero ? kv2.x : kv1.x;
		res.y = stzero ? kv2.y : kv1.y;
		res.z = stzero ? kv2.z : kv1.z;
	}
	/* now that we have angles straight (hah!) bounds check result */
	res.q = olda + gf_mulfix(fraction, newa - olda);
	if (res.q > GF_2PI) { 
		res.q -= GF_2PI;
	} else if (res.q < GF_2PI) {
		res.q += GF_2PI;
	}
	return res;
}

static void OrientInt_SetFraction(GF_Node *node)
{
	u32 i;
	Fixed frac;
	M_OrientationInterpolator *_this = (M_OrientationInterpolator *)node;

	if (! _this->key.count) return;
	if (_this->keyValue.count != _this->key.count) return;
	
	// The given fraction is less than the specified range
	if (_this->set_fraction < _this->key.vals[0]) {
		_this->value_changed = _this->keyValue.vals[0];
	} else if (_this->set_fraction >= _this->key.vals[_this->key.count-1]) {
		_this->value_changed = _this->keyValue.vals[_this->keyValue.count-1];
	} else {
		for (i=1; i<_this->key.count; i++) {
			// Find the key values the fraction lies between
			if (_this->set_fraction < _this->key.vals[i-1]) continue;
			if (_this->set_fraction >= _this->key.vals[i]) continue;

			frac = GetInterpolateFraction(_this->key.vals[i-1], _this->key.vals[i], _this->set_fraction);
			_this->value_changed = gf_sg_sfrotation_interpolate(_this->keyValue.vals[i-1], _this->keyValue.vals[i], frac);
			break;
		}
	}
	gf_node_event_out_str(node, "value_changed");
}

Bool InitOrientationInterpolator(M_OrientationInterpolator *node)
{
	node->on_set_fraction = OrientInt_SetFraction; 
	if (node->keyValue.count) node->value_changed = node->keyValue.vals[0];
	return 1;
}

static void CI4D_SetFraction(GF_Node *n)
{
	Fixed frac;
	u32 numElemPerKey, i, j;
	M_CoordinateInterpolator4D *_this = (M_CoordinateInterpolator4D *) n;

	if (! _this->key.count) return;
	if (_this->keyValue.count % _this->key.count) return;
	
	numElemPerKey = _this->keyValue.count / _this->key.count;
	//set size
	if (_this->value_changed.count != numElemPerKey)
		gf_sg_vrml_mf_alloc(&_this->value_changed, GF_SG_VRML_MFVEC4F, numElemPerKey);


	if (_this->set_fraction < _this->key.vals[0]) {
		for (i=0; i<numElemPerKey; i++)
			_this->value_changed.vals[i] = _this->keyValue.vals[i];
	} else if (_this->set_fraction > _this->key.vals[_this->key.count - 1]) {
		for (i=0; i<numElemPerKey; i++)
			_this->value_changed.vals[i] = _this->keyValue.vals[(_this->keyValue.count) - numElemPerKey + i];
	} else {
		for (j = 1; j < _this->key.count; j++) {
			// Find the key values the fraction lies between
			if ( _this->set_fraction < _this->key.vals[j-1]) continue;
			if (_this->set_fraction >= _this->key.vals[j]) continue;

			frac = GetInterpolateFraction(_this->key.vals[j-1], _this->key.vals[j], _this->set_fraction);
			for (i=0; i<numElemPerKey; i++) {
				_this->value_changed.vals[i].x = Interpolate(_this->keyValue.vals[(j-1)*numElemPerKey + i].x,
															_this->keyValue.vals[(j)*numElemPerKey + i].x, 
															frac);
				_this->value_changed.vals[i].y = Interpolate(_this->keyValue.vals[(j-1)*numElemPerKey + i].y,
															_this->keyValue.vals[(j)*numElemPerKey + i].y,
															frac);
				_this->value_changed.vals[i].z = Interpolate(_this->keyValue.vals[(j-1)*numElemPerKey + i].z,
															_this->keyValue.vals[(j)*numElemPerKey + i].z,
															frac);
				_this->value_changed.vals[i].q = Interpolate(_this->keyValue.vals[(j-1)*numElemPerKey + i].q,
															_this->keyValue.vals[(j)*numElemPerKey + i].q,
															frac);
			}
			break;
		}
	}
	//invalidate
	gf_node_event_out_str(n, "value_changed");
}

Bool InitCoordinateInterpolator4D(M_CoordinateInterpolator4D *node)
{
	node->on_set_fraction = CI4D_SetFraction;

	if (node->key.count && !(node->keyValue.count % node->key.count)) {
		u32 i, numElemPerKey = node->keyValue.count / node->key.count;
		gf_sg_vrml_mf_alloc(&node->value_changed, GF_SG_VRML_MFVEC4F, numElemPerKey);
		for (i=0; i<numElemPerKey; i++)
			node->value_changed.vals[i] = node->keyValue.vals[i];
	}
	return 1;
}

static void PI4D_SetFraction(GF_Node *node)
{
	u32 i;
	Fixed frac;
	M_PositionInterpolator4D *_this = (M_PositionInterpolator4D *)node;

	if (! _this->key.count) return;
	if (_this->keyValue.count != _this->key.count) return;
	
	// The given fraction is less than the specified range
	if (_this->set_fraction < _this->key.vals[0]) {
		_this->value_changed = _this->keyValue.vals[0];
	} else if (_this->set_fraction >= _this->key.vals[_this->key.count-1]) {
		_this->value_changed = _this->keyValue.vals[_this->keyValue.count-1];
	} else {
		for (i=1; i<_this->key.count; i++) {
			// Find the key values the fraction lies between
			if (_this->set_fraction < _this->key.vals[i-1]) continue;
			if (_this->set_fraction >= _this->key.vals[i]) continue;

			frac = GetInterpolateFraction(_this->key.vals[i-1], _this->key.vals[i], _this->set_fraction);
			_this->value_changed.x = Interpolate(_this->keyValue.vals[i-1].x, _this->keyValue.vals[i].x, frac);
			_this->value_changed.y = Interpolate(_this->keyValue.vals[i-1].y, _this->keyValue.vals[i].y, frac);
			_this->value_changed.z = Interpolate(_this->keyValue.vals[i-1].z, _this->keyValue.vals[i].z, frac);
			_this->value_changed.q = Interpolate(_this->keyValue.vals[i-1].q, _this->keyValue.vals[i].q, frac);
			break;
		}
	}
	gf_node_event_out_str(node, "value_changed");
}

Bool InitPositionInterpolator4D(M_PositionInterpolator4D *node)
{
	node->on_set_fraction = PI4D_SetFraction;
	if (node->keyValue.count) node->value_changed = node->keyValue.vals[0];
	return 1;
}



static void BooleanFilter_setValue(GF_Node *n)
{
	X_BooleanFilter *bf = (X_BooleanFilter *)n;
	if (!bf->set_boolean) {
		bf->inputFalse = 1;
		gf_node_event_out_str(n, "inputFalse");
	}
	if (bf->set_boolean) {
		bf->inputTrue = 1;
		gf_node_event_out_str(n, "inputTrue");
	}
	bf->inputNegate = bf->set_boolean ? 0 : 1;
	gf_node_event_out_str(n, "inputNegate");
}

void InitBooleanFilter(GF_Node *n)
{
	X_BooleanFilter *bf = (X_BooleanFilter *)n;
	bf->on_set_boolean = BooleanFilter_setValue;
}

static void BooleanSequencer_setFraction(GF_Node *n)
{
	u32 i;
	X_BooleanSequencer *bs = (X_BooleanSequencer*)n;
	if (! bs->key.count) return;
	if (bs->keyValue.count != bs->key.count) return;
	
	if (bs->set_fraction < bs->key.vals[0]) {
		bs->value_changed = bs->keyValue.vals[0];
	} else if (bs->set_fraction >= bs->key.vals[bs->key.count-1]) {
		bs->value_changed = bs->keyValue.vals[bs->keyValue.count-1];
	} else {
		for (i=1; i<bs->key.count; i++) {
			if (bs->set_fraction < bs->key.vals[i-1]) continue;
			if (bs->set_fraction >= bs->key.vals[i]) continue;
			bs->value_changed = bs->keyValue.vals[i-1];
			break;
		}
	}
	gf_node_event_out_str(n, "value_changed");
}

static void BooleanSequencer_setNext(GF_Node *n)
{
	s32 *prev_val, val;
	X_BooleanSequencer *bs = (X_BooleanSequencer*)n;
	if (!bs->next) return;

	prev_val = (s32 *)n->sgprivate->UserPrivate;
	val = (*prev_val + 1) % bs->keyValue.count;
	*prev_val = val;
	bs->value_changed = bs->keyValue.vals[val];
	gf_node_event_out_str(n, "value_changed");
}

static void BooleanSequencer_setPrevious(GF_Node *n)
{
	s32 *prev_val, val;
	X_BooleanSequencer *bs = (X_BooleanSequencer*)n;
	if (!bs->previous) return;

	prev_val = (s32 *)n->sgprivate->UserPrivate;
	val = (*prev_val - 1);
	if (val<0) val += bs->keyValue.count;
	val %= bs->keyValue.count;
	*prev_val = val;
	bs->value_changed = bs->keyValue.vals[val];
	gf_node_event_out_str(n, "value_changed");
}
static void DestroyBooleanSequencer(GF_Node *n, void *eff, Bool is_destroy)
{
	if (is_destroy) {
		s32 *st = (s32 *) gf_node_get_private(n);
		free(st);
	}
}
void InitBooleanSequencer(GF_Node *n)
{
	X_BooleanSequencer *bs = (X_BooleanSequencer*)n;
	bs->on_next = BooleanSequencer_setNext;
	bs->on_previous = BooleanSequencer_setPrevious;
	bs->on_set_fraction = BooleanSequencer_setFraction;
	n->sgprivate->UserPrivate = malloc(sizeof(s32));
	*(s32 *)n->sgprivate->UserPrivate = 0;
	n->sgprivate->UserCallback = DestroyBooleanSequencer;
}

static void BooleanToggle_setValue(GF_Node *n)
{
	X_BooleanToggle *bt = (X_BooleanToggle *)n;
	if (bt->set_boolean) {
		bt->toggle = !bt->toggle;
		gf_node_event_out_str(n, "toggle");
	}
}
void InitBooleanToggle(GF_Node *n)
{
	X_BooleanToggle *bt = (X_BooleanToggle *)n;
	bt->on_set_boolean = BooleanToggle_setValue;
}

static void BooleanTrigger_setTime(GF_Node *n)
{
	X_BooleanTrigger *bt = (X_BooleanTrigger *)n;
	bt->triggerTrue = 1;
	gf_node_event_out_str(n, "triggerTrue");
}
void InitBooleanTrigger(GF_Node *n)
{
	X_BooleanTrigger *bt = (X_BooleanTrigger *)n;
	bt->on_set_triggerTime = BooleanTrigger_setTime;
}

static void IntegerSequencer_setFraction(GF_Node *n)
{
	u32 i;
	X_IntegerSequencer *is = (X_IntegerSequencer *)n;
	if (! is->key.count) return;
	if (is->keyValue.count != is->key.count) return;
	
	if (is->set_fraction < is->key.vals[0]) {
		is->value_changed = is->keyValue.vals[0];
	} else if (is->set_fraction >= is->key.vals[is->key.count-1]) {
		is->value_changed = is->keyValue.vals[is->keyValue.count-1];
	} else {
		for (i=1; i<is->key.count; i++) {
			if (is->set_fraction < is->key.vals[i-1]) continue;
			if (is->set_fraction >= is->key.vals[i]) continue;
			is->value_changed = is->keyValue.vals[i-1];
			break;
		}
	}
	gf_node_event_out_str(n, "value_changed");
}

static void IntegerSequencer_setNext(GF_Node *n)
{
	s32 *prev_val, val;
	X_IntegerSequencer *is = (X_IntegerSequencer*)n;
	if (!is->next) return;

	prev_val = (s32 *)n->sgprivate->UserPrivate;
	val = (*prev_val + 1) % is->keyValue.count;
	*prev_val = val;
	is->value_changed = is->keyValue.vals[val];
	gf_node_event_out_str(n, "value_changed");
}

static void IntegerSequencer_setPrevious(GF_Node *n)
{
	s32 *prev_val, val;
	X_IntegerSequencer *is = (X_IntegerSequencer *)n;
	if (!is->previous) return;

	prev_val = (s32 *)n->sgprivate->UserPrivate;
	val = (*prev_val - 1);
	if (val<0) val += is->keyValue.count;
	val %= is->keyValue.count;
	*prev_val = val;
	is->value_changed = is->keyValue.vals[val];
	gf_node_event_out_str(n, "value_changed");
}
static void DestroyIntegerSequencer(GF_Node *n, void *eff, Bool is_destroy)
{
	if (is_destroy) {
		s32 *st = (s32 *)gf_node_get_private(n);
		free(st);
	}
}
void InitIntegerSequencer(GF_Node *n)
{
	X_IntegerSequencer *bs = (X_IntegerSequencer *)n;
	bs->on_next = IntegerSequencer_setNext;
	bs->on_previous = IntegerSequencer_setPrevious;
	bs->on_set_fraction = IntegerSequencer_setFraction;
	n->sgprivate->UserPrivate = malloc(sizeof(s32));
	*(s32 *)n->sgprivate->UserPrivate = 0;
	n->sgprivate->UserCallback = DestroyIntegerSequencer;
}

static void IntegerTrigger_setTrigger(GF_Node *n)
{
	X_IntegerTrigger *it = (X_IntegerTrigger *)n;
	if (it->set_boolean) {
		it->triggerValue = it->integerKey;
		gf_node_event_out_str(n, "triggerValue");
	}
}
void InitIntegerTrigger(GF_Node *n)
{
	X_IntegerTrigger *it = (X_IntegerTrigger *)n;
	it->on_set_boolean = IntegerTrigger_setTrigger;
}

static void TimeTrigger_setTrigger(GF_Node *n)
{
	X_TimeTrigger *tt = (X_TimeTrigger *)n;
	tt->triggerTime = gf_node_get_scene_time(n);
	gf_node_event_out_str(n, "triggerTime");
}
void InitTimeTrigger(GF_Node *n)
{
	X_TimeTrigger *tt = (X_TimeTrigger*)n;
	tt->on_set_boolean = TimeTrigger_setTrigger;
}