chvrmlevent.cpp

Windows上的MUD客户端程序

// ChVec3fEvent
ChVec3fEvent::ChVec3fEvent(const string &name, float vec[3]) : 
	ChIVrmlEvent(ChVRMLEvent::SFVec3f, name)
{
	AppendData(vec);
}
ChVec3fEvent::ChVec3fEvent(const string &name, float x, float y, float z) : 
	ChIVrmlEvent(ChVRMLEvent::SFVec3f, name)
{
	AppendData(x, y, z);
}

ChVec3fEvent::ChVec3fEvent(const string &name, int count, float *values) :
	ChIVrmlEvent(ChVRMLEvent::SFVec3f, name)
{
	AppendData(count, values);
}

ChVec3fEvent::ChVec3fEvent(const ChVec3fEvent &event) : 
	ChIVrmlEvent()
{
	Copy(event);
}

ChVec3fEvent::ChVec3fEvent(const ChVRMLEvent &event) : 
	ChIVrmlEvent()
{
	Copy(event);
}

ChVec3fEvent::~ChVec3fEvent() {}

int ChVec3fEvent::AppendData(float vec[3])
{
	return AppendData(vec[0], vec[1], vec[2]);
}
             
int ChVec3fEvent::AppendData(float x, float y, float z)
{
	int iNext = GetCount() * 3;	 // 3 floats per datum
	if(!SetSize(m_dataSize + (sizeof(float) * 3))) return false;

	float *pData = (float*)m_bytes;
	pData += iNext;

	*pData++ = x;
	*pData++ = y;
	*pData++ = z;
	return 1;
} 
int ChVec3fEvent::AppendData(int count, float *values)
{
	int iNext = GetCount() * 3;
	if(!SetSize(m_dataSize + count * (sizeof(float) * 3))) return false;
	float *pData = (float*)m_bytes;
	pData += iNext;

	for(int i = 0; i < count * 3; i++)
	{
		*pData++ = *values++;
	}

	return 1;
} 
int ChVec3fEvent::GetCount()
{
	return m_dataSize / (sizeof(float) * 3);
}
bool ChVec3fEvent::GetValue(int index, float vec[3])
{
	if(index >= GetCount()) return false;
	float *pData = (float*)m_bytes;

	pData += index;
	for(int i = 0; i < 3; i++) vec[i] = *pData++;
	return true;
}
bool ChVec3fEvent::GetValue(float vec[3])
{
	return GetValue(0, vec);
}


// ChLongEvent
ChLongEvent::ChLongEvent(const string &name, long value) : 
	ChIVrmlEvent(ChVRMLEvent::SFLong, name)
{
	AppendData(value);
}

ChLongEvent::ChLongEvent(const string &name, int count, long *values) :
	ChIVrmlEvent(ChVRMLEvent::SFLong, name)
{
	AppendData(count, values);
}

ChLongEvent::ChLongEvent(const ChLongEvent &event) : 
	ChIVrmlEvent()
{
	Copy(event);
}

ChLongEvent::ChLongEvent(const ChVRMLEvent &event) : 
	ChIVrmlEvent()
{
	Copy(event);
}

ChLongEvent::~ChLongEvent() {}

             
int ChLongEvent::AppendData(long value)
{
	int iNext = GetCount();	 // 1 longs per datum
	if(!SetSize(m_dataSize + (sizeof(long)))) return false;

	long *pData = (long*)m_bytes;
	pData += iNext;

	*pData = value;
	return 1;
} 
int ChLongEvent::AppendData(int count, long *values)
{
	int iNext = GetCount();
	if(!SetSize(m_dataSize + count * (sizeof(long)))) return false;
	long *pData = (long*)m_bytes;
	pData += iNext;

	for(int i = 0; i < count; i++)
	{
		*pData++ = *values++;
	}

	return 1;
} 
int ChLongEvent::GetCount()
{
	return m_dataSize / (sizeof(long));
}
bool ChLongEvent::GetValue(int index, long &value)
{
	if(index >= GetCount()) return false;
	long *pData = (long*)m_bytes;

	pData += index;
	value = *pData;
	return true;
}
bool ChLongEvent::GetValue(long &value)
{
	return GetValue(0, value);
}

