Classes/Spline/Spline.cpp

#include "../String/String.h"
#include "../String/StringInput.h"
#include "../System/System.h"
#include "Spline.h"
#include "../System/SystemDefine.h"


Spline::Spline(int iNumberOfSplines)
{
        numberOfSplines=iNumberOfSplines;
        motionValuesPointers=new int[numberOfSplines];
        motionSplinePointers=new int[numberOfSplines];

        for ( int n=0; n<numberOfSplines ; n++ )
        {
                motionValuesPointers[n]=0;
        }

        for ( int n2=0; n2<numberOfSplines ; n2++ )
        {
                motionSplinePointers[n2]=0;
        }

        motionFrames=0;
        motionLinear=0;
        motionTension=0;
        motionContinuity=0;
        motionBias=0;   

        sceneFrame=0;
}

Spline::~Spline()
{
        for ( int n=0; n<numberOfSplines ; n++ )
        {
                float *motionValues=(float*)motionValuesPointers[n];
                if ( motionValues != 0 )
                        delete []motionValues;
        }

        for ( int n2=0; n2<numberOfSplines ; n2++ )
        {
                float *motionSpline=(float*)motionSplinePointers[n2];
                if ( motionSpline != 0 )
                        delete []motionSpline;
        }
        
        if ( motionValuesPointers != 0 )
                delete []motionValuesPointers;
        if ( motionSplinePointers != 0 )
                delete []motionSplinePointers;
        if ( motionFrames != 0 )
                delete []motionFrames;
        if ( motionLinear != 0 )
                delete []motionLinear;
        if ( motionTension != 0 )
                delete []motionTension;
        if ( motionContinuity != 0 )
                delete []motionContinuity;
        if ( motionBias != 0 )
                delete []motionBias;
}

float Spline::div( float a, float b)
{
        if ( b > 0 )
        {
                return a/b;
        }

        return b=0;
}

void Spline::hermite(float t,float *h1,float *h2,float *h3,float *h4)
{
        double t2,t3,z;

        t2=t*t;
        t3=t*t2;
        z=3.0*t2-t3-t3;

        *h1=(float )(1.0-z);
        *h2=(float )(z);
        *h3=(float )(t3-t2-t2+t);
        *h4=(float )(t3-t2);
}

float Spline::calculateSpline(float t1, float t2, float t3, float t4, float p1, float p2 , float p3 , float p4, float tensionLast, float tensionNext, float continuityLast, float continuityNext, float biasLast, float biasNext)
{
        float length=t3-t2;
        float t=div((sceneFrame-t2),length);
                
        int forward=0;

        // TCB spline
        
        float h1,h2,h3,h4;
  
        hermite(t,&h1,&h2,&h3,&h4);
        float dd0a=(float )((1.0-tensionLast) * (1.0+continuityLast) * (1.0+biasLast));
        float dd0b=(float )((1.0-tensionLast) * (1.0-continuityLast) * (1.0-biasLast));
        float ds1a=(float )((1.0-tensionNext) * (1.0-continuityNext) * (1.0+biasNext));
        float ds1b=(float )((1.0-tensionNext) * (1.0+continuityNext) * (1.0-biasNext));


        float adj0=div(length,(t3-t1));
        float adj1=div(length,(t4-t2));
        float v=p3-p2;

        float dd0=0;
        float ds1=0;

        if (prev)
        {
                dd0=(float)0.5*(dd0a+dd0b)*v;
        }
        else
        {
                dd0=adj0*(dd0a*(p2-p1)+dd0b*v);
        }

        if (next)
        {
                ds1=(float)0.5*(ds1a+ds1b)*v;
        }
        else
        {
                ds1=adj1*(ds1a*v+ds1b*(p4-p3));
        }

        return (p2*h1+p3*h2+dd0*h3+ds1*h4);
}

