glhelpers.cpp

OPENGL2.0用于ARM11 3D处理

//TEMP: ripped from nate robins : http://www.xmission.com/~nate/tutors.html
extern "C" bool matInverse(float inverse[16], const float src[16])
{
double t;
    int i, j, k, swap;
    float tmp[4][4];
    
    matIdentity(inverse);
    
    for (i = 0; i < 4; i++) {
        for (j = 0; j < 4; j++) {
            tmp[i][j] = src[i*4+j];
        }
    }
    
    for (i = 0; i < 4; i++) {
        /* look for largest element in column. */
        swap = i;
        for (j = i + 1; j < 4; j++) {
            if (fabs(tmp[j][i]) > fabs(tmp[i][i])) {
                swap = j;
            }
        }
        
        if (swap != i) {
            /* swap rows. */
            for (k = 0; k < 4; k++) {
                t = tmp[i][k];
                tmp[i][k] = tmp[swap][k];
                tmp[swap][k] = t;
                
                t = inverse[i*4+k];
                inverse[i*4+k] = inverse[swap*4+k];
                inverse[swap*4+k] = t;
            }
        }
        
        if (tmp[i][i] == 0) {
        /* no non-zero pivot.  the matrix is singular, which
           shouldn't happen.  This means the user gave us a bad
            matrix. */
            return false;
        }
        
        t = tmp[i][i];
        for (k = 0; k < 4; k++) {
            tmp[i][k] /= t;
            inverse[i*4+k] /= t;
        }
        for (j = 0; j < 4; j++) {
            if (j != i) {
                t = tmp[j][i];
                for (k = 0; k < 4; k++) {
                    tmp[j][k] -= tmp[i][k]*t;
                    inverse[j*4+k] -= inverse[i*4+k]*t;
                }
            }
        }
    }
    return true;
}
/***************** Virdi added this set of code***********/
// m3=m1*m2
extern "C" void matMultl(float* m3, const float* m1, const float* m2) 
{
        
       m3[0] = m2[0]*m1[0] + m2[4]*m1[1] + m2[8]*m1[2] + m2[12]*m1[3];
       m3[1] = m2[1]*m1[0] + m2[5]*m1[1] + m2[9]*m1[2] + m2[13]*m1[3];
       m3[2] = m2[2]*m1[0] + m2[6]*m1[1] + m2[10]*m1[2] + m2[14]*m1[3];
       m3[3] = m2[3]*m1[0] + m2[7]*m1[1] + m2[11]*m1[2] + m2[15]*m1[3];
       
       m3[4] = m2[0]*m1[4] + m2[4]*m1[5] + m2[8]*m1[6] + m2[12]*m1[7];
       m3[5] = m2[1]*m1[4] + m2[5]*m1[5] + m2[9]*m1[6] + m2[13]*m1[7];
       m3[6] = m2[2]*m1[4] + m2[6]*m1[5] + m2[10]*m1[6] + m2[14]*m1[7];
       m3[7] = m2[3]*m1[4] + m2[7]*m1[5] + m2[11]*m1[6] + m2[15]*m1[7];
       
       m3[8] = m2[0]*m1[8] + m2[4]*m1[9] + m2[8]*m1[10] + m2[12]*m1[11];
       m3[9] = m2[1]*m1[8] + m2[5]*m1[9] + m2[9]*m1[10] + m2[13]*m1[11];
       m3[10] = m2[2]*m1[8] + m2[6]*m1[9] + m2[10]*m1[10] + m2[14]*m1[11];
       m3[11] = m2[3]*m1[8] + m2[7]*m1[9] + m2[11]*m1[10] + m2[15]*m1[11];
       
       m3[12] = m2[0]*m1[12] + m2[4]*m1[13] + m2[8]*m1[14] + m2[12]*m1[15];
       m3[13] = m2[1]*m1[12] + m2[5]*m1[13] + m2[9]*m1[14] + m2[13]*m1[15];
       m3[14] = m2[2]*m1[12] + m2[6]*m1[13] + m2[10]*m1[14] + m2[14]*m1[15];
       m3[15] = m2[3]*m1[12] + m2[7]*m1[13] + m2[11]*m1[14] + m2[15]*m1[15];

}
extern "C" void matMult(float* m3, const float* m1, const float* m2) 
{
        
       m3[0] = m1[0]*m2[0] + m1[4]*m2[1] + m1[8]*m2[2] + m1[12]*m2[3];
       m3[1] = m1[1]*m2[0] + m1[5]*m2[1] + m1[9]*m2[2] + m1[13]*m2[3];
       m3[2] = m1[2]*m2[0] + m1[6]*m2[1] + m1[10]*m2[2] + m1[14]*m2[3];
       m3[3] = m1[3]*m2[0] + m1[7]*m2[1] + m1[11]*m2[2] + m1[15]*m2[3];
       
       m3[4] = m1[0]*m2[4] + m1[4]*m2[5] + m1[8]*m2[6] + m1[12]*m2[7];
       m3[5] = m1[1]*m2[4] + m1[5]*m2[5] + m1[9]*m2[6] + m1[13]*m2[7];
       m3[6] = m1[2]*m2[4] + m1[6]*m2[5] + m1[10]*m2[6] + m1[14]*m2[7];
       m3[7] = m1[3]*m2[4] + m1[7]*m2[5] + m1[11]*m2[6] + m1[15]*m2[7];
       
       m3[8] = m1[0]*m2[8] + m1[4]*m2[9] + m1[8]*m2[10] + m1[12]*m2[11];
       m3[9] = m1[1]*m2[8] + m1[5]*m2[9] + m1[9]*m2[10] + m1[13]*m2[11];
       m3[10] = m1[2]*m2[8] + m1[6]*m2[9] + m1[10]*m2[10] + m1[14]*m2[11];
       m3[11] = m1[3]*m2[8] + m1[7]*m2[9] + m1[11]*m2[10] + m1[15]*m2[11];
       
       m3[12] = m1[0]*m2[12] + m1[4]*m2[13] + m1[8]*m2[14] + m1[12]*m2[15];
       m3[13] = m1[1]*m2[12] + m1[5]*m2[13] + m1[9]*m2[14] + m1[13]*m2[15];
       m3[14] = m1[2]*m2[12] + m1[6]*m2[13] + m1[10]*m2[14] + m1[14]*m2[15];
       m3[15] = m1[3]*m2[12] + m1[7]*m2[13] + m1[11]*m2[14] + m1[15]*m2[15];

}
//transform the vector x,y,z  with the transformation matrix m
extern "C" void vecMult(const float* m, float x, float y, float z)
{	
	float xo,yo,zo;
	   xo = m[0] * x + m[4] * y + m[8] * z + m[12];
       yo = m[1] * x + m[5] * y + m[9] * z + m[13];
       zo = m[2] * x + m[6] * y + m[10] * z + m[14];
	   
	   x=xo;
       y=yo;
	   z=zo;
}

