magic2.cpp

3D Game Engine Design Source Code非常棒

#include <fstream.h>
#include <stdio.h>
#include <string.h>
#include "elements.h"
#include "fileform.h"
#include "magic2.h"

int FT_MAGIC2;
int MAGIC2_message_size = 256;

static char magic_string[] = "MAGIC-ver2.0";
static char eol = '#';		// end of line
static char eoh = '\x1a';	// end of header

//===========================================================================
int MAGIC2_query (char* name)
{
	ifstream file;
	file.open(name,ios::in);
	if ( !file )
		return -1;

	const int quantity = 12;  // = strlen(magic_string)+1
	char buffer[quantity];
	file.read(buffer,quantity);
	for (int i = 0; i < quantity; i++)
		if ( buffer[i] != magic_string[i] ) {
			file.close();
			return 0;
		}

	file.close();
	return 1;
}
//---------------------------------------------------------------------------
int MAGIC2_gethead
	(char* name, int* dims, int** dim, char* elform, int* order)
{
	ifstream file;
	file.open(name,ios::in);
	if ( !file )
		return 0;

	const int buffer_size = 256;
	char* buffer = new char[buffer_size];

	// file format identifier
	file.getline(buffer,buffer_size,eol);
	int i;
	for (i = 0; magic_string[i]; i++)
		if ( buffer[i] != magic_string[i] ) {
			delete[] buffer;
			file.close();
			return 0;
		}

	// number of dimensions
	file.getline(buffer,buffer_size,eol);
	sscanf(buffer,"dims=%u",dims);
	if ( *dims == 0 )
		return 0;

	// size of each dimension
	*dim = new int[*dims];  // assumes *dim is a valid address
	for (i = 0; i < *dims; i++) {
		int dummy;
		file.getline(buffer,buffer_size,eol);
		sscanf(buffer,"dim[%d]=%d",&dummy,&((*dim)[i]));
	}

	// element type
	file.getline(buffer,buffer_size,eol);
	int j = 0;
	for (i = 7; buffer[i]; i++, j++)  // "format=%s"
		elform[j] = buffer[i];
	elform[j] = 0;

	// byte order
	file.getline(buffer,buffer_size,eol);
	sscanf(buffer,"order=%d",order);

	delete[] buffer;
	file.close();
	return 1;
}
//---------------------------------------------------------------------------
int MAGIC2_puthead (char* name, int dims, const int* dim,
	const char* elform, int order)
{
	ofstream file;
	file.open(name,ios::out);
	if ( !file )
		return 0;

	// file format identifier
	file << magic_string << eol;

	// number of dimensions
	file << "dims=" << dims << eol;

	// size of each dimension
	int i;
	for (i = 0; i < dims; i++)
		file << "dim[" << i << "]=" << dim[i] << eol;

	// element type
	file << "format=" << elform << eol;
	int eltype = mgcElementDBM::Type(elform);

	// byte order
	file << "order=" << order << eol;

	// messages
	char* messages = new char[MAGIC2_message_size];
	for (i = 0; i < MAGIC2_message_size; i++)
		messages[i] = 0;
	file << "messages=";
	file.write(messages,MAGIC2_message_size);
	delete[] messages;

	// end of header
	file << eoh;

	// allocate file space to hold all the elements
	const int buffer_size = 16384;
	char* buffer = new char[buffer_size];
	for (i = 0; i < buffer_size; i++)
		buffer[i] = 0;

	int quantity = 1;
	for (i = 0; i < dims; i++)
		quantity *= dim[i];

	int byte_quantity = quantity*mgcElementDBM::PackedSize(eltype);
	int block_count = byte_quantity / buffer_size;
	int block_remainder = byte_quantity % buffer_size;
	for (i = 0; i < block_count; i++)
		file.write(buffer,buffer_size);
	if ( block_remainder )
		file.write(buffer,block_remainder);

	delete[] buffer;
	file.close();
	return 1;
}
//---------------------------------------------------------------------------
int MAGIC2_getdata (char* name, long offset, int quantity, char* buffer)
{
	fstream file;
	file.open(name,ios::in|ios::binary);
	if ( !file )
		return 0;

	// move file pointer to first element of buffer
	char c = 0;
	while ( c != eoh )
		file >> c;

	file.seekp(offset,ios::cur);
	file.read(buffer,quantity);
	file.close();

	return 1;
}
//---------------------------------------------------------------------------
int MAGIC2_putdata (char* name, long offset, int quantity, char* buffer)
{
	fstream file;
	file.open(name,ios::in|ios::out|ios::ate|ios::binary);
	if ( !file )
		return 0;

	// move file pointer to first element of buffer
	file.seekp(0,ios::beg);
	char c = 0;
	while ( c != eoh )
		file.get(c);

	file.seekp(offset,ios::cur);
	file.write(buffer,quantity);
	file.close();

	return 1;
}
//---------------------------------------------------------------------------
int MAGIC2_getmessage (char* name, void* message)
{
	fstream file;
	file.open(name,ios::in|ios::binary);
	if ( !file )
		return 0;

	// get header block
	int header_size = 0;
	char c = 0;
	while ( c != eoh ) {
		file >> c;
		header_size++;
	}
	char* buffer = new char[header_size+1];
	file.seekp(0,ios::beg);
	file.read(buffer,header_size);
	buffer[header_size] = 0;

	// get message
	char* ptr = strstr(buffer,"messages=");
	ptr += 9;  // strlen("messages="), ptr points to message buffer
	char* msg = (char*) message;
	while ( *ptr != 0 && *ptr != eoh )
		*msg++ = *ptr++;
	*msg = 0;

	delete[] buffer;
	file.close();
	return 1;
}
//---------------------------------------------------------------------------
int MAGIC2_putmessage (char* name, void* message)
{
	fstream file;
	file.open(name,ios::in|ios::out|ios::ate|ios::binary);
	if ( !file  )
		return 0;

	// get header block
   	file.seekp(0,ios::beg);
	int header_size = 0;
	char c = 0;
	while ( c != eoh ) {
		file >> c;
		header_size++;
	}
	char* buffer = new char[header_size+1];
	file.seekp(0,ios::beg);
	file.read(buffer,header_size);
	buffer[header_size] = 0;

	// locate message buffer
	char* ptr = strstr(buffer,"messages=");
	ptr += 9;  // strlen("messages="), ptr points to message buffer

	// determine message buffer size, just in case MAGIC_message_size
	// was changed from its default value
	int message_size = header_size-(int)(ptr-buffer);

	// clear message buffer
	for (int i = 0; i < message_size; i++)
		ptr[i] = 0;

	// truncate new message to proper size, if necessary
	char* msg = (char*) message;
	if ( int(strlen(msg)) >= message_size )
		msg[message_size] = 0;

	// put message
	while ( *msg != 0  )
		*ptr++ = *msg++;
	file.seekp(0,ios::beg);
	file.write(buffer,header_size);

	delete[] buffer;
	file.close();
	return 1;
}
//---------------------------------------------------------------------------
int __MAGIC2_register__()
{
	// automatic registration of MAGIC2 file format
	static int is_registered = 0;

	if ( is_registered == 0 ) {
		mgcFileFormat::default_format = FT_MAGIC2 = 
                    mgcFileFormat::AddFileFormat(
			MAGIC2_query,
			MAGIC2_gethead,
			MAGIC2_puthead,
			MAGIC2_getdata,
			MAGIC2_putdata,
			MAGIC2_getmessage,
			MAGIC2_putmessage
		);
		is_registered = 1;
	}
	return is_registered;
}
//===========================================================================