void Spline::update()
{
        int i=0;
        int stop=0;
        int key=0;

        if ( sceneFrame > motionFrames[sNumberOfKeys] )
        {
                sceneFrame=motionFrames[sNumberOfKeys];
        }

        while ( i<numberOfKeys && stop == 0 )
        {
                if ( sceneFrame <= motionFrames[i+2]  )
                {
                        stop=1;                 
                }
                else
                {
                        key++;
                }
        
                i++;
        }

    keyP1=key+0;
    keyP2=key+1;
    keyP3=key+2;
    keyP4=key+3;

    mKeyP1=keyP1*3;
    mKeyP2=keyP2*3;
    mKeyP3=keyP3*3;
        mKeyP4=keyP4*3;

        prev=false;
        next=false;

        if (key == 0)
        {
                prev=true;
        }

        if ((key+3) == sNumberOfKeys || (key+2) == sNumberOfKeys)
        {
                next=true;
        }
        
        for ( int n=0; n<numberOfSplines ; n++ )
        {
                float *motionValues=(float*)motionValuesPointers[n];
                float *motionSpline=(float*)motionSplinePointers[n];

                for ( int n2=0; n2<3 ; n2++ )
                {
                        motionSpline[n2]=calculateSpline(motionFrames[keyP1], motionFrames[keyP2], motionFrames[keyP3], motionFrames[keyP4], motionValues[mKeyP1+n2], motionValues[mKeyP2+n2] , motionValues[mKeyP3+n2] , motionValues[mKeyP4+n2] ,motionTension[keyP2], motionTension[keyP3],motionContinuity[keyP2], motionContinuity[keyP3],motionBias[keyP2], motionBias[keyP3]);
                }
        }
}

float *Spline::getSplineChannel(int index)
{
        return (float*)motionSplinePointers[index];
}

void Spline::increaseTime(float time)
{
        sceneFrame+=time;
}

void Spline::insertdata( int p, int p2)
{
        for ( int n=0; n<3 ; n++ )
        {
                for ( int n2=0; n2<numberOfSplines ; n2++ )
                {
                        float *motionValues=(float*)motionValuesPointers[n2];
                        motionValues[p*3+n]=motionValues[p2*3+n];
                }
        }                       
                        
        motionFrames[p]=motionFrames[p2];
        motionLinear[p]=motionLinear[p2];
        motionTension[p]=motionTension[p2];
        motionContinuity[p]=motionContinuity[p2];
        motionBias[p]=motionBias[p2];
}

void Spline::insertdata2( int p, int p2, int t, int t2)
{
        for ( int n2=t ; n2>=t2 ; --n2 )
        {
                for ( int n=0; n<3 ; n++ )
                {
                        for ( int n3=0; n3<numberOfSplines ; n3++ )
                        {
                                float *motionValues=(float*)motionValuesPointers[n3];
                                motionValues[(n2+p)*3+n]=motionValues[(n2+p2)*3+n];
                        }
                }                       
                
                motionFrames[n2+p]=motionFrames[n2+p2];
                motionLinear[n2+p]=motionLinear[n2+p2];
                motionTension[n2+p]=motionTension[n2+p2];
                motionContinuity[n2+p]=motionContinuity[n2+p2];
                motionBias[n2+p]=motionBias[n2+p2];
        }
}

void Spline::insertdata3( int p, int t, int t2)
{
        for ( int n2=t ; n2<t2 ; n2++ )
        {
                for ( int n=0; n<3 ; n++ )
                {
                        for ( int n3=0; n3<numberOfSplines ; n3++ )
                        {
                                float *motionValues=(float*)motionValuesPointers[n3];
                                motionValues[n2*3+n]=motionValues[p*3+n];
                        }
                }                       
                
                motionFrames[n2]=motionFrames[p];
                motionLinear[n2]=motionLinear[p];
                motionTension[n2]=motionTension[p];
                motionContinuity[n2]=motionContinuity[p];
                motionBias[n2]=motionBias[p];
        }
}

