Initial commit of files from src zip.

3dsloader.c

+#include <stdio.h>
+#include <string.h>
+#include <malloc.h>
+#include <kallisti/limits.h>
+//#include <kallisti/fs/iso9660.h>
+#include <kallisti/abi/fs.h>
+
+#include "math.h"
+
+extern abi_fs_t	*fs;
+
+void vertex_list(uint32 filehnd,_object *obj)
+{
+	float x,y,z; // Temp float var's 
+	int i=0; // index
+	int cnt=1;
+
+	while (i < obj->numverts && cnt != 0) 
+	{
+	  
+		cnt = fs->read(filehnd, &x, sizeof(float));
+		cnt = fs->read(filehnd, &y, sizeof(float));
+		cnt = fs->read(filehnd, &z, sizeof(float));
+		
+	/*
+		obj->tri[i].vec.x = x;
+		obj->tri[i].vec.y = y;
+		obj->tri[i].vec.z = z;
+	*/
+
+
+		obj->vert_ary[(i)*3] =	 x;
+		obj->vert_ary[(i)*3+1] = y;
+		obj->vert_ary[(i)*3+2] = z;
+
+
+		i++;
+	}
+	
+	return;
+}
+
+
+void uv_list(uint32 filehnd,_object *obj)
+{
+	float u=0,v=0; // Temp float var's 
+	int i=0; // index
+	int cnt=1;
+
+	while (i < obj->numuv && cnt != 0) 
+	{
+		cnt = fs->read(filehnd, &u, sizeof(float));
+		cnt = fs->read(filehnd, &v, sizeof(float));
+		
+		obj->texmap[i].u = u;
+		obj->texmap[i].v = v;
+
+		i++;
+	}
+	
+	return;
+}
+
+
+void chunk_name(uint32 filehnd,int debug)
+{
+	int cnt=1;
+	char c=1;
+	int i=0;
+	char temp[100]; // This should be enough
+	
+	while ((c != 0)  && (cnt !=0)) {
+				
+		cnt = fs->read(filehnd, &c, sizeof(char));
+		
+		temp[i] = c;	
+		i++;
+
+	} 
+			
+	temp[i+1]='\n';
+	
+	if (debug)
+	   printf("%s\r\n",temp); 
+	   
+	return;
+}
+
+void face_list(uint32 filehnd,_object *obj)
+{
+	unsigned short a,b,c,flag; // Temp float var
+	int i=0; // index
+	int cnt=1;
+
+	while (i < obj->numpolys && cnt != 0) 
+	{
+		cnt = fs->read(filehnd, &a, sizeof(short));
+		cnt = fs->read(filehnd, &b, sizeof(short));
+		cnt = fs->read(filehnd, &c, sizeof(short));
+		cnt = fs->read(filehnd, &flag, sizeof(short));
+		obj->facelist[i].a = a;
+		obj->facelist[i].b = b;
+		obj->facelist[i].c = c;
+		i++;
+	}
+	
+	return;
+}
+
+
+int load3dsfile(char *filename,  _object *model, int debug)
+{
+
+/*  
+	Programmed by: Kevin Fowlks   Dec 29th 2000
+	
+	3DS Model Loader for the Dreamcast Compiles under KOS 0.7 with 
+	GCC 2.95.2 
+
+	Should work under libdream .95 with some minor changes.
+	This code should fit easily in any engine design that you 
+	may have. 
+	
+
+	This Code was Written By KamKa aka Kevin Fowlks
+	Codes theory is based off of an example 3dsloader 
+	by Ryan "Ark" Rubley & a 3DS loader found on flipcode
+	
+	Notes:
+	
+	   The debug switch controls weather 3ds file information is displayed on the term.
+	   debug can either be 1 or 0.
+	   
+	   This Code only loads the first object in a 3ds file.
+*/
+
+
+	uint32 file;
+	int cnt=0;
+	char c;
+	
+	/* This should be a struct but for some reason my compiler switches are forcing a 4 byte align on shorts 
+	 Hmm.. KOS doesn't like me malloc stuff in a function without free before exit... */
+	
+	unsigned short   chunkid;
+	unsigned long    chunklen;
+	unsigned short numverts = 0,numpolys = 0,numuv=0;
+	char tempname[80];
+	
+	
+	
+	file = fs->open(filename, O_RDONLY);
+
+
+	if (!file) {
+		printf("Error opening %s\r\n",filename);
+		return 1;
+	}
+	
+	
+	
+	cnt=1;
+	
+	while (cnt != 0)
+	{
+	
+	  /* Get the the first chunk */	
+	  cnt = fs->read(file, &chunkid, sizeof(short)); 
+	  cnt = fs->read(file, &chunklen, sizeof(long)); 
+	
+		switch (chunkid)
+		{
+		case 0x4D4D:
+			if (debug)
+				printf("0x%04X   chuck size = %d    ftell= %d\r\n",chunkid,chunklen,fs->tell(file));
+
+			break;
+		case 0x3D3D:
+			if (debug)
+				printf("0x%04X   chuck size = %d    ftell= %d\r\n",chunkid,chunklen,fs->tell(file));
+			break;
+		case 0x4000:
+		
+			if (debug) {
+				printf("0x%04X   chuck size = %d    ftell= %d\r\n",chunkid,chunklen,fs->tell(file));
+				chunk_name(file,1);
+			} 
+			else
+				chunk_name(file,0);
+			
+			break;
+		case 0x4100:
+			if (debug)
+				printf("0x%04X   chuck size = %d    ftell = %d\r\n",chunkid,chunklen,fs->tell(file));
+			break;
+		case 0x4110:
+			if (numverts == 0) {
+
+				if (debug)
+				    printf("0x%04X   chuck size = %d   ftell= %d\r\n",chunkid,chunklen,fs->tell(file));
+
+				cnt = fs->read(file, &numverts, sizeof(short));
+				
+				model->numverts = numverts;
+				
+				
+			
+				/*  BIG Problem.. HERE NOt SUre why Either Hoping it iwill got away*/
+		//	model->tri = malloc(numverts * sizeof(_3dtriangle));
+
+			
+			model->vert_ary = malloc(3 * (numverts * sizeof(float)));
+			
+			
+			/* Free Wasted Memory*/
+		//	if (model->tri)
+		//		free (model->tri);
+
+
+				
+				
+				if (debug)
+					printf("Numverts %d \r\n",model->numverts);
+				
+				
+				vertex_list(file,model);
+			}
+			else
+				fs->seek(file, chunklen-6, SEEK_CUR);	
+				
+			break;
+		
+		case 0x4120:
+			if (numpolys == 0)
+			{        
+				cnt = fs->read(file, &numpolys, sizeof(short));
+
+				
+				
+				model->numpolys = numpolys ;
+				model->facelist = malloc(numpolys * sizeof(_trifacelist));    
+				
+				if (debug)
+					printf("Numpolys %d \r\n",model->numpolys);
+
+				   face_list(file,model);
+			}
+			else
+				fs->seek(file, chunklen-6, SEEK_CUR);
+				
+			break;
+			
+			
+		case 0x4140:
+			if (debug)
+				printf("0x%04X   chuck size = %d    ftell = %d\r\n",chunkid,chunklen,fs->tell(file));
+
+			if (numuv == 0)
+			{        
+				cnt = fs->read(file, &numuv, sizeof(short));
+				
+				
+				model->numuv = numuv;
+				model->texmap = malloc(numuv * sizeof(_3duvmap)); 
+				
+				if (debug)
+					printf("NumUV %d \r\n",numuv);
+
+				   uv_list(file,model);
+			}
+			else
+				fs->seek(file, chunklen-6, SEEK_CUR);
+				
+			break;
+		
+	        case 0xAFFF:  
+		
+				if (debug)
+					printf("0x%04X   chuck size = %d   ftell= %d\r\n",chunkid,chunklen,fs->tell(file)); 
+			break;
+		case 0xA200: 
+		
+				if (debug)
+					printf("0x%04X   chuck size = %d   ftell= %d\r\n",chunkid,chunklen,fs->tell(file));
+			break;
+		case 0xA300:		
+			   if (debug) {
+				printf("0x%04X   chuck size = %d    ftell= %d\r\n",chunkid,chunklen,fs->tell(file));
+				chunk_name(file,1);
+			   	}
+			   else
+			   	chunk_name(file,0);
+			break;
+						
+								
+		default:
+			if (debug)
+			    printf("unknown 0x%04X   Chunk size = %d   ftell = %d \r\n",chunkid,chunklen,fs->tell(file));
+
+				fs->seek(file, chunklen-6, SEEK_CUR);
+				break;
+
+				}
+	
+	 
+		}
+
+	
+
+	printf("End of 3DS File\r\n");
+
+	fs->close(file);
+	
+	
+	return 0;
+	 
+}
+
+

