fcurve.cpp

机甲指挥官2源代码

				SCurve->m_seedCurve.TranslateBy(delta,curvenum);
		}
		break;
		
	case e_SplineSplineType:
		{
			SeededCurveOf<SplineCurve,SplineCurve,e_SplineSplineType> *SCurve=(SeededCurveOf<SplineCurve,SplineCurve,e_SplineSplineType> *)this;
			if(curvenum==0)
				SCurve->m_ageCurve.TranslateBy(delta,curvenum);
			else
				SCurve->m_seedCurve.TranslateBy(delta,curvenum);
		}
		break;
		
	default:
		break;
	}
	
}

void 
gosFX::Curve::LocalScale(Stuff::Scalar sfactor,int curvenum)
{
	Check_Object(this);
	AxisScale(sfactor,Mid(curvenum),curvenum);
}

void 
gosFX::Curve::AxisScale(Stuff::Scalar sfactor,Stuff::Scalar axis,int curvenum)
{
	Check_Object(this);
	switch(m_type)
	{
	case e_ConstantType:
		{
			ConstantCurve *SCurve=(ConstantCurve *)this;
			SCurve->SetCurve(axis+(SCurve->ComputeValue(0.0f,0.0f)-axis)*sfactor);
		}
		break;
		
	case e_LinearType:
		{
			LinearCurve *SCurve=(LinearCurve *)this;
			Stuff::Scalar v0,v1;
			v0=SCurve->ComputeValue(0.0f,0.0f);
			v1=SCurve->ComputeValue(1.0f,0.0f);
			v0=axis+(v0-axis)*sfactor;
			v1=axis+(v1-axis)*sfactor;
			SCurve->SetCurve(v0,v1);
		}
		break;
		
	case e_SplineType:
		{
			SplineCurve *SCurve=(SplineCurve *)this;
			Stuff::Scalar v0,v1,s0,s1;
			v0=SCurve->ComputeValue(0.0f,0.0f);
			v1=SCurve->ComputeValue(1.0f,0.0f);
			s0=SCurve->ComputeSlope(0.0f);
			s1=SCurve->ComputeSlope(1.0f);
			
			v0=axis+(v0-axis)*sfactor;
			v1=axis+(v1-axis)*sfactor;
			s0*=sfactor;
			s1*=sfactor;
			
			SCurve->SetCurve(v0,s0,v1,s1);
		}
		break;
		
	case e_ComplexType:
		{
			ComplexCurve *SCurve=(ComplexCurve *)this;
			Stuff::Scalar x1,x2,y1,y2;
			
			
			for(int key=0;key<SCurve->GetKeyCount()-1;key++)
			{
				x1=(*SCurve)[key].m_time;
				x2=(*SCurve)[key+1].m_time;
				y1=SCurve->ComputeValue(x1,0.0f);
				y2=SCurve->ComputeValue(x2,0.0f);
				y1=axis+(y1-axis)*sfactor;
				y2=axis+(y2-axis)*sfactor;
				(*SCurve)[key].SetLinearKey(x1,y1,y2,x2-x1);
			}
			
			x1=(*SCurve)[key].m_time;
			y1=SCurve->ComputeValue(x1,0.0f);
			y1=axis+(y1-axis)*sfactor;
			(*SCurve)[SCurve->GetKeyCount()-1].SetLinearKey(x1,y1,y1,1.0f);
			
		}
		break;
		
	case e_ComplexLinearType:
		{
			SeededCurveOf<ComplexCurve, LinearCurve,Curve::e_ComplexLinearType> *SCurve=(SeededCurveOf<ComplexCurve, LinearCurve,Curve::e_ComplexLinearType> *)this;
			if(curvenum==0)
				SCurve->m_ageCurve.AxisScale(sfactor,axis,curvenum);
			else
				SCurve->m_seedCurve.AxisScale(sfactor,axis,curvenum);
		}	
		break;
		
	case e_ComplexComplexType:
		{
			SeededCurveOf<ComplexCurve, ComplexCurve,e_ComplexComplexType> *SCurve=(SeededCurveOf<ComplexCurve, ComplexCurve,e_ComplexComplexType> *)this;
			if(curvenum==0)
				SCurve->m_ageCurve.AxisScale(sfactor,axis,curvenum);
			else
				SCurve->m_seedCurve.AxisScale(sfactor,axis,curvenum);
		}	
		break;
		
	case e_ComplexSplineType:
		{
			SeededCurveOf<ComplexCurve, SplineCurve,e_ComplexSplineType> *SCurve=(SeededCurveOf<ComplexCurve, SplineCurve,e_ComplexSplineType> *)this;
			if(curvenum==0)
				SCurve->m_ageCurve.AxisScale(sfactor,axis,curvenum);
			else
				SCurve->m_seedCurve.AxisScale(sfactor,axis,curvenum);
		}
		break;
		
	case e_ConstantComplexType:
		{
			SeededCurveOf<ConstantCurve,ComplexCurve,e_ConstantComplexType> *SCurve=(SeededCurveOf<ConstantCurve,ComplexCurve,e_ConstantComplexType> *)this;
			if(curvenum==0)
				SCurve->m_ageCurve.AxisScale(sfactor,axis,curvenum);
			else
				SCurve->m_seedCurve.AxisScale(sfactor,axis,curvenum);
		}
		break;
		
	case e_ConstantLinearType:
		{
			SeededCurveOf<ConstantCurve,LinearCurve,e_ConstantLinearType> *SCurve=(SeededCurveOf<ConstantCurve,LinearCurve,e_ConstantLinearType> *)this;
			if(curvenum==0)
				SCurve->m_ageCurve.AxisScale(sfactor,axis,curvenum);
			else
				SCurve->m_seedCurve.AxisScale(sfactor,axis,curvenum);
		}
		break;
		
	case e_ConstantSplineType:
		{
			SeededCurveOf<ConstantCurve,SplineCurve,e_ConstantSplineType> *SCurve=(SeededCurveOf<ConstantCurve,SplineCurve,e_ConstantSplineType> *)this;
			if(curvenum==0)
				SCurve->m_ageCurve.AxisScale(sfactor,axis,curvenum);
			else
				SCurve->m_seedCurve.AxisScale(sfactor,axis,curvenum);
		}
		break;
		
	case e_SplineLinearType:
		{
			SeededCurveOf<SplineCurve,LinearCurve,e_SplineLinearType> *SCurve=(SeededCurveOf<SplineCurve,LinearCurve,e_SplineLinearType> *)this;
			if(curvenum==0)
				SCurve->m_ageCurve.AxisScale(sfactor,axis,curvenum);
			else
				SCurve->m_seedCurve.AxisScale(sfactor,axis,curvenum);
		}
		break;
		
	case e_SplineSplineType:
		{
			SeededCurveOf<SplineCurve,SplineCurve,e_SplineSplineType> *SCurve=(SeededCurveOf<SplineCurve,SplineCurve,e_SplineSplineType> *)this;
			if(curvenum==0)
				SCurve->m_ageCurve.AxisScale(sfactor,axis,curvenum);
			else
				SCurve->m_seedCurve.AxisScale(sfactor,axis,curvenum);
		}
		break;
		
	default:
		break;
	}
	
}


