Esempio n. 1
0
cOneParameter cMorph::Interpolate(const int keyframe, float factor)
{
	int key = findInMorph(keyframe);
	if (key == -1) return dataSets[0].parameter;
	if (dataSets[key].parameter.GetValueType() == typeString
			|| dataSets[key].parameter.GetValueType() == typeBool)
	{
		return None(key);
	}

	switch (dataSets[0].parameter.GetMorphType())
	{
		case morphNone:
			return None(key);
		case morphLinear:
			return Linear(key, factor, false);
		case morphLinearAngle:
			return Linear(key, factor, true);
		case morphCatMullRom:
			return CatmullRom(key, factor, false);
		case morphCatMullRomAngle:
			return CatmullRom(key, factor, true);
		case morphAkima:
			return Akima(key, factor, false);
		case morphAkimaAngle:
			return Akima(key, factor, true);
		default:
			return None(key);
	}
}
    /**
     * @brief SampleImage samples an image in uniform coordiantes.
     * @param img
     * @param x
     * @param y
     * @param vOut
     */
    void SampleImage(Image *img, float x, float y, float *vOut)
    {
        float xx, yy, dx, dy;

        //Coordiantes in [0,width-1]x[0,height-1]
        x *= img->width1f;
        y *= img->height1f;

        //Coordinates without fractions
        xx = floorf(x);
        yy = floorf(y);

        //Interpolation values
        dx = (x - xx);
        dy = (y - yy);

        //Integer coordinates
        int ix = int(xx);
        int iy = int(yy);

        for(int k = 0; k < img->channels; k++) {
            vOut[k] = 0.0f;
        }

        //Catmull-rom interpolation
        float rx, ry;
        int ey, ex;
        for(int j = -1; j < 3; j++) {
            ry = CatmullRom(float(j) - dy);
            ey = CLAMP(iy + j, img->height);

            for(int i = -1; i < 3; i++) {
                rx = CatmullRom(-(float(i) - dx));
                ex = CLAMP(ix + i, img->width);
                int ind = (ey * img->width + ex) * img->channels;

                rx *= ry;
                for(int k = 0; k < img->channels; k++) {
                    vOut[k] += img->data[ind + k] * rx;
                }
            }
        }
    }