3dutil.c

+#include <stdio.h>
+#include <string.h>
+#include <malloc.h>
+#include <ctype.h>
+#include <kallisti/abi/fs.h>
+#include <kallisti/abi/ta.h>
+#include "matrix.h"
+#include <kallisti/timer.h>
+#include <kallisti/fs.h>
+#include <kallisti/fs/iso9660.h>
+#include "3dutil.h"
+
+
+extern  abi_ta_t *ta;
+extern abi_fs_t	*fs;
+//extern _camera curr_cam;
+/* 3D Utils Functions like Printing text & and blitting textures
+   Kevin aka "KamKa" Fowlks
+*/
+#define RGB565(r,g,b) ((r >> 3) << 11)| ((g >> 2) << 5)| ((b >> 3) << 0)
+
+unsigned int texture_alloc(uint32 size)
+{
+    unsigned int rv;
+    
+    rv = texture_pool;
+    
+    /* Align to 8 bytes */  
+    size = (size + 7) & (~7);
+    texture_pool += size;
+    
+    printf("Allocating texture at %08x\r\n", rv);
+    return rv;
+}
+
+void texture_release_all() {
+	texture_pool = 0;
+}
+
+unsigned int tex_load(unsigned short *data,int32 sz) 
+{
+    unsigned short *tex;
+    unsigned int check_tex;
+
+    check_tex = texture_alloc(sz);
+    
+	tex = (short *)ta->txr_map(check_tex);
+
+	//tex = (short *)ta_texture_map(check_tex);
+
+    memcpy(tex,data, sz);
+
+  return check_tex;
+}
+
+/* Draws Textured 3DS Model On the Screen */
+ void draw_3ds(_object testdummy,uint32 textureaddr,int tw, int th,_camera curr_cam)
+{
+
+     register i;
+     poly_hdr_t poly;
+     _3dvector d1,d2;
+	
+	clear_matrix();  
+    
+	apply_matrix(&screenview_matrix);
+    
+	apply_matrix(&projection_matrix);
+
+    translate(testdummy.x,testdummy.y,testdummy.z);
+
+	if (testdummy.x_rot > 0)  rotate_x(testdummy.x_rot);
+	if (testdummy.y_rot > 0)  rotate_y(testdummy.y_rot);
+	if (testdummy.z_rot > 0)  rotate_z(testdummy.z_rot);
+
+
+	//set_camera( curr_cam.position,curr_cam.target, curr_cam.roll);
+	
+	translate(	curr_cam.position.v[0],	curr_cam.position.v[1],	curr_cam.position.v[2]);
+	rotate_y(curr_cam.roll);
+
+	transform_coords((float*)testdummy.vert_ary, trans_coords, testdummy.numverts);
+ 
+       	   ta->poly_hdr_txr(&poly, TA_OPAQUE,TA_RGB565, tw, th,textureaddr,TA_NO_FILTER);
+       	   ta->commit_poly_hdr(&poly);
+
+	   for (i=0;i<testdummy.numpolys;i++) {
+
+			d1.x= trans_coords[testdummy.facelist[i].c][0] - trans_coords[testdummy.facelist[i].a][0]; 
+			d1.y= trans_coords[testdummy.facelist[i].c][1] - trans_coords[testdummy.facelist[i].a][1]; 
+
+			d2.x= trans_coords[testdummy.facelist[i].c][0] - trans_coords[testdummy.facelist[i].b][0]; 
+			d2.y= trans_coords[testdummy.facelist[i].c][1] - trans_coords[testdummy.facelist[i].b][1]; 
+		              
+		   if ((d1.x * d2.y) - (d2.x * d1.y) >= 0 )
+			{
+				draw_tri(trans_coords[testdummy.facelist[i].a], trans_coords[testdummy.facelist[i].b],
+				trans_coords[testdummy.facelist[i].c],testdummy,i);
+			}
+
+		}
+
+
+}
+
+
+void draw_tri_color(float *t1, float *t2, float *t3,_object obj,int i)
+ {
+	vertex_oc_t vertc;
+	 		
+	vertc.flags = TA_VERTEX_NORMAL;
+	vertc.x = t1[0] ; vertc.y =t1[1] ; vertc.z =t1[3];
+	vertc.a = 1.0f; vertc.r = .40f; vertc.g = 0.0f; vertc.b = 1.0f;
+	ta->commit_vertex(&vertc, sizeof(vertc));
+	
+	vertc.flags = TA_VERTEX_NORMAL;
+	vertc.x = t2[0] ; vertc.y =t2[1] ; vertc.z =t2[3];
+	vertc.a = 1.0f; vertc.r = 0.0; vertc.g = 0.0f; vertc.b = 0.0f;
+	ta->commit_vertex(&vertc, sizeof(vertc));
+
+	vertc.flags = TA_VERTEX_EOL;
+	vertc.x = t3[0]; vertc.y =t3[1]; vertc.z =t3[3];
+	vertc.a = 1.0f; vertc.r = 0.0f; vertc.g = 0.0f; vertc.b = 0.0f;
+	ta->commit_vertex(&vertc, sizeof(vertc));
+}
+
+
+void draw_tri(float *t1, float *t2, float *t3,_object obj,int i)
+ {
+
+	vertex_ot_t vertc;
+	
+	vertc.flags = TA_VERTEX_NORMAL;
+	vertc.x = t1[0] ; vertc.y =t1[1] ; vertc.z =t1[3];
+	vertc.a = 1.0f; vertc.r = .63f; vertc.g = .63f; vertc.b = .63f;
+	vertc.u = obj.texmap[obj.facelist[i].a].u;
+	vertc.v = obj.texmap[obj.facelist[i].a].v;
+	vertc.oa = vertc.or = vertc.og = vertc.ob = 0.0f;
+	ta->commit_vertex(&vertc, sizeof(vertc));
+	
+	vertc.flags = TA_VERTEX_NORMAL;
+	vertc.x = t2[0] ; vertc.y =t2[1] ; vertc.z =t2[3];
+	vertc.a = 1.0f; vertc.r = .63f; vertc.g = .63f; vertc.b = .63f;
+	vertc.u = obj.texmap[obj.facelist[i].b].u;
+	vertc.v = obj.texmap[obj.facelist[i].b].v;
+	ta->commit_vertex(&vertc, sizeof(vertc));
+
+	vertc.flags = TA_VERTEX_EOL;
+	vertc.x = t3[0]; vertc.y =t3[1]; vertc.z =t3[3];
+	vertc.u = obj.texmap[obj.facelist[i].c].u;
+	vertc.v = obj.texmap[obj.facelist[i].c].v;
+	ta->commit_vertex(&vertc, sizeof(vertc));
+
+}
+
+void destroy_obj(_object *obj)
+{
+	if (obj->vert_ary) free(obj->vert_ary);
+	if (obj->texmap) free(obj->texmap);
+	if (obj->facelist) free(obj->facelist);
+	if (obj->tri) free(obj->tri);
+}
+
+void show_tex(float sx,float sy,float size,float sizew,float sizeh,float x,float y,float x2,float y2,float alpha)
+{
+ 
+/*
+
+	This Function creates & Displays a rectangle polygon(useing a triangle strip) with textures at any position
+	you would like.
+
+	sx, sy is the position that you would like to display the rectangle polygon on the
+	screen at. 
+
+	Size is the total texture size e.g 256x256 is just 256 this assumes that your textures are square.
+
+	Sizew, Sizeh is the size of the polygon  * Note: This does not have to be
+	the same as the above in that case the texture will be stretched to fit the poly.
+
+	x, y start a 1,1 NOT 0, 0  x2, y2 start at 64, 64 not 63, 63
+	x, y / x2, y2 is the start/end position of the texture postion given in REAL
+	Bitmap pixel format this creates a box and grabs that data from the texture map to display.
+
+*/
+
+
+
+ vertex_ot_t vert;
+ vert.flags = TA_VERTEX_NORMAL;
+ vert.x =  sx;
+ vert.y =  sizeh + sy;
+ vert.z = 512.0f; /* Puts Blit infront of everything*/
+ vert.u = 0.0f + (x / size);
+ vert.v = y2 / size;
+
+ /* ? Funny it seems that you must set the RGB value to something in a range .1 .. 1.0 
+    This also controls the intensity of the texture. if you don't want your texture to have any
+    funny colors then set all RGB values to the same color */
+ 
+ vert.a = alpha; vert.r = 0.9f; vert.g = 0.9f; vert.b = 0.9f;
+ vert.oa = vert.or = vert.og = vert.ob = 0.0f;
+ 
+ ta->commit_vertex(&vert, sizeof(vert));
+
+ vert.x = sx;
+ vert.y = sy;
+ vert.u = (x / size);
+ vert.v = (y / size);
+ ta->commit_vertex(&vert, sizeof(vert));
+
+ vert.x = sizew+sx;
+ vert.y = sizeh+sy;
+ vert.u =  (x2 / size);
+ vert.v =  (y2 / size);
+ ta->commit_vertex(&vert, sizeof(vert));
+
+ vert.flags = TA_VERTEX_EOL;
+ vert.x =  sizew + sx;
+ vert.y =  sy;
+ vert.u =  (x2 / size);
+ vert.v =  (y / size);
+ ta->commit_vertex(&vert, sizeof(vert));
+
+}
+
+
+
+void tri_strip(float sx,float sy,float sz,float size,_3dvector rgb,float alpha)
+{
+ 
+/*
+
+	This Function creates & Displays a rectangle polygon(useing a triangle strip) with textures at any position
+	you would like.
+
+	sx, sy is the position that you would like to display the rectangle polygon on the
+	screen at. 
+
+	Size is the total texture size e.g 256x256 is just 256 this assumes that your textures are square.
+
+	Sizew, Sizeh is the size of the polygon  * Note: This does not have to be
+	the same as the above in that case the texture will be stretched to fit the poly.
+
+	x, y start a 1,1 NOT 0, 0  x2, y2 start at 64, 64 not 63, 63
+	x, y / x2, y2 is the start/end position of the texture postion given in REAL
+	Bitmap pixel format this creates a box and grabs that data from the texture map to display.
+
+*/
+float x=1.0,y=1.0,x2=size,y2=size;
+
+
+ vertex_ot_t vert;
+ vert.flags = TA_VERTEX_NORMAL;
+ vert.x =  sx;
+ vert.y =  size + sy;
+ vert.z = sz; /* Puts Blit infront of everything*/
+ vert.u = 0.0f + (x / size);
+ vert.v = y2 / size;
+
+ /* ? Funny it seems that you must set the RGB value to something in a range .1 .. 1.0 
+    This also controls the intensity of the texture. if you don't want your texture to have any
+    funny colors then set all RGB values to the same color */
+ 
+ vert.a = alpha; 
+ vert.r = rgb.v[0];
+ vert.g = rgb.v[1];
+ vert.b = rgb.v[2];
+  vert.oa = vert.or = vert.og = vert.ob = 0.0f;
+
+ /*
+ vert.oa = rgb.v[2]/alpha;
+
+ vert.or = rgb.v[1];
+	 vert.og = rgb.v[2];
+		 vert.ob = rgb.v[0];
+ */
+
+ ta->commit_vertex(&vert, sizeof(vert));
+
+ vert.x = sx;
+ vert.y = sy;
+ vert.u = (x / size);
+ vert.v = (y / size);
+ ta->commit_vertex(&vert, sizeof(vert));
+
+ vert.x = size+sx;
+ vert.y = size+sy;
+ vert.u =  (x2 / size);
+ vert.v =  (y2 / size);
+ ta->commit_vertex(&vert, sizeof(vert));
+
+ vert.flags = TA_VERTEX_EOL;
+ vert.x =  size + sx;
+ vert.y =  sy;
+ vert.u =  (x2 / size);
+ vert.v =  (y / size);
+ ta->commit_vertex(&vert, sizeof(vert));
+
+}
+
+
+
+
+void print_char(char c,short x,short y,char size,float alpha)
+{
+  int r = 9; /* Start at second Font set and start at numbers*/
+
+  /*ABCDEFGHIJKMLNO r++
+  PQRSTUVWXYZ */
+
+ if (c > '?') 
+    r++;
+ 
+ if (c > 'O') 
+    r++;
+
+   c = c - '0';
+
+   show_tex(x,y,256,size,size,16*c+2,2+16*r,16+16*c,16+16*r,alpha);
+}
+
+
+
+
+
+void print_string(char *str,short x,short y,float alpha)
+{
+  int len=strlen(str);
+  int i;
+
+ /* No Buffer Overflow Here 480 / 16 = 30 Max Char per line */
+
+  for (i=0;i<len;i++) 
+     if (str[i] != ' ')
+     	print_char(str[i],x+(16*i),y ,16,alpha);
+}
+
+// GOOD
+int  LoadTexture(char *filename,unsigned char *data,unsigned short *temp)
+{
+	unsigned char buff[256];
+	int ii=0;
+	int cnt,hi=0,wi=0;
+    int count=0,equ=0;
+	uint32 hnd;	
+	uint16  w=0,h=0,bpp=0;
+	_tga_header tga_header;
+	
+	
+	hnd = fs->open(filename, O_RDONLY);
+	
+	if (!hnd) {
+		printf("Error opening %s\r\n", filename);
+		return;
+	}
+
+	cnt = fs->read(hnd, &tga_header, sizeof(_tga_header));
+	
+	w = tga_header.width[0]+tga_header.width[1]*0x0100;
+
+	h = tga_header.height[0]+tga_header.height[1]*0x0100;
+	
+	bpp = tga_header.bpp;
+
+	printf("Width = %d   Height = %d    Bpp = %d \r\n",w,h,bpp);
+
+	if (bpp != 24)
+	{
+	    fs->close(hnd);
+	    printf("Error: Wrong File format \r\n");
+	    return -1;
+	}
+
+	
+	fs->seek(hnd,0,SEEK_SET);
+
+	while ((cnt = fs->read(hnd, buff, 256)) != 0) 
+	{
+	int i;
+	
+	for (i = 0; i < cnt; i++) 
+	{
+			
+		if (count == 0) { i+=15; }
+
+		data[count] = buff[i];
+		count++;
+
+	}
+
+	}
+	
+
+
+	printf("closeing filesystem\r\n");
+
+	fs->close(hnd);	
+	
+	for (hi=(h-1);hi>=0;hi--) 
+	    { 
+      	     equ = (hi*w);
+		
+	      for (wi=0;wi<=(w-1);wi++)
+     		{
+	       	 temp[equ+wi] = RGB565(data[ii+2],data[ii],data[ii+1]);
+       		  ii+=3;
+	     	}
+	    }
+	
+	
+
+	return -1;
+}	
+

