void WriteObj(clump *clp, FILE *obj)
{
	int i, j, k, faceinc;
	int g, f;
	float *vert;
	float newvert[4];

	/* faceinc is used to increment face indices */
	faceinc = 0;

	for (i = 0; i < clp->objcount; i++) {
		g = clp->atm[i].geometryindex;
		f = clp->atm[i].frameindex;
		if (clp->frm[f].display == 0)
			continue;
		GetTotalTrans(clp->frm, f);
		fprintf(obj, "g %s\n", clp->frm[f].name);

		for (j = 0; j < clp->geo[g].splitcount; j++) {
			split cursplit;
			cursplit = clp->geo[g].splt[j];

/*
			fprintf(obj, "# tex: %s\n",
				clp->geo[g].mat[cursplit.matindex].tex[0].tex);
			fprintf(obj, "# alpha: %s\n",
			       clp->geo[g].mat[cursplit.matindex].tex[0].alpha);
*/

			/* print vertices */
			for (k = 0; k < cursplit.vertexcount; k++) {
				vert = cursplit.vertices[k];
				newvert[X] = vert[X];
				newvert[Y] = vert[Y];
				newvert[Z] = vert[Z];
				newvert[3] = 1;

				/* Get absolute position */
				MultMat44Vect(newvert, clp->frm[f].absmat, newvert);
				fprintf(obj, "v %f %f %f\n",
				  newvert[X],
				  newvert[Y], 
				  newvert[Z]);
			}

	/* print UV coordinates */
			for (k = 0; k < cursplit.vertexcount; k++) {

				fprintf(obj, "vt %f %f\n",
				  cursplit.uv[0][k][U],
				  1 - cursplit.uv[0][k][V]);
			}


	/* print normals */
				for (k = 0; k < cursplit.vertexcount; k++) {
					fprintf(obj, "vn %f %f %f\n",
					  cursplit.normals[k][X],
					  cursplit.normals[k][Y], 
					  cursplit.normals[k][Z]);
				}

				
	/* print faces */
	
			/* Vertex strip */
			if (clp->geo[g].facetype == 1) {
			for (k = 2; k < cursplit.vertexcount; k++) {

	/* if two vertices of the same face are the same, begin a new face */
				if (IsSameVert(cursplit.vertices[k],
						cursplit.vertices[k-1])
				  || IsSameVert(cursplit.vertices[k],
						cursplit.vertices[k-2])
				  || IsSameVert(cursplit.vertices[k-1],
						cursplit.vertices[k-2]))
					continue;

				fprintf(obj,
				  "f %d/%d/%d %d/%d/%d %d/%d/%d\n",
				  k-1+faceinc, k-1+faceinc, k-1+faceinc,
				  k + faceinc, k + faceinc, k + faceinc,
				  k+1+faceinc, k+1+faceinc, k+1+faceinc
				  );
			}
			/* Vertex list */
			} else {
				for (k = 0; k < cursplit.vertexcount; k += 3) {
					fprintf(obj,
					  "f %d/%d/%d %d/%d/%d %d/%d/%d\n",
					  k+1+faceinc, k+1+faceinc, k+1+faceinc,
					  k+2+faceinc, k+2+faceinc, k+2+faceinc,
					  k+3+faceinc, k+3+faceinc,k+3+faceinc);
				}
			}
			faceinc += clp->geo[g].splt[j].vertexcount;
		}
	}
}
void printmat44(float mat[][4])
{
	printf("%f %f %f %f\n%f %f %f %f\n%f %f %f %f\n%f %f %f %f\n\n",
		mat[0][0],
		mat[0][1],
		mat[0][2],
		mat[0][3],
		mat[1][0],
		mat[1][1],
		mat[1][2],
		mat[1][3],
		mat[2][0],
		mat[2][1],
		mat[2][2],
		mat[2][3],
		mat[3][0],
		mat[3][1],
		mat[3][2],
		mat[3][3]);
}

/* Copies a 4x4 matrix. */
void CopyMat44(float from[][4], float to[][4])
{
	to[0][0] = from[0][0];
	to[0][1] = from[0][1];
	to[0][2] = from[0][2];
	to[0][3] = from[0][3];
	to[1][0] = from[1][0];
	to[1][1] = from[1][1];
	to[1][2] = from[1][2];
	to[1][3] = from[1][3];
	to[2][0] = from[2][0];
	to[2][1] = from[2][1];
	to[2][2] = from[2][2];
	to[2][3] = from[2][3];
	to[3][0] = from[3][0];
	to[3][1] = from[3][1];
	to[3][2] = from[3][2];
	to[3][3] = from[3][3];
}

/* Copies a vector. */
void CopyVect(float *from, float *to)
{
	to[0] = from[0];
	to[1] = from[1];
	to[2] = from[2];
	to[3] = from[3];
}

/* Muliplies a 4x4 matrix with a vector. */
void MultMat44Vect(float dest[], float mat[][4], float vect[])
{
	float temp[4];
	int i;
	for (i = 0; i < 4; i++) {
		temp[i] = 
			mat[i][0] * vect[0] +
			mat[i][1] * vect[1] +
			mat[i][2] * vect[2] +
			mat[i][3] * vect[3];
	}
	CopyVect(temp, dest);
}

/* Multiplies to 4x4 matrices and saves result in "dest". */
void MultMat44(float dest[][4], float one[][4], float two[][4])
{
	int i;
	float temp[4][4];

	for (i = 0; i < 4; i++) {
		temp[0][i] = one[0][0] * two[0][i] + one[0][1] * two[1][i] +
			one[0][2] * two[2][i] + one[0][3] * two[3][i];
		temp[1][i] = one[1][0] * two[0][i] + one[1][1] * two[1][i] +
			one[1][2] * two[2][i] + one[1][3] * two[3][i];
		temp[2][i] = one[2][0] * two[0][i] * one[2][1] * two[1][i] +
			one[2][2] * two[2][i] + one[2][3] * two[3][i];
		temp[3][i] = one[3][0] * two[0][i] * one[3][1] * two[1][i] +
			one[3][2] * two[2][i] + one[3][3] * two[3][i];
	}
	CopyMat44(temp, dest);
}

void GetTotalTrans(frame *frm, int i)
{
	if (frm[i].parent == -1) {
		CopyMat44(frm[i].absmat, frm[i].rotmatrix);
		frm[i].absmat[0][3] = frm[i].positionv[0];
		frm[i].absmat[1][3] = frm[i].positionv[1];
		frm[i].absmat[2][3] = frm[i].positionv[2];
		return;
	}
	GetTotalTrans(frm, frm[i].parent);
	
	CopyMat44(frm[i].absmat, frm[i].rotmatrix);
	frm[i].absmat[0][3] = frm[i].positionv[0];
	frm[i].absmat[1][3] = frm[i].positionv[1];
	frm[i].absmat[2][3] = frm[i].positionv[2];
	
	MultMat44(frm[i].absmat, frm[frm[i].parent].absmat, frm[i].absmat);
}