// GlobalObject.cpp: implementation of the CGlobalObject class.
//
//////////////////////////////////////////////////////////////////////

//#include "render_inc.h"
#include "GlobalObject.h"
// added by CCKAO
#include <iomanip>
#include <math.h>
//#include <strstream>
#include "../../Node/DEBUG.H"

using namespace std;

//////////////////////////////////////////////////////////////////////////
// System Global Object [1/20/2002]
// Fei-tian
//////////////////////////////////////////////////////////////////////////

VsSystemObject::VsSystemObject()
{
	static VsObjectSymbolTable tbl[] = {
		_ENTRY(Out)
		_ENTRY(In)
		_ENTRY_END
	};
	m_tbl = tbl;
}

VsValue VsSystemObject::Assign(int member, const VsValue &v)
{
	return VsValue(0.0);
}

void VsSystemObject::Evaluate(int member, VsValue& value, VsExprList &args, VsFunctionCall *parent)
{
	value.SetVoid();

	VsValue var;
	if (args.size() > 0)
		var = args[0]->evaluate(parent);

	switch(member)
	{
	case fOut:
		if (var.GetType() == VsValue::vSTRING)
		{
			bool specChar = false;
			for (int i = 0; i < strlen(var.GetString()); i++)
			{
				if (specChar)
				{
					switch(var.GetString()[i])
					{
					case 'n':
						printf("\n");
						break;
					case 'r':
						printf("\r");
						break;
					case 't':
						printf("\t");
						break;
					case '\\':
						printf("\\");
						break;
					}
					specChar = false;
				}
				else
				{
					if (var.GetString()[i] == '\\')
						specChar = true;
					else
						printf("%c", var.GetString()[i]);
				}
			}
		}
		else if (var.GetType() == VsValue::vNUMBER) {
			printf("%f", var.GetNumber());
		}
		break;

	case fIn:
		{
			static char temp[256];
			scanf("%s", temp);
			value.SetString( temp );
		}
		break;
	}
}


//////////////////////////////////////////////////////////////////////////
// Math Global Object [1/20/2002]
// Fei-tian
//////////////////////////////////////////////////////////////////////////

VsMathObject::VsMathObject()
{
	static VsObjectSymbolTable tbl[] = {
		// property
		_ENTRY(E)		_ENTRY(LN10)		_ENTRY(LN2)
		_ENTRY(PI)		_ENTRY(SQRT1_2)		_ENTRY(SQRT2)
		// member
		_ENTRY(abs)		_ENTRY(acos)		_ENTRY(asin)
		_ENTRY(atan)	_ENTRY(ceil)		_ENTRY(cos)
		_ENTRY(exp)		_ENTRY(floor)		_ENTRY(log)
		_ENTRY(max)		_ENTRY(min)			_ENTRY(pow)
		_ENTRY(random)	_ENTRY(round)		_ENTRY(sin)
		_ENTRY(sqrt)	_ENTRY(tan)			_ENTRY(fabs)
		_ENTRY_END
	};
	m_tbl = tbl;
}

VsValue VsMathObject::Assign(int member, const VsValue &v)
{
	return VsValue(0.0);
}