// ChTimeEvent

ChTimeEvent::ChTimeEvent(const string &name, double value) : 
	ChIVrmlEvent(ChVRMLEvent::SFTime, name)
{
	AppendData(value);
}

ChTimeEvent::ChTimeEvent(const string &name, int count, double *values) :
	ChIVrmlEvent(ChVRMLEvent::SFTime, name)
{
	AppendData(count, values);
}

ChTimeEvent::ChTimeEvent(const ChTimeEvent &event) : 
	ChIVrmlEvent()
{
	Copy(event);
}

ChTimeEvent::ChTimeEvent(const ChVRMLEvent &event) : 
	ChIVrmlEvent()
{
	Copy(event);
}

ChTimeEvent::~ChTimeEvent() {}

             
int ChTimeEvent::AppendData(double value)
{
	int iNext = GetCount();	 // 1 doubles per datum
	if(!SetSize(m_dataSize + (sizeof(double)))) return false;

	double *pData = (double*)m_bytes;
	pData += iNext;

	*pData = value;
	return 1;
}
 
int ChTimeEvent::AppendData(int count, double *values)
{
	int iNext = GetCount();
	if(!SetSize(m_dataSize + count * (sizeof(double)))) return false;
	double *pData = (double*)m_bytes;
	pData += iNext;

	for(int i = 0; i < count; i++)
	{
		*pData++ = *values++;
	}

	return 1;
} 
int ChTimeEvent::GetCount()
{
	return m_dataSize / (sizeof(double));
}
bool ChTimeEvent::GetValue(int index, double &value)
{
	if(index >= GetCount()) return false;
	double *pData = (double*)m_bytes;

	pData += index;
	value = *pData;
	return true;
}
bool ChTimeEvent::GetValue(double &value)
{
	return GetValue(0, value);
}
// ChBoolEvent
ChBoolEvent::ChBoolEvent(const string &name, bool value) : 
	ChIVrmlEvent(ChVRMLEvent::SFBool, name)
{
	AppendData(value);
}

ChBoolEvent::ChBoolEvent(const string &name, int count, bool *values) :
	ChIVrmlEvent(ChVRMLEvent::SFBool, name)
{
	AppendData(count, values);
}

ChBoolEvent::ChBoolEvent(const ChBoolEvent &event) : 
	ChIVrmlEvent()
{
	Copy(event);
}

ChBoolEvent::ChBoolEvent(const ChVRMLEvent &event) : 
	ChIVrmlEvent()
{
	Copy(event);
}

ChBoolEvent::~ChBoolEvent() {}

             
int ChBoolEvent::AppendData(bool value)
{
	int iNext = GetCount();	 // 1 bools per datum
	if(!SetSize(m_dataSize + (sizeof(bool)))) return false;

	bool *pData = (bool*)m_bytes;
	pData += iNext;

	*pData = value;
	return 1;
} 
int ChBoolEvent::AppendData(int count, bool *values)
{
	int iNext = GetCount();
	if(!SetSize(m_dataSize + count * (sizeof(bool)))) return false;
	bool *pData = (bool*)m_bytes;
	pData += iNext;

	for(int i = 0; i < count; i++)
	{
		*pData++ = *values++;
	}

	return 1;
} 
int ChBoolEvent::GetCount()
{
	return m_dataSize / (sizeof(bool));
}
bool ChBoolEvent::GetValue(int index, bool &value)
{
	if(index >= GetCount()) return false;
	bool *pData = (bool*)m_bytes;

	pData += index;
	value = *pData;
	return true;
}
bool ChBoolEvent::GetValue(bool &value)
{
	return GetValue(0, value);
}
// ChFloatEvent
ChFloatEvent::ChFloatEvent(const string &name, float value) : 
	ChIVrmlEvent(ChVRMLEvent::SFBool, name)
{
	AppendData(value);
}

