import3ds.cpp

3DS_ImportCode

	{
		fprintf(logfile, " local_centre_x,y,z : %f %f %f\n", 
			local_centre_x, local_centre_y, local_centre_z);
	}
	
	oblist[total_num_objects].local_centre_x = local_centre_x;
	oblist[total_num_objects].local_centre_y = local_centre_y;
	oblist[total_num_objects].local_centre_z = local_centre_z;
}



// PROCESS TEXTURE, MATERIAL, AND MAPPING DATA ROUTINES

void C3DS::AddMapName(HWND hwnd, FILE *fp, int pmodel_id)
{
	int	i; 
	BOOL error = TRUE;
	char map_name[256];

	// read in map name from file

	for (i = 0; i < 256; i++)
	{
		fread(&map_name[i], sizeof(char), 1, fp);
		if(map_name[i] == 0)
			break;
	}

	// remove file extention from string

	for (i = 0; i < 256; i++)
	{	
		if(map_name[i] == '.')
		{
			map_name[i] = 0;
			break;
		}
	}

		// lookup texture alias

	for (i = 0; i < 100; i++)
	{	
		if(strcmpi(map_name, pCMyApp->TexMap[i].tex_alias_name) == 0)
		{
			pCMyApp->pmdata[pmodel_id].texture_maps[num_maps] = i;
			error = FALSE;
			break;
		}
	}

	if(error == TRUE)
	{
		MessageBox(hwnd,"Error : AddMapName", map_name, MB_OK);
		strcpy(mapnames[num_maps], "error");
		return;
	}

	strcpy(mapnames[num_maps], map_name);
	if(bEnable3dsLogfile)
		fprintf(logfile, "%s %s\n", "MAPPING_NAME ", mapnames[num_maps]); 
	num_maps++;

}

void C3DS::AddMaterialName(HWND hwnd, FILE *fp)
{	
	int	i; 
	BOOL error = TRUE;
	char mat_name[256];

	for (i = 0; i < 256; i++)
	{
		fread(&mat_name[i], sizeof(char), 1, fp);
		if(mat_name[i] == 0)
		{
			error = FALSE;
			break;
		}
	}

	if(error == TRUE)
	{
		MessageBox(hwnd,"Error : AddMaterialName", NULL, MB_OK);
		strcpy(material_list[num_materials], "error");
		return;
	}

	if(bEnable3dsLogfile)
		fprintf(logfile,"MAT_NAME01  %s\n",mat_name);
	strcpy(material_list[num_materials], mat_name) ;
	num_materials++;
}

void C3DS::ProcessMaterialData(HWND hwnd, FILE *fp, int pmodel_id)
{
	int	i; 
	short findex, current_texture;
	unsigned short num_faces;
	BOOL error = TRUE;
	char mat_name[256];


	for (i = 0; i < 256; i++)
	{
		fread(&mat_name[i], sizeof(char), 1, fp);
		if(mat_name[i] == 0)
			break;
	}

	for (i = 0; i < MAX_NUM_3DS_TEXTURES; i++)
	{
		if(strcmpi(mat_name, material_list[i]) == 0)
		{
			current_texture = pCMyApp->pmdata[pmodel_id].texture_maps[i];
			error = FALSE;
			break;
		}
	}

	if(error == TRUE)
	{
		MessageBox(hwnd,"Error : ProcessMaterialData", NULL, MB_OK);
		strcpy(material_list[num_materials], "error");
		return;
	}

	fread(&num_faces, sizeof(num_faces), 1, fp);

	if(bEnable3dsLogfile)
		fprintf(logfile, "TRIANGLE_MATERIAL %d\n", num_faces);

	for (i = 0; i < num_faces; i++)
	{
		fread(&findex, sizeof(short), 1, fp);
		faces[last_num_faces + findex].tex = current_texture;
		object_texture[total_num_objects] = current_texture;
	}
	return;
}