void VsMathObject::Evaluate(int member, VsValue& value, VsExprList &args, VsFunctionCall *parent)
{
	value.SetVoid();

	VsValue arg0(0.0), arg1(0.0);
	
	if (args.size() > 0)
		arg0 = args[0]->evaluate(parent);

	if (args.size() > 1)
		arg1 = args[1]->evaluate(parent);

	switch(member)
	{
	case fE:
		value.SetNumber( 2.7182818284590452354 );
		break;
	case fLN10:
		value.SetNumber( 2.30258509299404568402 );
		break;
	case fLN2:
		value.SetNumber( 0.69314718055994530942 );
		break;
	case fPI:
		value.SetNumber( 3.1415926535897932384626433832795 );
		break;
	case fSQRT1_2:
		value.SetNumber( 1.41421356237309504880 );
		break;
	case fSQRT2:
		value.SetNumber( 1.41421356237309504880 );
		break;
	case fabs:
		value.SetNumber( fabs(arg0.GetNumber()) );
		break;
	case ffabs:
		value.SetNumber( fabs(arg0.GetNumber()) );
		break;
	case facos:
		value.SetNumber( acos(arg0.GetNumber()) );
		break;
	case fasin:
		value.SetNumber( asin(arg0.GetNumber()) );
		break;
	case fatan:
		value.SetNumber( atan(arg0.GetNumber()) );
		break;
	case fceil:
		value.SetNumber( ceil(arg0.GetNumber()) );
		break;
	case fcos:
		value.SetNumber( cos(arg0.GetNumber()) );
		break;
	case fexp:
		value.SetNumber( exp(arg0.GetNumber()) );
		break;
	case ffloor:
		value.SetNumber( floor(arg0.GetNumber()) );
		break;
	case flog:
		value.SetNumber( log(arg0.GetNumber()) );
		break;
	case fmax:
		value.SetNumber( max(arg0.GetNumber(), arg1.GetNumber()) );
		break;
	case fmin:
		value.SetNumber( min(arg0.GetNumber(), arg1.GetNumber()) );
		break;
	case fpow:
		value.SetNumber( pow(arg0.GetNumber(), arg1.GetNumber()) );
		break;
	case frandom:
		value.SetNumber( double(rand()) / RAND_MAX );
		break;
	case fround:
		value.SetNumber( floor(arg0.GetNumber() + 0.5) );
		break;
	case fsin:
		value.SetNumber( sin(arg0.GetNumber()) );
		break;
	case fsqrt:
		value.SetNumber( sqrt(arg0.GetNumber()) );
		break;
	case ftan:
		value.SetNumber( tan(arg0.GetNumber()) );
		break;
	default:
		ASSERT(false);
	}
}


//////////////////////////////////////////////////////////////////////////
// Browser Global Object [12/11/2002]
// Cardy
//////////////////////////////////////////////////////////////////////////

VsBrowserObject::VsBrowserObject()
{
	static VsObjectSymbolTable tbl[] = {
		_ENTRY(getName)					_ENTRY(getVersion)
		_ENTRY(getCurrentSpeed)			_ENTRY(getCurrentFrameRate)
		_ENTRY(getWorldURL)				_ENTRY(replaceWorld)
		_ENTRY(createVrmlFromString)	_ENTRY(createVrmlFromURL)
		_ENTRY(addRoute)				_ENTRY(deleteRoute)
		_ENTRY(loadURL)					_ENTRY(setDescription)
		_ENTRY_END
	};
	m_tbl = tbl;
}

VsValue VsBrowserObject::Assign(int member, const VsValue &v)
{
	return VsValue(0.0);
}

void VsBrowserObject::Evaluate(int member, VsValue& value, VsExprList &args, VsFunctionCall *parent)
{
}