//will update the current matrix' m' with the tranalation vector x,y,z
extern "C" void matTranslate(float* m, const float x, const float y, const float z  )
{
       m[12] = m[0] * x + m[4] *y + m[8]* z + m[12];
       m[13] = m[1] * x + m[5] *y + m[9]* z + m[13];
       m[14] = m[2] * x + m[6] *y + m[10]* z + m[14];
	   m[15] = m[3] * x + m[7] *y + m[11]* z + m[15];
}  

//rotate about arbit axis
extern "C" bool matRotate(float* m, float DEGAngle, float x, float y, float z)
{
	    
	   float Sq = sqrt(x*x + y*y + z*z);
	   float inv;
	   if(Sq > -FLT_EPSILON && Sq < FLT_EPSILON) //chk for divide by zero......
		   return false;
	   inv = 1.0f/Sq;	
	   x = x * inv;   
	   y = y * inv;
	   z = z * inv;
	   float radian = PI_OVER_180 * DEGAngle;
       float f32c = (float)cos(radian); //TODO!! Optimize me
       float f32s = (float)sin(radian);
       float f32OneMinC = 1 - f32c;
		
		float RotMat[16];
       RotMat[0] = f32c + f32OneMinC * x * x;
       RotMat[1] = (f32OneMinC * x * y) + (z * f32s);
       RotMat[2] = (f32OneMinC * x * z) - (y * f32s);
	   RotMat[3] = 0.0;
       RotMat[4] = (f32OneMinC * x * y) - (z * f32s);
       RotMat[5] = f32c + f32OneMinC * y * y;
       RotMat[6] = (f32OneMinC * y * z) + (x * f32s);
	   RotMat[7] = 0.0;
       RotMat[8] = (f32OneMinC * x * z) + (y * f32s);
       RotMat[9] = (f32OneMinC * y * z) - (x * f32s);
       RotMat[10] = f32c + f32OneMinC * z * z;
	   RotMat[11] = RotMat[12] =RotMat[13] = RotMat[14] = 0.0;RotMat[15] =1.0f;
	   float t[16];
	   matMult( &t[0] ,  m , &RotMat[0]);
	   for(int i = 0; i < 16; ++i)
		m[i] = t[i];
		
	  return true;
}

