chvrmlevent.cpp

Windows上的MUD客户端程序

/*----------------------------------------------------------------------------
                        _                              _ _       
        /\             | |                            | (_)      
       /  \   _ __   __| |_ __ ___  _ __ ___   ___  __| |_  __ _ 
      / /\ \ | '_ \ / _` | '__/ _ \| '_ ` _ \ / _ \/ _` | |/ _` |
     / ____ \| | | | (_| | | | (_) | | | | | |  __/ (_| | | (_| |
    /_/    \_\_| |_|\__,_|_|  \___/|_| |_| |_|\___|\__,_|_|\__,_|

    The contents of this file are subject to the Andromedia Public
	License Version 1.0 (the "License"); you may not use this file
	except in compliance with the License. You may obtain a copy of
	the License at http://www.andromedia.com/APL/

    Software distributed under the License is distributed on an
	"AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
	implied. See the License for the specific language governing
	rights and limitations under the License.

    The Original Code is Pueblo client code, released November 4, 1998.

    The Initial Developer of the Original Code is Andromedia Incorporated.
	Portions created by Andromedia are Copyright (C) 1998 Andromedia
	Incorporated.  All Rights Reserved.

	Andromedia Incorporated                         415.365.6700
	818 Mission Street - 2nd Floor                  415.365.6701 fax
	San Francisco, CA 94103

    Contributor(s):
	--------------------------------------------------------------------------
	   Chaco team:  Dan Greening, Glenn Crocker, Jim Doubek,
	                Coyote Lussier, Pritham Shetty.

					Wrote and designed original codebase.

------------------------------------------------------------------------------

	Implementation for WM event processing in VRML/RenderLab

----------------------------------------------------------------------------*/

#include "grheader.h"
#ifdef CH_MSW
#include <windows.h>
#endif
#ifdef HUGE
#undef HUGE
#endif
#include "ChVrmlEvent.h"
#include "QvNode.h"
#include "QvField.h"

// Class ChIVrmlEvent

ChIVrmlEvent::ChIVrmlEvent() :
	m_eventType(ChVRMLEvent::invalid),
	m_dataSize(0),
	m_bytes(0),
	m_eventTime(0),
	m_nextEvent(0)
{
	
};

ChIVrmlEvent::ChIVrmlEvent(const ChVRMLEvent::type theType, const string &name) :
	m_eventType(theType),
	m_dataSize(0),
	m_bytes(0),
	m_eventTime(0),
	m_nextEvent(0),
	m_eventName(name)
{
	
};

ChIVrmlEvent::~ChIVrmlEvent()
{
	m_dataSize = 0;
	delete [] m_bytes;
	m_bytes = 0;
}

QvField::type ChIVrmlEvent::GetFieldType()
{
	switch (m_eventType)
	{
		case ChVRMLEvent::SFBitMask:
			return QvField::typeQvSFBitMask; 
		case ChVRMLEvent::SFBool:
			return QvField::typeQvSFBool; 
		case ChVRMLEvent::SFColor:
			return QvField::typeQvSFColor; 
		case ChVRMLEvent::SFEnum:
			return QvField::typeQvSFEnum; 
		case ChVRMLEvent::SFFloat:
			return QvField::typeQvSFFloat; 
		case ChVRMLEvent::SFImage:
			return QvField::typeQvSFImage; 
		case ChVRMLEvent::SFLong:
			return QvField::typeQvSFLong; 
		case ChVRMLEvent::SFMatrix:
			return QvField::typeQvSFMatrix; 
		case ChVRMLEvent::SFNode:
			return QvField::typeQvSFNode; 
		case ChVRMLEvent::SFRotation:
			return QvField::typeQvSFRotation; 
		case ChVRMLEvent::SFString:
			return QvField::typeQvSFString; 
		case ChVRMLEvent::SFVec2f:
			return QvField::typeQvSFVec2f; 
		case ChVRMLEvent::SFVec3f:
			return QvField::typeQvSFVec3f; 
		case ChVRMLEvent::SFTime:
			return QvField::typeQvSFTime; 
		case ChVRMLEvent::SFPick:
			return QvField::typeQvSFPick; 
		case ChVRMLEvent::SFProximity:
			return QvField::typeQvSFProximity; 
		case ChVRMLEvent::SFCollision:
			return QvField::typeQvSFCollision; 
		case ChVRMLEvent::MFBitMask:
			return QvField::typeQvMFBitMask; 
		case ChVRMLEvent::MFBool:
			return QvField::typeQvMFBool; 
		case ChVRMLEvent::MFColor:
			return QvField::typeQvMFColor; 
		case ChVRMLEvent::MFEnum:
			return QvField::typeQvMFEnum; 
		case ChVRMLEvent::MFFloat:
			return QvField::typeQvMFFloat; 
		case ChVRMLEvent::MFImage:
			return QvField::typeQvMFImage; 
		case ChVRMLEvent::MFLong:
			return QvField::typeQvMFLong; 
		case ChVRMLEvent::MFMatrix:
			return QvField::typeQvMFMatrix; 
		case ChVRMLEvent::MFNode:
			return QvField::typeQvMFNode; 
		case ChVRMLEvent::MFRotation:
			return QvField::typeQvMFRotation; 
		case ChVRMLEvent::MFString:
			return QvField::typeQvMFString; 
		case ChVRMLEvent::MFVec2f:
			return QvField::typeQvMFVec2f; 
		case ChVRMLEvent::MFVec3f:
			return QvField::typeQvMFVec3f; 
		case ChVRMLEvent::MFTime:
			return QvField::typeQvMFTime; 
		case ChVRMLEvent::MFPick:
			return QvField::typeQvMFPick; 
		case ChVRMLEvent::MFProximity:
			return QvField::typeQvMFProximity; 
		case ChVRMLEvent::MFCollision:
			return QvField::typeQvMFCollision;
	
	}
	return QvField::typeInvalid;
}

