The first commit

src/core1/done/gu/guint.h

@@ -0,0 +1,42 @@
+/**************************************************************************
+ *									  *
+ *		 Copyright (C) 1994, Silicon Graphics, Inc.		  *
+ *									  *
+ *  These coded instructions, statements, and computer programs  contain  *
+ *  unpublished  proprietary  information of Silicon Graphics, Inc., and  *
+ *  are protected by Federal copyright law.  They  may  not be disclosed  *
+ *  to  third  parties  or copied or duplicated in any form, in whole or  *
+ *  in part, without the prior written consent of Silicon Graphics, Inc.  *
+ *									  *
+ **************************************************************************/
+
+#include "mbi.h"
+#include "gu.h"
+
+typedef union
+{
+	struct
+	{
+		unsigned int hi;
+		unsigned int lo;
+	} word;
+
+	double	d;
+} du;
+
+typedef union
+{
+	unsigned int	i;
+	float		f;
+} fu;
+
+#ifndef __GL_GL_H__
+
+typedef	float	Matrix[4][4];
+
+#endif
+
+#define ROUND(d)	(int)(((d) >= 0.0) ? ((d) + 0.5) : ((d) - 0.5))
+#define	ABS(d)		((d) > 0) ? (d) : -(d)
+
+extern float	__libm_qnan_f;

src/core1/done/gu/normalize.c

@@ -0,0 +1,15 @@
+#include <ultra64.h>
+#include "functions.h"
+#include "variables.h"
+
+
+void guNormalize(float *x, float *y, float *z)
+{
+	float	m;
+
+	m = gu_sqrtf((*x)*(*x) + (*y)*(*y) + (*z)*(*z));
+    m = (f32)1.0/ m;
+	*x *= m;
+	*y *= m;
+	*z *= m;
+}

src/core1/done/gu/ortho.c

@@ -0,0 +1,31 @@
+#include <ultra64.h>
+#include "functions.h"
+#include "variables.h"
+
+
+void guOrthoF(float mf[4][4], float l, float r, float b, float t, float n, float f, float scale)
+{
+	int	i, j;
+
+	guMtxIdentF(mf);
+
+	mf[0][0] = 2/(r-l);
+	mf[1][1] = 2/(t-b);
+	mf[2][2] = -2/(f-n);
+	mf[3][0] = -(r+l)/(r-l);
+	mf[3][1] = -(t+b)/(t-b);
+	mf[3][2] = -(f+n)/(f-n);
+	mf[3][3] = 1;
+
+	for (i=0; i<4; i++)
+	    for (j=0; j<4; j++)
+		mf[i][j] *= scale;
+}
+
+void guOrtho(Mtx *m, float l, float r, float b, float t, float n, float f, float scale)
+{
+	float	mf[4][4];
+
+	guOrthoF(mf, l, r, b, t, n, f, scale);
+	guMtxF2L(mf, m);
+}

src/core1/done/gu/sinf.c