//will update the current matrix' m' with the tranalation vector x,y,z
extern "C" void matTranslatel(float* m, const float x, const float y, const float z  )
{
       m[3] = m[0] * x + m[1] *y + m[2]* z + m[3];
       m[7] = m[4] * x + m[5] *y + m[6]* z + m[7];
       m[10] = m[8] * x + m[9] *y + m[10]* z + m[11];
	   m[15] = m[12] * x + m[13] *y + m[14]* z + m[15];
}  

//rotate about arbit axis
extern "C" bool matRotatel(float* m, float DEGAngle, float x, float y, float z)
{
	    
	   float Sq = sqrt(x*x + y*y + z*z);
	   float inv;
	   if(Sq > -FLT_EPSILON && Sq < FLT_EPSILON) //chk for divide by zero......
		   return false;
	   inv = 1.0f/Sq;	
	   x = x * inv;   
	   y = y * inv;
	   z = z * inv;
	   float radian = PI_OVER_180 * DEGAngle;
       float f32c = (float)cos(radian); //TODO!! Optimize me
       float f32s = (float)sin(radian);
       float f32OneMinC = 1 - f32c;
		
		float RotMat[16];
       RotMat[0] = f32c + f32OneMinC * x * x;
       RotMat[4] = (f32OneMinC * x * y) + (z * f32s);
       RotMat[8] = (f32OneMinC * x * z) - (y * f32s);
	   RotMat[12] = 0.0;
       RotMat[1] = (f32OneMinC * x * y) - (z * f32s);
       RotMat[5] = f32c + f32OneMinC * y * y;
       RotMat[9] = (f32OneMinC * y * z) + (x * f32s);
	   RotMat[13] = 0.0;
       RotMat[2] = (f32OneMinC * x * z) + (y * f32s);
       RotMat[6] = (f32OneMinC * y * z) - (x * f32s);
       RotMat[10] = f32c + f32OneMinC * z * z;
	   RotMat[14] = RotMat[3] = RotMat[7] = RotMat[11] = 0.0;RotMat[15] =1.0f;
	   float t[16];
	   matMult( &t[0] ,  m , &RotMat[0]);
	   for(int i = 0; i < 16; ++i)
		m[i] = t[i];
		
	  return true;
}

extern "C" void matScale(float*m, float x, float y, float z)
{
	m[0] *= x ; m[4] *= y ; m[8] *= z ;// m[12] *= x ;  
	m[1] *= x ; m[5] *= y ; m[9] *= z ; //m[13] *= y ;  
	m[2] *= x ; m[6] *= y ; m[10] *= z ; //m[14] *= z ;  
}

//like glfrustum
extern "C" bool matFrustum(float* m,float f32Left, float f32Right,float f32Bottom, float f32Top, float f32ZNear, float f32ZFar)
{
	float diff = f32Right - f32Left;
	if(diff > -FLT_EPSILON && diff < FLT_EPSILON) //chk for divide by zero......
		return false;
	
	diff = f32Top - f32Bottom;
	if(diff > -FLT_EPSILON && diff < FLT_EPSILON) //chk for divide by zero......
		return false;
		
	diff = f32ZFar - f32ZNear;
	if(diff > -FLT_EPSILON && diff < FLT_EPSILON) //chk for divide by zero......
		return false;	   
		
       m[0] = float(2.0*f32ZNear/(f32Right-f32Left));
       m[1] = m[2] = m[3] = 0;

       m[4] = 0;
       m[5] = float(2.0*f32ZNear/(f32Top-f32Bottom));
       m[6] = m[7] = 0;

       m[8] = (f32Right + f32Left) / (f32Right - f32Left);
       m[9] = (f32Top + f32Bottom) / (f32Top - f32Bottom);
       m[10] = -( (f32ZNear + f32ZFar) / (f32ZFar - f32ZNear)  );
       m[11] = -1;
       
       m[12] = m[13] =0;
       m[14] = -( (2*f32ZNear*f32ZFar) / (f32ZFar-f32ZNear));
       m[15] = 0;
	   return true;
}