void Spline::read(float *buffer)
{
  numberOfKeys=(int)buffer[0];
  sNumberOfKeys=numberOfKeys+1;

  int plus=4;

  for ( int v=0; v<numberOfSplines ; v++ )
  {
        motionValuesPointers[v]=(int)new int[(sNumberOfKeys+plus)*3];
  }  
  
  for ( int v2=0; v2<numberOfSplines ; v2++ )
  {
        motionSplinePointers[v2]=(int)new int[3];
  }  

  motionTension=new float[(sNumberOfKeys+plus)];
  motionContinuity=new float[(sNumberOfKeys+plus)];
  motionBias=new float[(sNumberOfKeys+plus)];
  motionFrames=new float[(sNumberOfKeys+plus)];
  motionLinear=new int[(sNumberOfKeys+plus)];

  int forward=(numberOfSplines*3)+5;

  for ( int n=0; n<numberOfKeys ; n++ )
  {
        int step=0;

        for ( int n2=0; n2<numberOfSplines ; n2++ )
        {
                float *motionValues=(float*)motionValuesPointers[n2];
                motionValues[n*3+n2]=buffer[n*forward+n2+1+(step*3)];
                step+=3;
        }

        motionFrames[n]=buffer[n*forward+1+step];
        motionLinear[n]=(int)buffer[n*forward+1+step+1];
        motionTension[n]=buffer[n*forward+1+step+2];
        motionContinuity[n]=buffer[n*forward+1+step+3];
        motionBias[n]=buffer[n*forward+1+step+4];
  }
  
  if ( numberOfKeys == 1 )
  {
        insertdata3(0, 1, 5);
  }

  if ( numberOfKeys == 2 )
  {
        --sNumberOfKeys;
  }

  if ( numberOfKeys > 1 )
  {
        insertdata2(0,-1,(numberOfKeys+1),1);
        insertdata(1,0);
        insertdata(numberOfKeys+1,numberOfKeys);
  }
}


