void COptionTreeWrapper::SerializeStaticItemBool(IArchive &ar, COptionTreeItem *item, bool read) { bool bVal; COptionTreeItemStatic *otiStatic; CString text; otiStatic = dynamic_cast<COptionTreeItemStatic*>(item); if(otiStatic == NULL) { //error StdString error = _T("Could not cast item to COptionTreeItemStatic: "); error += item->GetLabelText(); ::MessageBox(NULL, error, _T("Invalid Command"), MB_OK); return; } if(read) { ar.Read(bVal); otiStatic->SetStaticText( bVal ? _T("true") : _T("false") ); } else { text = otiStatic->GetStaticText(); if (_tcscmp( text, _T("true") ) == 0) ar.Write(true); else ar.Write(false); } }
void CQHState::Serialize( IArchive &ar ) { if( ar.IsReading() ) { float fVersion; ar.Read( fVersion, _T("version") ); if( 1.2f == fVersion ) { ReadFromVersion_1_2( ar ); } else if( 1.1f == fVersion ) { ReadFromVersion_1_1( ar ); } else if( 1.0f == fVersion ) { ReadFromVersion_1_0( ar ); } else { LPCTSTR fmt = _T("%s(%d): Unsupported version (%f) of state machine state"); m_ToolBox->Log( LOGERROR, fmt, __FILE__, __LINE__, fVersion ); return; } } else { ar.Write( m_fCurrentVersion, _T("version") ); ar.Write( m_Name.GetString(), _T("name") ); ar.Write( m_EntryEvent.GetString(), _T("entryEvent") ); ar.Write( m_UpdateEvent.GetString(), _T("updateEvent") ); ar.Write( m_ExitEvent.GetString(), _T("exitEvent") ); } }
void CModelViewRender::CreateScene() { Vec3 v3Zero(0.0f, 0.0f, 0.0f); EulerAngle eZero; Vec3 v3Scale(1.0f,1.0f,1.0f); StdString szEntityType(_T("EditorObject")); IArchive *pArchive = CreateMemoryArchive(); pArchive->Write(_T("EditorObject"), _T("EntityType")); pArchive->Write(v3Zero, _T("Position")); pArchive->Write(eZero, _T("Rotation")); pArchive->Write(v3Scale, _T("Scale")); pArchive->SetIsWriting(false); // Create Instance of CEntity static CHashString hszEntity(_T("CEntity")); CreateEEObject(&m_hszSceneName, &hszEntity, m_hszEntityName, pArchive); pArchive->Close(); m_v3Position.Set(0, 0, 0); m_v3CameraPos.Set(0.0f, 0.0f, 200.0f); m_v3Rotation.Set(0.0f, 0.0f, 0.0f); LoadModel(); }
void CDetailObject::Serialize( IArchive &ar ) { StdString temp; if(ar.IsReading()) { ar.Read(temp, "LayerLink"); m_LayerLink = temp.c_str(); ar.Read(temp, "ModelName"); m_ModelName = temp.c_str(); ar.Read(m_XCoverage, "XCoverage"); ar.Read(m_YCoverage, "YCoverage"); ar.Read(m_XRandomness, "XRandomness"); ar.Read(m_YRandomness, "YRandomness"); ar.Read(m_MinScale, "MinScale"); ar.Read(m_MinScale, "MaxScale"); ar.Read(m_MinYaw, "MinYaw"); ar.Read(m_MaxYaw, "MaxYaw"); } else { ar.Write(m_LayerLink.GetString(), "LayerLink"); ar.Write(m_ModelName.GetString(), "ModelName"); ar.Write(m_XCoverage, "XCoverage"); ar.Write(m_YCoverage, "YCoverage"); ar.Write(m_XRandomness, "XRandomness"); ar.Write(m_YRandomness, "YRandomness"); ar.Write(m_MinScale, "MinScale"); ar.Write(m_MinScale, "MaxScale"); ar.Write(m_MinYaw, "MinYaw"); ar.Write(m_MaxYaw, "MaxYaw"); } }
void CModelViewRender::LoadModel() { ASSERT(GetDocument() != NULL); CString strPath = GetDocument()->GetPathName(); LPCTSTR szPath = strPath; TCHAR extStr[_MAX_EXT]; TCHAR fileName[_MAX_FNAME]; _tsplitpath(szPath, NULL, NULL, fileName, extStr); if (strPath.IsEmpty()) { m_ToolBox->Log(LOGWARNING, _T("%s(%i):LoadModel shouldn't have been called with NULL path\n"), __FILE__, __LINE__); return; } StdString szFilename = fileName; szFilename += extStr; m_hszModelName = szFilename; CFileVersionSetter setter( _T("2.5") ); if (0 == _tcsicmp(extStr, _T(".cfg"))) { IArchive *pArchive = CreateMemoryArchive(); if (pArchive != NULL) { pArchive->Write(szPath, _T("Filepath")); pArchive->SetIsWriting(false); static CHashString hszCal3DRenderObject(_T("Cal3DRenderObject")); CreateEEObject(&m_hszEntityName, &hszCal3DRenderObject, m_hszModelName, pArchive); FillAnimationList(); pArchive->Close(); } } else if (0 == _tcsicmp(extStr, _T(".hrc"))) { IArchive *pArchive = CreateMemoryArchive(); if (pArchive != NULL) { pArchive->Write(szPath); pArchive->SetIsWriting(false); static CHashString hszCal3DRenderObject(_T("CHierarchicalModel")); CreateEEObject(&m_hszEntityName, &hszCal3DRenderObject, m_hszModelName, pArchive); pArchive->Close(); } } else { m_ToolBox->Log(LOGWARNING, _T("%s(%i):LoadModel was passed %s extension, which is not recognized\n"), __FILE__, __LINE__, extStr); } }
void COptionTreeWrapper::SerializeStaticItemDouble(IArchive &ar, COptionTreeItem *item, bool read) { double dVal; COptionTreeItemStatic *otiStatic; TCHAR buff[50]; CString text; otiStatic = dynamic_cast<COptionTreeItemStatic*>(item); if(otiStatic == NULL) { //error StdString error = _T("Could not cast item to COptionTreeItemStatic: "); error += item->GetLabelText(); ::MessageBox(NULL, error, _T("Invalid Command"), MB_OK); return; } if(read) { ar.Read(dVal); _stprintf(buff, "%g", dVal); otiStatic->SetStaticText(buff); } else { text = otiStatic->GetStaticText(); dVal = _tstof(text); ar.Write(dVal); } }
void COptionTreeWrapper::SerializeStaticItemInt(IArchive &ar, COptionTreeItem *item, bool read) { int iVal; COptionTreeItemStatic *otiStatic; TCHAR buffer[50]; CString text; otiStatic = dynamic_cast<COptionTreeItemStatic*>(item); if(otiStatic == NULL) { //error StdString error = _T("Could not cast item to COptionTreeItemStatic: "); error += item->GetLabelText(); ::MessageBox(NULL, error, _T("Invalid Command"), MB_OK); return; } if(read) { ar.Read(iVal); _itot(iVal, buffer, 10); otiStatic->SetStaticText(buffer); } else { text = otiStatic->GetStaticText(); iVal = _tstoi(text); ar.Write(iVal); } }
void COptionTreeWrapper::SerializeEditItemString(IArchive &ar, COptionTreeItem *item, bool read) { StdString szString; COptionTreeItemEdit *otiEdit; CString szItem; otiEdit = dynamic_cast<COptionTreeItemEdit*>(item); if(otiEdit == NULL) { //error StdString error = _T("Could not cast item to COptionTreeItemEdit: "); error += item->GetLabelText(); ::MessageBox(NULL, error, _T("Invalid Command"), MB_OK); return; } otiEdit->CreateEditItem(0, NULL); if (read) { ar.Read(szString); otiEdit->SetEditText(szString.c_str()); } else { otiEdit->GetWindowText(szItem); ar.Write(szItem); } }
void COptionTreeWrapper::SerializeEditItemDouble(IArchive &ar, COptionTreeItem *item, bool read) { double dVal; COptionTreeItemEdit *otiEdit; otiEdit = dynamic_cast<COptionTreeItemEdit*>(item); if(otiEdit == NULL) { //error StdString error = _T("Could not cast item to COptionTreeItemEdit: "); error += item->GetLabelText(); ::MessageBox(NULL, error, _T("Invalid Command"), MB_OK); return; } otiEdit->CreateEditItem(OT_EDIT_NUMERICAL, NULL); if(read) { ar.Read(dVal); otiEdit->SetEditDouble(dVal); } else { otiEdit->GetEditDouble(dVal); ar.Write(dVal); } }
DWORD CSchemaItem::GetType( DATABASEATTRIBUTEPARAMS *databaseAttributeParams ) { DWORD retVal = MSG_NOT_HANDLED; if( databaseAttributeParams != NULL ) { if( databaseAttributeParams->m_AttributeTypeArchive != NULL ) { IArchive *ar = databaseAttributeParams->m_AttributeTypeArchive; ar->SetIsWriting( true ); ar->SeekTo( 0 ); ar->Write( m_hszType.GetString() ); } else { m_ToolBox->Log( LOGWARNING, _T("No archive specified for GetAttributeType.\n") ); } retVal = MSG_HANDLED_STOP; } else { m_ToolBox->Log( LOGWARNING, _T("Attribute parameters not defined.\n") ); } return retVal; }
void COptionTreeWrapper::SerializeStaticItemString(IArchive &ar, COptionTreeItem *item, bool read) { StdString szString; COptionTreeItemStatic *otiStatic = dynamic_cast<COptionTreeItemStatic*>(item); CString szItem; if(otiStatic == NULL) { //error StdString error = _T("Could not cast item to COptionTreeItemStatic: "); error += item->GetLabelText(); ::MessageBox(NULL, error, _T("Invalid Command"), MB_OK); return; } if(read) { ar.Read(szString); otiStatic->SetStaticText(szString.c_str()); } else { szItem = otiStatic->GetStaticText(); ar.Write(szItem); } }
void COptionTreeWrapper::SerializeCheckBoxItem(IArchive &ar, COptionTreeItem *item, bool read) { bool bVal; COptionTreeItemCheckBox *otiCheckBox; otiCheckBox = dynamic_cast<COptionTreeItemCheckBox*>(item); if(otiCheckBox == NULL) { //error StdString error = _T("Could not cast item to COptionTreeItemCheckBox: "); error += item->GetLabelText(); ::MessageBox(NULL, error, _T("Invalid Command"), MB_OK); return; } if(read) { ar.Read(bVal); otiCheckBox->SetCheck(bVal); } else { bVal = (otiCheckBox->GetCheck() != 0); ar.Write(bVal); } }
void COptionTreeWrapper::SerializeSpinnerItemDouble(IArchive &ar, COptionTreeItem *item, bool read) { double dVal; COptionTreeItemSpinner *otiSpinner; otiSpinner = dynamic_cast<COptionTreeItemSpinner*>(item); if (otiSpinner == NULL) { //error StdString error = _T("Could not cast item to COptionTreeItemSpinner: "); error += item->GetLabelText(); ::MessageBox(NULL, error, _T("Invalid Command"), MB_OK); return; } if (read) { ar.Read(dVal); otiSpinner->SetEditDouble(dVal); } else { otiSpinner->GetEditDouble(dVal); ar.Write(dVal); } }
IArchive* CGUIStaticText::CreateAndFillArchive() { if (m_LanguageTextParams) { CREATEARCHIVE ca; static CHashString memType(_T("Memory")); ca.mode = STREAM_MODE_WRITE | STREAM_MODE_READ; ca.streamData = NULL; ca.streamSize = 0; ca.streamType = &memType; static DWORD msgHash_CreateArchive = CHashString(_T("CreateArchive")).GetUniqueID(); m_ToolBox->SendMessage(msgHash_CreateArchive, sizeof(CREATEARCHIVE), &ca); IArchive *ar = ca.archive; if (ar) { ar->SetIsWriting(true); ar->SeekTo(0); ar->Write(m_LanguageTextParams, m_iLangTextParamSize); } return ar; } else { return NULL; } }
void COptionTreeWrapper::SerializeRadioItem(IArchive &ar, COptionTreeItem *item, bool read) { StdString szVal; COptionTreeItemRadio *otiRadio; OT_RADIO_NODE *node; int index; otiRadio = dynamic_cast<COptionTreeItemRadio*>(item); if (item == NULL) { //error StdString error = _T("Could not cast item to COptionTreeItemRadio: "); error += item->GetLabelText(); ::MessageBox(NULL, error, _T("Invalid Command"), MB_OK); return; } if (read) { ar.Read(szVal); node = otiRadio->Node_FindNode(szVal.c_str()); if (node != NULL) { otiRadio->Node_UnCheckAll(); node->m_bChecked = true; } } else { index = otiRadio->Node_GetChecked(); node = otiRadio->Node_FindNode(index); ar.Write(node->m_strText); } }
void CModelViewRender::PlaySequence(const ANIMATIONSEQUENCE &sequence) { // make a copy of the requested sequence m_PlayingAnimationSequence.clear(); std::copy(sequence.begin(), sequence.end(), std::back_inserter(m_PlayingAnimationSequence)); m_itCurrentAnimationID = m_PlayingAnimationSequence.begin(); // create all the callbacks at once for the sequence set<int> uniqueCallbackSet; for (ANIMATIONSEQUENCE::iterator itrAnim = m_PlayingAnimationSequence.begin(); itrAnim != m_PlayingAnimationSequence.end(); itrAnim++) { // skip duplicate animations (only need to make one callback per animation) if (uniqueCallbackSet.find( *itrAnim ) != uniqueCallbackSet.end()) continue; IArchive* pArchive = CreateMemoryArchive(); pArchive->Write(m_hszEntityName.GetString(), _T("EntityName")); pArchive->Write(*itrAnim); pArchive->SetIsWriting(false); m_AnimationCallbackArchives.push_back( pArchive ); static CHashString hszCal3DRenderObject = _T("Cal3DRenderObject"); static CHashString hszCModelViewComponent(_T("CModelViewComponent")); static CHashString hszPlayAnimationSequenceStep(_T("PlayAnimationSequenceStep")); REGISTERCAL3DANIMATIONCALLBACK ac; ac.AnimationId = *itrAnim; ac.bTriggerOnComplete = true; ac.bTriggerOnStop = false; ac.StateObjectName = &hszCModelViewComponent; ac.EventName = &hszPlayAnimationSequenceStep; ac.EventParamsArchive = pArchive; static DWORD msgHash_RegisterAnimationCallback = CHashString(_T("RegisterAnimationCallback")).GetUniqueID(); DWORD res = m_ToolBox->SendMessage(msgHash_RegisterAnimationCallback, sizeof(ac), &ac, &m_hszEntityName, &hszCal3DRenderObject); if (MSG_HANDLED != res) { m_ToolBox->Log(LOGERROR, _T("%s(%i): Cannot register animation callback. \n"), __FILE__, __LINE__); } uniqueCallbackSet.insert( *itrAnim ); } if (HasAnimation()) { SINGLETONINSTANCE(CModelViewComponent)->PlayAnimation(this); } }
void COceanRenderObject::Serialize(IArchive &ar) { if(ar.IsReading()) { CHashString hszVersion = _T(""); float version; static DWORD msgHash_GetFileVersion = CHashString(_T("GetFileVersion")).GetUniqueID(); DWORD retval = m_ToolBox->SendMessage(msgHash_GetFileVersion, sizeof(IHashString), &hszVersion); if (retval != MSG_HANDLED) { m_ToolBox->Log(LOGERROR, _T("CEntity Serialize: Could not get file version!")); assert(0); return; } version = (float)_tstof(hszVersion.GetString()); if( version >= 3.0 ) { ar.Read( m_szFoamTexture, "FoamTexture" ); ar.Read( m_szEnvMapTexture, "EnvMapTexture" ); ar.Read( m_DiffuseColor, "DiffuseColor" ); ar.Read( m_AmbientValue, "AmbientValue" ); ar.Read( m_SunDir, "SunDir" ); ar.Read( m_fClipScale, "ClipScale" ); ar.Read( m_fClipOffset, "ClipOffset" ); ar.Read( m_fTextureScale, "TextureScale" ); ar.Read( m_fWindy, "Windy" ); } else { Vec3 temp; ar.Read( m_szFoamTexture, "FoamTexture" ); ar.Read( m_szEnvMapTexture, "EnvMapTexture" ); ar.Read( m_DiffuseColor, "DiffuseColor" ); ar.Read( m_AmbientValue, "AmbientValue" ); ar.Read( temp, "SunDir" ); m_SunDir.Set( temp.x, temp.z, -temp.y ); ar.Read( m_fClipScale, "ClipScale" ); ar.Read( m_fClipOffset, "ClipOffset" ); ar.Read( m_fTextureScale, "TextureScale" ); ar.Read( m_fWindy, "Windy" ); } } else { ar.Write( m_szFoamTexture, "FoamTexture" ); ar.Write( m_szEnvMapTexture, "EnvMapTexture" ); ar.Write( m_DiffuseColor, "DiffuseColor" ); ar.Write( m_AmbientValue, "AmbientValue" ); ar.Write( m_SunDir, "SunDir" ); ar.Write( m_fClipScale, "ClipScale" ); ar.Write( m_fClipOffset, "ClipOffset" ); ar.Write( m_fTextureScale, "TextureScale" ); ar.Write( m_fWindy, "Windy" ); } }
void CHeightmapObject::Serialize(IArchive &ar) { if (ar.IsReading()) { int iSize = 0; ar.Read( iSize ); iSize = EE_ENDIANSWAP32( iSize ); m_iWidth = iSize; m_iHeight = iSize; SAFE_DELETE_ARRAY( m_pHeightmapData ); int iSamples = iSize * iSize; if( iSamples > 0 ) { float f; m_pHeightmapData = new float[iSamples]; for( int i = 0; i < iSamples; ++i ) { ar.Read( f ); m_pHeightmapData[i] = EE_ENDIANSWAP32F( f ); } } } else { int iSize = m_iWidth; ar.Write( iSize ); int iSamples = iSize * iSize; if( m_pHeightmapData != NULL ) { for( int i = 0; i < iSamples; ++i ) { ar.Write( m_pHeightmapData[i] ); } } else { for( int i = 0; i < iSamples; ++i ) { ar.Write( 0.0f ); } } } }
void CPrecacheObject::Serialize( IArchive &ar ) { if( ar.IsReading() ) { // Version ar.Read( m_iVersion ); // Number of Entries unsigned int tmpCount; ar.Read( tmpCount ); // Read Entries and insert into the list for( unsigned int i = 0; i < tmpCount; i++ ) { CHashString hszResourceName; StdString szResourceName; ar.Read( szResourceName ); hszResourceName.Init( szResourceName ); m_ResourceSet.insert( hszResourceName.GetUniqueID()); } } else { // Version ar.Write( m_iVersion, _T("Version") ); // Number of Entries ar.Write( (int)m_ResourceSet.size(), _T("NumEntries") ); // Write out all the Entries from the list RESOURCESET::iterator itr = m_ResourceSet.begin(); StdString szPrecacheEntry( _T("PrecacheEntry") ); while( itr != m_ResourceSet.end() ) { ar.StartClass( szPrecacheEntry ); ar.Write( m_ToolBox->GetHashString( *itr ), _T("Name") ); ar.EndClass(); itr++; } } }
void GameComponent::SetGlobalAttribute( IHashString *attributeName, bool value ) { if( attributeName != NULL ) { IArchive *archive = CreateMemoryArchive(); archive->SetIsWriting( true ); archive->Write( (bool)value ); archive->SetIsWriting( false ); SetGlobalAttribute( attributeName, archive ); archive->Close(); } }
void CLuaScript::Serialize(IArchive &ar) { if(ar.IsReading()) { ar.Read(m_ScriptName); ar.Read(m_bAutoStart); } else { ar.Write(m_ScriptName); ar.Write(m_bAutoStart); } }
void CQHStateMachineActionHandler::Serialize( IArchive &ar ) { if( ar.IsReading() ) { float fVersion; StdString tempStr; ar.Read( fVersion, _T("version") ); if( fVersion > m_fCurrentVersion ) { LPCTSTR fmt = _T("%s(%d): Unsupported version (%f) of state machine action handler"); m_ToolBox->Log( LOGERROR, fmt, __FILE__, __LINE__, fVersion ); return; } ar.Read( tempStr, _T("name") ); m_szName.Init( tempStr ); ar.Read( tempStr, _T("actionName") ); m_szActionName.Init( tempStr ); IComponent *amanagerComponent = m_ToolBox->GetComponent( GetManagerName() ); CQHStateMachineManager *amanager = static_cast<CQHStateMachineManager*>( amanagerComponent ); CQHStateMachineEvent *aparentEvent = amanager->GetEvent( GetParentName() ); if( aparentEvent != NULL ) { aparentEvent->AddActionHandler( this ); } else { m_ToolBox->Log( LOGERROR, _T("Could not find parent event %s for action handler %s."), GetParentName()->GetString(), GetName()->GetString() ); } } else { ar.Write( m_fCurrentVersion, _T("version") ); ar.Write( m_szName.GetString(), _T("name") ); ar.Write( m_szActionName.GetString(), _T("actionName") ); } }
void CSchemaItem::Serialize( IArchive &ar ) { if( ar.IsReading() ) { StdString name; // Dummy variable to read the name. It should already be stored as CObjectTemplate StdString type; StdString attributeClass; ar.Read( m_fVersion, _T("Version") ); ar.Read( name, _T("Name") ); ar.Read( type, _T("Type") ); ar.Read( attributeClass, _T("Class") ); m_hszLabel.Init( name ); m_hszType.Init( type ); m_hszClass.Init( attributeClass ); DBRead( &m_DefaultValue, &ar, _T("Default") ); // IMPORTANT: DBRead is dependent on m_hszType. Make sure m_hszType has been initialized before calling DBRead. // NOTE: We are assuming the order in which schema items are instantiated will be // the order in which to read data items. if( m_Schema != NULL ) { m_Schema->RegisterSchemaItem( this ); } } else { ar.StartClass(_T("CSchemaItem")); ar.Write( m_fVersion, _T("Version") ); ar.Write( m_hszLabel.GetString(), _T("Name") ); ar.Write( m_hszType.GetString(), _T("Type") ); ar.Write( m_hszClass.GetString(), _T("Class") ); DBWrite( &m_DefaultValue, &ar, _T("Default") ); ar.EndClass(); } }
void COptionTreeWrapper::SerializeFileItem(IArchive &ar, COptionTreeItem *item, bool read) { StdString fileName; COptionTreeItemFile *otiFile; CString szItem; otiFile = dynamic_cast<COptionTreeItemFile*>(item); if(otiFile == NULL) { //error StdString error = _T("Could not cast item to COptionTreeItemFile: "); error += item->GetLabelText(); ::MessageBox(NULL, error, _T("Invalid Command"), MB_OK); return; } if (read) { ar.Read(fileName); CString fName = (const TCHAR*)fileName; GetRelativePath(fName, szItem); if ( _tcscmp(szItem, _T("")) != 0 ) { otiFile->SetFileString(szItem); } } else { // Try to convert to a relative path if( !GetRelativePath(otiFile->GetFileString(), szItem) ) { // if an invalid path reset the string otiFile->ResetFileString(); // run it through the relative pathizer again GetRelativePath(otiFile->GetFileString(), szItem); } // CGDSApp *app = DYNAMIC_DOWNCAST(CGDSApp, AfxGetApp()); // CString resourcePath = app->GetResourcePath(); StdString rootDir, resDir; EngineGetToolBox()->GetDirectories(&rootDir, &resDir); resDir += "\\"; resDir += szItem; otiFile->SetFileString( szItem ); // do not want to save absolute path! my bad // ar.Write(resDir); ar.Write(szItem); } }
void COptionTreeWrapper::SerializeComboItem(IArchive &ar, COptionTreeItem *item, bool read) { StdString defaultSelect; COptionTreeItemComboBox *otiCombo; CString szItem; int index; otiCombo = dynamic_cast<COptionTreeItemComboBox*>(item); if(otiCombo == NULL) { //error StdString error = _T("Could not cast item to COptionTreeItemCombo: "); error += item->GetLabelText(); ::MessageBox(NULL, error, _T("Invalid Command"), MB_OK); return; } if(read) { ar.Read(defaultSelect); if( _tcscmp( defaultSelect, _T("")) != 0 ) { index = otiCombo->FindStringExact(0, defaultSelect.c_str()); otiCombo->SetCurSel((index >= 0) ? index : 0); } } else { int sel = otiCombo->GetCurSel(); if(sel == CB_ERR) { //display some message? } otiCombo->GetLBText(sel, szItem); ar.Write(szItem); } }
///////////////////////////////////////////////////////////// // LOAD PARTICLE EMITTER ///////////////////////////////////////////////////////////// DWORD CParticleLoader::OnLoadParticleFile(DWORD size, void *params) { PERFORMANCE_PROFILER_AUTO(ParticleLoader_loadfile); VERIFY_MESSAGE_SIZE(size, sizeof(TCHAR *)); TCHAR *pFilepath = (TCHAR *)params; StdString szFilename = ExtractFileName(pFilepath); CHashString hszFilename(szFilename); StdString szFilepath(pFilepath); CHashString hszFilepath(pFilepath); DWORD result; // Search for Object to see if it is already loaded // Check using the FindObject Message if the CParticleEmitter exists static DWORD msgHash_FindObject = CHashString(_T("FindObject")).GetUniqueID(); FINDOBJECTPARAMS param; param.hszName = &hszFilepath; result = m_ToolBox->SendMessage(msgHash_FindObject, sizeof(FINDOBJECTPARAMS), ¶m); if (param.bFound == true) { //Object Exists return MSG_HANDLED_STOP; } // Create XMLArchive using IXML IXMLArchive *XMLar; CHashString streamType(_T("File")); CREATEARCHIVE ca; ca.mode = STREAM_MODE_READ; ca.streamData = pFilepath; ca.streamType = &streamType; static DWORD msgHash_CreateXMLArchive = CHashString(_T("CreateXMLArchive")).GetUniqueID(); result = EngineGetToolBox()->SendMessage(msgHash_CreateXMLArchive, sizeof(CREATEARCHIVE), &ca); if( result != MSG_HANDLED ) { m_ToolBox->Log(LOGWARNING, _T("Failed to load particle file: \"%s\"!\n"), szFilepath.c_str() ); return MSG_ERROR; } XMLar = dynamic_cast<IXMLArchive *>(ca.archive); // break out if XMLar is NULL. if( !XMLar ) { m_ToolBox->Log(LOGWARNING, _T("Failed to load particle file: \"%s\"!\n"), szFilepath.c_str() ); XMLar->Close(); return MSG_ERROR; } // Create MemArchive using IAR IArchive *MemArchive; CHashString memType(_T("Memory")); CREATEARCHIVE caOut; caOut.mode = STREAM_MODE_READ | STREAM_MODE_WRITE; caOut.streamData = NULL; caOut.streamSize = 0; caOut.streamType = &memType; static DWORD msgHash_CreateArchive = CHashString(_T("CreateArchive")).GetUniqueID(); if (m_ToolBox->SendMessage(msgHash_CreateArchive, sizeof(CREATEARCHIVE), &caOut) != MSG_HANDLED) return MSG_ERROR; MemArchive = caOut.archive; // EMITTER PARSE VALUES PARTICLEPROPERTIESKEY k; StdString szEmitterCheck; StdString szEmitterName; int numBrushes = 0; int numKeyframes = 0; StdString szType; StdString szBrushFilename; StdString szPropertyName; // Archive -> GetNode (this should be "CParticleEmitter" ) XMLar->GetNode(szEmitterCheck); // if this is particle line type, load it if ( szEmitterCheck == _T("CParticleLineType") ) { static CHashString hszCParticleLineType(_T("CParticleLineType")); AddLoadedParticleType( &hszFilepath, &hszCParticleLineType, XMLar ); m_ParticleObjectMap[ hszFilepath.GetUniqueID() ] = hszFilepath.GetUniqueID(); XMLar->Close(); MemArchive->Close(); return MSG_HANDLED_STOP; } // if this is particle ribbon type, load it if ( szEmitterCheck == _T("CParticleRibbonType") ) { static CHashString hszCParticleRibbonType(_T("CParticleRibbonType")); AddLoadedParticleType( &hszFilepath, &hszCParticleRibbonType, XMLar ); m_ParticleObjectMap[ hszFilepath.GetUniqueID() ] = hszFilepath.GetUniqueID(); XMLar->Close(); MemArchive->Close(); return MSG_HANDLED_STOP; } if ( szEmitterCheck != _T("ParticleEmitter") ) { // Exit out if GetNode != CParticleEmitter XMLar->Close(); MemArchive->Close(); return MSG_ERROR; } MemArchive->SetIsWriting(true); // PARSE HEADER // READ XMLar->Read(szEmitterName, _T("name")); XMLar->Read(numBrushes, _T("brushes")); XMLar->Read(numKeyframes, _T("keyframes")); // WRITE // MemArchive->Write( szFilename, _T("filename") ); MemArchive->Write( szEmitterName, _T("name")); MemArchive->Write( PARTICLE_SERIALIZE_NORMAL, _T("flag")); MemArchive->Write( numBrushes, _T("brushes")); MemArchive->Write( numKeyframes, _T("keyframes")); // PARSE BRUSHES for (int i = 0; i < numBrushes; i++) { XMLar->GetNode(szType); if (szType == _T("Brush")) { // READ XMLar->Read(szBrushFilename, _T("file")); // WRITE MemArchive->Write( szBrushFilename, _T("file")); } // Too many keyframes or invalid brush node else { XMLar->Close(); MemArchive->Close(); return MSG_ERROR; } } // PARSE KEYFRAMES for (int i = 0 ; i < numKeyframes ; i++) { XMLar->GetNode(szType); if (szType == _T("Keyframe")) { // READ XMLar->Read(szPropertyName, _T("type")); XMLar->Read(k.time, _T("time")); XMLar->Read(k.value, _T("value")); // WRITE MemArchive->Write( szPropertyName, _T("type")); MemArchive->Write( k.time, _T("time")); MemArchive->Write( k.value, _T("value")); } // Too many keyframes or invalid keyframe node else { XMLar->Close(); MemArchive->Close(); return MSG_ERROR; } } XMLar->Close(); // Change the Memarchive to read; MemArchive->SetIsWriting(false); CHashString hszParticleManager = _T("CParticleManager"); PARTICLELOADINFO pli; pli.filepath = &hszFilepath; pli.data = MemArchive; static DWORD msgHash_AddLoadedEmitter = CHashString(_T("AddLoadedEmitter")).GetUniqueID(); result = m_ToolBox->SendMessage(msgHash_AddLoadedEmitter, sizeof( PARTICLELOADINFO), &pli); if (result != MSG_HANDLED) { m_ToolBox->Log(LOGERROR, _T("%s(%d): ParticleLoader failed to add emitter %s to manager map\n"), __FILE__, __LINE__, hszFilepath.GetString()); } // Clean up temporary data. MemArchive->Close(); return MSG_HANDLED_STOP; }
void CModelViewRender::InitRenderScene() { // set active scene to model view scene so objects created here will be placed in the correct scene SetActiveScene(); //Create Cal3DRenderObject from loaded file CreateScene(); // create a new Memory Archive IArchive *pArchive = CreateMemoryArchive(); if (pArchive == NULL) { return; } StdString szEntityType(_T("EditorObject")); //Vec3 v3Zero(0.0f, 0.0f, 0.0f); Vec3 v3EntityLightPosition(0.0f, 200.0f, 200.0f); EulerAngle eaZero; Vec3 v3Scale(1.0f, 1.0f, 1.0f); pArchive->Write(szEntityType, _T("EntityType")); pArchive->Write(v3EntityLightPosition, _T("Position")); pArchive->Write(eaZero, _T("Rotation")); pArchive->Write(v3Scale, _T("Scale")); pArchive->SetIsWriting(false); CFileVersionSetter setter; // Create the CEntity LightObject Parent ///////////////////////////////////////////////////////// static CHashString hszCEntity(_T("CEntity")); if (CreateEEObject(&m_hszSceneName, &hszCEntity, m_hszLightEntityName, pArchive)) { pArchive->SetIsWriting(true); pArchive->SeekTo(0); int iVersionNumber = 1000; Vec3 v3LightPosition( 0.0, 0.0f, 0.0f ); Vec3 v3LightDirection( 0.0f, 0.0f, 0.0f ); float fAttenuation = 99999.0f; float fColor[] = { 0.75f, 0.75f, 0.75f, 1.0f }; StdString szLightType(_T("OMNI_POINT_LIGHT")); bool bCastShadows = false; UINT numKeys = 0; pArchive->Write(iVersionNumber, _T("Version")); pArchive->Write(v3LightPosition, _T("Position")); pArchive->Write(v3LightDirection, _T("Direction")); pArchive->Write(fAttenuation, _T("Attenuation")); pArchive->Write(fColor[0], _T("ColorRed") ); pArchive->Write(fColor[1], _T("ColorGreen") ); pArchive->Write(fColor[2], _T("ColorBlue") ); pArchive->Write(fColor[3], _T("ColorAlpha") ); pArchive->Write(szLightType, _T("LightType") ); pArchive->Write(bCastShadows, _T("CastShadows") ); pArchive->Write(numKeys, _T("NumKeyframes") ); pArchive->SetIsWriting(false); // Create the Light Object //////////////////////////////////////////////////////////////// static CHashString hszCLightObject(_T("CLightObject")); CreateEEObject(&m_hszLightEntityName, &hszCLightObject, m_hszLightObjectName, pArchive); } pArchive->Close(); }
///////////////////////////////////////////////////////////// // LOAD PARTICLE BRUSH ///////////////////////////////////////////////////////////// DWORD CParticleLoader::OnLoadParticleBrush(DWORD size, void *params) { VERIFY_MESSAGE_SIZE(size, sizeof(TCHAR *)); TCHAR *pFilepath = (TCHAR *)params; StdString szFilename = ExtractFileName(pFilepath); CHashString hszFilename(szFilename); StdString szFilepath(pFilepath); CHashString hszFilepath(pFilepath); DWORD result; // Search for Object to see if it is already loaded // Check using the FindObject Message if the CParticleEmitter exists static DWORD msgHash_FindObject = CHashString(_T("FindObject")).GetUniqueID(); FINDOBJECTPARAMS param; param.hszName = &hszFilename; result = m_ToolBox->SendMessage(msgHash_FindObject, sizeof(FINDOBJECTPARAMS), ¶m); if (param.bFound == true) { //Object Exists return MSG_HANDLED_STOP; } // Create XMLArchive using IXML IXMLArchive *XMLar; CHashString streamType(_T("File")); CREATEARCHIVE ca; ca.mode = STREAM_MODE_READ; ca.streamData = pFilepath; ca.streamType = &streamType; static DWORD msgHash_CreateXMLArchive = CHashString(_T("CreateXMLArchive")).GetUniqueID(); result = EngineGetToolBox()->SendMessage(msgHash_CreateXMLArchive, sizeof(CREATEARCHIVE), &ca); if( result != MSG_HANDLED ) { m_ToolBox->Log(LOGWARNING, _T("Failed to load particle file: \"%s\"!\n"), szFilepath.c_str() ); return MSG_ERROR; } XMLar = dynamic_cast<IXMLArchive *>(ca.archive); // break out if XMLar is NULL. if( !XMLar ) { m_ToolBox->Log(LOGWARNING, _T("Failed to load particle file: \"%s\"!\n"), szFilepath.c_str() ); XMLar->Close(); return MSG_ERROR; } // Create MemArchive using IAR IArchive *MemArchive; CHashString memType(_T("Memory")); CREATEARCHIVE caOut; caOut.mode = STREAM_MODE_READ | STREAM_MODE_WRITE; caOut.streamData = NULL; caOut.streamSize = 0; caOut.streamType = &memType; static DWORD msgHash_CreateArchive = CHashString(_T("CreateArchive")).GetUniqueID(); if (m_ToolBox->SendMessage(msgHash_CreateArchive, sizeof(CREATEARCHIVE), &caOut) != MSG_HANDLED) { XMLar->Close(); return MSG_ERROR; } MemArchive = caOut.archive; // BRUSH PARSE VALUES StdString szType; StdString szPropertyName; StdString szBrushCheck; StdString szBrushName; bool additive; int nKeyframes; float framerate; float texturerate; StdString szTexturePath; bool loop; float AttachToEmitter; StdString szShader; PARTICLEPROPERTIESKEY k; // Archive -> GetNode (this should be "ParticleBrush" ) XMLar->GetNode(szBrushCheck); if ( szBrushCheck != _T("ParticleBrush") ) { // Exit out if GetNode != ParticleBrush XMLar->Close(); MemArchive->Close(); return MSG_ERROR; } MemArchive->SetIsWriting(true); // PARSE HEADER // READ XMLar->Read( szBrushName, _T("name")); XMLar->Read( additive, _T("additive")); XMLar->Read( framerate, _T("framerate")); XMLar->Read( texturerate, _T("texturerate")); XMLar->Read( szTexturePath, _T("texture")); XMLar->Read( loop, _T("loop")); XMLar->Read( AttachToEmitter, _T("AttachToEmitter")); XMLar->Read( szShader, _T("shader")); XMLar->Read( nKeyframes, _T("keyframes")); // WRITE // MemArchive->Write( szFilename, _T("filename") ); // MemArchive->Write( szFilepath, _T("filepath") ); MemArchive->Write( szBrushName, _T("name")); MemArchive->Write( additive, _T("additive")); MemArchive->Write( framerate, _T("framerate")); MemArchive->Write( texturerate, _T("texturerate")); MemArchive->Write( szTexturePath, _T("texture")); MemArchive->Write( loop, _T("loop")); MemArchive->Write( AttachToEmitter, _T("AttachToEmitter")); MemArchive->Write( szShader, _T("shader")); MemArchive->Write( PARTICLE_SERIALIZE_NORMAL, _T("flag")); MemArchive->Write( nKeyframes, _T("keyframes")); // PARSE KEYFRAMES for (int i = 0 ; i < nKeyframes ; i++) { XMLar->GetNode(szType); if (szType == _T("Keyframe")) { // READ XMLar->Read(szPropertyName, _T("type")); XMLar->Read(k.time, _T("time")); XMLar->Read(k.value, _T("value")); // WRITE MemArchive->Write( szPropertyName, _T("type")); MemArchive->Write( k.time, _T("time")); MemArchive->Write( k.value, _T("value")); } // Too many keyframes or invalid keyframe node else { XMLar->Close(); MemArchive->Close(); return MSG_ERROR; } } XMLar->Close(); // Change the Memarchive to read; MemArchive->SetIsWriting(false); CHashString hszParticleManager = _T("CParticleManager"); PARTICLELOADINFO pli; pli.filepath = &hszFilepath; pli.data = MemArchive; static DWORD msgHash_AddLoadedBrush = CHashString(_T("AddLoadedBrush")).GetUniqueID(); result = m_ToolBox->SendMessage(msgHash_AddLoadedBrush, sizeof( PARTICLELOADINFO), &pli); if (result != MSG_HANDLED) { m_ToolBox->Log(LOGERROR, _T("ParticleLoader failed to add emitter to manager map")); } // Object Serialized, close memarchive; MemArchive->Close(); return MSG_HANDLED_STOP; }
///////////////////////////////////////////////////////////// // New Particle Brush ///////////////////////////////////////////////////////////// DWORD CParticleLoader::OnNewParticleBrush(DWORD size, void *params) { VERIFY_MESSAGE_SIZE(size, sizeof(TCHAR *)); TCHAR *czFilepath = (TCHAR *)params; StdString szFilename = ExtractFileName(czFilepath); CHashString hszFilename(szFilename); StdString szFilepath(czFilepath); CHashString hszFilepath(czFilepath); CREATE_PARTICLE_STRING_TABLE(BrushPropertyStringTable); DWORD result; // Search for Object to see if it is already loaded // Check using the FindObject Message if the CParticleEmitter exists static DWORD msgHash_FindObject = CHashString(_T("FindObject")).GetUniqueID(); FINDOBJECTPARAMS param; param.hszName = &hszFilename; result = m_ToolBox->SendMessage(msgHash_FindObject, sizeof(FINDOBJECTPARAMS), ¶m); if (param.bFound == true) { //Object Exists return MSG_HANDLED_STOP; } // Use Create Object Message to create the object (use the filename as the name) CHashString hszTypeName(_T("CParticleType")); CREATEOBJECTPARAMS cop; cop.name = &hszFilename; cop.parentName = NULL; cop.typeName = &hszTypeName; static DWORD msgHash_CreateObject = CHashString(_T("CreateObject")).GetUniqueID(); result = m_ToolBox->SendMessage(msgHash_CreateObject, sizeof(CREATEOBJECTPARAMS), &cop); if (result == MSG_ERROR) return MSG_ERROR; // Create MemArchive using IAR IArchive *MemArchive; CHashString memType(_T("Memory")); CREATEARCHIVE caOut; caOut.mode = STREAM_MODE_READ | STREAM_MODE_WRITE; caOut.streamData = NULL; caOut.streamSize = 0; caOut.streamType = &memType; static DWORD msgHash_CreateArchive = CHashString(_T("CreateArchive")).GetUniqueID(); result = m_ToolBox->SendMessage(msgHash_CreateArchive, sizeof(CREATEARCHIVE), &caOut); if (result == MSG_ERROR) return MSG_ERROR; MemArchive = caOut.archive; // Change the Memarchive to write MemArchive->SetIsWriting(true); // Write Initial Emitter Properties: // WRITE INTERNAL DATA MemArchive->Write( szFilename, _T("filename") ); MemArchive->Write( szFilepath, _T("filepath") ); // WRITE FILE HEADER MemArchive->Write( _T("NewEmitter"), _T("name")); MemArchive->Write( false, _T("additive")); MemArchive->Write( 30.0f, _T("framerate")); MemArchive->Write( 30.0f, _T("texturerate")); MemArchive->Write( _T(""), _T("texture")); MemArchive->Write( false, _T("loop")); MemArchive->Write( 0.0f, _T("AttachToEmitter")); MemArchive->Write( _T(""), _T("shader")); MemArchive->Write( PARTICLE_VARIABLE_MAX, _T("keyframes")); // WRITE PROPERTIES for (int i = 0; i < PARTICLE_VARIABLE_MAX; i++) { MemArchive->Write(BrushPropertyStringTable[i], _T("type")); MemArchive->Write(0.0f, _T("time")); MemArchive->Write(0.0f, _T("value")); } // Change the Memarchive to read MemArchive->SetIsWriting(false); // Serialize out Emitter Data SERIALIZEOBJECTPARAMS sop; sop.archive = MemArchive; sop.name = &hszFilename; static DWORD msgHash_SerializeObject = CHashString(_T("SerializeObject")).GetUniqueID(); result = m_ToolBox->SendMessage(msgHash_SerializeObject, sizeof(SERIALIZEOBJECTPARAMS), &sop, NULL, NULL); if (result == MSG_ERROR) { MemArchive->Close(); return MSG_ERROR; } // Object Serialized, close memarchive; MemArchive->Close(); // Use the Init Message with the MemArchive INITOBJECTPARAMS iop; iop.name = &hszFilename; static DWORD msgHash_InitObject = CHashString(_T("InitObject")).GetUniqueID(); m_ToolBox->SendMessage(msgHash_InitObject, sizeof(INITOBJECTPARAMS), &iop, NULL, NULL); return MSG_HANDLED_STOP; }
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; }