Beispiel #1
0
vector<StdString> Universe::handleArguments(long argc, char** argv) {
    vector<StdString> vmArgs = vector<StdString>();
    dumpBytecodes = 0;
    gcVerbosity   = 0;

    for (long i = 1; i < argc; ++i) {

        if (strncmp(argv[i], "-cp", 3) == 0) {
            if ((argc == i + 1) || classPath.size() > 0)
                printUsageAndExit(argv[0]);
            setupClassPath(StdString(argv[++i]));
        } else if (strncmp(argv[i], "-d", 2) == 0) {
            ++dumpBytecodes;
        } else if (strncmp(argv[i], "-g", 2) == 0) {
            ++gcVerbosity;
        } else if (strncmp(argv[i], "-H", 2) == 0) {
            long heap_size = 0;
            char unit[3];
            if (sscanf(argv[i], "-H%ld%2s", &heap_size, unit) == 2) {
                if (strcmp(unit, "KB") == 0)
                    heapSize = heap_size * 1024;
                else if (strcmp(unit, "MB") == 0)
                    heapSize = heap_size * 1024 * 1024;
            } else
                printUsageAndExit(argv[0]);

        } else if ((strncmp(argv[i], "-h", 2) == 0)
                || (strncmp(argv[i], "--help", 6) == 0)) {
            printUsageAndExit(argv[0]);
        } else {
            vector<StdString> extPathTokens = vector<StdString>(2);
            StdString tmpString = StdString(argv[i]);
            if (getClassPathExt(extPathTokens, tmpString) == ERR_SUCCESS) {
                addClassPath(extPathTokens[0]);
            }
            //Different from CSOM!!!:
            //In CSOM there is an else, where the original filename is pushed into the vm_args.
            //But unlike the class name in extPathTokens (extPathTokens[1]) that could
            //still have the .som suffix though.
            //So in SOM++ getClassPathExt will strip the suffix and add it to extPathTokens
            //even if there is no new class path present. So we can in any case do the following:
            vmArgs.push_back(extPathTokens[1]);
        }
    }
    addClassPath(StdString("."));

    return vmArgs;
}
Beispiel #2
0
bool SociContainer::begin(void)
{
	mRecordCount = 0;
	Progress prg("Open database", "Connecting ...");
	prg->setMaximum(prg->maximum()+2);

	if(!getSession())
	{
		prg->setValue(prg->value()+2);
		ErrorMessage(spt::logging::LoggingItem::LOG_ERROR, MODULENAME, "Unable to open database.");
		return false;
	}
	prg->setValue(prg->value()+1);
	if(isReader())
	{
		if(!prepareStatement(selectorToQuery()))
			return false;
	}
	prg->setValue(prg->value()+1);


	if(mSQLToFile)
	{
		mSQLFile.open(mSQLFilename, std::ios::out | std::ios::trunc);
		if(!mSQLFile.is_open())
		{
			ErrorMessage(spt::logging::LoggingItem::LOG_ERROR, MODULENAME, StdString("Unable to open the file: ")+mSQLFilename);
			return false;
		}
	}

	return true;
}
Beispiel #3
0
FileStream::FileStream(StdString filename) {
    ipos = 0;

Console::WriteLine(StdString("Opening ")+filename);
 fpointer = fopen(filename.rstr(),"r+b");
    GetLen();
}
void CObjectToolPal::OnEnKilLFocusLockValue( )
{
	CString szBuffer;
	m_LockValue.GetWindowText( szBuffer );
	m_fLockValue = (float)atof( StdString(szBuffer) );

	UpdateData(FALSE);
}
void CObjectToolPal::OnEnKillfocusEditSensitivity()
{
	CString szBuffer;
	m_EditSensitivity.GetWindowText( szBuffer );
	m_fSensitivity = (float)atof( StdString(szBuffer) );
	m_fSensitivity = max( m_fSensitivity, 0.1f );
	m_fSensitivity = min( m_fSensitivity, 10.0f );

	UpdateData(FALSE);
}
void CObjectToolPal::OnEnKillfocusEditGrid()
{
	CString szBuffer;
	m_EditGrid.GetWindowText( szBuffer );
	m_fSnapToGrid = (float)atof( StdString(szBuffer) );
	m_fSnapToGrid = max( m_fSnapToGrid, 0.001f );
	m_fSnapToGrid = min( m_fSnapToGrid, 100000.0f );

	UpdateData(FALSE);
}
StdString CNetCdfInterface::openMode2String(int oMode)
{
  StdString modeMes;
  switch (oMode)
  {
  case NC_NOWRITE:
    modeMes = StdString("NC_NOWRITE: Opening netCDF file with read-only access with buffering and caching access");
    break;
  case NC_SHARE:
    modeMes = StdString("NC_SHARE: Several processes can read the file concurrently");
    break;
  case NC_WRITE:
    modeMes = StdString("NC_WRITE: NetCDF file is readable and writable");
    break;
  default:
    modeMes = StdString("In the composed opening mode");
    break;
  }
  return modeMes;
}
void USocketIOClientComponent::Bind(FString Name)
{
    PrivateClient.socket()->on(StdString(Name), sio::socket::event_listener_aux([&](std::string const& name, sio::message::ptr const& data, bool isAck, sio::message::list &ack_resp) {

        const FString SafeName = FStringFromStd(name);
        const FString SafeData = FStringFromStd(data->get_string());
        FFunctionGraphTask::CreateAndDispatchWhenReady([&, SafeName, SafeData]
        {
            On.Broadcast(SafeName, SafeData);
        }, TStatId(), nullptr, ENamedThreads::GameThread);
    }));
}
StdString CNetCdfInterface::creationMode2String(int cMode)
{
  StdString modeMes;
  switch (cMode)
  {
  case NC_NOCLOBBER:
    modeMes = StdString("NC_NOCLOBBER: Not overwrite an exisiting netCDF file ");
    break;
  case NC_SHARE:
    modeMes = StdString("NC_SHARE: Several processes can read from and write into the file concurrently");
    break;
  case NC_64BIT_OFFSET:
    modeMes = StdString("NC_64BIT_OFFSET: NetCDF file is 64-bit offset");
    break;
  case NC_NETCDF4:
    modeMes = StdString("NC_NETCDF4: NetCDF file is HDF5/NetCDF-4");
    break;
  case NC_CLASSIC_MODEL:
    modeMes = StdString("NC_CLASSIC_MODEL: NetCDF file is classical model");
    break;
  default:
    modeMes = StdString("In the composed creation mode");
    break;
  }
  return modeMes;
}
			static StdString ReadString(HKEY hKey, const TCHAR *name, const TCHAR *defaultValue = _T(""))
			{
				const UINT MAX_STRING_LENGTH = 1024;
				TCHAR value[MAX_STRING_LENGTH + 1];
				ZeroMemory(value, sizeof(value));
				DWORD type = 0;
				DWORD bytes = MAX_STRING_LENGTH * sizeof(TCHAR);
				LONG result = RegQueryValueEx(hKey, name, NULL, &type, (BYTE *)value, &bytes);
				if(result == ERROR_SUCCESS && type == REG_SZ){
					return StdString(value);
				}
				return defaultValue;
			}