3dutil.h

+#ifndef __3DUTIL_H
+#define __3DUTIL_H
+
+#include "math.h"
+
+
+
+
+typedef struct{
+	unsigned char numiden3[12];
+	unsigned char width[2];
+	unsigned char height[2];
+	unsigned char bpp;
+	unsigned char imagedes;
+} _tga_header;
+
+
+
+static unsigned texture_pool = 0;
+static float trans_coords[9000][4];
+
+void show_tex(float ,float ,float ,float ,float ,float ,float ,float ,float,float);
+void tri_strip(float ,float ,float,float ,_3dvector ,float );
+
+void print_string(char *,short ,short ,float);
+void print_char(char ,short ,short ,char ,float);
+unsigned int texture_alloc(uint32 );
+unsigned int tex_load(unsigned short *,int32 );
+void draw_tri(float *, float *, float *,_object ,int );
+void draw_tri_color(float *, float *, float *,_object ,int );
+void draw_3ds(_object ,uint32 ,int , int ,_camera);
+void destroy_obj(_object *);
+void texture_release_all();
+
+#endif
\ No newline at end of file

Makefile

+# KallistiOS 0.80
+#
+# userland/2ndmix/Makefile
+# (c)2000 Dan Potter
+#   
+# $Id: Makefile,v 1.1 2000/11/09 05:11:08 bard Exp $
+
+PROG = main
+OBJS = main.o math.o matrix.o sqrt.o 3dutil.o 3dsloader.o
+
+include ../Makefile.prefab
+
+#INCS += -Imatrix -O
+#LIBS += -Lsupport -Lxingmp3 -lxingmp3 -lm -lk -lgcc 
+# LIBS += -Lsupport -Lxingmp3 -lxingmp3 -lk -lgcc
+