void C3DS::ProcessMappingData(HWND hwnd, FILE *fp)
{
	int	i; 
	unsigned short num_mapping_coords;
	
	total_num_mcoords = last_num_verts;

	fread(&num_mapping_coords, sizeof(num_mapping_coords), 1, fp);

	if(bEnable3dsLogfile)
		fprintf(logfile, "%s %d\n", "TRIANGLE_MAPPINGCOORS ", num_mapping_coords);

	for (i = 0; i < num_mapping_coords; i++)
	{
		fread(&mcoords[total_num_mcoords].x, sizeof(float), 1, fp);
		fread(&mcoords[total_num_mcoords].y, sizeof(float), 1, fp);

		if(bEnable3dsLogfile)
		{
			fprintf(logfile, " %f %f\n", 
				mcoords[total_num_mcoords].x,
				mcoords[total_num_mcoords].y);
		}
		total_num_mcoords++;
	}
	return;
}



// KEYFRAME - PROCESS ANIMATION DATA ROUTINES

void C3DS::ProcessPivots(HWND hwnd, FILE *fp)
{
	float x,y,z;
	
	fread(&x, sizeof(float), 1, fp);
	fread(&y,  sizeof(float), 1, fp);
	fread(&z,  sizeof(float), 1, fp);

	oblist[kf_count].pivot.x = x;
	oblist[kf_count].pivot.y = y;
	oblist[kf_count].pivot.z = z;

	if(bEnable3dsLogfile)
		fprintf(logfile, "PIVOT: %f %f %f\n", x, y, z);	

	
}

void C3DS::ProcessRotationTrack(HWND hwnd, FILE *fp)
{		
	int i;
	short framenum;
	long lunknown; 
	float rotation_rad;
	float axis_x;
	float axis_y;
	float axis_z;



	fread(&pt_flags, sizeof(short), 1, fp);

	fread(&unknown,  sizeof(short), 1, fp);
	fread(&unknown,  sizeof(short), 1, fp);
	fread(&unknown,  sizeof(short), 1, fp);
	fread(&unknown,  sizeof(short), 1, fp);

	fread(&oblist[kf_count].rotkeys,	 sizeof(short), 1, fp);
	fread(&unknown,  sizeof(short), 1, fp);
	
	if(bEnable3dsLogfile)
		fprintf(logfile, "ROT_TRACK_TAG %d\n", oblist[kf_count].rotkeys);
	
	for(i = 0; i < oblist[kf_count].rotkeys; i++)
	{
		fread(&framenum,  sizeof(short), 1, fp);
		fread(&lunknown,  sizeof(long), 1, fp);
		fread(&rotation_rad,  sizeof(float), 1, fp);
		fread(&axis_x,  sizeof(float), 1, fp);
		fread(&axis_y,  sizeof(float), 1, fp);
		fread(&axis_z,  sizeof(float), 1, fp);

		if(bEnable3dsLogfile)
		{
			fprintf(logfile, " framenum = %d  rot_angle/rads = %f  axis_x,y,z : %f %f %f\n", 
			              framenum, rotation_rad, axis_x, axis_y, axis_z);	
		}

		if(i < total_num_frames)
		{
			oblist[kf_count].rot_track[i].framenum = framenum;
			oblist[kf_count].rot_track[i].lunknown = lunknown;
			oblist[kf_count].rot_track[i].rotation_rad = rotation_rad;
			oblist[kf_count].rot_track[i].axis_x = axis_x;
			oblist[kf_count].rot_track[i].axis_y = axis_y;
			oblist[kf_count].rot_track[i].axis_z = axis_z;
		}
	}

}