void USocketIOClientComponent::Connect(FString AddressAndPort, FString nSpace)
{
    if (!AddressAndPort.IsEmpty())
    {
        Namespace = nSpace;
        PrivateClient.connect(StdString(AddressAndPort));
        UE_LOG(LogTemp, Log, TEXT("Using Namespae: %s"), *nSpace);

    }
    else
    {
        PrivateClient.connect("http://localhost:3000");
    }
}
CEditorManager::CEditorManager() : m_HashName( _T("CEditorManager") )
{
	m_EditorMap.clear();
	m_ToolMap.clear();
	m_LinkMap.clear();
	m_ToolBox = EngineGetToolBox();

	m_iCurrentCollisionGroup = ALL;

	// Set the control group not to collide with objects or terrain


	LoadLinkMap( StdString(theApp.GetAppPath() + "\\objectproperties\\LinkMap.xml") );
}
///	\brief	extract first attribute with name "name" from archive
///	\param	pArchive - pointer to XML archive with values
///	\return name of object or empty string
StdString CStateMachineClipboardPreprocessor::GetName( IXMLArchive *pArchive ) const
{
	int count = pArchive->GetNumAttributes();
	StdString sName;
	StdString sValue;
	while( count-- )
	{
		sName = pArchive->GetCurrentNodeName();
		pArchive->Read( sValue, sName );
		if( sName == _T("name") )
		{
			return sValue;
		}
	}
	return StdString();
}
/*!
This function makes a request to netcdf, returns name of a dimension, given its id
\param [in] ncid Groupd id (or File Id)
\param [in] dimId Id of desired dimension
\param [out] dimName Name of desired dimension
\return Status code
*/
int CNetCdfInterface::inqDimName(int ncid, int dimId, StdString& dimName)
{
  char fullNameIn[NC_MAX_NAME + 1];
  int status = nc_inq_dimname(ncid, dimId, fullNameIn);
  if (NC_NOERR != status)
  {
    StdString errormsg(nc_strerror(status));
    StdStringStream sstr;

    sstr << "Error when calling function nc_inq_dimname(ncid, dimId, fullNameIn)" << std::endl
         << errormsg << std::endl
         << "Unable to get dimension name: " << dimName << " given its id: " << dimId << std::endl;
    StdString e = sstr.str();
    throw CNetCdfException(e);
  }
  dimName = StdString(fullNameIn);
  return status;
}
DWORD CLuaScriptVarList::OnGetSchema(DWORD size, void *in_params)
{
	VERIFY_MESSAGE_SIZE(size, sizeof(GETSCHEMAPARAMS));
	GETSCHEMAPARAMS *pParams = (GETSCHEMAPARAMS*)in_params;
	IXMLArchive *pArchive = pParams->ar;
	if (!pArchive)
		return MSG_ERROR;

	int iSchemaItemCount = 2 + m_Variables.size() * 3;
	pArchive->StartClass( StdString(GetComponentType()->GetString()) );
	pArchive->Write( GetName()->GetString(), "Name" );
	pArchive->Write( iSchemaItemCount, "Num" );

	// hidden Schema Name
	pArchive->StartClass(_T("hidden") );
	pArchive->Write( _T("string"), _T("Type") );
	pArchive->EndClass();
	// hidden Variable count
	pArchive->StartClass(_T("hidden") );
	pArchive->Write( _T("int"), _T("Type") );
	pArchive->EndClass();
	// Variables
	for( unsigned int i = 0; i < m_Variables.size(); i++ )
	{
		// hidden Variable Name string
		pArchive->StartClass(_T("hidden") );
		pArchive->Write( _T("string"), _T("Type") );
		pArchive->EndClass();
		// shown Variable Value string
		pArchive->StartClass(_T("edit") );
		pArchive->Write( _T("string"), _T("Type") );
		pArchive->Write( m_Variables[i].GetName(), _T("Name") );
		pArchive->Write( false, _T("Key") );
		pArchive->EndClass();
		// hidden Variable Default bool
		pArchive->StartClass(_T("hidden") );
		pArchive->Write( _T("bool"), _T("Type") );
		pArchive->EndClass();
	}
	pArchive->EndClass();

	return MSG_HANDLED_STOP;
}
void CResourceOptions::OnEnKillfocusCullobjectsdistance()
{
	TCHAR szBuffer[256];
	szBuffer[0] = '\0';
	m_ctrlCullObjectDistance.GetWindowText( szBuffer, 256 );
	m_iCullDistance = (int)atoi( StdString(szBuffer) );

	// TODO: Add your control notification handler code here
	if( m_iCullDistance < 0 )
	{
		m_iCullDistance = 0;
		m_ctrlCullObjectDistance.SetWindowText( _T("0") );
	}
	if( m_iCullDistance > 999999 )
	{
		m_iCullDistance = 999999;
		m_ctrlCullObjectDistance.SetWindowText( _T("999999") );
	}

	float tmpCullDistance = (float)m_iCullDistance;
	static DWORD msgHash_SetObjectCullDistance = CHashString(_T("SetObjectCullDistance")).GetUniqueID();
	EngineGetToolBox()->SendMessage(msgHash_SetObjectCullDistance, sizeof(tmpCullDistance), &tmpCullDistance );
}
Beispiel #17
0
void Parser::primary(MethodGenerationContext* mgenc, bool* super) {
    *super = false;
    switch (sym) {
    case Primitive:
    case Identifier: {
        StdString v = variable();
        if (v == "super") {
            *super = true;
            // sends to super push self as the receiver
            v = StdString("self");
        }

        genPushVariable(mgenc, v);
        break;
    }
    case NewTerm:
        nestedTerm(mgenc);
        break;
    case NewBlock: {
        MethodGenerationContext* bgenc = new MethodGenerationContext();
        bgenc->SetIsBlockMethod(true);
        bgenc->SetHolder(mgenc->GetHolder());
        bgenc->SetOuter(mgenc);

        nestedBlock(bgenc);

        VMMethod* block_method = bgenc->Assemble();
        mgenc->AddLiteral(block_method);
        bcGen->EmitPUSHBLOCK(mgenc, block_method);
        delete (bgenc);
        break;
    }
    default:
        literal(mgenc);
        break;
    }
}
Beispiel #18
0
 StdString CD360Calendar::getType(void) const
 { return (StdString("360_day")); }