//like gluperspective matrix		 
extern "C" bool matPerspective(float* m ,float fieldOfViewDegree, float aspectRatio, float zNear, float zFar)
{
   if(fieldOfViewDegree <= 0.0f || fieldOfViewDegree >=180.0f)
      //fieldOfViewDegree = 45.0f;   //assign FOV to 45 deg if value passed is not in proper range 
	   return false;

   float FOVrad = float(PI_OVER_180*fieldOfViewDegree*0.5f);//angle divided by 2 !!!

   float f32top = float( zNear*tan(FOVrad) );
   float f32Right = aspectRatio*f32top;
   return matFrustum(m,-f32Right,f32Right,-f32top,f32top,zNear,zFar);

}  

//like glortho
extern "C" bool matOrtho(float* m,float f32Left, float f32Right,float f32Top, float f32Bottom, float f32ZNear, float f32ZFar)
{
    float diff = f32Right - f32Left;
	if(diff > -FLT_EPSILON && diff < FLT_EPSILON) //chk for divide by zero......
		return false;
	
	diff = f32Top - f32Bottom;
	if(diff > -FLT_EPSILON && diff < FLT_EPSILON) //chk for divide by zero......
		return false;
		
	diff = f32ZFar - f32ZNear;
	if(diff > -FLT_EPSILON && diff < FLT_EPSILON) //chk for divide by zero......
		return false;
		
    m[0] = float(2.0/(f32Right-f32Left));
   m[1] = m[2] = m[3] = 0;

   m[4] = 0;
   m[5] = float(2.0/(f32Top-f32Bottom));
   m[6] = m[7] = 0;

   m[8] = m[9] = 0;
   m[10] = -float(2.0/(f32ZFar - f32ZNear));
   m[11] = 0;
   
   m[12] = -((f32Right+f32Left)/(f32Right-f32Left));
   m[13] = -((f32Top+f32Bottom)/(f32Top-f32Bottom));
   m[14] = -((f32ZNear+f32ZFar)/(f32ZFar-f32ZNear));
   m[15] = 1;
   return true;
}
extern "C" bool vecNormalize(float& x, float& y, float& z)
{
	   float Sq = sqrt(x*x + y*y + z*z);
	   float inv;
	   if(Sq > -FLT_EPSILON && Sq < FLT_EPSILON) //chk for divide by zero......
		   return false;
	   inv = 1.0f/Sq;	
	   x = x * inv;   
	   y = y * inv;
	   z = z * inv;
	   return true;
}

//vector x = x1 cross y1
extern "C" void vecCrossProduct(float& x,float& y, float& z , float x1,float y1, float z1 ,float x2,float y2, float z2)
{
	//x= y1*z2 - y1*z2;
	x= y1*z2 - y2*z1;
	y= z1*x2 - z2*x1;
	z= x1*y2 - x2*y1;
}		 
//like gluLookAt
extern "C" void matLookAt(float* m, float px, float py, float pz,float tx, float ty, float tz, float ux, float uy, float uz)
 {
    float sx,sy,sz;
    float uux,uuy,uuz;
    float M[16];

    float zx = tx-px;
    float zy = ty-py;
    float zz = tz-pz;

    vecNormalize(zx,zy,zz);
    vecNormalize(ux,uy,uz);

    vecCrossProduct(sx,sy,sz,zx,zy,zz,ux,uy,uz);

    vecCrossProduct(uux,uuy,uuz,sx,sy,sz,zx,zy,zz);

    vecNormalize(sx,sy,sz);
    vecNormalize(uux,uuy,uuz);

    M[0]=sx; M[4]=sy; M[8]=sz; M[12]=0;
    M[1]=uux; M[5]=uuy; M[9]=uuz; M[13]=0;
    M[2]=-zx; M[6]=-zy; M[10]=-zz; M[14]=0;
    M[3]=0; M[7]=0; M[11]=0; M[15]=1.0;

    matTranslate(M,-px,-py,-pz);

 }

extern "C" void matPrint(float* m)
{
    for(int i=0; i<16; i++)
    {
        if(i%4 == 0) printf("\n");
        printf("%f  ",m[i]);
    }
    printf("\n");
}


extern "C" unsigned int simpleCheckSum(const unsigned int* bin, int length)
{
	int i;
	unsigned int cs = 0;
	unsigned char* cbin =(unsigned char *) bin;		//added shariq
	for(i=0; i< length ; i++)
	{
		cs ^= cbin[i];
	}

	return cs;
}

extern "C" void isCheckSumValid(const unsigned int* bin, int len, int checkSum, const char* name)
{
	int cs = simpleCheckSum(bin,len);
	
	if(cs != checkSum)
	{
		
		//printf("Checksum MISMATCH! for %s\n", name);
		return;
	}
	
	//printf("Checksum PASS! for %s\n",name);
	
}