ChFloatEvent::ChFloatEvent(const string &name, int count, float *values) :
	ChIVrmlEvent(ChVRMLEvent::SFBool, name)
{
	AppendData(count, values);
}

ChFloatEvent::ChFloatEvent(const ChFloatEvent &event) : 
	ChIVrmlEvent()
{
	Copy(event);
}

ChFloatEvent::ChFloatEvent(const ChVRMLEvent &event) : 
	ChIVrmlEvent()
{
	Copy(event);
}

ChFloatEvent::~ChFloatEvent() {}

             
int ChFloatEvent::AppendData(float value)
{
	int iNext = GetCount();	 // 1 floats per datum
	if(!SetSize(m_dataSize + (sizeof(float)))) return false;

	float *pData = (float*)m_bytes;
	pData += iNext;

	*pData = value;
	return 1;
} 
int ChFloatEvent::AppendData(int count, float *values)
{
	int iNext = GetCount();
	if(!SetSize(m_dataSize + count * (sizeof(float)))) return false;
	float *pData = (float*)m_bytes;
	pData += iNext;

	for(int i = 0; i < count; i++)
	{
		*pData++ = *values++;
	}

	return 1;
} 
int ChFloatEvent::GetCount()
{
	return m_dataSize / (sizeof(float));
}
bool ChFloatEvent::GetValue(int index, float &value)
{
	if(index >= GetCount()) return false;
	float *pData = (float*)m_bytes;

	pData += index;
	value = *pData;
	return true;
}
bool ChFloatEvent::GetValue(float &value)
{
	return GetValue(0, value);
}
// ChMatrixEvent
ChMatrixEvent::ChMatrixEvent(const string &name, ChVrmlMatrix &mat) : 
	ChIVrmlEvent(ChVRMLEvent::SFVec3f, name)
{
	AppendData(mat);
}

ChMatrixEvent::ChMatrixEvent(const string &name, int count, float *values) :
	ChIVrmlEvent(ChVRMLEvent::SFVec3f, name)
{
	AppendData(count, values);
}

ChMatrixEvent::ChMatrixEvent(const ChMatrixEvent &event) : 
	ChIVrmlEvent()
{
	Copy(event);
}

ChMatrixEvent::ChMatrixEvent(const ChVRMLEvent &event) : 
	ChIVrmlEvent()
{
	Copy(event);
}

ChMatrixEvent::~ChMatrixEvent() {}

             
int ChMatrixEvent::AppendData(ChVrmlMatrix &mat)
{
	int iNext = GetCount() * 16;	 // 16 floats per datum
	if(!SetSize(m_dataSize + (sizeof(float) * 16))) return false;

	float *pData = (float*)m_bytes;
	pData += iNext;

	memcpy(pData, &mat, 16 * sizeof(float));
	return 1;
} 
int ChMatrixEvent::AppendData(int count, float *values)
{
	int iNext = GetCount() * 16;
	if(!SetSize(m_dataSize + count * (sizeof(float) * 16))) return false;
	float *pData = (float*)m_bytes;
	pData += iNext;

	for(int i = 0; i < count * 16; i++)
	{
		*pData++ = *values++;
	}

	return 1;
} 
int ChMatrixEvent::GetCount()
{
	return m_dataSize / (sizeof(float) * 16);
}
bool ChMatrixEvent::GetValue(int index, ChVrmlMatrix &mat)
{
	if(index >= GetCount()) return false;
	float *pData = (float*)m_bytes;

	pData += index;
	float *vec = (float*)&mat;
	for(int i = 0; i < 16; i++) vec[i] = *pData++;
	return true;
}
bool ChMatrixEvent::GetValue(ChVrmlMatrix &mat)
{
	return GetValue(0, mat);
}