Beispiel #19
0
 StdString CDomain::GetName(void)   { return (StdString("domain")); }
 StdString CReduceDomainToScalar::GetDefName(void) { return StdString("reduce_domain_to_scalar"); }
Beispiel #21
0
void CGUIPage::Serialize(IArchive &ar)
{
	CGUIManager *manager;
	static CHashString managerName(_T("CGUIManager"));
	IObject *Object;
	StdString pageName;
	StdString guiName;
	StdString guiType;
	StdString type;
	int iNumGuiElements;
	OBJECTLIST::iterator olIter;

	if(ar.IsReading())
	{
		CHashString versionName;
		static DWORD msgHash_GetFileVersion = CHashString(_T("GetFileVersion")).GetUniqueID();
		DWORD retval = EngineGetToolBox()->SendMessage(msgHash_GetFileVersion, sizeof(IHashString), &versionName);

		static DWORD Vers2_0a = CHashString(_T("2.0a")).GetUniqueID();
		static DWORD Vers2_0b = CHashString(_T("2.0b")).GetUniqueID();
		static DWORD Vers2_0c = CHashString(_T("2.0c")).GetUniqueID();

		int verNum = 0;
		
		if (versionName.GetUniqueID() == Vers2_0a)
		{
			verNum = 3;
		}
		else if (versionName.GetUniqueID() == Vers2_0b)
		{
			verNum = 4;
		}
		else if (versionName.GetUniqueID() == Vers2_0c)
		{
			verNum = 5;
		}
		else 
		{
			m_ToolBox->Log(LOGERROR, _T("Bad GUI file version!"));
			assert(0);
			return;
		}

		float loadVersion = 0.0f;

		if (verNum >= 4)
		{
			ar.Read(loadVersion);
			if (loadVersion == 0.0f)
			{
				// initial serialize from editor; set to save version (up to date schema)
				loadVersion = m_fSaveVersion;
			}
		}

		ar.Read(iNumGuiElements);
		while(iNumGuiElements != 0)
		{
			ar.Read(guiName);
			ar.Read(guiType);

			CHashString szhGuiName(guiName.c_str());
			CHashString szhGuiType(guiType.c_str());

			// ask gui manager for the object to add
			manager = dynamic_cast<CGUIManager*>(EngineGetToolBox()->GetComponent( &managerName ));
			if (!manager)
			{
				EngineGetToolBox()->SetErrorValue(ERR_NULL_POINTER);
				EngineGetToolBox()->Log(LOGERROR, _T("could not cast IComponent from EngineToolBox to CGUIManager\n")); 
				return;
			}
			Object = manager->GetObject(&szhGuiName, &szhGuiType);
			if(Object == NULL)
			{
				CREATEOBJECTPARAMS cop;
				INITOBJECTPARAMS iop;
				cop.name = &szhGuiName;
				cop.typeName = &szhGuiType;
				cop.parentName = GetName();
				iop.name = &szhGuiName;

				static DWORD msgHash_CreateObject = CHashString(_T("CreateObject")).GetUniqueID();
				m_ToolBox->SendMessage(msgHash_CreateObject, sizeof(CREATEOBJECTPARAMS), &cop, NULL, NULL);
				static DWORD msgHash_InitObject = CHashString(_T("InitObject")).GetUniqueID();
				m_ToolBox->SendMessage(msgHash_InitObject, sizeof(INITOBJECTPARAMS), &cop, NULL, NULL);
				Object = manager->GetObject(&szhGuiName, &szhGuiType);
			}
			m_ObjectList.push_back(Object);
			iNumGuiElements--;
		}

	}
	else //ar.IsWritting()
	{
		TCHAR strNum[50];
		int count = 1;
		StdString itemName;
		StdString itemType;

		//pageName = GetName()->GetString();
		//type = GetComponentType()->GetString();
		iNumGuiElements = m_ObjectList.size();

		ar.Write(m_fSaveVersion, _T("Version"));

		// start the page class
		//ar.StartClass(type); // <CGUIPage
		// write the page's name
		//ar.Write( pageName, _T("Name") );
		// write the number of gui elements 
		ar.Write( iNumGuiElements, _T("NumGuiElements") );
		
		for(olIter = m_ObjectList.begin(); olIter != m_ObjectList.end();
			olIter++)
		{

			_ltot(count, strNum, 10);
			itemName = StdString(_T("GuiName")) + strNum;
			itemType = StdString(_T("GuiType")) + strNum;

			guiName = (*olIter)->GetName()->GetString();
			ar.Write( guiName, itemName );
			guiType = (*olIter)->GetComponentType()->GetString();
			ar.Write( guiType, itemType );
			count++;
		}
		//ar.EndClass(); // </CGUIPage>
	}
}
void USocketIOClientComponent::Emit(FString Name, FString Data)
{
    PrivateClient.socket(StdString(Namespace))->emit(StdString(Name), StdString(Data));
    UE_LOG(LogTemp, Log, TEXT("Emit on Namespces %s, with eventname %s with %s"), *Namespace, *Name, *Data);
}
Beispiel #23
0
 CMinimum::CMinimum(CArray<double,1>& doutput, double missingValue)
    : SuperClass(StdString("minimum"), doutput, missingValue)
 { /* Ne rien faire de plus */ }