gosFX::Curve * 
gosFX::Curve::GetSubCurve(int curvenum)
{
	Check_Object(this);
	
	switch(m_type)
	{
		
	case e_ConstantType:
	case e_LinearType:
	case e_SplineType:
	case e_ComplexType:
		{
			if(curvenum==0)
				return this;
			else
				return NULL;
		}	
		break;
		
	case e_ComplexLinearType:
		{
			SeededCurveOf<ComplexCurve, LinearCurve,Curve::e_ComplexLinearType> *SCurve=(SeededCurveOf<ComplexCurve, LinearCurve,Curve::e_ComplexLinearType> *)this;
			if(curvenum==0)
				return &(SCurve->m_ageCurve);
			else
				return &(SCurve->m_seedCurve);
		}	
		break;
		
	case e_ComplexComplexType:
		{
			SeededCurveOf<ComplexCurve, ComplexCurve,e_ComplexComplexType> *SCurve=(SeededCurveOf<ComplexCurve, ComplexCurve,e_ComplexComplexType> *)this;
			if(curvenum==0)
				return &(SCurve->m_ageCurve);
			else
				return &(SCurve->m_seedCurve);
		}	
		break;
		
	case e_ComplexSplineType:
		{
			SeededCurveOf<ComplexCurve, SplineCurve,e_ComplexSplineType> *SCurve=(SeededCurveOf<ComplexCurve, SplineCurve,e_ComplexSplineType> *)this;
			if(curvenum==0)
				return &(SCurve->m_ageCurve);
			else
				return &(SCurve->m_seedCurve);
		}
		break;
		
	case e_ConstantComplexType:
		{
			SeededCurveOf<ConstantCurve,ComplexCurve,e_ConstantComplexType> *SCurve=(SeededCurveOf<ConstantCurve,ComplexCurve,e_ConstantComplexType> *)this;
			if(curvenum==0)
				return &(SCurve->m_ageCurve);
			else
				return &(SCurve->m_seedCurve);
		}
		break;
		
	case e_ConstantLinearType:
		{
			SeededCurveOf<ConstantCurve,LinearCurve,e_ConstantLinearType> *SCurve=(SeededCurveOf<ConstantCurve,LinearCurve,e_ConstantLinearType> *)this;
			if(curvenum==0)
				return &(SCurve->m_ageCurve);
			else
				return &(SCurve->m_seedCurve);
		}
		break;
		
	case e_ConstantSplineType:
		{
			SeededCurveOf<ConstantCurve,SplineCurve,e_ConstantSplineType> *SCurve=(SeededCurveOf<ConstantCurve,SplineCurve,e_ConstantSplineType> *)this;
			if(curvenum==0)
				return &(SCurve->m_ageCurve);
			else
				return &(SCurve->m_seedCurve);
		}
		break;
		
	case e_SplineLinearType:
		{
			SeededCurveOf<SplineCurve,LinearCurve,e_SplineLinearType> *SCurve=(SeededCurveOf<SplineCurve,LinearCurve,e_SplineLinearType> *)this;
			if(curvenum==0)
				return &(SCurve->m_ageCurve);
			else
				return &(SCurve->m_seedCurve);
		}
		break;
		
	case e_SplineSplineType:
		{
			SeededCurveOf<SplineCurve,SplineCurve,e_SplineSplineType> *SCurve=(SeededCurveOf<SplineCurve,SplineCurve,e_SplineSplineType> *)this;
			if(curvenum==0)
				return &(SCurve->m_ageCurve);
			else
				return &(SCurve->m_seedCurve);
		}
		break;
		
	default:
		break;
	}
	return NULL;
}