copying

+		    GNU GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+                          675 Mass Ave, Cambridge, MA 02139, USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+		    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+			    NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+	Appendix: How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) 19yy  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) 19yy name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Library General
+Public License instead of this License.

isqrt.h

+float isqrt(float x);

isqrt.s

+	.globl _isqrt
+
+	.text
+_isqrt:	
+	fsrra fr4
+	rts	
+	fmov  fr4,fr0
+
+	.end
+

main.bkp

+
+#include <stdio.h>
+#include <string.h>
+#include <malloc.h>
+#include <kallisti/ta.h>
+#include <kallisti/video.h>
+#include <kallisti/fs.h>
+#include <kallisti/controller.h>
+#include <kallisti/maple.h>
+#include <kallisti/timer.h>
+#include <kallisti/fs/iso9660.h>
+#include "math.h"
+#include "3dutil.h"
+#include "matrix.h"
+
+int joy_x=0,joy_y=0;
+
+
+
+float coords[8][3] = {
+    { -1.0, -1.0, -1.0 },
+    {  1.0, -1.0, -1.0 },
+    { -1.0,  1.0, -1.0 },
+    {  1.0,  1.0, -1.0 },
+    { -1.0, -1.0,  1.0 },
+    {  1.0, -1.0,  1.0 },
+    { -1.0,  1.0,  1.0 },
+    {  1.0,  1.0,  1.0 },
+};
+
+/* transformed coordinates */
+
+float trans_coords2[8][4];
+#define RGB565(r,g,b) ((r >> 3) << 11)| ((g >> 2) << 5)| ((b >> 3) << 0)
+
+
+
+uint8 check_control() {
+	uint8 mcont=0;
+	cont_cond_t cond;
+    
+	if (!mcont) 
+	{
+
+        mcont = maple_first_device(MAPLE_FUNC_CONTROLLER);
+		if (!mcont) 
+		{
+			printf("No controllers attached\r\n");
+			return 0;
+		}
+		
+		return mcont;
+
+	}
+}
+
+
+void Kill_Program()
+{
+   timer_shutdown();
+   maple_shutdown();
+   fs_iso9660_shutdown();
+   ta_shutdown();
+   vid_shutdown();
+
+	return ;
+}
+
+int main(void)
+{
+
+  poly_hdr_t poly; /* Our Basic Textured Poly  */
+    
+  
+  unsigned int tex; /* Pointer to Texture Memory  */
+  unsigned int f14_tex;
+
+  uint32 i=0;  
+  uint32 count = 0; 
+
+  float test=0.0;
+  float f14_coords[8000][3]; /* IMPORTANT: You must addjest these to the number of vertices in the model  */
+  
+  uint8 mcont=0;
+  
+  cont_cond_t cond;
+  unsigned short *temp = malloc(256*256*sizeof(unsigned short));
+  unsigned  char *data = malloc(256*256*4); /* Need a better way to allocate file size but..it's only temp */
+
+  /* _object struct is defined in math.h used for 3DS Files*/
+  _object testdummy, f14;;
+  
+  vid_init(DM_640x480,PM_RGB565); 
+  ta_init();
+  vid_border_color(63,200,63);
+  fs_iso9660_init();
+  maple_init();
+  
+   
+  mcont=check_control();
+
+  /* change arg 3 to a 1 to view 3ds file debug info  */
+  if (load3dsfile("f14.3ds", &f14,0) == 1) {
+      Kill_Program();
+	  return 0;
+  }
+
+	if (load3dsfile("biplane.3ds", &testdummy,0) == 1) {
+      Kill_Program();
+	  return 0;
+  }
+
+
+ /*  Loads Texture Auto Increment*/
+  if (!LoadTexture("f14.tga",data,temp)) {Kill_Program();} 
+   
+	  f14_tex = tex_load(temp,(256*256)*sizeof(unsigned short));
+
+
+  if (!LoadTexture("biplane.tga",data,temp)) {Kill_Program();} 
+   
+	  tex = tex_load(temp,(256*256)*sizeof(unsigned short));
+
+
+
+   /* Ok lets free some memory */
+   if (temp) free(temp);
+   if (data) free(data);
+
+
+  printf("Numverts =  %d  \r\n",testdummy.numverts);
+  printf("NumPolys =  %d   \r\n",testdummy.numpolys);
+  printf("NumUV  =  %d   \r\n",testdummy.numuv);
+    
+  printf("Entering Main Loop \r\n");
+  
+
+  
+
+  while(count < 900)
+  {
+  
+    ta_begin_render(); 
+    
+    clear_matrix();
+    
+    apply_matrix(&screenview_matrix);
+   // apply_matrix(&translation_matrix);
+	apply_matrix(&projection_matrix);
+//	apply_matrix(&camera_matrix);
+
+
+  
+//	translate(0.0, 0.0, 45.0);
+	
+
+	//translate(0.0, 0.0, 5.0);
+
+    rotate_x(90*34/5);
+    rotate_z(count*47/9);
+ //   rotate_y(count*47/9);
+   translate(0.0+joy_x,0.0,48.0+joy_y);
+    		
+	
+
+//	draw_3ds(testdummy,tex,0);
+
+	draw_3ds(f14,f14_tex,256,256);
+
+    ta_commit_eol();
+
+    /* TA freaks out at having a completely empty list */
+
+    ta_poly_hdr_col(&poly, TA_TRANSLUCENT);
+    ta_commit_poly_hdr(&poly);
+
+	ta_commit_eol();
+
+
+    /* Must Call to Finish Rendering Process*/
+    ta_finish_frame();
+
+
+
+	/* Check for start on the controller */
+	if (cont_get_cond(mcont, &cond)) {
+		printf("Error getting controller status\r\n");
+			count=990;
+		//return 0;
+	}
+		
+	if (!(cond.buttons & CONT_START)) {
+		printf("Pressed start\r\n");
+		
+		Kill_Program();
+		return 0;
+
+	}
+
+
+	if (!(cond.buttons & CONT_DPAD_UP)) {
+		    joy_y=joy_y-1.0;
+	}
+	
+	if (!(cond.buttons & CONT_DPAD_DOWN)) {
+		  joy_y=joy_y+1.0;
+
+	}
+	
+	if (!(cond.buttons & CONT_DPAD_LEFT)) {
+		joy_x=joy_x-1.0;
+
+	}
+
+	if (!(cond.buttons & CONT_DPAD_RIGHT)) 
+		joy_x=joy_x+1.0;
+	
+
+
+
+
+    count++;
+
+  }
+
+   printf("Exiting Main Loop \r\n",testdummy.numuv);
+
+/*
+   if (testdummy.tri) free(testdummy.tri);
+   if (testdummy.facelist) free(testdummy.facelist);
+   if (testdummy.texmap) free(testdummy.texmap);
+  */
+   
+   timer_shutdown();
+   maple_shutdown();
+   fs_iso9660_shutdown();
+   ta_shutdown();
+   vid_shutdown();
+
+    
+  
+  return 0;
+
+}
+
+