void C3DS::ProcessPositionTrack(HWND hwnd, FILE *fp)
{	
	
	int i;
	short framenum;
	long  lunknown;
	float pos_x;
	float pos_y;
	float pos_z;


	
	fread(&pt_flags, sizeof(short), 1, fp);

	fread(&unknown,  sizeof(short), 1, fp);
	fread(&unknown,  sizeof(short), 1, fp);
	fread(&unknown,  sizeof(short), 1, fp);
	fread(&unknown,  sizeof(short), 1, fp);

	fread(&oblist[kf_count].poskeys,	 sizeof(short), 1, fp);
	fread(&unknown,  sizeof(short), 1, fp);
	
	if(bEnable3dsLogfile)
		fprintf(logfile, "POS_TRACK_TAG %d\n", oblist[kf_count].poskeys);
	
	for(i = 0; i < oblist[kf_count].poskeys; i++)
	{
		fread(&framenum,  sizeof(short), 1, fp);
		fread(&lunknown,  sizeof(long), 1, fp);
		fread(&pos_x,  sizeof(float), 1, fp);
		fread(&pos_y,  sizeof(float), 1, fp);
		fread(&pos_z,  sizeof(float), 1, fp);

		if(bEnable3dsLogfile)
		{
			fprintf(logfile, " framenum = %d   pos_x,y,z : %f %f %f\n", 
			              framenum, pos_x, pos_y, pos_z);
		}

		if(i < total_num_frames)
		{
			//fprintf(logfile, "i: %d   total_num_frames: %d\n", 
			  //                i, total_num_frames);	

			oblist[kf_count].pos_track[i].framenum = framenum;
			oblist[kf_count].pos_track[i].lunknown = lunknown;
			oblist[kf_count].pos_track[i].pos_x = pos_x;
			oblist[kf_count].pos_track[i].pos_y = pos_y;
			oblist[kf_count].pos_track[i].pos_z = pos_z;
		}
	}
}
	
void C3DS::ProcessScaleTrack(HWND hwnd, FILE *fp)
{	
	
	int i;
	short framenum;
	long lunknown;		
	float scale_x;
	float scale_y;
	float scale_z;


	fread(&pt_flags, sizeof(short), 1, fp);

	fread(&unknown,  sizeof(short), 1, fp);
	fread(&unknown,  sizeof(short), 1, fp);
	fread(&unknown,  sizeof(short), 1, fp);
	fread(&unknown,  sizeof(short), 1, fp);

	fread(&oblist[kf_count].sclkeys,	 sizeof(short), 1, fp);
	fread(&unknown,  sizeof(short), 1, fp);
	
	if(bEnable3dsLogfile)
		fprintf(logfile, "SCL_TRACK_TAG %d\n", oblist[kf_count].sclkeys);
	
	for(i = 0; i < oblist[kf_count].sclkeys; i++)
	{
		fread(&framenum,  sizeof(short), 1, fp);
		fread(&lunknown,  sizeof(long), 1, fp);
		
		fread(&scale_x,  sizeof(float), 1, fp);
		fread(&scale_y,  sizeof(float), 1, fp);
		fread(&scale_z,  sizeof(float), 1, fp);

		if(bEnable3dsLogfile)
		{
			fprintf(logfile, " framenum = %d   x,y,z : %f %f %f\n", 
				framenum, scale_x, scale_y, scale_z);	
		}

	}
}

void C3DS::ProcessNodeId(FILE *fp)
{
	short node_id;


	fread(&node_id, sizeof(short), 1, fp);
	if(bEnable3dsLogfile)
		fprintf(logfile, "NODE_ID  %d\n", node_id); 
}

void C3DS::ProcessNodeHeader(FILE *fp)
{
	int i;
	short flags1, flags2, heirarchy;
	char node_name[256];


	// read in node name from file

	for (i = 0; i < 256; i++)
	{
		fread(&node_name[i], sizeof(char), 1, fp);
		if(node_name[i] == 0)
			break;
	}

	fread(&flags1, sizeof(short), 1, fp);
	fread(&flags2, sizeof(short), 1, fp);
	fread(&heirarchy, sizeof(short), 1, fp);

	if(bEnable3dsLogfile)
	{
		fprintf(logfile, "NODE_HDR %s\n", node_name);
		fprintf(logfile, " flags1 %d\n", flags1);
		fprintf(logfile, " flags2 %d\n", flags2);
		fprintf(logfile, " heirarchy %d\n", heirarchy);
	}

}