Beispiel #24
0
void PrimitiveContainer::SetPrimitive(const char* name,
        PrimitiveRoutine* routine) {
    (*methods)[StdString(name)] = routine;
}
Beispiel #25
0
 StdString CCalendar::getType(void) const { return (StdString(this->getId())); }
V8ScriptHolder* V8IsolateImpl::Compile(const StdString& documentName, const StdString& code)
{
    BEGIN_ISOLATE_SCOPE

        SharedPtr<V8ContextImpl> spContextImpl((m_ContextPtrs.size() > 0) ? m_ContextPtrs.front() : new V8ContextImpl(this, StdString(), false, true, 0));
        return spContextImpl->Compile(documentName, code);

    END_ISOLATE_SCOPE
}
Beispiel #27
0
 const StdString CFile::getFileOutputName(void) const
 {
   return (name.isEmpty() ? getId() : name) + (name_suffix.isEmpty() ? StdString("") :  name_suffix.getValue());
 }
bool CWorldVisitor::Visit( IComponent * component, bool bVisitEnter )
{
	IObject *theObject;
	IHashString *name;
	IHashString *parentName;
	IHashString *type;

	StdString parentType;
	StdString childType;

	std::string str;

	theObject = dynamic_cast<IObject *>(component);
	// This shouldn't happen but it does for some odd reason....
	assert(theObject);
	if( theObject == NULL )
	{
		return false;
	}
	name = theObject->GetName();
	parentName = theObject->GetParentName();
	type = theObject->GetComponentType();

	//Check to see if it is a valid object (for object exclusion)
	if( !CheckObject( type->GetString() ) )
	{
		return true;
	}

	else
	{
		if ( name == NULL )
		{
			name = &CHashString(_T("NULL"));
		}	

		if( bVisitEnter == true )
		{
			//if( (m_pArchiver != NULL) && ( _tcscmp( type->GetString(), _T("CPhysicsObject") ) != 0 ) )
			if( (m_pArchiver != NULL) )
			{
				// Start the Node
				m_pArchiver->StartClass( type->GetString() );
				
				// Write out the Unique ID aka Name
				m_pArchiver->Write( name->GetString(), _T("Name") );
				theObject->Serialize( *m_pArchiver );
			}

			// Removal of CPhysShape and changes to CPhysicsObject
			if( _tcscmp( type->GetString(), _T("CPhysicsObject") ) == 0 )
			{
				
				CPhysObjectStruct tmpCPhysObject;
				StdString CPhyShapeFile;
				StdString CPhyShapeFileOld;
				// if it's parent is not a CTerrainSector Object
				if( _tcsstr( name->GetString(), _T("Terrain") ) == NULL )
				{
					static DWORD msgHash_GetModelFileName = CHashString(_T("GetModelFileName")).GetUniqueID();
					m_ToolBox->SendMessage(msgHash_GetModelFileName, sizeof(StdString*), &CPhyShapeFile, parentName, NULL );
					CPhyShapeFile += _T(".psl");
				}
				// CTerrainSector Object
				else
				{
					CPhyShapeFile = _T("maps\\terrain.psl");
				}

				IArchive *PhysObjectIn;
				IArchive *PhysObjectRead;
				CHashString memTypePhysObjectIn(_T("Memory"));
				
				int PhysObjectInMemSize = 1024 * 1024 * sizeof(char);
				char* PhysObjectInMemChunk = new char[PhysObjectInMemSize];
				memset( PhysObjectInMemChunk, 0, PhysObjectInMemSize );

				CREATEARCHIVE caPhysObjectIn;
				caPhysObjectIn.mode = STREAM_MODE_READ;
				caPhysObjectIn.streamData = PhysObjectInMemChunk;
				caPhysObjectIn.streamSize = PhysObjectInMemSize;
				caPhysObjectIn.streamType = &memTypePhysObjectIn;
				static DWORD msgHash_CreateArchive = CHashString(_T("CreateArchive")).GetUniqueID();
				if (m_ToolBox->SendMessage(msgHash_CreateArchive, sizeof(CREATEARCHIVE), &caPhysObjectIn) != MSG_HANDLED)
				{
					return true;
				}
				PhysObjectIn = caPhysObjectIn.archive;

				CREATESTREAM csPhysObjectIn;
				csPhysObjectIn.streamData = caPhysObjectIn.streamData;
				csPhysObjectIn.streamSize = caPhysObjectIn.streamSize;
				csPhysObjectIn.mode = STREAM_MODE_WRITE;
				static DWORD msgHash_CreateStream_Memory = CHashString(_T("CreateStream_Memory")).GetUniqueID();
				if (m_ToolBox->SendMessage(msgHash_CreateStream_Memory, sizeof(CREATESTREAM), &csPhysObjectIn) != MSG_HANDLED)
				{
					return true;
				}
				PhysObjectIn->Init(csPhysObjectIn.openStream);		    

				SERIALIZEOBJECTPARAMS sop;
				sop.name = name;
				sop.archive = PhysObjectIn;
				static DWORD msgHash_SerializeObject = CHashString(_T("SerializeObject")).GetUniqueID();
				m_ToolBox->SendMessage(msgHash_SerializeObject, sizeof(SERIALIZEOBJECTPARAMS), &sop, NULL, NULL);
				PhysObjectIn->Close();
				
				CREATEARCHIVE caPhysObjectRead;
				caPhysObjectRead.mode = STREAM_MODE_WRITE;
				caPhysObjectRead.streamData = PhysObjectInMemChunk;
				caPhysObjectRead.streamSize = PhysObjectInMemSize;
				caPhysObjectRead.streamType = &memTypePhysObjectIn;
				if (m_ToolBox->SendMessage(msgHash_CreateArchive, sizeof(CREATEARCHIVE), &caPhysObjectRead) != MSG_HANDLED)
				{
					return true;
				}
				PhysObjectRead = caPhysObjectRead.archive;

				CREATESTREAM csPhysObjectRead;
				csPhysObjectRead.streamData = caPhysObjectRead.streamData;
				csPhysObjectRead.streamSize = caPhysObjectRead.streamSize;
				csPhysObjectRead.mode = STREAM_MODE_READ;
				if (m_ToolBox->SendMessage(msgHash_CreateStream_Memory, sizeof(CREATESTREAM), &csPhysObjectRead) != MSG_HANDLED)
				{
					return true;
				}
				PhysObjectRead->Init(csPhysObjectRead.openStream);
				PhysObjectRead->Read( tmpCPhysObject.vPosition, _T("pos") );
				PhysObjectRead->Read( tmpCPhysObject.vRotation, _T("rot") );
				PhysObjectRead->Read( tmpCPhysObject.vScale, _T("scale") );
				PhysObjectRead->Read( tmpCPhysObject.fMass, _T("mass") );
				PhysObjectRead->Read( tmpCPhysObject.szDynamic, _T("dynamics") );
				PhysObjectRead->Read( CPhyShapeFileOld, _T("shapeFile") );
				PhysObjectRead->Close();
                
				// Archive the Data Back In
				IArchive *MemArchivePhysObject;	
				CHashString memTypePhysObject(_T("Memory"));
				//int sizePhysObject = 1024 * 1024;
				//char* memchunkPhysObject = new char[sizePhysObject];

				CREATEARCHIVE caPhysObject;
				caPhysObject.mode = STREAM_MODE_WRITE;
				caPhysObject.streamData = PhysObjectInMemChunk;
				caPhysObject.streamSize = PhysObjectInMemSize;
				caPhysObject.streamType = &memTypePhysObject;
				if (m_ToolBox->SendMessage(msgHash_CreateArchive, sizeof(CREATEARCHIVE), &caPhysObject) != MSG_HANDLED)
				{
					return true;
				}
				MemArchivePhysObject = caPhysObject.archive;
				MemArchivePhysObject->Write( tmpCPhysObject.vPosition, _T("pos") );
				MemArchivePhysObject->Write( tmpCPhysObject.vRotation, _T("rot") );
				MemArchivePhysObject->Write( tmpCPhysObject.vScale, _T("scale") );
				MemArchivePhysObject->Write( tmpCPhysObject.fMass, _T("mass") );
				MemArchivePhysObject->Write( tmpCPhysObject.szDynamic, _T("dynamics") );
				MemArchivePhysObject->Write( CPhyShapeFile, _T("shapeFile") );
				
				CREATESTREAM csPhysObject;
				csPhysObject.streamData = caPhysObject.streamData;
				csPhysObject.streamSize = caPhysObject.streamSize;
				csPhysObject.mode = STREAM_MODE_READ;
				if (m_ToolBox->SendMessage(msgHash_CreateStream_Memory, sizeof(CREATESTREAM), &csPhysObject) != MSG_HANDLED)
				{
					return true;
				}
				MemArchivePhysObject->Init(csPhysObject.openStream);

				SERIALIZEOBJECTPARAMS sopPhysObject;
				sopPhysObject.name = name;
				sopPhysObject.archive = MemArchivePhysObject;
				m_ToolBox->SendMessage(msgHash_SerializeObject, sizeof(SERIALIZEOBJECTPARAMS), &sopPhysObject, NULL, NULL);

				MemArchivePhysObject->Close();
				//delete [] memchunkPhysObject;
				//memchunkPhysObject = NULL;
				delete [] PhysObjectInMemChunk;
				PhysObjectInMemChunk = NULL;
			}

			// Model Rename Changes
			if( (m_pReporter != NULL) && ( _tcscmp( type->GetString(), _T("CV3ORenderObject") ) == 0 ) )
			{
				IArchive *MemArchive;
				IArchive *MemArchive2;
				CHashString memType(_T("Memory"));
				memset( m_pMemChunk, '\0', m_iMemSize );

				CREATEARCHIVE ca;
				ca.mode = STREAM_MODE_READ;
				ca.streamData = m_pMemChunk;
				ca.streamSize = m_iMemSize;
				ca.streamType = &memType;
				static DWORD msgHash_CreateArchive = CHashString(_T("CreateArchive")).GetUniqueID();
				if (m_ToolBox->SendMessage(msgHash_CreateArchive, sizeof(CREATEARCHIVE), &ca) != MSG_HANDLED)
				{
					return true;
				}
				MemArchive = ca.archive;

				CREATESTREAM cs;
				cs.streamData = ca.streamData;
				cs.streamSize = ca.streamSize;
				cs.mode = STREAM_MODE_WRITE;
				static DWORD msgHash_CreateStream_Memory = CHashString(_T("CreateStream_Memory")).GetUniqueID();
				if (m_ToolBox->SendMessage(msgHash_CreateStream_Memory, sizeof(CREATESTREAM), &cs) != MSG_HANDLED)
				{
					return true;
				}
				MemArchive->Init(cs.openStream);		    

				SERIALIZEOBJECTPARAMS sop;
				sop.name = name;
				sop.archive = MemArchive;
				static DWORD msgHash_SerializeObject = CHashString(_T("SerializeObject")).GetUniqueID();
				m_ToolBox->SendMessage(msgHash_SerializeObject, sizeof(SERIALIZEOBJECTPARAMS), &sop, NULL, NULL);
				MemArchive->Close();
				
				CREATEARCHIVE ca2;
				ca2.mode = STREAM_MODE_WRITE;
				ca2.streamData = m_pMemChunk;
				ca2.streamSize = m_iMemSize;
				ca2.streamType = &memType;
				if (m_ToolBox->SendMessage(msgHash_CreateArchive, sizeof(CREATEARCHIVE), &ca2) != MSG_HANDLED)
				{
					return true;
				}
				MemArchive2 = ca2.archive;

				CREATESTREAM cs2;
				cs2.streamData = ca2.streamData;
				cs2.streamSize = ca2.streamSize;
				cs2.mode = STREAM_MODE_READ;
				if (m_ToolBox->SendMessage(msgHash_CreateStream_Memory, sizeof(CREATESTREAM), &cs2) != MSG_HANDLED)
				{
					return true;
				}
				MemArchive2->Init(cs2.openStream);

				StdString wszModelFileName;
				Vec3 Position;
				Vec3 Rotation;
				Vec3 Scale;

				MemArchive2->Read( wszModelFileName );
				MemArchive2->Read( Position );
				MemArchive2->Read( Rotation );
				MemArchive2->Read( Scale );
				MemArchive2->Close();
				
				MODELMAP::iterator itr;
				bool bReArchive = false;
				while( 1 )
				{		
					itr = m_vModelReference.find( wszModelFileName );
					// If the Model Refernce already exists
					if( itr != m_vModelReference.end() )
					{
						// If its newfilename is different and it isn't an empty string
						// We Change the file name and set the archive flag
						if( (wszModelFileName != itr->second.m_wszNewFileName) &&
							(itr->second.m_wszNewFileName != StdString("")) )
						{
							wszModelFileName = itr->second.m_wszNewFileName;
							bReArchive = true;
						}
						
						// We've reached a file that has the same exact newfilename, no change neccisary
						else
						{
							break;
						}
					}
					
					
					// We change model name first (up above) and then make sure to add it as a reference and break out
					itr = m_vModelReference.find( wszModelFileName );
					if( itr == m_vModelReference.end() )
					{
						/*
						MODELINFO tmpModelInfo;
						tmpModelInfo.m_wszNewFileName = wszModelFileName;
						m_vModelReference[wszModelFileName] = tmpModelInfo;
						m_iNewEntries++;
						*/
						break;
					}
					
				}
				
				m_szLastV3OFileName = wszModelFileName;

				// Archive the object back out
				if( bReArchive == true )
				{
					IArchive *MemArchiveRE;	
					CHashString memTypeRE(_T("Memory"));
					int sizeRE = 1024 + sizeof(Vec3) * 3;
					char* memchunkRE = new char[sizeRE];

					CREATEARCHIVE caRE;
					caRE.mode = STREAM_MODE_WRITE;
					caRE.streamData = memchunkRE;
					caRE.streamSize = sizeRE;
					caRE.streamType = &memTypeRE;
					static DWORD msgHash_CreateArchive = CHashString(_T("CreateArchive")).GetUniqueID();
					if (m_ToolBox->SendMessage(msgHash_CreateArchive, sizeof(CREATEARCHIVE), &caRE) != MSG_HANDLED)
					{
						return true;
					}
					MemArchiveRE = caRE.archive;
					MemArchiveRE->Write( wszModelFileName );
					MemArchiveRE->Write( Position );
					MemArchiveRE->Write( Rotation );
					MemArchiveRE->Write( Scale );

					CREATESTREAM csRE;
					csRE.streamData = caRE.streamData;
					csRE.streamSize = caRE.streamSize;
					csRE.mode = STREAM_MODE_READ;
					static DWORD msgHash_CreateStream_Memory = CHashString(_T("CreateStream_Memory")).GetUniqueID();
					if (m_ToolBox->SendMessage(msgHash_CreateStream_Memory, sizeof(CREATESTREAM), &csRE) != MSG_HANDLED)
					{
						return true;
					}
					MemArchiveRE->Init(csRE.openStream);

					SERIALIZEOBJECTPARAMS sopRE;
					sopRE.name = name;
					sopRE.archive = MemArchiveRE;
					static DWORD msgHash_SerializeObject = CHashString(_T("SerializeObject")).GetUniqueID();
					m_ToolBox->SendMessage(msgHash_SerializeObject, sizeof(SERIALIZEOBJECTPARAMS), &sopRE, NULL, NULL);

					MemArchiveRE->Close();
					delete [] memchunkRE;
					memchunkRE = NULL;
					m_iV3ONameEdits++;
				}
			}
		}

		// bVisitEnter == false
		else
		{
			if( m_pArchiver != NULL )
			{
				m_pArchiver->EndClass();
			}
		}
	}
	
	return true;
}
Beispiel #29
0
 StdString CZoomDomain::GetDefName(void) { return StdString("zoom_domain"); }
Beispiel #30
0
  ///---------------------------------------------------------------
 //! Get name of file
  StdString CFile::GetName(void)   { return (StdString("file")); }