//////////////////////////////////////////////////////////////////////////
// CameraTrack Global Object [1/20/2002]
// Fei-tian, balama
//////////////////////////////////////////////////////////////////////////
/*
VsCameraTrackObject::VsCameraTrackObject()
{
	static VsObjectSymbolTable tbl[] = {
		_ENTRY(Enable)
		_ENTRY(Disable)
		_ENTRY(Update)
		_ENTRY(GetPosition)
		_ENTRY(GetOrientation)
		_ENTRY_END
	};
	m_tbl = tbl;
}

VsValue VsCameraTrackObject::Assign(int member, const VsValue &v)
{
	return VsValue(0.0);
}

void VsCameraTrackObject::Evaluate(int member, VsValue& value, VsExprList &args, VsFunctionCall *parent)
{
	value.SetVoid();

	switch(member)
	{
	case fEnable:
		{
			SFVec3f*	viewPointPosition		= NULL;
			SFRotation*	viewPointOrientation	= NULL;
			SFVec3f*	targetPosition			= NULL;
			SFRotation*	targetOrientation		= NULL;
			double scale = 1.0;

			if (!(	GetFieldArg(viewPointPosition,		0) &&
					GetFieldArg(viewPointOrientation,	1) &&
					GetFieldArg(targetPosition,			2) &&
					GetFieldArg(targetOrientation,		3) &&
					GetNumberArg(scale,					4)))
				return;

			// todo: call CameraTrack::InitCameraAutoTrack()
			DVector v;
			double* const vp = v.Vec();
			double* dp;

			DMatrix sj_coord, cam_coord;
			double  sj_height;
			//fill parameters
			vp[0] = targetOrientation->GetX();
			vp[1] = targetOrientation->GetY();
			vp[2] = targetOrientation->GetZ();
			vp[3] = targetOrientation->GetANGLE() * DM_RADIAN_TO_DEGREE;
			sj_coord.RotateAboutVector(v);
			dp = sj_coord.Mat();
			dp[ 3] = targetPosition->GetX();
			dp[ 7] = targetPosition->GetY();
			dp[11] = targetPosition->GetZ();
			
			vp[0] = viewPointOrientation->GetX();
			vp[1] = viewPointOrientation->GetY();
			vp[2] = viewPointOrientation->GetZ();
			vp[3] = viewPointOrientation->GetANGLE() * DM_RADIAN_TO_DEGREE;
			cam_coord.RotateAboutVector(v);
			dp = cam_coord.Mat();
			dp[ 3] = viewPointPosition->GetX();
			dp[ 7] = viewPointPosition->GetY();
			dp[11] = viewPointPosition->GetZ();
			cam_coord.InverseQuick();

			sj_height = scale;

			m_cameraTrack.InitCameraAutoTrack(0, sj_coord, sj_height, cam_coord);
		}
		break;
	case fDisable:
		{
			// todo: call CameraTrack::DisableCameraTrack()
			m_cameraTrack.DisableCameraAutoTrack();
		}
		break;
	case fUpdate:
		{
			SFVec3f*	targetPosition		= NULL;
			SFRotation*	targetOrientation	= NULL;

			if (!(GetFieldArg(targetPosition,	 0) &&
				  GetFieldArg(targetOrientation, 1)))
				return;

			// todo: call CameraTrack::ApplyCameraTrack()
			DVector v;
			double* const vp = v.Vec();
			double* dp;

			DMatrix sj_coord;
			//fill parameters
			vp[0] = targetOrientation->GetX();
			vp[1] = targetOrientation->GetY();
			vp[2] = targetOrientation->GetZ();
			vp[3] = targetOrientation->GetANGLE() * DM_RADIAN_TO_DEGREE;
			sj_coord.RotateAboutVector(v);
			dp = sj_coord.Mat();
			dp[ 3] = targetPosition->GetX();
			dp[ 7] = targetPosition->GetY();
			dp[11] = targetPosition->GetZ();

			m_cameraTrackResult = m_cameraTrack.ApplyCameraAutoTrack(0, sj_coord);
			m_cameraTrackResult.InverseQuick();
		}
		break;
	case fGetPosition:
		{
			// todo : set m_cameraPosition;
			//NOTE: only valid after CameraTrack::ApplyCameraTrack() is called
			double* dp = m_cameraTrackResult.Mat();

			m_cameraPosition.SetX(dp[ 3]);
			m_cameraPosition.SetY(dp[ 7]);
			m_cameraPosition.SetZ(dp[11]);

			value.SetField( &m_cameraPosition );
		}
		break;
		
	case fGetOrientation:
		{
			// todo : set m_cameraOrientation;
			//NOTE: only valid after CameraTrack::ApplyCameraTrack() is called
			DVector v,q;
			double* const vp = v.Vec();
			double* const qp = q.Vec();
			MatToQuat(m_cameraTrackResult, q);
			QuatToRotationVector(q, v);

			m_cameraOrientation.SetX(vp[0]);
			m_cameraOrientation.SetY(vp[1]);
			m_cameraOrientation.SetZ(vp[2]);
			m_cameraOrientation.SetANGLE(vp[3] * DM_DEGREE_TO_RADIAN);
			
			value.SetField( &m_cameraOrientation );
		}
		break;
	}
}
*/
//////////////////////////////////////////////////////////////////////////
// CameraControl Global Object [Mar/07/2002]
// balama
//////////////////////////////////////////////////////////////////////////
/*
VsCameraControlObject::VsCameraControlObject()
{
	static VsObjectSymbolTable tbl[] = {
		_ENTRY(SetParameter)
		_ENTRY(InsertCameraPath)
		_ENTRY(SwitchToPath)
		_ENTRY(SwitchToMode)
		_ENTRY(Update)
		_ENTRY(GetPosition)
		_ENTRY(GetOrientation)
		_ENTRY(GetMode)
		_ENTRY(FollowObject)
		_ENTRY_END
	};
	m_tbl = tbl;
}

VsValue VsCameraControlObject::Assign(int member, const VsValue &v)
{
	return VsValue(0.0);
}

void VsCameraControlObject::Evaluate(int member, VsValue& value, VsExprList &args, VsFunctionCall *parent)
{
	value.SetVoid();

	switch(member)
	{
	case fSetParameter:
		{
			std::string	param_name;
			double		param_value;
			
			if (!(	GetStrArg	(param_name,	0) &&
					GetNumberArg(param_value,	1) ))
				return;
			
			m_cameraControl.SetParameter(param_name.c_str(), param_value);
		}
		break;

	case fInsertCameraPath:
		{
			std::string path_url;
			std::string cam_name;
			std::string local;

			if (!(	GetStrArg(path_url, 0) &&
					GetStrArg(cam_name, 1) &&
					GetStrArg(local,    2) ))
				return;

			bool fLocal = true;
			if (stricmp(local.c_str(), "true") == 0)
				fLocal = true;
			else if (stricmp(local.c_str(), "false") == 0)
				fLocal = false;
			else
				return;

			CameraControl::CCStatus stat;
			bool fResult = 
			m_cameraControl.InsertCameraPathFromMemory(	
				(const BYTE *)path_url.c_str(),
				cam_name.c_str(),
				fLocal, &stat
			);
		}
		break;

	case fSwitchToPath:
		{
			std::string cam_name;
			SFVec3f*	objectPosition		= NULL;
			SFRotation*	objectOrientation	= NULL;
			std::string immediate;
			double		playback_time = 0.0;
			double		tm;

			if (!(	GetStrArg	(cam_name,			0) &&
					GetFieldArg	(objectPosition,	1) &&
					GetFieldArg	(objectOrientation,	2) &&
					GetNumberArg(playback_time,		3) &&
					GetStrArg	(immediate,			4) &&
					GetNumberArg(tm,				5) ))
				return;

			bool fImmediate = true;
			if (stricmp(immediate.c_str(), "true") == 0)
				fImmediate = true;
			else if (stricmp(immediate.c_str(), "false") == 0)
				fImmediate = false;
			else
				return;

			double obj_transl[4];
			double obj_orient[4];
			obj_transl[0] = objectPosition->GetX();
			obj_transl[1] = objectPosition->GetY();
			obj_transl[2] = objectPosition->GetZ();
			obj_orient[0] = objectOrientation->GetX();
			obj_orient[1] = objectOrientation->GetY();
			obj_orient[2] = objectOrientation->GetZ();
			obj_orient[3] = objectOrientation->GetANGLE();

			bool fResult = 
			m_cameraControl.SwitchToPath(cam_name.c_str(),
										 obj_transl,
										 obj_orient,
										 playback_time,
										 !fImmediate,//fPathFinding
										 tm);

		}
		break;
	
	case fSwitchToMode:
		{
			std::string	mode;
			std::string immediate;
			SFVec3f*	objectPosition		= NULL;
			SFRotation*	objectOrientation	= NULL;
			SFVec3f*	cameraPosition		= NULL;
			SFRotation*	cameraOrientation	= NULL;
			double		height = 1.0;
			double		tm;

			if (!(	GetStrArg   (mode,				0) &&
					GetFieldArg (objectPosition,	1) &&
					GetFieldArg (objectOrientation,	2) &&
					GetFieldArg (cameraPosition,	3) &&
					GetFieldArg (cameraOrientation,	4) &&
					GetNumberArg(height,			5) &&
					GetStrArg	(immediate,			6) &&
					GetNumberArg(tm,				7) ))
				return;
			
			CameraControl::Mode cam_mode = CameraControl::kNone;
			if (stricmp(mode.c_str(), "none") == 0)
				cam_mode = CameraControl::kNone;
			else if (stricmp(mode.c_str(), "follow") == 0)
				cam_mode = CameraControl::kFollow;
			else
				return;

			bool fImmediate = true;
			if (stricmp(immediate.c_str(), "true") == 0)
				fImmediate = true;
			else if (stricmp(immediate.c_str(), "false") == 0)
				fImmediate = false;
			else
				return;
			
			double obj_transl[4];
			double obj_orient[4];
			double cam_transl[4];
			double cam_orient[4];
			obj_transl[0] = objectPosition->GetX();
			obj_transl[1] = objectPosition->GetY();
			obj_transl[2] = objectPosition->GetZ();
			obj_orient[0] = objectOrientation->GetX();
			obj_orient[1] = objectOrientation->GetY();
			obj_orient[2] = objectOrientation->GetZ();
			obj_orient[3] = objectOrientation->GetANGLE();

			cam_transl[0] = cameraPosition->GetX();
			cam_transl[1] = cameraPosition->GetY();
			cam_transl[2] = cameraPosition->GetZ();
			cam_orient[0] = cameraOrientation->GetX();
			cam_orient[1] = cameraOrientation->GetY();
			cam_orient[2] = cameraOrientation->GetZ();
			cam_orient[3] = cameraOrientation->GetANGLE();

			bool fResult = 
			m_cameraControl.SwitchToMode(	cam_mode,
											obj_transl,
											obj_orient,
											cam_transl,
											cam_orient,
											height,
											!fImmediate, //fPathFinding
											tm);
		}
		break;

	case fUpdate:
		{
			SFVec3f*	objectPosition		= NULL;
			SFRotation*	objectOrientation	= NULL;
			double		tm;

			if (!(GetFieldArg (objectPosition,		0) &&
				  GetFieldArg (objectOrientation,	1) &&
				  GetNumberArg(tm,					2) ))
				return;

			double obj_transl[4];
			double obj_orient[4];
			obj_transl[0] = objectPosition->GetX();
			obj_transl[1] = objectPosition->GetY();
			obj_transl[2] = objectPosition->GetZ();
			obj_orient[0] = objectOrientation->GetX();
			obj_orient[1] = objectOrientation->GetY();
			obj_orient[2] = objectOrientation->GetZ();
			obj_orient[3] = objectOrientation->GetANGLE();

			m_cameraControl.GetCameraCoordinate(obj_transl, 
												obj_orient,
												tm,
												m_cam_transl, 
												m_cam_orient);
			m_cameraPosition.SetX((float)m_cam_transl[0]);
			m_cameraPosition.SetY((float)m_cam_transl[1]);
			m_cameraPosition.SetZ((float)m_cam_transl[2]);

			m_cameraOrientation.SetX	((float)m_cam_orient[0]);
			m_cameraOrientation.SetY	((float)m_cam_orient[1]);
			m_cameraOrientation.SetZ	((float)m_cam_orient[2]);
			m_cameraOrientation.SetANGLE((float)m_cam_orient[3]);
		}
		break;
	case fGetPosition:
		{
			value.SetField( &m_cameraPosition );
		}
		break;
	case fGetOrientation:
		{
			value.SetField( &m_cameraOrientation );
		}
		break;
	case fGetMode:
		{
			strcpy(m_mode_str, m_cameraControl.GetModeStr());
			value.AllocString(m_mode_str);
		}
		break;
	case fFollowObject:
		{
			SFVec3f*	objectPosition		= NULL;
			SFRotation*	objectOrientation	= NULL;
			if (!(GetFieldArg (objectPosition,		0) &&
				  GetFieldArg (objectOrientation,	1) ))
				return;
			
			double obj_transl[4];
			double obj_orient[4];
			obj_transl[0] = objectPosition->GetX();
			obj_transl[1] = objectPosition->GetY();
			obj_transl[2] = objectPosition->GetZ();
			obj_orient[0] = objectOrientation->GetX();
			obj_orient[1] = objectOrientation->GetY();
			obj_orient[2] = objectOrientation->GetZ();
			obj_orient[3] = objectOrientation->GetANGLE();

			m_cameraControl.FollowObject(obj_transl, obj_orient);
		}
		break;
	}
}
*/
//////////////////////////////////////////////////////////////////////////
// MapGrid Object [Mar/01/2002]
// balama
//////////////////////////////////////////////////////////////////////////
/*
VsMapGridObject::VsMapGridObject()
{
	static VsObjectSymbolTable tbl[] = {
		_ENTRY(SetPosition)
		_ENTRY(SetDirection)
		_ENTRY(Step)
		_ENTRY(GetLabel)
		_ENTRY(GetXGrid)
		_ENTRY(GetZGrid)
		_ENTRY(GetDir)
		_ENTRY(Block)
		_ENTRY(UnBlock)
		_ENTRY_END
	};
	m_tbl = tbl;

	m_label = 0;
	m_grid.GetPosition	(m_x_grid, m_z_grid);
	m_grid.GetDirection	(m_dir);
}

VsValue VsMapGridObject::Assign(int member, const VsValue &v)
{
	return VsValue(0.0);
}

void VsMapGridObject::Evaluate(int member, VsValue& value, VsExprList &args, VsFunctionCall *parent)
{
	value.SetVoid();

	switch(member)
	{
	case fSetPosition:
		{
			double xGrid,zGrid;

			if (!(	GetNumberArg(xGrid,	0) &&
					GetNumberArg(zGrid,	1)  ))
				return;

			if (m_grid.SetPosition((int)xGrid, (int)zGrid))
			{
				m_grid.GetPosition(m_x_grid, m_z_grid);
			}
		}
		break;
	
	case fSetDirection:
		{
			MapGrid::Direction	dir = MapGrid::kNegZ;
			std::string			dir_str;
			char				dir_buf[8];

			if (!(GetStrArg(dir_str, 0)))
				return;
			
			strncpy(dir_buf, dir_str.c_str(),7);
			if (strlen(dir_buf) != 2) return;

			if		(stricmp(dir_buf,"+x") == 0)
				dir = MapGrid::kPosX;
			else if (stricmp(dir_buf,"-x") == 0)
				dir = MapGrid::kNegX;
			else if (stricmp(dir_buf,"+z") == 0)
				dir = MapGrid::kPosZ;
			else if (stricmp(dir_buf,"-z") == 0)
				dir = MapGrid::kNegZ;

			if (m_grid.SetDirection(dir))
			{
				m_grid.GetDirection(m_dir);
			}
		}
		break;

	case fStep:
		{
			m_grid.Step(m_label, m_x_grid, m_z_grid, m_dir);
		}
		break;
	
	case fGetLabel:
		{
			value.SetNumber( m_label );
		}
		break;

	case fGetXGrid:
		{
			value.SetNumber( m_x_grid );
		}
		break;

	case fGetZGrid:
		{
			value.SetNumber( m_z_grid );
		}
		break;

	case fGetDir:
		{
			double radian = 0.0;
			switch (m_dir)
			{
				case MapGrid::kPosZ:
						radian = 0.0;
						break;
				case MapGrid::kPosX:
						radian = 0.5;	// 0.5*PI
						break;
				case MapGrid::kNegZ:
						radian = 1;		// PI
						break;
				case MapGrid::kNegX:
						radian = 1.5;	// 1.5*PI
						break;
			}
			value.SetNumber( radian );
		}
		break;

	case fBlock:
		{
			double xGrid,zGrid;
			int blockedLabel;

			if (!(	GetNumberArg(xGrid,	0) &&
					GetNumberArg(zGrid,	1)  ))
				return;

			m_grid.Block(xGrid, zGrid, blockedLabel);

			value.SetNumber( blockedLabel );
		}
		break;
	
	case fUnBlock:
		{
			double xGrid,zGrid,label;

			if (!(	GetNumberArg(xGrid,	0) &&
					GetNumberArg(zGrid,	1) &&
					GetNumberArg(label, 2) ))
				return;

			m_grid.UnBlock(xGrid, zGrid, label);
		}
		break;
	}
}
*/
//////////////////////////////////////////////////////////////////////////
// AnsiString (String utility functions) Global Object [Mar/12/2002]
// CCKAO
//////////////////////////////////////////////////////////////////////////
/*
template<class T>
string StringConv(const T& obj)
{
    ostrstream os;
    os << obj << '\0';
    return string(os.str());

}

string StringConv(const double& dle, const int width)
{   
    ostrstream os;
    os << setprecision(width) << dle << '\0';
    return std::string(os.str());
}

VsAnsiStringObject::VsAnsiStringObject()
{
	static VsObjectSymbolTable tbl[] = {
		// property
		// member
		_ENTRY(FromInt32)
		_ENTRY(FromFloat)
		_ENTRY(AddString)
		_ENTRY(CheckLength)
		_ENTRY(CheckLength2)
		_ENTRY(CheckLength3)
		_ENTRY_END
	};
	m_tbl = tbl;
}

VsValue VsAnsiStringObject::Assign(int member, const VsValue &v)
{
	return VsValue(0.0);
}

void VsAnsiStringObject::Evaluate(int member, VsValue& value, VsExprList &args, VsFunctionCall *parent)
{
	double		arg0;
	string		str, str_par2;
	static char	strBuf[40];

 //	Memory leak are caused in StringConv func
 
	switch(member)
	{
		case fFromInt32:
			if (args.size() == 1) GetNumberArg(arg0, 0); 
			else return;

			arg0 = floor(arg0);
			sprintf(strBuf, "%d", (int) arg0);
			value.AllocString(strBuf);
			break;
		
		case fFromFloat:
			if (args.size() == 1) GetNumberArg(arg0, 0); 
			else return;
			
			sprintf(strBuf, "%10lf", arg0);
			value.AllocString(strBuf);
			break;

		case fAddString:
			if (args.size() == 2) {
				GetStrArg(str, 0); 
				GetStrArg(str_par2, 1);
			} else return;

			str += str_par2;

			value.AllocString(str.c_str());
			break;

		case fCheckLength:
		{
			if (args.size() == 2) {
				GetStrArg(str, 0);
				GetNumberArg(arg0, 1);
			}
			else return;
			
			int i, j, len = (int)(floor(arg0));
			i = str.length();
			while (i>=len)
			{
				j = i/len;
				str.insert(j*len, "\n");
				i-=len;
			}
			value.AllocString(str.c_str());
			break;
		}

		case fCheckLength2:
		{
			if (args.size() == 2) {
				GetStrArg(str, 0);
				GetNumberArg(arg0, 1);
			}
			else return;

			int pos1 = 0, pos2 = 0, crlf = 0, len = (int)(floor(arg0));
			while ((pos1 = str.find(' ', pos1+1)) != std::string::npos)
			{
				if (pos1 > (crlf + len))	{
					str[pos2] = '\n';
					crlf = pos2;
				}
				pos2 = pos1;
			}
			if (str.length() > (crlf + len))
				str[pos2] = '\n';
			value.AllocString(str.c_str());
			break;
		}
		case fCheckLength3:
		{
			MFString* mfs = NULL;
			if (args.size() == 3) {
				GetStrArg(str, 0);
				GetFieldArg(mfs, 1);
				GetNumberArg(arg0, 2);
			}
			else return;

			mfs->Clear();

			int len = (int)(floor(arg0));
			int slen = str.length();
			for (int k = 0; k < (slen + len - 1) / len; k++)
			{
				mfs->InsertValue(mfs->GetSize(), str.substr(k * len, len));
			}
			value.AllocString(str.c_str());
			break;
		}
	}
}
*/
//////////////////////////////////////////////////////////////////////////
// HttpFile Global Object [Mar/22/2002]
// KEIN
//////////////////////////////////////////////////////////////////////////
/*
VsHttpFileObject::VsHttpFileObject()
{
	static VsObjectSymbolTable tbl[] = {
		// property
		// member
		_ENTRY(Connect)
		_ENTRY(OpenRequest)		
		_ENTRY(ReadString)
		_ENTRY(CloseRequest)
		_ENTRY(Disconnect)
		
		_ENTRY_END
	};
	m_tbl = tbl;
	m_tearKey = 0;
}

VsHttpFileObject::~VsHttpFileObject()
{
	TearMap::iterator iter = m_tearmap.begin();
	for (; iter!=m_tearmap.end(); iter++)
		delete iter->second;
}

VsValue VsHttpFileObject::Assign(int member, const VsValue &v)
{
	return VsValue(0.0);
}

void VsHttpFileObject::Evaluate(int member, VsValue& value, VsExprList &args, VsFunctionCall *parent)
{	
	string str,str1,course,level,question;
	double arg0,arg1;
	int mapkey,i;
	ITear* Tear;
	
	switch (member)
	{
	case fConnect:						//Connect to a MySQL Server				
		GetStrArg(SERVERNAME, 0);
		GetNumberArg(arg0,1);
		port=(int)arg0;
		break;

	case fOpenRequest:					//Get a text file from th server
		GetStrArg(course, 0);
		GetNumberArg(arg0, 1);
		GetNumberArg(arg1, 2);

		i=(int)arg0;
		level = StringConv(i);

		i=(int)arg1;
		question = StringConv(i);

		Tear = CreateObject();

		if( Tear->OpenRequest(course.c_str(), level.c_str(), question.c_str(), SERVERNAME.c_str(), port) == S_OK )
		{
			m_tearmap.insert( TearMap::value_type( ++m_tearKey , Tear ) );
			value.SetNumber( m_tearKey );
		}
		else
			value.SetNumber( 0 );
		
		break;

		
	case fReadString:					//Read a string from the file

		GetNumberArg(arg0, 0); 
		mapkey = (int)arg0;

		m_tearIt = m_tearmap.find( mapkey );

		if(m_tearIt != m_tearmap.end() )
		{
			Tear = (*m_tearIt).second;
			Tear->ReadString(str1);

			value.AllocString(str1.c_str());
		}
		else
		{
			value.SetNumber( 0 );
		}
		break;

	case fCloseRequest:					//Close the file
		GetNumberArg(arg0,0);
		mapkey = (int)arg0;
		m_tearIt = m_tearmap.find( mapkey );
		if(m_tearIt != m_tearmap.end() )
		{
			Tear = (*m_tearIt).second;
			delete Tear;
		}
		m_tearmap.erase(m_tearIt);		
		break;

	case fDisconnect:					//Disconnect from the server
		for(m_tearIt = m_tearmap.begin() ; m_tearIt != m_tearmap.end() ; m_tearIt = m_tearmap.erase(m_tearIt))
		{
			Tear = (*m_tearIt).second;
			delete Tear;
		}
		m_tearKey = 0;
		break;
	}
}
*/