ChIVrmlEvent * ChIVrmlEvent::Create(const ChVRMLEvent &anEvent)
{
	ChIVrmlEvent *pList = 0, *pTail = 0, *pEvent = 0;
	const ChVRMLEvent *pSrc	 = &anEvent;

	while(pSrc)
	{
		switch(pSrc->eventType)
		{
			case  ChVRMLEvent::SFNode :
			{
				pEvent = (ChIVrmlEvent *)(new ChNodeEvent(*pSrc));
				break;
			}

			default:
			{
				break;
			}
		}

		if(pList)
		{
			pTail->Append(pEvent);
			pTail = pEvent;
		}
		else
		{
			pList = pTail = pEvent;
		}
		pSrc = pSrc->nextEvent;
	} 

	return pList;
}

ChIVrmlEvent * ChIVrmlEvent::Append(ChIVrmlEvent * pTail )
{
	m_nextEvent = pTail;
	return pTail;		// This lets you do a->append()->append() && also allows Append(0) to delete tail	
}

void ChIVrmlEvent::Copy(const ChVRMLEvent &anEvent)
{
	m_nextEvent = 0;
	m_eventType = anEvent.eventType;
	m_eventTime= anEvent.eventTime;
	m_eventName= anEvent.eventName;
	m_dataSize= anEvent.dataSize;
	m_bytes = new char[m_dataSize];

	SetBytes((char*)anEvent.bytes);

}

void ChIVrmlEvent::Copy(const ChIVrmlEvent &anEvent)
{
	m_nextEvent = 0;
	m_eventType = anEvent.m_eventType;
	m_eventTime= anEvent.m_eventTime;
	m_eventName= anEvent.m_eventName;
	m_dataSize= anEvent.m_dataSize;
	m_bytes = new char[m_dataSize];

	SetBytes(anEvent.m_bytes);

}

void ChIVrmlEvent::SetBytes(const char *bytes)
{
	memmove(m_bytes, bytes, m_dataSize);
} 
	
bool ChIVrmlEvent::SetSize(int iNewDataSize)
{
	if(iNewDataSize == m_dataSize) return true;	// no need to do anything
	char * pNew = new char [iNewDataSize];
	if(!pNew) return 0; // oughta throw
	int iSize = min(iNewDataSize, m_dataSize);	// truncate if new is smaller
	if(iSize > 0)
	{ 
		memmove(pNew, m_bytes, iSize);
	}
	delete [] m_bytes;
	m_bytes = pNew;
	m_dataSize = iNewDataSize;
	return true;
}

// ChNodeEvent

ChNodeEvent::ChNodeEvent(const string &name, ChNode* const value) : 
	ChIVrmlEvent(ChVRMLEvent::SFNode, name)
{
	AppendData(value);
}

ChNodeEvent::ChNodeEvent(const string &name, const int count, ChNode **values) :
	ChIVrmlEvent(ChVRMLEvent::SFNode, name)
{
	AppendData(count, values);
}

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

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

ChNodeEvent::~ChNodeEvent()
{
	int num = m_dataSize / sizeof(ChNode*);
	for(int i = 0; i < num; i++)
	{
		Release(i);
	}
	// Super class will delete bytes

}
int ChNodeEvent::AppendData(ChNode* const value)
{
	int iNext = GetCount();	 // 1 ptr per datum
	if(!SetSize(m_dataSize + (sizeof(ChNode*)))) return false;

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

	*pData = value;
	((QvNode*)value)->Use();
	return 1;
};             
int ChNodeEvent::AppendData(const int count,  ChNode ** values)
{
	int iNext = GetCount();
	if(!SetSize(m_dataSize + count * (sizeof(ChNode *)))) return false;
	ChNode **pData = (ChNode **)m_bytes;
	pData += iNext;

	for(int i = 0; i < count * 4; i++)
	{
		((QvNode*)(*values))->Use();
		*pData++ = *values++;
	}

	return 1;
} 

 
int ChNodeEvent::GetCount()
{
	return m_dataSize / (sizeof(ChNode *));
}


bool ChNodeEvent::GetValue(const int index, ChNode * &value)
{
	if(index >= GetCount()) return false;
	ChNode* *pData = (ChNode**)m_bytes;

	pData += index;
	value = *pData;
	return true;
}

bool ChNodeEvent::GetValue(ChNode * &value)
{
	return GetValue(0, value);
}

void ChNodeEvent::Use()
{
	int num = m_dataSize / sizeof(ChNode*);
	for(int i = 0; i < num; i++) Use(i);
}

void ChNodeEvent::Use(int index)
{
	QvNode *pNode = ((QvNode**)m_bytes)[index];
	if(pNode) pNode->Use();
}

void ChNodeEvent::Release(int index)
{
	QvNode *pNode = ((QvNode**)m_bytes)[index];
	if(pNode) pNode->Release();
}

void ChNodeEvent::SetBytes(const char *bytes)
{
	memmove(m_bytes, bytes, m_dataSize);
	Use();
} 


// ChRotationEvent
ChRotationEvent::ChRotationEvent(const string &name, float axis[3], float angle) : 
	ChIVrmlEvent(ChVRMLEvent::SFRotation, name)
{
	AppendData(axis, angle);
}
ChRotationEvent::ChRotationEvent(const string &name, float x, float y, float z, float angle) : 
	ChIVrmlEvent(ChVRMLEvent::SFRotation, name)
{
	AppendData(x, y, z, angle);
}

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

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

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

ChRotationEvent::~ChRotationEvent() {}

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

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

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

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

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

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