void C3DS::Process3DSVersion(FILE *fp)
{
	short version;

	fread(&version, sizeof(short), 1, fp);
	if(bEnable3dsLogfile)
		fprintf(logfile, "3DS VERSION %d\n",version);
	fread(&version, sizeof(short), 1, fp);
}

void C3DS::ProcessMasterScale(FILE *fp)
{
	float master_scale;

	fread(&master_scale, sizeof(float), 1, fp);
	if(bEnable3dsLogfile)
		fprintf(logfile, "MASTER_SCALE %f\n",master_scale);	
}

// RELEASE AND DEBUG ROUTINES

void C3DS::ReleaseTempMemory()
{
	
}

void C3DS::PrintLogFile(FILE *logfile, char *commmand)
{
	if(bEnable3dsLogfile)
	{
		fprintf(logfile, commmand);
		fprintf(logfile,"\n");
	}
	command_found_flag = TRUE;
}


void C3DS::Write_pmdata_debugfile(HWND hwnd, int pmodel_id)
{
	FILE *fp;
	int i;
	int frame_num;
	float x,y,z;
	int face;
	int num_verts;
	int num_faces;
	int tex;


	if ((fp = fopen("pmdata.txt", "w+")) == 0) 
	{
		MessageBox(hwnd,"logfile error : Can't open", "pmdata.txt", MB_OK);
		return;
	}

	////////////////////////////////////////////////////

	frame_num = 0;
	num_verts = pCMyApp->pmdata[pmodel_id].num_verts;

	fprintf(fp, "model id  =  %d\n\n", pmodel_id);	
	fprintf(fp, "num verts =  %d\n\n", num_verts);	

	for(i = 0; i < num_verts; i++)
	{
		x = pCMyApp->pmdata[pmodel_id].w[frame_num][i].x;
		y = pCMyApp->pmdata[pmodel_id].w[frame_num][i].y;
		z = pCMyApp->pmdata[pmodel_id].w[frame_num][i].z;
		fprintf(fp, "%d   %f %f %f\n", i, x, y, z);		
	}

	fprintf(fp, "\n");	

	////////////////////////////////////////////////////


	num_faces = pCMyApp->pmdata[pmodel_id].num_faces;

	
	fprintf(fp, "num_faces =  %d\n\n", num_faces);	

	for(i = 0; i < num_faces*3; i++)
	{
		face = pCMyApp->pmdata[pmodel_id].f[i];
		
		fprintf(fp, "%d   %d\n", i, face);		
	}

	fprintf(fp, "\n");	

	////////////////////////////////////////////////////


	num_faces = pCMyApp->pmdata[pmodel_id].num_faces;

	
	fprintf(fp, "num_faces =  %d tex\n\n", num_faces);	

	for(i = 0; i < num_faces*3; i++)
	{
		x = pCMyApp->pmdata[pmodel_id].t[i].x; 
		y = pCMyApp->pmdata[pmodel_id].t[i].y;
		
		fprintf(fp, "%d   %f %f\n", i, x, y);		
	}

	fprintf(fp, "\n");	
	
	////////////////////////////////////////////////////

	num_faces = pCMyApp->pmdata[pmodel_id].num_faces;

	for(i = 0; i < total_num_objects; i++)
	{
		tex = pCMyApp->pmdata[pmodel_id].texture_list[i];
			
		fprintf(fp, "%d   %d\n", i, tex);		
	}

	fprintf(fp, "\n");	

	////////////////////////////////////////////////////


	fclose (fp);
}