main.c

+#include <stdio.h>
+#include <string.h>
+#include <malloc.h>
+#include "matrix.h"
+#include <kallisti/libk.h>
+#include <kallisti/abi/fs.h>
+#include <kallisti/abi/ta.h>
+#include <kallisti/abi/spu.h>
+#include <kallisti/abi/maple.h>
+#include <kallisti/abi/thread.h>
+#include "../kosh/abi/conio.h"
+#include "math.h"
+#include "3dutil.h"
+
+
+
+ /* Library handles */
+  abi_fs_t	*fs = NULL;
+  abi_ta_t	*ta = NULL;
+  abi_spu_t	*spu = NULL;
+  abi_maple_t	*maple = NULL;
+  
+
+/* 
+	Code Released under GPL By Kevin Fowlks aka KamKa Feb 14th 2001
+    Portion of this code where taken from NeHe Particle Tutor
+	minor editing was done to get it working in my base code..
+	I hope this code is of some use to someone :) .
+
+	Code should Compile under KOS .80 
+	Just Unzip into the userland dir and type run make.
+	You need genroms workign on your system too... 
+
+	kamka@barcode-search.com
+
+ */
+
+
+
+#define MAX_PARTICLES 150 /* Transparent Polys are VERY TA INTENSIVE */
+
+typedef struct						// Create A Structure For Particle
+{
+	int	active;					// Active (Yes/No)
+	float	life;					// Particle Life
+	float	fade;					// Fade Speed
+	float	r;						// Red Value
+	float	g;						// Green Value
+	float	b;						// Blue Value
+	float	x;						// X Position
+	float	y;						// Y Position
+	float	z;						// Z Position
+	float	xi;						// X Direction
+	float	yi;						// Y Direction
+	float	zi;						// Z Direction
+	float	xg;						// X Gravity
+	float	yg;						// Y Gravity
+	float	zg;						// Z Gravity
+}
+particles;							// Particles Structure
+
+particles particle[MAX_PARTICLES];	// Particle Array (Room For Particle Info)
+
+float	zoom=-40.0f;
+int col=0;
+float	slowdown=1.0f;				// Slow Down Particles
+float	xspeed;						// Base X Speed (To Allow Keyboard Direction Of Tail)
+float	yspeed;	
+float  joy_x=0.0;
+float joy_y=0.0;
+float yr=0.0;
+
+static float colors[12][3]=		// Rainbow Of Colors
+{
+	{1.0f,0.5f,0.5f},{1.0f,0.75f,0.5f},{1.0f,1.0f,0.5f},{0.75f,1.0f,0.5f},
+	{0.5f,1.0f,0.5f},{0.5f,1.0f,0.75f},{0.5f,1.0f,1.0f},{0.5f,0.75f,1.0f},
+	{0.5f,0.5f,1.0f},{0.75f,0.5f,1.0f},{1.0f,0.5f,1.0f},{1.0f,0.5f,0.75f}
+};
+
+
+
+
+
+#define RGB565(r,g,b) ((r >> 3) << 11)| ((g >> 2) << 5)| ((b >> 3) << 0)
+
+
+
+void init_particle()
+{
+
+	int loop;
+
+
+	for (loop=0;loop<MAX_PARTICLES;loop++)				// Initials All The Textures
+	{
+		particle[loop].active=1;						// Make All The Particles Active
+		particle[loop].life=1.0f;
+
+		// Give All The Particles Full Life
+		particle[loop].fade= (float)randnum(100) / 1500.0f;
+		particle[loop].r=colors[(loop+1)/(MAX_PARTICLES/12)][0];	// Select Red Rainbow Color
+		particle[loop].g=colors[(loop+1)/(MAX_PARTICLES/12)][1];	// Select Green Rainbow Color
+		particle[loop].b=colors[(loop+1)/(MAX_PARTICLES/12)][2];	// Select Blue Rainbow Color
+		particle[loop].xi=(float)(randnum(50)-26.0f)*10.0f;	// Random Speed On X Axis
+		particle[loop].yi=(float)(randnum(50)-25.0f)*10.0f;	// Random Speed On Y Axis
+		particle[loop].zi=(float)(randnum(50)-25.0f)*10.0f;	// Random Speed On Z Axis
+		particle[loop].xg=0.0f;							// Set Horizontal Pull To Zero
+		particle[loop].yg=0.8f;						// Set Vertical Pull Downward
+		particle[loop].zg=0.0f;							// Set Pull On Z Axis To Zero
+	}
+
+}
+
+
+
+void draw_part(int x_pos,int y_pos)
+{
+int loop;
+float x;
+float y;
+float z;
+_3dvector rgb;
+
+for (loop=0;loop<MAX_PARTICLES;loop++)					// Loop Through All The Particles
+	{
+		if (particle[loop].active == 1)							// If The Particle Is Active
+		{
+
+			x=particle[loop].x;
+			y=particle[loop].y;
+
+			/* Don't really need this cuz z is not being transformed  */
+			z=particle[loop].z+zoom;
+
+			rgb.v[0] = particle[loop].r;
+			rgb.v[1] = particle[loop].g;
+			rgb.v[2] = particle[loop].b;
+
+			/* Main Call this does all the work it's in 3dutil.c */
+			tri_strip(x+x_pos,y+y_pos,512,32,rgb,particle[loop].life);
+
+			particle[loop].x+=particle[loop].xi/(slowdown*75);// Move On The X Axis By X Speed
+			particle[loop].y+=particle[loop].yi/(slowdown*75);// Move On The Y Axis By Y Speed
+			particle[loop].z+=particle[loop].zi/(slowdown*100);// Move On The Z Axis By Z Speed
+
+			particle[loop].xi+=particle[loop].xg;			// Take Pull On X Axis Into Account
+			particle[loop].yi+=particle[loop].yg;			// Take Pull On Y Axis Into Account
+			particle[loop].zi+=particle[loop].zg;			// Take Pull On Z Axis Into Account
+		 	
+			particle[loop].life = particle[loop].life - particle[loop].fade; 	// Random Fade Speed
+		
+
+			if (particle[loop].life<0.0f)					// If Particle Is Burned Out
+			{
+
+				particle[loop].life=1.0f;					// Give It New Life
+				particle[loop].fade=(float)randnum(100)/1500.0f+0.003f;	// Random Fade Value
+				particle[loop].x=0.0f;						// Center On X Axis
+				particle[loop].y=0.0f;						// Center On Y Axis
+				particle[loop].z=0.0f;						// Center On Z Axis
+				particle[loop].xi=xspeed+(float)(randnum(70)-32.0f);	// X Axis Speed And Direction
+				particle[loop].yi=yspeed+(float)(randnum(70)-30.0f);	// Y Axis Speed And Direction
+				particle[loop].zi=(float)(randnum(60)-30.0f);	// Z Axis Speed And Direction
+				particle[loop].r=colors[col][0];			// Select Red From Color Table
+				particle[loop].g=colors[col][1];			// Select Green From Color Table
+				particle[loop].b=colors[col][2];			// Select Blue From Color Table
+			}
+		}
+
+	}
+}
+
+
+int main() {
+
+
+  poly_hdr_t poly; /* Our Basic Textured Poly  */
+  
+  unsigned int particle_txr,font_txr,bk_txr;
+ 
+  uint8 mcont=0;
+  abi_conio_t *conio;  
+  cont_cond_t cond;
+ 
+  /* Make a BIG BUFFER THE SIZE OF OUR MAX TEXTURE THIS IS JUST TEMP */
+  unsigned short *temp = malloc(512*512*sizeof(unsigned short));
+  unsigned  char *data = malloc(512*512*4); 
+
+  
+	fs = lib_open("fs");
+	if (fs == NULL) { printf("Can't open FS lib\r\n"); return -1; }
+	spu = lib_open("spu");
+	if (spu == NULL) { printf("Can't open SPU lib\r\n"); return -1; }
+	ta = lib_open("ta");
+	if (ta == NULL) { printf("Can't open TA lib\r\n"); return -1; }
+	maple = lib_open("maple");
+	if (maple == NULL) { printf("Can't open Maple lib\r\n"); return -1; }
+
+	conio = lib_open("conio");
+
+	if (conio != NULL) {
+		printf("Kosh detected; freezing\r\n");
+		conio->freeze();
+	}
+
+
+  if (!LoadTexture("/rd/part.tga",data,temp)) {return -1;} 
+   
+	  particle_txr = tex_load(temp,(32*32)*sizeof(unsigned short));
+
+
+  if (!LoadTexture("/rd/FONT1.TGA",data,temp)) {return -1;} 
+   
+	  font_txr = tex_load(temp,(256*256)*sizeof(unsigned short));
+
+
+   /* Ok lets free some memory */
+   if (temp) free(temp);
+   if (data) free(data);
+
+
+   setseed(1232); /*Sets Seed Value for Random Functions */
+
+
+   init_particle();
+
+
+
+  while(1)
+  {
+  
+    ta->begin_render(); 
+	/* IMPORTANT: YOU DON"T NEED A HEADER JUST MAKE SURE AN EOL IS SENT */
+    ta->commit_eol();
+
+
+    /* TA freaks out at having a completely empty list */
+	ta->poly_hdr_txr(&poly, TA_TRANSLUCENT,TA_ARGB4444,256, 256, font_txr,TA_NO_FILTER);
+    ta->commit_poly_hdr(&poly);
+	
+    print_string(" THIS IS A SAMPLE DREAMCAST PROGRAM",15,2,1.0);
+	
+	print_string("USE JOYPAD TO CHANGE PARTICLE DIRECTION",0,435,1.0);
+
+	print_string("   KAMKA PRESENTS PARTICLE WORLD ",15,450,1.0);
+
+
+	ta->poly_hdr_txr(&poly, TA_TRANSLUCENT,TA_ARGB4444,32, 32, particle_txr,TA_NO_FILTER);
+    ta->commit_poly_hdr(&poly);
+
+	draw_part(640/2,480/2); /* Draw Particle's and Center then on the screen */
+	
+    ta->commit_eol();
+
+
+    /* Must Call to Finish Rendering Process*/
+    ta->finish_frame();
+
+
+	if (maple->cont_get_cond(maple->first_controller(), &cond) < 0)
+			break;
+
+	if (!(cond.buttons & CONT_START))
+			break;
+
+	
+	if (!(cond.buttons & CONT_DPAD_UP)) {
+		    joy_y = joy_y - 1.0;
+				if (yspeed>-200) yspeed-= 1.0f;
+	}
+	
+	if (!(cond.buttons & CONT_DPAD_DOWN)) {
+		  joy_y =joy_y + 1.0;
+		  if (yspeed<200) yspeed+=1.0f;
+
+		 
+	}
+	
+	if (!(cond.buttons & CONT_DPAD_LEFT)) {
+		joy_x=joy_x-1.0;
+			if (xspeed<200) xspeed-= 1.0f;
+
+	}
+
+	if (!(cond.buttons & CONT_DPAD_RIGHT)) {
+		joy_x=joy_x+1.0;
+			if (xspeed>-200) xspeed+= 1.0f;
+	}
+
+
+	
+		if (col>11)	col=0;				// If Color Is To High Reset It
+
+			col++;
+
+  }
+
+   printf("Exiting Main Loop \r\n");
+
+
+  
+  if (conio != NULL) {
+		conio->thaw();
+	}
+  
+      
+  return 0;
+
+}