//##########################################################################
//########################    ConstantCurve    #############################
//##########################################################################

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
void
gosFX::ConstantCurve::Save(Stuff::MemoryStream *stream)
{
	Check_Object(this);
	Check_Object(stream);
	
	*stream << m_value;
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
void 
	gosFX::ConstantCurve::Load(
		Stuff::MemoryStream *stream,
		int gfx_version
	)
{
	Check_Pointer(this);
	Check_Object(stream);
	
	*stream >> m_value;
}

//##########################################################################
//#########################    LinearCurve    ##############################
//##########################################################################

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
void
gosFX::LinearCurve::Save(Stuff::MemoryStream *stream)
{
	Check_Object(this);
	Check_Object(stream);
	
	ConstantCurve::Save(stream);
	*stream << m_slope;
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
void 
	gosFX::LinearCurve::Load(
		Stuff::MemoryStream *stream,
		int gfx_version
	)
{
	Check_Pointer(this);
	Check_Object(stream);
	
	ConstantCurve::Load(stream, gfx_version);
	*stream >> m_slope;
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// return:  true=math good, false=math unstable
bool
gosFX::LinearCurve::SetCurve(Stuff::Scalar v)
{
	Check_Object(this);
	
	m_slope = 0.0f;
	m_value = v;
	return true;
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// return:  true=math good, false=math unstable
bool
gosFX::LinearCurve::SetCurve(
							 Stuff::Scalar v0,
							 Stuff::Scalar v1
							 )
{
	Check_Object(this);
	
	m_slope = v1 - v0;
	m_value = v0;
	return Stuff::Close_Enough(m_slope + v0, v1);
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
void
gosFX::LinearCurve::ComputeRange(
								 Stuff::Scalar *low,
								 Stuff::Scalar *hi
								 )
{
	Check_Object(this);
	Check_Pointer(low);
	Check_Pointer(hi);
	
	//
	//------------------------------------------------------------------------
	// We know that we will have to test the function at the beginning and end
	// of the segment, so go ahead and do that now
	//------------------------------------------------------------------------
	//
	*hi = *low = m_value;
	Stuff::Scalar t = m_slope+m_value;
	if (t>*hi)
		*hi = t;
	else if (t<*low)
		*low = t;
}

//##########################################################################
//##########################    SplineCurve    ##############################
//##########################################################################

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
gosFX::SplineCurve&
gosFX::SplineCurve::operator=(const SplineCurve& curve)
{
	m_a = curve.m_a;
	m_b = curve.m_b;
	m_slope = curve.m_slope;
	m_value = curve.m_value;
	return *this;
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
void
gosFX::SplineCurve::Save(Stuff::MemoryStream *stream)
{
	Check_Object(this);
	Check_Object(stream);
	
	LinearCurve::Save(stream);
	*stream << m_b << m_a;
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
void 
	gosFX::SplineCurve::Load(
		Stuff::MemoryStream *stream,
		int gfx_version
	)
{
	Check_Pointer(this);
	Check_Object(stream);
	
	LinearCurve::Load(stream, gfx_version);
	*stream >> m_b >> m_a;
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// return:  true=math good, false=math unstable
bool
gosFX::SplineCurve::SetCurve(Stuff::Scalar v)
{
	Check_Object(this);
	
	m_a = m_b = m_slope = 0.0f;
	m_value = v;
	return true;
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// return:  true=math good, false=math unstable
bool
gosFX::SplineCurve::SetCurve(
							 Stuff::Scalar v0,
							 Stuff::Scalar v1
							 )
{
	Check_Object(this);
	
	m_a = 0.0f;
	m_b = 0.0f;
	m_slope = v1 - v0;
	m_value = v0;
	return Stuff::Close_Enough(m_slope + v0, v1);
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// return:  true=math good, false=math unstable
bool
gosFX::SplineCurve::SetCurve(
							 Stuff::Scalar v0,
							 Stuff::Scalar s0,