void camera()
{
    int j=0;
    int i=move_i;
    
    p.x= CatmullRom(move, g_Splines[j].points[i].x, g_Splines[j].points[i+1].x, g_Splines[j].points[i+2].x, g_Splines[j].points[i+3].x);
    p.y= CatmullRom(move, g_Splines[j].points[i].y, g_Splines[j].points[i+1].y, g_Splines[j].points[i+2].y, g_Splines[j].points[i+3].y);
    p.z= CatmullRom(move, g_Splines[j].points[i].z, g_Splines[j].points[i+1].z, g_Splines[j].points[i+2].z, g_Splines[j].points[i+3].z);
    
    t.x= CatmullRomTangent(move, g_Splines[j].points[i].x, g_Splines[j].points[i+1].x, g_Splines[j].points[i+2].x, g_Splines[j].points[i+3].x);
    t.y= CatmullRomTangent(move, g_Splines[j].points[i].y, g_Splines[j].points[i+1].y, g_Splines[j].points[i+2].y, g_Splines[j].points[i+3].y);
    t.z= CatmullRomTangent(move, g_Splines[j].points[i].z, g_Splines[j].points[i+1].z, g_Splines[j].points[i+2].z, g_Splines[j].points[i+3].z);
    t = normalize(t);
    
    n = CrossProduct(t, v);
    n = normalize(n);
    
    b = CrossProduct(t, n);
    b = normalize(b);
    float f=0.05,f1=0.1;
    
    point c;
    
    f=0.1,f1=0.05;
    c.x = p.x +f1*n.x + f*b.x;
    c.y = p.y + f1*n.y + f*b.y;
    c.z = p.z + f1*n.z + f*b.z;
    
    
    
    gluLookAt(
              // 5.0,5.0,14.0,
              c.x,c.y,c.z,
              p.x+f1*n.x+t.x, p.y+f1*n.y+t.y, p.z+f1*n.z+t.z,
              
              b.x,b.y,b.z);
}
Esempio n. 4
0
Vec3 GameSDK::CLightningRenderNode::CSegment::GetPoint(const SLightningParams& desc, const SPointData& pointData, int point, float deviationMult) const
{
	const int numSegs = desc.m_strikeNumSegments;
	const int numSubSegs = desc.m_strikeNumPoints;

	const float deviation = desc.m_lightningDeviation;
	const float fuzzyness = desc.m_lightningFuzzyness;

	int i = point / numSubSegs;
	int j = point % numSubSegs;

	int idx[4] =
	{
		max(i-1, 0),
		i,
		min(i+1, numSegs),
		min(i+2, numSegs)
	};

	Vec3 positions[4];
	for (int l = 0; l < 4; ++l)
	{
		positions[l] = LERP(m_origin, m_destany, idx[l] / float(numSegs));
		positions[l] += pointData.m_points[m_firstPoint+idx[l]] * deviation * deviationMult;
		positions[l] += pointData.m_velocity[m_firstPoint+idx[l]] * desc.m_lightningVelocity * m_time * deviationMult;
	}

	float x = j / float(numSubSegs);
	int k = i*numSubSegs + j;
	Vec3 result = CatmullRom(
		positions[0], positions[1],
		positions[2], positions[3], x);
	result = result + pointData.m_fuzzyPoints[m_firstFuzzyPoint+k] * fuzzyness * deviationMult;

	return result;
}
Esempio n. 5
0
WaypointList*
PathFinder::SmoothWaypointList( WaypointList* pWaypointList )
{
    if (!pWaypointList)
        return NULL;

	if( pWaypointList->size() > 2 )
	{
		WORLD_POSITION newPoint0( 0.0f, 0.0f, 0.0f );
		WORLD_POSITION newPoint1( 0.0f, 0.0f, 0.0f );

		WaypointList oldList;
		for( WaypointList::iterator i = pWaypointList->begin(); i != pWaypointList->end(); i++ )
		{
			oldList.push_back( *i );
		}
		pWaypointList->clear();

		WORLD_POSITION p0, p1, p2, p3;

		//First
		WaypointList::iterator iter = oldList.begin();
		p0 = p1 = p2 = *iter;
		iter++;
		p3 = *iter;
		iter++;

		const int divisions = 5;
		while( iter != oldList.end() )
		{
			p0 = p1;
			p1 = p2;
			p2 = p3;
			p3 = *iter;

			for( int count=1; count<divisions+1; count++)
			{
				vec3 newPoint = CatmullRom( p0, p1, p2, p3, (float)count/(float)divisions );
				if( pWaypointList->size() > 1 )
				{
					vec3 lastDir = newPoint1 - newPoint0;
					vec3 curDir = newPoint - newPoint1;
                    
                    lastDir.Normalize();
                    curDir.Normalize();
                    float dot = lastDir.Dot( curDir );
                    
					if( dot > 0.99f )
					{
						pWaypointList->pop_back();
					}
				}
				newPoint0 = newPoint1;
				newPoint1 = newPoint;
				pWaypointList->push_back( newPoint );
			}
			iter++;
		}

		//Last
		p0 = p1;
		p1 = p2;
		p2 = p3;
		p3 = p3;	//Redundant, but put here to make it clear what is intended
		
		for( int count=1; count<divisions+1; count++)
		{
			WORLD_POSITION newPoint = CatmullRom( p0, p1, p2, p3, (float)count/(float)divisions );
			if( pWaypointList->size() > 1 )
			{
				vec3 lastDir = newPoint1 - newPoint0;
				vec3 curDir = newPoint - newPoint1;
                
                lastDir.Normalize();
                curDir.Normalize();
                float dot = lastDir.Dot( curDir );
                
				if( dot > 0.99f )
				{
					pWaypointList->pop_back();
				}
			}
			newPoint0 = newPoint1;
			newPoint1 = newPoint;
			pWaypointList->push_back( newPoint );
		}
	}

    return pWaypointList;
}
void displayRails()
{
    //DISPLAY RAILS ON ROLLER COASTER
    glColor3f(1.0, 1.0, 1.0);
    texture = LoadTexture("wood.jpg",256, 256);
    glEnable(GL_TEXTURE_2D);
    glBegin(GL_QUADS);
    for (int j = 0; j < g_iNumOfSplines; j++) {
        for(int i=-2;i<g_Splines[j].numControlPoints-1;i++)
        {
            for(float u=0.0;u<1.0;u+=0.05){
                
                point p,t,n,v,n1,t1,p1;
                v.x=0.0;v.y=0.0;v.z=-1.0;
                
                float f=0.1;
                //Point
                p.x= CatmullRom(u, g_Splines[j].points[i].x, g_Splines[j].points[i+1].x, g_Splines[j].points[i+2].x, g_Splines[j].points[i+3].x);
                p.y= CatmullRom(u, g_Splines[j].points[i].y, g_Splines[j].points[i+1].y, g_Splines[j].points[i+2].y, g_Splines[j].points[i+3].y);
                p.z= CatmullRom(u, g_Splines[j].points[i].z, g_Splines[j].points[i+1].z, g_Splines[j].points[i+2].z, g_Splines[j].points[i+3].z);
                //Tangent
                t.x= CatmullRomTangent(u, g_Splines[j].points[i].x, g_Splines[j].points[i+1].x, g_Splines[j].points[i+2].x, g_Splines[j].points[i+3].x);
                t.y= CatmullRomTangent(u, g_Splines[j].points[i].y, g_Splines[j].points[i+1].y, g_Splines[j].points[i+2].y, g_Splines[j].points[i+3].y);
                t.z= CatmullRomTangent(u, g_Splines[j].points[i].z, g_Splines[j].points[i+1].z, g_Splines[j].points[i+2].z, g_Splines[j].points[i+3].z);
                t = normalize(t);
                //Normal
                n = CrossProduct(t, v);
                n = normalize(n);
                
                p1.x= CatmullRom(u+0.01, g_Splines[j].points[i].x, g_Splines[j].points[i+1].x, g_Splines[j].points[i+2].x, g_Splines[j].points[i+3].x);
                p1.y= CatmullRom(u+0.01, g_Splines[j].points[i].y, g_Splines[j].points[i+1].y, g_Splines[j].points[i+2].y, g_Splines[j].points[i+3].y);
                p1.z= CatmullRom(u+0.01, g_Splines[j].points[i].z, g_Splines[j].points[i+1].z, g_Splines[j].points[i+2].z, g_Splines[j].points[i+3].z);
                
                t1.x= CatmullRomTangent(u+0.01, g_Splines[j].points[i].x, g_Splines[j].points[i+1].x, g_Splines[j].points[i+2].x, g_Splines[j].points[i+3].x);
                t1.y= CatmullRomTangent(u+0.01, g_Splines[j].points[i].y, g_Splines[j].points[i+1].y, g_Splines[j].points[i+2].y, g_Splines[j].points[i+3].y);
                t1.z= CatmullRomTangent(u+0.01, g_Splines[j].points[i].z, g_Splines[j].points[i+1].z, g_Splines[j].points[i+2].z, g_Splines[j].points[i+3].z);
                t1 = normalize(t1);
                
                n1 = CrossProduct(t1, v);
                n1 = normalize(n1);
                
                glColor3f(1.0, 1.0, 1.0);
                glTexCoord2d(0.0,0.0);glVertex3f(p.x,p.y,p.z);
                glTexCoord2d(3,0.0);glVertex3f(p.x+f*(n.x),p.y+f*(n.y),p.z+f*(n.z));
                glTexCoord2d(3,1);glVertex3f(p1.x+f*(n1.x),p1.y+f*(n1.y),p1.z+f*(n1.z));
                glTexCoord2d(0.0,1);glVertex3f(p1.x,p1.y,p1.z);
                
                glColor3f(1.0, 1.0, 1.0);
                glTexCoord2d(0.0,0.0);glVertex3f(p.x,p.y,p.z-0.003);
                glTexCoord2d(3.0,0.0);glVertex3f(p.x+f*(n.x),p.y+f*(n.y),p.z+f*(n.z)-0.003);
                glTexCoord2d(3.0,1.0);glVertex3f(p1.x+f*(n1.x),p1.y+f*(n1.y),p1.z+f*(n1.z)-0.003);
                glTexCoord2d(0.0,1.0);glVertex3f(p1.x,p1.y,p1.z-0.003);
                
                glColor3f(0.8, 0.5, 0.0);
                glTexCoord2d(0.0,0.0);glVertex3f(p.x,p.y,p.z);
                glTexCoord2d(3.0,0.0);glVertex3f(p.x+f*(n.x),p.y+f*(n.y),p.z+f*(n.z));
                glTexCoord2d(3.0,1.0);glVertex3f(p.x+f*(n.x),p.y+f*(n.y),p.z+f*(n.z)-0.003);
                glTexCoord2d(0.0,1.0);glVertex3f(p.x,p.y,p.z-0.003);
                
                glColor3f(1.0, 1.0, 1.0);
                glTexCoord2d(0.0,0.0);glVertex3f(p1.x,p1.y,p1.z);
                glTexCoord2d(3.0,0.0);glVertex3f(p1.x+f*(n1.x),p1.y+f*(n1.y),p1.z+f*(n1.z));
                glTexCoord2d(3.0,1.0);glVertex3f(p1.x+f*(n1.x),p1.y+f*(n1.y),p1.z+f*(n1.z)-0.003);
                glTexCoord2d(0.0,1.0);glVertex3f(p1.x,p1.y,p1.z-0.003);
                
                
            }
        }
    }
    glEnd();
    glDisable(GL_TEXTURE_2D);
}
void displayRollerCoaster()
{
    //DISPLAY THE ROLLER COASTER
    float a=0.01,f=0.1;
    texture = LoadTexture("wood.jpg",256, 256);
    glEnable(GL_TEXTURE_2D);
    for(float r=0;r<2;r++){
        glBegin(GL_QUADS);
        for (int j = 0; j < g_iNumOfSplines; j++) {
            for(int i=-2;i<g_Splines[j].numControlPoints-1;i++)
            {
                for(float u=0.0;u<1.0;u+=0.02){
                    //Point
                    p.x= CatmullRom(u, g_Splines[j].points[i].x, g_Splines[j].points[i+1].x, g_Splines[j].points[i+2].x, g_Splines[j].points[i+3].x);
                    p.y= CatmullRom(u, g_Splines[j].points[i].y, g_Splines[j].points[i+1].y, g_Splines[j].points[i+2].y, g_Splines[j].points[i+3].y);
                    p.z= CatmullRom(u, g_Splines[j].points[i].z, g_Splines[j].points[i+1].z, g_Splines[j].points[i+2].z, g_Splines[j].points[i+3].z);
                    //Tangent
                    t.x= CatmullRomTangent(u, g_Splines[j].points[i].x, g_Splines[j].points[i+1].x, g_Splines[j].points[i+2].x, g_Splines[j].points[i+3].x);
                    t.y= CatmullRomTangent(u, g_Splines[j].points[i].y, g_Splines[j].points[i+1].y, g_Splines[j].points[i+2].y, g_Splines[j].points[i+3].y);
                    t.z= CatmullRomTangent(u, g_Splines[j].points[i].z, g_Splines[j].points[i+1].z, g_Splines[j].points[i+2].z, g_Splines[j].points[i+3].z);
                    t = normalize(t);
                    //Normal
                    n = CrossProduct(t, v);
                    n = normalize(n);
                    //Binormal
                    b = CrossProduct(t, n);
                    b = normalize(b);
                    
                    p1.x= CatmullRom(u+0.02, g_Splines[j].points[i].x, g_Splines[j].points[i+1].x, g_Splines[j].points[i+2].x, g_Splines[j].points[i+3].x);
                    p1.y= CatmullRom(u+0.02, g_Splines[j].points[i].y, g_Splines[j].points[i+1].y, g_Splines[j].points[i+2].y, g_Splines[j].points[i+3].y);
                    p1.z= CatmullRom(u+0.02, g_Splines[j].points[i].z, g_Splines[j].points[i+1].z, g_Splines[j].points[i+2].z, g_Splines[j].points[i+3].z);
                    
                    t1.x= CatmullRomTangent(u+0.02, g_Splines[j].points[i].x, g_Splines[j].points[i+1].x, g_Splines[j].points[i+2].x, g_Splines[j].points[i+3].x);
                    t1.y= CatmullRomTangent(u+0.02, g_Splines[j].points[i].y, g_Splines[j].points[i+1].y, g_Splines[j].points[i+2].y, g_Splines[j].points[i+3].y);
                    t1.z= CatmullRomTangent(u+0.02, g_Splines[j].points[i].z, g_Splines[j].points[i+1].z, g_Splines[j].points[i+2].z, g_Splines[j].points[i+3].z);
                    t1 = normalize(t1);
                    
                    n1 = CrossProduct(t1, v);
                    n1 = normalize(n1);
                    b1 = CrossProduct(t1, n1);
                    b1 = normalize(b1);
                    
                    if(r==1)
                    {
                        p.x+=f*n.x;
                        p.y+=f*n.y;
                        p.z+=f*n.z;
                        
                        p1.x+=f*n1.x;
                        p1.y+=f*n1.y;
                        p1.z+=f*n1.z;
                        
                    }
                    
                    glColor3f(1.0, 0.0, 0.0);
                    //V1
                    glTexCoord2d(0.0,0.0);glVertex3f(p.x+a*(n.x-b.x),p.y+a*(n.y-b.y),p.z+a*(n.z-b.z));
                    //V2
                    glTexCoord2d(1.0,0.0);glVertex3f(p.x+a*(n.x+b.x),p.y+a*(n.y+b.y),p.z+a*(n.z+b.z));
                    //V3
                    glTexCoord2d(1.0,1.0);glVertex3f(p.x+a*(-n.x+b.x),p.y+a*(-n.y+b.y),p.z+a*(-n.z+b.z));
                    //V4
                    glTexCoord2d(0.0,1.0);glVertex3f(p.x+a*(-n.x-b.x),p.y+a*(-n.y-b.y),p.z+a*(-n.z-b.z));
                    
                    //V5
                    glTexCoord2d(0.0,0.0);glVertex3f(p1.x+a*(n1.x-b1.x),p1.y+a*(n1.y-b1.y),p1.z+a*(n1.z-b1.z));
                    //V6
                    glTexCoord2d(1.0,0.0);glVertex3f(p1.x+a*(n1.x+b1.x),p1.y+a*(n1.y+b1.y),p1.z+a*(n1.z+b1.z));
                    //V7
                    glTexCoord2d(1.0,1.0);glVertex3f(p1.x+a*(-n1.x+b1.x),p1.y+a*(-n1.y+b1.y),p1.z+a*(-n1.z+b1.z));
                    //V8
                    glTexCoord2d(0.0,1.0);glVertex3f(p1.x+a*(-n1.x-b1.x),p1.y+a*(-n1.y-b1.y),p1.z+a*(-n1.z-b1.z));
                    
                    //V1
                    glTexCoord2d(0.0,0.0);glVertex3f(p.x+a*(n.x-b.x),p.y+a*(n.y-b.y),p.z+a*(n.z-b.z));
                    //V4
                    glTexCoord2d(0.0,1.0);glVertex3f(p.x+a*(-n.x-b.x),p.y+a*(-n.y-b.y),p.z+a*(-n.z-b.z));
                    //V8
                    glTexCoord2d(0.0,1.0);glVertex3f(p1.x+a*(-n1.x-b1.x),p1.y+a*(-n1.y-b1.y),p1.z+a*(-n1.z-b1.z));
                    //V5
                    glTexCoord2d(0.0,0.0);glVertex3f(p1.x+a*(n1.x-b1.x),p1.y+a*(n1.y-b1.y),p1.z+a*(n1.z-b1.z));
                    
                    //V3
                    glTexCoord2d(1.0,1.0);glVertex3f(p.x+a*(-n.x+b.x),p.y+a*(-n.y+b.y),p.z+a*(-n.z+b.z));
                    //V4
                    glTexCoord2d(0.0,1.0);glVertex3f(p.x+a*(-n.x-b.x),p.y+a*(-n.y-b.y),p.z+a*(-n.z-b.z));
                    //V8
                    glTexCoord2d(0.0,1.0);glVertex3f(p1.x+a*(-n1.x-b1.x),p1.y+a*(-n1.y-b1.y),p1.z+a*(-n1.z-b1.z));
                    //V7
                    glTexCoord2d(1.0,1.0);glVertex3f(p1.x+a*(-n1.x+b1.x),p1.y+a*(-n1.y+b1.y),p1.z+a*(-n1.z+b1.z));
                    
                    //V2
                    glTexCoord2d(1.0,0.0);glVertex3f(p.x+a*(n.x+b.x),p.y+a*(n.y+b.y),p.z+a*(n.z+b.z));
                    //V3
                    glTexCoord2d(1.0,1.0);glVertex3f(p.x+a*(-n.x+b.x),p.y+a*(-n.y+b.y),p.z+a*(-n.z+b.z));
                    //V7
                    glTexCoord2d(1.0,1.0);glVertex3f(p1.x+a*(-n1.x+b1.x),p1.y+a*(-n1.y+b1.y),p1.z+a*(-n1.z+b1.z));
                    //V6
                    glTexCoord2d(1.0,0.0);glVertex3f(p1.x+a*(n1.x+b1.x),p1.y+a*(n1.y+b1.y),p1.z+a*(n1.z+b1.z));
                    
                    //V1
                    glTexCoord2d(0.0,0.0);glVertex3f(p.x+a*(n.x-b.x),p.y+a*(n.y-b.y),p.z+a*(n.z-b.z));
                    //V2
                    glTexCoord2d(1.0,0.0);glVertex3f(p.x+a*(n.x+b.x),p.y+a*(n.y+b.y),p.z+a*(n.z+b.z));
                    //V6
                    glTexCoord2d(1.0,0.0);glVertex3f(p1.x+a*(n1.x+b1.x),p1.y+a*(n1.y+b1.y),p1.z+a*(n1.z+b1.z));
                    //V5
                    glTexCoord2d(0.0,0.0);glVertex3f(p1.x+a*(n1.x-b1.x),p1.y+a*(n1.y-b1.y),p1.z+a*(n1.z-b1.z));
                }
            }
        }
        glEnd();
    }
    glDisable(GL_TEXTURE_2D);
}