@@ -0,0 +1,157 @@
+/**************************************************************************
+ *									  *
+ *		 Copyright (C) 1994, Silicon Graphics, Inc.		  *
+ *									  *
+ *  These coded instructions, statements, and computer programs  contain  *
+ *  unpublished  proprietary  information of Silicon Graphics, Inc., and  *
+ *  are protected by Federal copyright law.  They  may  not be disclosed  *
+ *  to  third  parties  or copied or duplicated in any form, in whole or  *
+ *  in part, without the prior written consent of Silicon Graphics, Inc.  *
+ *									  *
+ **************************************************************************/
+
+#include "guint.h"
+
+/* ====================================================================
+ * ====================================================================
+ *
+ * Module: fsin.c
+ * $Revision: 1.2 $
+ * $Date: 1995/07/12 17:48:01 $
+ * $Author: jeffd $
+ * $Source: /disk6/Master/cvsmdev2/PR/libultra/gu/sinf.c,v $
+ *
+ * Revision history:
+ *  09-Jun-93 - Original Version
+ *
+ * Description:	source code for fsin function
+ *
+ * ====================================================================
+ * ====================================================================
+ */
+
+#pragma weak fsin = __sinf
+#pragma weak sinf = __sinf
+#define	fsin __sinf
+
+/* coefficients for polynomial approximation of sin on +/- pi/2 */
+
+static const du	P[] =
+{
+{0x3ff00000,	0x00000000},
+{0xbfc55554,	0xbc83656d},
+{0x3f8110ed,	0x3804c2a0},
+{0xbf29f6ff,	0xeea56814},
+{0x3ec5dbdf,	0x0e314bfe},
+};
+
+static const du	rpi =
+{0x3fd45f30,	0x6dc9c883};
+
+static const du	pihi =
+{0x400921fb,	0x50000000};
+
+static const du	pilo =
+{0x3e6110b4,	0x611a6263};
+
+static const fu	zero = {0x00000000};
+
+
+/* ====================================================================
+ *
+ * FunctionName		fsin
+ *
+ * Description		computes sine of arg
+ *
+ * ====================================================================
+ */
+
+float
+sinf( float x )
+{
+double	dx, xsq, poly;
+double	dn;
+int	n;
+double	result;
+int	ix, xpt;
+
+
+	ix = *(int *)&x;
+	xpt = (ix >> 22);
+	xpt &= 0x1ff;
+
+	/* xpt is exponent(x) + 1 bit of mantissa */
+
+	if ( xpt < 0xff )	
+	{
+		/* |x| < 1.5 */
+
+		dx = x;
+
+		if ( xpt >= 0xe6 )
+		{
+			/* |x| >= 2^(-12) */
+
+			/* compute sin(x) with a standard polynomial approximation */
+
+			xsq = dx*dx;
+
+			poly = ((P[4].d*xsq + P[3].d)*xsq + P[2].d)*xsq + P[1].d;
+
+			result = dx + (dx*xsq)*poly;
+
+			return ( (float)result );
+		}
+
+		return ( x );
+	}
+
+	if ( xpt < 0x136 )
+	{
+		/* |x| < 2^28 */
+
+		dx = x;
+
+		/*  reduce argument to +/- pi/2  */
+
+		dn = dx*rpi.d;
+
+		n = ROUND(dn);
+		dn = n;
+
+		dx = dx - dn*pihi.d;
+		dx = dx - dn*pilo.d;	/* dx = x - n*pi */
+
+		/* compute sin(dx) as before, negating result if n is odd
+		*/
+
+		xsq = dx*dx;
+
+		poly = ((P[4].d*xsq + P[3].d)*xsq + P[2].d)*xsq + P[1].d;
+
+		result = dx + (dx*xsq)*poly;
+
+
+		if ( (n & 1) == 0 )
+			return ( (float)result );
+
+		return ( -(float)result );
+	}
+
+	if ( x != x )
+	{
+		/* x is a NaN; return a quiet NaN */
+
+#ifdef _IP_NAN_SETS_ERRNO
+
+		*__errnoaddr = EDOM;
+#endif
+		
+		return ( __libm_qnan_f );
+	}
+
+	/* just give up and return 0.0 */
+
+	return ( zero.f );
+}
+

src/core1/done/gu/sqrtf.c

@@ -0,0 +1,8 @@
+#include <ultra64.h>
+#include "functions.h"
+#include "variables.h"
+
+
+float gu_sqrtf(float val){
+    return sqrtf(val);
+}

src/core1/done/gu/translate.c

@@ -0,0 +1,22 @@
+#include <ultra64.h>
+#include "functions.h"
+#include "variables.h"
+
+
+void guTranslateF(float mf[4][4], float x, float y, float z)
+{
+	guMtxIdentF(mf);
+
+	mf[3][0] = x;
+	mf[3][1] = y;
+	mf[3][2] = z;
+}
+
+
+void guTranslate(Mtx *m, float x, float y, float z)
+{
+	float	mf[4][4];
+
+	guTranslateF(mf, x, y, z);
+	guMtxF2L(mf, m);
+}