//////////////////////////////////////////////////////////////////////////
// Occlusion Detection Global Object [April/23/2002]
// CCKAO
//////////////////////////////////////////////////////////////////////////
/*
VsOCCDetectionObject::VsOCCDetectionObject()
{
	static VsObjectSymbolTable tbl[] = {
		// property
		// member
		_ENTRY(SetFileWO)
		_ENTRY(SetCylinderWO)
		_ENTRY(SetBoxWO)
		_ENTRY(ifOcclusion)
		_ENTRY_END
	};
	m_tbl = tbl;
}

VsValue VsOCCDetectionObject::Assign(int member, const VsValue &v)
{
	return VsValue(0.0);
}

void VsOCCDetectionObject::Evaluate(int member, VsValue& value, VsExprList &args, VsFunctionCall *parent)
{
	SFVec3f*	center	= NULL;
	SFVec3f*	size	= NULL;
	SFVec3f*	vpPosition	= NULL;
	SFVec3f*	tgPosition	= NULL;
	std::string	objfile;

	switch(member)
	{
	case fSetFileWO:
		if (!GetStrArg(objfile, 0)) return;
		m_occDetection.SetWatchObjects((char*)objfile.c_str());
		break;
	
	case fSetCylinderWO:
		if (!(GetFieldArg(center, 0) && GetNumberArg(radius, 1) && GetNumberArg(height, 2))) 
			return;
		
		objCenter[0] = center->GetX();
		objCenter[1] = center->GetY();
		objCenter[2] = center->GetZ();
		m_occDetection.SetWatchObjects(objCenter, radius, height);
		break;

	case fSetBoxWO:
		if (!(GetFieldArg(center, 0) && GetFieldArg(size, 1))) return;
		
		objCenter[0] = center->GetX();
		objCenter[1] = center->GetY();
		objCenter[2] = center->GetZ();
		objSize[0] = size->GetX();
		objSize[1] = size->GetY();
		objSize[2] = size->GetZ();
		m_occDetection.SetWatchObjects(objCenter, objSize);
		break;

	case fifOcclusion:
		if (!(GetFieldArg(vpPosition, 0) && GetFieldArg(tgPosition, 1))) return;
		
		viewPoint[0] = vpPosition->GetX();
		viewPoint[1] = vpPosition->GetY();
		viewPoint[2] = vpPosition->GetZ();
		targetObj[0] = tgPosition->GetX();
		targetObj[1] = tgPosition->GetY();
		targetObj[2] = tgPosition->GetZ();
		value.SetBool(m_occDetection.ifOcclusion(viewPoint, targetObj));
		break;
	}
}
*/