1	#include "../String/String.h"
2	#include "../String/StringInput.h"
3	#include "../System/System.h"
4	#include "Spline.h"
5	#include "../System/SystemDefine.h"
6
7
8	Spline::Spline(int iNumberOfSplines)
9	{
10	numberOfSplines=iNumberOfSplines;
11	motionValuesPointers=new int[numberOfSplines];
12	motionSplinePointers=new int[numberOfSplines];
13
14	for ( int n=0; n<numberOfSplines ; n++ )
15	{
16	motionValuesPointers[n]=0;
17	}
18
19	for ( int n2=0; n2<numberOfSplines ; n2++ )
20	{
21	motionSplinePointers[n2]=0;
22	}
23
24	motionFrames=0;
25	motionLinear=0;
26	motionTension=0;
27	motionContinuity=0;
28	motionBias=0;
29
30	sceneFrame=0;
31	}
32
33	Spline::~Spline()
34	{
35	for ( int n=0; n<numberOfSplines ; n++ )
36	{
37	float motionValues=(float)motionValuesPointers[n];
38	if ( motionValues != 0 )
39	delete []motionValues;
40	}
41
42	for ( int n2=0; n2<numberOfSplines ; n2++ )
43	{
44	float motionSpline=(float)motionSplinePointers[n2];
45	if ( motionSpline != 0 )
46	delete []motionSpline;
47	}
48
49	if ( motionValuesPointers != 0 )
50	delete []motionValuesPointers;
51	if ( motionSplinePointers != 0 )
52	delete []motionSplinePointers;
53	if ( motionFrames != 0 )
54	delete []motionFrames;
55	if ( motionLinear != 0 )
56	delete []motionLinear;
57	if ( motionTension != 0 )
58	delete []motionTension;
59	if ( motionContinuity != 0 )
60	delete []motionContinuity;
61	if ( motionBias != 0 )
62	delete []motionBias;
63	}
64
65	float Spline::div( float a, float b)
66	{
67	if ( b > 0 )
68	{
69	return a/b;
70	}
71
72	return b=0;
73	}
74
75	void Spline::hermite(float t,float h1,float h2,float h3,float h4)
76	{
77	double t2,t3,z;
78
79	t2=t*t;
80	t3=t*t2;
81	z=3.0*t2-t3-t3;
82
83	*h1=(float )(1.0-z);
84	*h2=(float )(z);
85	*h3=(float )(t3-t2-t2+t);
86	*h4=(float )(t3-t2);
87	}
88
89	float Spline::calculateSpline(float t1, float t2, float t3, float t4, float p1, float p2 , float p3 , float p4, float tensionLast, float tensionNext, float continuityLast, float continuityNext, float biasLast, float biasNext)
90	{
91	float length=t3-t2;
92	float t=div((sceneFrame-t2),length);
93
94	int forward=0;
95
96	// TCB spline
97
98	float h1,h2,h3,h4;
99
100	hermite(t,&h1,&h2,&h3,&h4);
101	float dd0a=(float )((1.0-tensionLast) * (1.0+continuityLast) * (1.0+biasLast));
102	float dd0b=(float )((1.0-tensionLast) * (1.0-continuityLast) * (1.0-biasLast));
103	float ds1a=(float )((1.0-tensionNext) * (1.0-continuityNext) * (1.0+biasNext));
104	float ds1b=(float )((1.0-tensionNext) * (1.0+continuityNext) * (1.0-biasNext));
105
106
107	float adj0=div(length,(t3-t1));
108	float adj1=div(length,(t4-t2));
109	float v=p3-p2;
110
111	float dd0=0;
112	float ds1=0;
113
114	if (prev)
115	{
116	dd0=(float)0.5(dd0a+dd0b)v;
117	}
118	else
119	{
120	dd0=adj0(dd0a(p2-p1)+dd0b*v);
121	}
122
123	if (next)
124	{
125	ds1=(float)0.5(ds1a+ds1b)v;
126	}
127	else
128	{
129	ds1=adj1(ds1av+ds1b*(p4-p3));
130	}
131
132	return (p2h1+p3h2+dd0h3+ds1h4);
133	}
134
135	void Spline::update()
136	{
137	int i=0;
138	int stop=0;
139	int key=0;
140
141	if ( sceneFrame > motionFrames[sNumberOfKeys] )
142	{
143	sceneFrame=motionFrames[sNumberOfKeys];
144	}
145
146	while ( i<numberOfKeys && stop == 0 )
147	{
148	if ( sceneFrame <= motionFrames[i+2] )
149	{
150	stop=1;
151	}
152	else
153	{
154	key++;
155	}
156
157	i++;
158	}
159
160	keyP1=key+0;
161	keyP2=key+1;
162	keyP3=key+2;
163	keyP4=key+3;
164
165	mKeyP1=keyP1*3;
166	mKeyP2=keyP2*3;
167	mKeyP3=keyP3*3;
168	mKeyP4=keyP4*3;
169
170	prev=false;
171	next=false;
172
173	if (key == 0)
174	{
175	prev=true;
176	}
177
178	if ((key+3) == sNumberOfKeys \|\| (key+2) == sNumberOfKeys)
179	{
180	next=true;
181	}
182
183	for ( int n=0; n<numberOfSplines ; n++ )
184	{
185	float motionValues=(float)motionValuesPointers[n];
186	float motionSpline=(float)motionSplinePointers[n];
187
188	for ( int n2=0; n2<3 ; n2++ )
189	{
190	motionSpline[n2]=calculateSpline(motionFrames[keyP1], motionFrames[keyP2], motionFrames[keyP3], motionFrames[keyP4], motionValues[mKeyP1+n2], motionValues[mKeyP2+n2] , motionValues[mKeyP3+n2] , motionValues[mKeyP4+n2] ,motionTension[keyP2], motionTension[keyP3],motionContinuity[keyP2], motionContinuity[keyP3],motionBias[keyP2], motionBias[keyP3]);
191	}
192	}
193	}
194
195	float *Spline::getSplineChannel(int index)
196	{
197	return (float*)motionSplinePointers[index];
198	}
199
200	void Spline::increaseTime(float time)
201	{
202	sceneFrame+=time;
203	}
204
205	void Spline::insertdata( int p, int p2)
206	{
207	for ( int n=0; n<3 ; n++ )
208	{
209	for ( int n2=0; n2<numberOfSplines ; n2++ )
210	{
211	float motionValues=(float)motionValuesPointers[n2];
212	motionValues[p3+n]=motionValues[p23+n];
213	}
214	}
215
216	motionFrames[p]=motionFrames[p2];
217	motionLinear[p]=motionLinear[p2];
218	motionTension[p]=motionTension[p2];
219	motionContinuity[p]=motionContinuity[p2];
220	motionBias[p]=motionBias[p2];
221	}
222
223	void Spline::insertdata2( int p, int p2, int t, int t2)
224	{
225	for ( int n2=t ; n2>=t2 ; --n2 )
226	{
227	for ( int n=0; n<3 ; n++ )
228	{
229	for ( int n3=0; n3<numberOfSplines ; n3++ )
230	{
231	float motionValues=(float)motionValuesPointers[n3];
232	motionValues[(n2+p)3+n]=motionValues[(n2+p2)3+n];
233	}
234	}
235
236	motionFrames[n2+p]=motionFrames[n2+p2];
237	motionLinear[n2+p]=motionLinear[n2+p2];
238	motionTension[n2+p]=motionTension[n2+p2];
239	motionContinuity[n2+p]=motionContinuity[n2+p2];
240	motionBias[n2+p]=motionBias[n2+p2];
241	}
242	}
243
244	void Spline::insertdata3( int p, int t, int t2)
245	{
246	for ( int n2=t ; n2<t2 ; n2++ )
247	{
248	for ( int n=0; n<3 ; n++ )
249	{
250	for ( int n3=0; n3<numberOfSplines ; n3++ )
251	{
252	float motionValues=(float)motionValuesPointers[n3];
253	motionValues[n23+n]=motionValues[p3+n];
254	}
255	}
256
257	motionFrames[n2]=motionFrames[p];
258	motionLinear[n2]=motionLinear[p];
259	motionTension[n2]=motionTension[p];
260	motionContinuity[n2]=motionContinuity[p];
261	motionBias[n2]=motionBias[p];
262	}
263	}
264
265	void Spline::read(float *buffer)
266	{
267	numberOfKeys=(int)buffer[0];
268	sNumberOfKeys=numberOfKeys+1;
269
270	int plus=4;
271
272	for ( int v=0; v<numberOfSplines ; v++ )
273	{
274	motionValuesPointers[v]=(int)new int[(sNumberOfKeys+plus)*3];
275	}
276
277	for ( int v2=0; v2<numberOfSplines ; v2++ )
278	{
279	motionSplinePointers[v2]=(int)new int[3];
280	}
281
282	motionTension=new float[(sNumberOfKeys+plus)];
283	motionContinuity=new float[(sNumberOfKeys+plus)];
284	motionBias=new float[(sNumberOfKeys+plus)];
285	motionFrames=new float[(sNumberOfKeys+plus)];
286	motionLinear=new int[(sNumberOfKeys+plus)];
287
288	int forward=(numberOfSplines*3)+5;
289
290	for ( int n=0; n<numberOfKeys ; n++ )
291	{
292	int step=0;
293
294	for ( int n2=0; n2<numberOfSplines ; n2++ )
295	{
296	float motionValues=(float)motionValuesPointers[n2];
297	motionValues[n3+n2]=buffer[nforward+n2+1+(step*3)];
298	step+=3;
299	}
300
301	motionFrames[n]=buffer[n*forward+1+step];
302	motionLinear[n]=(int)buffer[n*forward+1+step+1];
303	motionTension[n]=buffer[n*forward+1+step+2];
304	motionContinuity[n]=buffer[n*forward+1+step+3];
305	motionBias[n]=buffer[n*forward+1+step+4];
306	}
307
308	if ( numberOfKeys == 1 )
309	{
310	insertdata3(0, 1, 5);
311	}
312
313	if ( numberOfKeys == 2 )
314	{
315	--sNumberOfKeys;
316	}
317
318	if ( numberOfKeys > 1 )
319	{
320	insertdata2(0,-1,(numberOfKeys+1),1);
321	insertdata(1,0);
322	insertdata(numberOfKeys+1,numberOfKeys);
323	}
324	}
325
326
327