math.c

+#include "math.h"
+
+
+
+
+
+unsigned long seed=123;
+
+#define RNDC 1013904223
+#define RNDM 1164525
+
+
+/* Floating-point Sin/Cos; 256 angles, -1.0 to 1.0 */
+
+#define SIN(x) (sinus_tab[(x)&2047])
+#define COS(x) (sinus_tab[((x)+512)&2047])
+
+
+void setseed(int i) { if(i) seed=i;}
+
+
+
+int rand() {
+
+	seed = seed * RNDM + RNDC;
+
+	return seed;
+
+}
+
+
+
+int randnum(int limit) { return (rand() & 0x7fffffff) % limit; }
+
+
+
+
+
+/* matrices for transforming world coordinates to
+
+   screen coordinates (with perspective)        */
+
+
+
+
+
+
+
+void translate(float x, float y, float z)
+{
+    static float matrix[4][4] = {
+	{ 1.0, 0.0, 0.0, 0.0 },
+	{ 0.0, 1.0, 0.0, 0.0 },
+	{ 0.0, 0.0, 1.0, 0.0 },
+	{ 0.0, 0.0, 0.0, 1.0 },
+    };
+    
+    matrix[3][0] = x;
+    matrix[3][1] = y;
+    matrix[3][2] = z;
+    apply_matrix(&matrix);
+}
+
+void rotate_x(int n)
+{
+    static float matrix[4][4] = {
+	{ 1.0, 0.0, 0.0, 0.0 },
+	{ 0.0, 1.0, 0.0, 0.0 },
+	{ 0.0, 0.0, 1.0, 0.0 },
+	{ 0.0, 0.0, 0.0, 1.0 },
+    };
+    matrix[1][1] = matrix[2][2] = COS(n);
+    matrix[1][2] = -(matrix[2][1] = SIN(n));
+    apply_matrix(&matrix);
+}
+
+void rotate_y(int n)
+{
+    static float matrix[4][4] = {
+	{ 1.0, 0.0, 0.0, 0.0 },
+	{ 0.0, 1.0, 0.0, 0.0 },
+	{ 0.0, 0.0, 1.0, 0.0 },
+	{ 0.0, 0.0, 0.0, 1.0 },
+    };
+    matrix[0][0] = matrix[2][2] = COS(n);
+    matrix[2][0] = -(matrix[0][2] = SIN(n));
+    apply_matrix(&matrix);
+}
+
+void rotate_z(int n)
+{
+    static float matrix[4][4] = {
+	{ 1.0, 0.0, 0.0, 0.0 },
+	{ 0.0, 1.0, 0.0, 0.0 },
+	{ 0.0, 0.0, 1.0, 0.0 },
+	{ 0.0, 0.0, 0.0, 1.0 },
+    };
+    matrix[0][0] = matrix[1][1] = COS(n);
+    matrix[0][1] = -(matrix[1][0] = SIN(n));
+    apply_matrix(&matrix);
+}
+
+void
+lib3ds_vector_sub(_3dvector c, _3dvector a, _3dvector b)
+{
+  int i;
+  for (i=0; i<3; ++i) {
+    c.v[i]=a.v[i]-b.v[i];
+  }
+}
+
+
+void
+lib3ds_vector_cross(_3dvector c, _3dvector a, _3dvector b)
+{
+  c.v[0]=a.v[1]*b.v[2] - a.v[2]*b.v[1];
+  c.v[1]=a.v[2]*b.v[0] - a.v[0]*b.v[2];
+  c.v[2]=a.v[0]*b.v[1] - a.v[1]*b.v[0];
+}
+
+
+void
+set_camera_view( _3dvector pos,
+  _3dvector tgt, float roll)
+{
+
+  float M[4][4] = {
+	{ 1.0, 0.0, 0.0, 0.0 },
+	{ 0.0, 1.0, 0.0, 0.0 },
+	{ 0.0, 0.0, 1.0, 0.0 },
+	{ 0.0, 0.0, 0.0, 1.0 },
+    };
+
+ float R[4][4] = {
+	{ 1.0, 0.0, 0.0, 0.0 },
+	{ 0.0, 1.0, 0.0, 0.0 },
+	{ 0.0, 0.0, 1.0, 0.0 },
+	{ 0.0, 0.0, 0.0, 1.0 },
+    };
+
+
+  
+  _3dvector x, y, z;
+
+  lib3ds_vector_sub(y, tgt, pos);
+//  lib3ds_vector_normalize(y);
+  
+  z.v[0] = 0;
+  z.v[1] = 0;
+  z.v[2] = 1.0;
+  
+  lib3ds_vector_cross(x, y, z);
+  lib3ds_vector_cross(z, x, y);
+
+//  lib3ds_vector_normalize(x);
+ // lib3ds_vector_normalize(y);
+
+  //lib3ds_matrix_identity(M);
+  M[0][0] = x.v[0];
+  M[1][0] = x.v[1];
+  M[2][0] = x.v[2];
+  M[0][1] = y.v[0];
+  M[1][1] = y.v[1];
+  M[2][1] = y.v[2];
+  M[0][2] = z.v[0];
+  M[1][2] = z.v[1];
+  M[2][2] = z.v[2];
+
+  //lib3ds_matrix_identity(R);
+  //lib3ds_matrix_rotate_y(R, roll);
+ // lib3ds_matrix_mul(matrix, R,M);
+  
+  apply_matrix(&R);
+  rotate_y(roll);
+
+  apply_matrix(&M);
+  //lib3ds_matrix_translate_xyz(matrix, );
+
+  translate(-pos.v[0],-pos.v[1],-pos.v[2]);
+}
+
+
+float dot_product(const _3dvector *a,const _3dvector *b)
+
+{
+
+   return (a->x*b->x + a->y*b->y + a->z*b->z);
+
+
+
+}
+
+
+
+ float vec_length(const _3dvector *a)
+
+{
+
+	return ((float ) int_sqrt(a->x*a->x + a->y*a->y + a->z*a->z));
+
+}
+
+
+
+
+
+void calc_norm( const _3dvector *a, const _3dvector *b, const _3dvector *c, _3dvector *norm )
+
+{
+
+	_3dvector v,w;
+
+	float len;
+
+
+
+	//calc vectors for two of the sides of the triangle
+
+	v.x = c->x - a->x;
+
+	v.y = c->y - a->y;
+
+	v.z = c->z - a->z;
+
+	w.x = b->x - a->x;
+
+	w.y = b->y - a->y;
+
+	w.z = b->z - a->z;
+
+
+
+	//normal is the cross product of the two sides
+
+	norm->x = v.y*w.z - w.y*v.z;
+
+	norm->y = w.x*v.z - v.x*w.z;
+
+	norm->z = v.x*w.y - w.x*v.y;
+
+
+
+	//normalize the vector
+
+	// err.. no native square yet will add later
+
+	// len = sqrt( norm->x*norm->x + norm->y*norm->y + norm->z*norm->z );
+
+	
+
+	len= int_sqrt(norm->x*norm->x + norm->y*norm->y + norm->z*norm->z);
+
+	
+
+	norm->x /= len;
+
+	norm->y /= len;
+
+	norm->z /= len;
+
+}
+
+
+
+
+
+
+
+float vector_length(const _3dvector *a)
+
+{
+
+  float len;
+
+  len*=(a->x*a->x) + (a->y*a->y) + (a->z*a->z);
+
+  return len;
+
+}
+
+
+
+void set_camera(float x,float y,float z)
+
+{
+
+	camera_matrix[3][0] = -x;
+
+	camera_matrix[3][1] = -y;
+
+	camera_matrix[3][2] = -z;
+
+}
+
+
+
+
+
+
+
+
+
+int int_sqrt(long x) {
+
+
+
+  long sub = -1;
+
+
+
+  if (x > 4096) {               /* start it off with accuracy of 128 */
+
+    if (x > 16384) {
+
+      if (x > 36864) {
+
+        if (x > 65536) {
+
+          if (x > 119716) {
+
+            sub = 693;
+
+            x -= 119716;
+
+          }
+
+          else {
+
+            sub = 511;
+
+            x -= 65536;
+
+          }
+
+        }
+
+        else {
+
+          sub = 383;
+
+          x -= 36864;
+
+        }
+
+      }
+
+      else {
+
+        sub = 255;
+
+        x -= 16384;
+
+      }
+
+    }
+
+    else {
+
+      sub = 127;
+
+      x -= 4096;
+
+    }
+
+  }
+
+  do {
+
+    sub +=2;
+
+    x -= sub;
+
+    sub +=2;
+
+    x -= sub;
+
+    if (x<0)             /* a jump takes longer than no jump, */
+
+      goto EndLoop;      /* so I unrolled it and used gotos.  */
+
+    sub +=2;
+
+    x -= sub;
+
+    sub +=2;
+
+    x -= sub;
+
+    if (x<0)
+
+      goto EndLoop;
+
+    sub +=2;
+
+    x -= sub;
+
+    sub +=2;
+
+    x -= sub;
+
+    if (x<0)
+
+      goto EndLoop;
+
+    sub +=2;
+
+    x -= sub;
+
+    sub +=2;
+
+    x -= sub;
+
+  } while(x>=0);
+
+EndLoop:
+
+  if (x < -sub)
+
+    return (unsigned)(sub>>1) - 1;
+
+  return (unsigned)sub>>1;
+
+}
+
+
+
+
+

