element.cpp

《3D游戏引擎设计》的源码

#include <string.h>
#include <fstream.h>
#include "element.h"
#include "elements.h"

// error handling
int mgcElement::verbose = 0;

//===========================================================================
mgcElement& mgcElement::
operator= (const mgcElement& element)
{
	mgcElementDBM::EFconvert convert =
		mgcElementDBM::record[element.type].convert_to[type];
	if ( convert )
		convert(1,element.data,data);
	return *this;
}
//---------------------------------------------------------------------------
int mgcElement::
operator== (const mgcElement& element)
{
	if ( type != element.type )
		return 0;

	char* op1 = (char*)data;
	char* op2 = (char*)element.data;
	for (int i = 0; i < mgcElementDBM::MemorySize(type); i++, op1++, op2++)
		if ( *op1 != *op2 )
			return 0;

	return 1;
}
//---------------------------------------------------------------------------
istream&
operator>> (istream& istr, mgcElement& element)
{
	mgcElementDBM::EFinput input =
		mgcElementDBM::record[element.type].input;
	if ( input )
		input(istr,element.data);
	return istr;
}

//---------------------------------------------------------------------------
ostream&
operator<< (ostream& ostr, const mgcElement& element)
{
	mgcElementDBM::EFoutput output =
		mgcElementDBM::record[element.type].output;
	if ( output )
		output(ostr,element.data);
	return ostr;
}
//---------------------------------------------------------------------------
#define CONVERT(TypeName,typename)                                          \
mgcElement::                                                                \
operator typename ()                                                        \
{                                                                           \
	typename value = 0;                                                     \
	mgcElementDBM::EFconvert convert =                                      \
		mgcElementDBM::record[type].convert_to[TypeName::type];             \
	if ( convert )                                                          \
		convert(1,data,&value);                                             \
	return value;                                                           \
}

CONVERT(mgcChar,char);
CONVERT(mgcUchar,unsigned char);
CONVERT(mgcShort,short);
CONVERT(mgcUshort,unsigned short);
CONVERT(mgcInt,int);
CONVERT(mgcUint,unsigned int);
CONVERT(mgcLong,long);
CONVERT(mgcUlong,unsigned long);
CONVERT(mgcFloat,float);
CONVERT(mgcDouble,double);
//---------------------------------------------------------------------------
#define ASSIGN(TypeName,typename)                                           \
mgcElement& mgcElement::                                                    \
operator= (typename value)                                                  \
{                                                                           \
	mgcElementDBM::EFconvert convert =                                      \
		mgcElementDBM::record[TypeName::type].convert_to[type];             \
	if ( convert )                                                          \
		convert(1,&value,data);                                             \
	return *this;                                                           \
}

ASSIGN(mgcChar,char);
ASSIGN(mgcUchar,unsigned char);
ASSIGN(mgcShort,short);
ASSIGN(mgcUshort,unsigned short);
ASSIGN(mgcInt,int);
ASSIGN(mgcUint,unsigned int);
ASSIGN(mgcLong,long);
ASSIGN(mgcUlong,unsigned long);
ASSIGN(mgcFloat,float);
ASSIGN(mgcDouble,double);
//---------------------------------------------------------------------------
#define COMPARE(TypeName,typename)                                          \
int mgcElement::                                                            \
operator== (typename value)                                                 \
{                                                                           \
	if ( type != TypeName::type )                                           \
		return 0;                                                           \
																			\
	char* op1 = (char*)data;                                                \
	char* op2 = (char*)&value;                                              \
	for (int i = 0; i < TypeName::size; i++, op1++, op2++)                  \
		if ( *op1 != *op2 )                                                 \
			return 0;                                                       \
																			\
	return 1;                                                               \
}

COMPARE(mgcChar,char);
COMPARE(mgcUchar,unsigned char);
COMPARE(mgcShort,short);
COMPARE(mgcUshort,unsigned short);
COMPARE(mgcInt,int);
COMPARE(mgcUint,unsigned int);
COMPARE(mgcLong,long);
COMPARE(mgcUlong,unsigned long);
COMPARE(mgcFloat,float);
COMPARE(mgcDouble,double);
//===========================================================================