matrix.h

+extern void clear_matrix();
+extern void apply_matrix(float (*matrix)[4][4]);
+extern void transform_coords(float (*src)[3], float (*dest)[4], int n);

matrix.s

+
+	! SH4 matrix operations
+	!
+	! The matrix is kept in the XMTRX register set between calls
+
+	
+	.globl _clear_matrix, _apply_matrix, _transform_coords
+
+	.text
+
+
+	! Initialize the matrix to the identity matrix
+	!
+	! no args
+	
+_clear_matrix:
+	fldi0 fr0
+	fldi0 fr1
+	fldi1 fr2
+	fldi0 fr3
+	fldi0 fr4
+	fldi1 fr5
+	fschg
+	fmov dr2,xd0
+	fmov dr0,xd2
+	fmov dr4,xd4
+	fmov dr0,xd6
+	fmov dr0,xd8
+	fmov dr2,xd10
+	fmov dr0,xd12
+	fmov dr4,xd14
+	rts
+	fschg
+
+
+
+	! Multiply another matrix to the current matrix
+	!
+	! r4 = pointer to the other matrix (4 * 4 floats)
+
+_apply_matrix:
+	fmov.s fr12, @-r15
+	fmov.s fr13, @-r15
+	fmov.s fr14, @-r15
+	fmov.s fr15, @-r15
+	fmov.s @r4+,fr0
+	fmov.s @r4+,fr1
+	fmov.s @r4+,fr2
+	fmov.s @r4+,fr3
+	ftrv xmtrx,fv0
+	fmov.s @r4+,fr4
+	fmov.s @r4+,fr5
+	fmov.s @r4+,fr6
+	fmov.s @r4+,fr7
+	ftrv xmtrx,fv4
+	fmov.s @r4+,fr8
+	fmov.s @r4+,fr9
+	fmov.s @r4+,fr10
+	fmov.s @r4+,fr11
+	ftrv xmtrx,fv8
+	fmov.s @r4+,fr12
+	fmov.s @r4+,fr13
+	fmov.s @r4+,fr14
+	fmov.s @r4+,fr15
+	ftrv xmtrx,fv12
+	fschg
+	fmov dr0,xd0
+	fmov dr2,xd2
+	fmov dr4,xd4
+	fmov dr6,xd6
+	fmov dr8,xd8
+	fmov dr10,xd10
+	fmov dr12,xd12
+	fmov dr14,xd14
+	fschg
+	fmov.s @r15+, fr15
+	fmov.s @r15+, fr14
+	fmov.s @r15+, fr13
+	rts
+	fmov.s @r15+, fr12
+
+	! Multiply a set of 3D vectors with the matrix
+	! (vectors are extended to 4D homogenous coordinates by
+	!  setting W=1), and then normalize the resulting
+	! vectors before storing them in the result array
+	!
+	! r4 = pointer to a source set of 3D vectors (n * 3 floats)
+	! r5 = pointer to a destination set of 3D vectors (n * 4 floats)
+	!      output vector is (x, y, z, -1/w)
+	! r6 = number of vectors to transform
+
+_transform_coords:
+	pref @r4
+	mov r5,r0
+	mov #4,r1
+	mov r4,r3
+	mov #8,r2
+	add #32,r3
+	mov #12,r7
+.loop:
+	fmov.s @r4+,fr0
+	fmov.s @r4+,fr1
+	fmov.s @r4+,fr2
+	fldi1 fr3
+	pref @r3
+	ftrv xmtrx,fv0
+	dt r6
+	fdiv fr3,fr0
+	fmov.s fr0,@r0
+	fdiv fr3,fr1
+	fmov.s fr1,@(r0,r1)
+	fdiv fr3,fr2
+	add #4*3,r3
+	fmov.s fr2,@(r0,r2)
+	fldi1 fr1
+	fneg fr1
+	fdiv fr3,fr1
+	fmov.s fr1,@(r0,r7)
+	bf/s .loop
+	add #4*4,r0
+	rts	
+	nop
+
+	.end
+