bool CSoundLoader::LoadPlaylistFile(const TCHAR* fileName) { CHashString hszFileName(fileName); CHashString streamType(_T("File")); CREATEARCHIVE ca; ca.streamData = (void *)fileName; ca.mode = STREAM_MODE_READ; ca.streamType = &streamType; static DWORD msgHash_CreateXMLArchive = CHashString(_T("CreateXMLArchive")).GetUniqueID(); if (m_ToolBox->SendMessage(msgHash_CreateXMLArchive, sizeof(CREATEARCHIVE), &ca) != MSG_HANDLED) { m_ToolBox->Log(LOGWARNING, _T("Could not create archive for playlist %s\n"), (const TCHAR*)fileName); return false; } LOADPLAYLISTPARAMS lpp; lpp.fileName = &hszFileName; lpp.ar = ca.archive; static DWORD msgHash_LoadMusicPlaylist = CHashString(_T("LoadMusicPlaylist")).GetUniqueID(); if (m_ToolBox->SendMessage(msgHash_LoadMusicPlaylist, sizeof(LOADPLAYLISTPARAMS), &lpp) != MSG_HANDLED) { m_ToolBox->Log(LOGWARNING, _T("Could not send playlist data to sound manager\n")); return false; } ca.archive->Close(); return true; }
DWORD CInputManager::OnLoadKeyBinding(DWORD msgSize, void *param) { IHashString *szhFileName; VERIFY_MESSAGE_SIZE(msgSize, sizeof(IHashString*)); szhFileName = (IHashString*)param; StdString szNodeName; IXMLArchive *Archive; CHashString streamType(_T("File")); CREATEARCHIVE ca; DWORD retVal = MSG_NOT_HANDLED; ca.streamData = (void*)szhFileName->GetString(); ca.mode = STREAM_MODE_READ; ca.streamType = &streamType; // call the Archive factory to create an XML archive static DWORD msgHash_CreateXMLArchive = CHashString(_T("CreateXMLArchive")).GetUniqueID(); if (retVal = m_ToolBox->SendMessage(msgHash_CreateXMLArchive, sizeof(CREATEARCHIVE), &ca) != MSG_HANDLED) { //log error m_ToolBox->SetErrorValue(WARN_INVALID_OPERATION); m_ToolBox->Log(LOGWARNING, _T("CInputManager: Could not create archive from: %s\n"), szhFileName->GetString()); return MSG_NOT_HANDLED; } Archive = dynamic_cast<IXMLArchive *>(ca.archive); int num; CHashString curKeyBind(_T("")); StdString keybindName; StdString parentType; StdString childType; StdString msg; int key; bool hitOnce; Archive->GetNode(szNodeName); Archive->Read(keybindName, _T("name")); Archive->Read(num, _T("num")); curKeyBind = keybindName.c_str(); while (num != 0) { Archive->Read( msg, _T("msg") ); Archive->Read( key, _T("key") ); Archive->Read( hitOnce, _T("hitOnce") ); //Add Entry to page CHashString szMessage(msg); KEYBINDINGMAP &curPage = m_KeyMap[ curKeyBind.GetUniqueID() ]; curPage[ key ].msg = szMessage.GetUniqueID(); curPage[ key ].hitOnce = hitOnce; num--; } Archive->Close(); return MSG_HANDLED_STOP; }
void CWorldEventToolPal::UpdateWorldEventTrigger( void ) { static DWORD msgHash_FindObject = CHashString(_T("FindObject")).GetUniqueID(); static DWORD msgHash_GetComponentType = CHashString(_T("GetComponentType")).GetUniqueID(); static DWORD msgHash_CreateArchive = CHashString(_T("CreateArchive")).GetUniqueID(); static DWORD msgHash_SerializeObject = CHashString(_T("SerializeObject")).GetUniqueID(); static CHashString Hash_Type = CHashString(_T("CWorldEventTrigger")); CString buf; m_Name.GetLBText(m_Name.GetCurSel(), buf); CHashString hszName((TCHAR*)buf.GetBuffer()); FINDOBJECTPARAMS param; param.hszName = &hszName; DWORD result = m_ToolBox->SendMessage(msgHash_FindObject, sizeof(FINDOBJECTPARAMS), ¶m); // object exists if( param.bFound == true ) { GETCOMPONENTTYPEPARAMS gctp; gctp.name = &hszName; m_ToolBox->SendMessage(msgHash_GetComponentType, sizeof(gctp), &gctp); // it is a world event, get values from it if ( (gctp.componenttype != NULL) && (gctp.componenttype->GetUniqueID() == Hash_Type.GetUniqueID()) ) { CREATEARCHIVE ca; CHashString streamType(_T("Memory")); ca.streamData = NULL; ca.mode = STREAM_MODE_WRITE | STREAM_MODE_READ; ca.streamType = &streamType; m_ToolBox->SendMessage(msgHash_CreateArchive, sizeof(CREATEARCHIVE), &ca, NULL, NULL); IArchive *MemArchive = (ca.archive); MemArchive->SetIsWriting(true); MemArchive->SeekTo(0); SERIALIZEOBJECTPARAMS sop; sop.name = &hszName; sop.archive = MemArchive; m_ToolBox->SendMessage(msgHash_SerializeObject, sizeof(SERIALIZEOBJECTPARAMS), &sop, NULL, NULL); MemArchive->SetIsWriting(false); MemArchive->SeekTo(0); StdString tmp; MemArchive->Read( tmp ); m_EntityName.SetWindowText( tmp.c_str() ); MemArchive->Read( tmp ); m_EntityType.SetWindowText( tmp.c_str() ); MemArchive->Read( tmp ); m_EventName.SetWindowText( tmp.c_str() ); MemArchive->Close(); } } }
/// \brief Populate the LINKMAP from an XML file /// \param fileName - The name of the XML file to load void CEditorManager::LoadLinkMap( StdString &fileName ) { CREATEARCHIVE ca; IXMLArchive *ar; IToolBox *toolBox = EngineGetToolBox(); StdString elementName; StdString source; StdString dest; CHashString streamType(_T("File")); ca.streamData = (void*)(fileName.c_str()); ca.mode = STREAM_MODE_READ; ca.streamType = &streamType; // Try opening the archive static DWORD msgHash_CreateXMLArchive = CHashString(_T("CreateXMLArchive")).GetUniqueID(); if (toolBox->SendMessage(msgHash_CreateXMLArchive, sizeof(CREATEARCHIVE), &ca) != MSG_HANDLED) { std::string szText; szText = "Failed to load xml format file: "; szText += fileName; ::MessageBox(NULL, szText.c_str(), "Warning!", MB_OK|MB_ICONEXCLAMATION); } // Start reading from the archive ar = dynamic_cast<IXMLArchive *>(ca.archive); // skip the header info ar->GetNode(elementName); while (ar->GetNode(elementName)) { if (elementName == _T("Link")) { ar->Read(source); ar->Read(dest); CHashString hashSrc(source); CHashString hashDest(dest); m_LinkMap.insert( LINKPAIR(hashDest.GetUniqueID(), hashSrc.GetUniqueID() ) ); } } ar->Close(); }
IBaseTextureObject * CTextureManager::LoadCubeDDSTexture( IHashString* name ) { //Open the data stream DWORD result; IArchive *FileArchive; CHashString streamType(_T("File")); CREATEARCHIVE ca; ca.mode = STREAM_MODE_READ | STREAM_MODE_BINARY; ca.streamData = (void*)name->GetString(); ca.streamType = &streamType; static DWORD msgHash_CreateArchive = CHashString(_T("CreateArchive")).GetUniqueID(); result = m_ToolBox->SendMessage(msgHash_CreateArchive, sizeof(CREATEARCHIVE), &ca); IBaseTextureObject *pTexture = NULL; if( result == MSG_HANDLED ) { FileArchive = dynamic_cast<IArchive *>(ca.archive); //Check DDS UINT fourcc; FileArchive->Read( fourcc ); if( EE_ENDIANSWAP32(fourcc) != MAKEFOURCC( 'D', 'D', 'S', ' ' ) ) { return NULL; } DDSHeader header; char * pheader = (char*)&header; //DDS, start loading header for( int i = 0; i < sizeof( header ); i++ ) { FileArchive->Read( (*pheader) ); pheader++; } //close the file, no longer needed FileArchive->Close(); if( IsDDSCubeMap( header ) ) { static CHashString DX9CubeTexObj(_T("CDX9CubeTextureObject")); pTexture = CreateTextureObject( name, &DX9CubeTexObj); pTexture->LoadFromFile( name->GetString() ); } } return pTexture; }
///////////////////////////////////////////////////////////// // LOAD MESH FILE ///////////////////////////////////////////////////////////// DWORD CCal3dMeshLoader::OnLoadCal3dCMFFile(DWORD size, void *params) { VERIFY_MESSAGE_SIZE(size, sizeof(TCHAR *)); // Get the Filepath and convert it all to lower case TCHAR* ptmp = (TCHAR *)params; // store the stdstring and chashstring version StdString szFilepath( ptmp ); szFilepath.MakeSafeFileName(); CHashString hszFilepath( szFilepath ); static DWORD msgHash_FindObject = CHashString(_T("FindObject")).GetUniqueID(); FINDOBJECTPARAMS param; param.hszName = &hszFilepath; if( EngineGetToolBox()->SendMessage(msgHash_FindObject, sizeof(FINDOBJECTPARAMS), ¶m) != MSG_HANDLED) return MSG_ERROR; if (param.bFound == true) return MSG_HANDLED_STOP; CHashString streamType(_T("Memory")); CREATEARCHIVE ca; ca.mode = STREAM_MODE_WRITE | STREAM_MODE_READ | STREAM_MODE_BINARY; ca.streamData = NULL; ca.streamSize = 0; ca.streamType = &streamType; static DWORD msgHash_CreateArchive = CHashString(_T("CreateArchive")).GetUniqueID(); if (EngineGetToolBox()->SendMessage(msgHash_CreateArchive, sizeof(ca), &ca) != MSG_HANDLED) return MSG_ERROR; CREATESTREAM cs; cs.streamData = (TCHAR*)szFilepath.c_str(); cs.mode = STREAM_MODE_READ | STREAM_MODE_BINARY; static DWORD msgHash_CreateStream_File = CHashString(_T("CreateStream_File")).GetUniqueID(); DWORD msgRet = m_ToolBox->SendMessage(msgHash_CreateStream_File, sizeof(CREATESTREAM), &cs); if (msgRet != MSG_HANDLED || cs.openStream == NULL) { ca.archive->Close(); return MSG_ERROR; } cs.openStream->SeekTo(0,SEEK_END); int iFileSize = cs.openStream->Tell(); cs.openStream->SeekTo(0,SEEK_SET); void *pFileData = new BYTE[iFileSize]; cs.openStream->Read( pFileData, iFileSize ); delete cs.openStream; ca.archive->SetIsWriting( true ); ca.archive->Write( &pFileData, sizeof(void*) ); ca.archive->SetIsWriting( false ); static CHashString Cal3DCoreMeshCacheType(_T("CCal3DCoreMeshCache")); bool bResult = BuildObject( &hszFilepath, &Cal3DCoreMeshCacheType, ca.archive ); m_CMFMap[hszFilepath.GetUniqueID()] = hszFilepath.GetUniqueID(); ca.archive->Close(); delete[] (BYTE *)pFileData; if (bResult) return MSG_HANDLED_STOP; else return MSG_ERROR; }
///////////////////////////////////////////////////////////// // SAVE PARTICLE EMITTER ///////////////////////////////////////////////////////////// DWORD CParticleLoader::OnSaveParticleFile(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; // Check to see that Emitter 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 == false) { //Object does not exist to save out. return MSG_ERROR; } // Create XMLArchive using IXML IXMLArchive *XMLar; CHashString streamType(_T("File")); CREATEARCHIVE ca; ca.mode = STREAM_MODE_WRITE; 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_ERROR ) { return MSG_ERROR; } XMLar = dynamic_cast<IXMLArchive *>(ca.archive); if( !XMLar ) { 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; // Change the Memarchive to write MemArchive->SetIsWriting(true); // Serialize out Emitter Data SERIALIZEOBJECTPARAMS sop; sop.archive = MemArchive; sop.name = &hszFilepath; static DWORD msgHash_SerializeObject = CHashString(_T("SerializeObject")).GetUniqueID(); m_ToolBox->SendMessage(msgHash_SerializeObject, sizeof(SERIALIZEOBJECTPARAMS), &sop, NULL, NULL); // EMITTER PARSE VALUES StdString szName(_T("ParticleEmitter")); StdString szBrush(_T("Brush")); StdString szKeyframe(_T("Keyframe")); // StdString szDummy; float time = 0.0f; float value = 0.0f; StdString szEmitterName; int numBrushes = 0; int numKeyframes = 0; StdString szBrushFilepath; StdString szPropertyName; // Change the Memarchive to read MemArchive->SetIsWriting(false); // MemArchive->Read( szDummy, _T("filename")); MemArchive->Read( szEmitterName, _T("name")); MemArchive->Read( numBrushes, _T("brushes")); MemArchive->Read( numKeyframes, _T("keyframes")); XMLar->StartClass(szName); XMLar->Write(szEmitterName, _T("name")); XMLar->Write(numBrushes, _T("brushes")); XMLar->Write(numKeyframes, _T("keyframes")); for (int i = 0; i < numBrushes; i++) { MemArchive->Read( szBrushFilepath, _T("Brush") ); XMLar->StartClass( szBrush ); XMLar->Write( szBrushFilepath, _T("file") ); XMLar->EndClass(); } for ( int i = 0; i < numKeyframes; i++ ) { MemArchive->Read( szPropertyName, _T("type") ); MemArchive->Read( time, _T("time") ); MemArchive->Read( value, _T("value") ); XMLar->StartClass( szKeyframe ); XMLar->Write( szPropertyName, _T("type") ); XMLar->Write( time, _T("time") ); XMLar->Write( value, _T("value") ); XMLar->EndClass(); } XMLar->EndClass(); MemArchive->Close(); XMLar->Close(); return MSG_HANDLED_STOP; }
///////////////////////////////////////////////////////////// // 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; }
///////////////////////////////////////////////////////////// // 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; }
bool QGstreamerStreamsControl::isActive(int streamNumber) { return streamNumber != -1 && streamNumber == m_session->activeStream(streamType(streamNumber)); }
// load a file if we recognize the type. DWORD CXMLWorldLoader::OnLoadWorldFile(DWORD size, void *params) { CHashString oldVersion = _T(""); CREATEOBJECTPARAMS cop; INITOBJECTPARAMS iop; SERIALIZEOBJECTPARAMS sop; DWORD retVal; IXMLArchive *Archive = NULL; DWORD currNode = 0; LOADINGUPDATEPARAMS pbp; VERIFY_MESSAGE_SIZE(size, sizeof(TCHAR *)); TCHAR *pFileName = (TCHAR *)params; // use both a hashstring and a pointer so that the first iteration of the loop // will pass SetParentName a NULL instead of an address of a hashstring // hashed to "" CHashString hszParentType(_T("CWorld")); CHashString hszParentName(_T("World")); CHashString hszName(_T("")); CHashString hszTypeName(_T("")); CHashString streamType(_T("File")); // delete previous world root DELETEOBJECTPARAMS dop; dop.name = &hszParentName; static DWORD msgHash_DeleteObject = CHashString(_T("DeleteObject")).GetUniqueID(); EngineGetToolBox()->SendMessage(msgHash_DeleteObject, sizeof(dop), &dop ); // delete is ok to fail if no world has been created yet // create new world root cop.name = &hszParentName; cop.parentName = NULL; cop.typeName = &hszParentType; static DWORD msgHash_CreateObject = CHashString(_T("CreateObject")).GetUniqueID(); DWORD returnValue = EngineGetToolBox()->SendMessage(msgHash_CreateObject, sizeof(cop), &cop ); if (returnValue != MSG_HANDLED) { EngineGetToolBox()->Log(LOGERROR, _T("Failed to create World Root Object\n")); return MSG_ERROR; } CREATEARCHIVE ca; ca.streamData = (void *)pFileName; ca.mode = STREAM_MODE_READ; ca.streamType = &streamType; #ifdef USEXMLFILESTREAMS // call the Archive factory to create an XML archive static DWORD msgHash_CreateXMLArchiveStream = CHashString(_T("CreateXMLArchiveStream")).GetUniqueID(); if (retVal = m_ToolBox->SendMessage(msgHash_CreateXMLArchiveStream, sizeof(CREATEARCHIVE), &ca) != MSG_HANDLED) #else // call the Archive factory to create an XML archive static DWORD msgHash_CreateXMLArchive = CHashString(_T("CreateXMLArchive")).GetUniqueID(); if (retVal = m_ToolBox->SendMessage(msgHash_CreateXMLArchive, sizeof(CREATEARCHIVE), &ca) != MSG_HANDLED) #endif { return retVal; } Archive = dynamic_cast<IXMLArchive *>(ca.archive); DWORD numNodes = Archive->GetNumberOfNodes(); // Deteriminte World Version int iWorldNumAttrib = Archive->GetNumAttributes(); StdString szNodeName; Archive->GetNode(szNodeName); pbp.currentPosition = Archive->GetCurrentNodePosition(); pbp.totalSize = numNodes; // update progress bar static DWORD msgHash_LoadingUpdate = CHashString(_T("LoadingUpdate")).GetUniqueID(); m_ToolBox->SendMessage(msgHash_LoadingUpdate, sizeof(LOADINGUPDATEPARAMS), &pbp); // must start with <World> if (szNodeName != _T("CWorld")) { EngineGetToolBox()->SetErrorValue(WARN_INVALID_FILE); EngineGetToolBox()->Log(LOGWARNING, _T("Invalid world file %s\n"), pFileName); Archive->Close(); return MSG_ERROR; } // Version 1.0 if( iWorldNumAttrib == 1 ) { // read the name of the world StdString szName; Archive->Read( szName, _T("Name") ); m_WorldFileVersion = 1.0f; static DWORD msgHash_GetFileVersion = CHashString(_T("GetFileVersion")).GetUniqueID(); DWORD retval = m_ToolBox->SendMessage(msgHash_GetFileVersion, sizeof(IHashString), &oldVersion); if (retval != MSG_HANDLED) { m_ToolBox->Log(LOGERROR, _T("Could not get world version!")); return MSG_ERROR; } CHashString hszNewVersion = _T("1.0"); static DWORD msgHash_SetFileVersion = CHashString(_T("SetFileVersion")).GetUniqueID(); retval = m_ToolBox->SendMessage(msgHash_SetFileVersion, sizeof(IHashString), &hszNewVersion); if (retval != MSG_HANDLED) { m_ToolBox->Log(LOGERROR, _T("Could not set world version!")); return MSG_ERROR; } } // Version 1.5 else if( iWorldNumAttrib == 2 ) { StdString szName; Archive->Read( szName, _T("Name") ); float fileVersion = 0; Archive->Read( m_WorldFileVersion, _T("Version") ); static DWORD msgHash_GetFileVersion = CHashString(_T("GetFileVersion")).GetUniqueID(); DWORD retval = m_ToolBox->SendMessage(msgHash_GetFileVersion, sizeof(IHashString), &oldVersion); if (retval != MSG_HANDLED) { m_ToolBox->Log(LOGERROR, _T("Could not get world version!")); return MSG_ERROR; } TCHAR buf[50]; _stprintf(buf, "%.1f", m_WorldFileVersion); CHashString hszNewVersion(buf); static DWORD msgHash_SetFileVersion = CHashString(_T("SetFileVersion")).GetUniqueID(); retval = m_ToolBox->SendMessage(msgHash_SetFileVersion, sizeof(IHashString), &hszNewVersion); if (retval != MSG_HANDLED) { m_ToolBox->Log(LOGERROR, _T("Could not set world version!")); return MSG_ERROR; } } // Unknown Version else { EngineGetToolBox()->SetErrorValue(WARN_INVALID_FILE); EngineGetToolBox()->Log(LOGWARNING, _T("Invalid world file %s\n"), pFileName); Archive->Close(); static DWORD msgHash_SetFileVersion = CHashString(_T("SetFileVersion")).GetUniqueID(); m_ToolBox->SendMessage(msgHash_SetFileVersion, sizeof(IHashString), &oldVersion); return MSG_ERROR; } // failure checks bool componentFailed = false; int failedDepth = 0; float secondsPerFrame = 1 / m_fLoadingUpdateFPS; ITimer *timer = EngineGetToolBox()->GetTimer(); float lastLoadTime = timer->GetRealTime(); float elapsedTime = 0.0f; while (Archive->GetNode(szNodeName)) { int currDepth = Archive->GetDepth(); if (componentFailed == true) { // current node is child of failed if (currDepth > failedDepth) { continue; } // if sibling or uncle, reset comp failed flag else { componentFailed = false; } } hszTypeName.Init( szNodeName.c_str() ); StdString parentName; StdString parentType; StdString childType; Archive->GotoParentNode( parentType ); Archive->Read( parentName, _T("Name") ); if ( parentName != _T("") ) { hszParentName = parentName; } Archive->ReturnToChildNode( childType ); if( hszTypeName.GetString() != childType ) { assert( hszTypeName.GetString() == childType ); static DWORD msgHash_SetFileVersion = CHashString(_T("SetFileVersion")).GetUniqueID(); m_ToolBox->SendMessage(msgHash_SetFileVersion, sizeof(IHashString), &oldVersion); return MSG_ERROR; } //parentName = Archive->GetParentName(); StdString szName; Archive->Read( szName, _T("Name") ); hszName.Init( szName.c_str() ); cop.parentName = &hszParentName; cop.typeName = &hszTypeName; cop.name = &hszName; static DWORD msgHash_CreateObject = CHashString(_T("CreateObject")).GetUniqueID(); DWORD retval = m_ToolBox->SendMessage(msgHash_CreateObject, sizeof(CREATEOBJECTPARAMS), &cop, NULL, NULL); if (retval != MSG_HANDLED) { m_ToolBox->Log(LOGINFORMATION, _T("World loader: could not create component; skipping children!\n")); componentFailed = true; failedDepth = Archive->GetDepth(); continue; } // 1.0 -> 1.5 Readjusted scale and position on object by 1000/898 if( m_WorldFileVersion == 1.0 ) { float fConvert = 1000.0f/898.0f; if( hszTypeName.GetUniqueID() == CHashString(_T("CV3ORenderObject")).GetUniqueID() ) { StdString szFileName; Vec3 vPosition(0,0,0); Vec3 vRotation(0,0,0); Vec3 vScaling(0,0,0); Archive->Read( szFileName, _T("FileName") ); Archive->Read( vPosition, _T("Position") ); vPosition.x = ( vPosition.x * fConvert ); vPosition.y = ( vPosition.y * fConvert ); vPosition.z = ( vPosition.z * fConvert ); Archive->Read( vRotation, _T("Rotation") ); Archive->Read( vScaling, _T("Scaling") ); vScaling.x = ( vScaling.x * fConvert ); vScaling.y = ( vScaling.y * fConvert ); vScaling.z = ( vScaling.z * fConvert ); IArchive *MemArchive; CHashString memType(_T("Memory")); CREATEARCHIVE caOut; caOut.mode = 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) { static DWORD msgHash_SetFileVersion = CHashString(_T("SetFileVersion")).GetUniqueID(); m_ToolBox->SendMessage(msgHash_SetFileVersion, sizeof(IHashString), &oldVersion); return true; } MemArchive = caOut.archive; MemArchive->Write( szFileName, _T("FileName") ); MemArchive->Write( vPosition, _T("Position") ); MemArchive->Write( vRotation, _T("Rotation") ); MemArchive->Write( vScaling, _T("Scaling") ); CREATESTREAM cs; cs.streamData = caOut.streamData; cs.streamSize = caOut.streamSize; cs.mode = STREAM_MODE_READ; static DWORD msgHash_CreateStream_Memory = CHashString(_T("CreateStream_Memory")).GetUniqueID(); if (m_ToolBox->SendMessage(msgHash_CreateStream_Memory, sizeof(CREATESTREAM), &cs) != MSG_HANDLED) { static DWORD msgHash_SetFileVersion = CHashString(_T("SetFileVersion")).GetUniqueID(); m_ToolBox->SendMessage(msgHash_SetFileVersion, sizeof(IHashString), &oldVersion); return true; } MemArchive->Init(cs.openStream); sop.name = &hszName; sop.archive = MemArchive; static DWORD msgHash_SerializeObject = CHashString(_T("SerializeObject")).GetUniqueID(); m_ToolBox->SendMessage(msgHash_SerializeObject, sizeof(SERIALIZEOBJECTPARAMS), &sop, NULL, NULL); MemArchive->Close(); } else if( hszTypeName.GetUniqueID() == CHashString(_T("CPhysicsObject")).GetUniqueID() ) { //StdString szDynamics; StdString szType; StdString szShapeFileName; //float fMass; //Vec3 vPosition; //Vec3 vRotation; //Vec3 vScaling; //Archive->Read( vPosition, _T("pos") ); //vPosition.SetX( vPosition.GetX() * fConvert ); //vPosition.SetY( vPosition.GetY() * fConvert ); //vPosition.SetZ( vPosition.GetZ() * fConvert ); //Archive->Read( vRotation, _T("rot") ); //Archive->Read( vScaling, _T("scale") ); //vScaling.SetX( vScaling.GetX() * fConvert ); //vScaling.SetY( vScaling.GetY() * fConvert ); //vScaling.SetZ( vScaling.GetZ() * fConvert ); //Archive->Read( fMass, _T("mass") ); Archive->Read( szType, _T("Type") ); Archive->Read( szShapeFileName, _T("filename") ); IArchive *MemArchive; CHashString memType(_T("Memory")); //int size = sizeof(char) * 256 * 2 + sizeof(float) + sizeof(Vec3) * 3 + 256; CREATEARCHIVE caOut; caOut.mode = 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) { static DWORD msgHash_SetFileVersion = CHashString(_T("SetFileVersion")).GetUniqueID(); m_ToolBox->SendMessage(msgHash_SetFileVersion, sizeof(IHashString), &oldVersion); return true; } MemArchive = caOut.archive; //MemArchive->Write( vPosition, _T("pos") ); //MemArchive->Write( vRotation, _T("rot") ); //MemArchive->Write( vScaling, _T("scale") ); //MemArchive->Write( fMass, _T("mass") ); //MemArchive->Write( szDynamics, _T("dynamics") ); //MemArchive->Write( szShapeFileName, _T("shapeFile") ); MemArchive->Write( szType, _T("Type") ); MemArchive->Write( szShapeFileName, _T("filename") ); CREATESTREAM cs; cs.streamData = caOut.streamData; cs.streamSize = caOut.streamSize; cs.mode = STREAM_MODE_READ; static DWORD msgHash_CreateStream_Memory = CHashString(_T("CreateStream_Memory")).GetUniqueID(); if (m_ToolBox->SendMessage(msgHash_CreateStream_Memory, sizeof(CREATESTREAM), &cs) != MSG_HANDLED) { static DWORD msgHash_SetFileVersion = CHashString(_T("SetFileVersion")).GetUniqueID(); m_ToolBox->SendMessage(msgHash_SetFileVersion, sizeof(IHashString), &oldVersion); return true; } MemArchive->Init(cs.openStream); sop.name = &hszName; sop.archive = MemArchive; static DWORD msgHash_SerializeObject = CHashString(_T("SerializeObject")).GetUniqueID(); m_ToolBox->SendMessage(msgHash_SerializeObject, sizeof(SERIALIZEOBJECTPARAMS), &sop, NULL, NULL); MemArchive->Close(); } else if( hszTypeName.GetUniqueID() == CHashString(_T("CTerrainConfig")).GetUniqueID() ) { StdString szTerShaderLib; StdString szTerShaderEff; int iSectorRes; float fSectorSize; float fZScale; float fLODDistance; Archive->Read( szTerShaderLib, _T("TerrainShaderLibrary") ); Archive->Read( szTerShaderEff, _T("TerrainShaderEffect") ); Archive->Read( iSectorRes, _T("SectorResolution") ); Archive->Read( fSectorSize, _T("SectorSize") ); fSectorSize = fSectorSize * fConvert; Archive->Read( fZScale, _T("ZScale") ); fZScale = fZScale * fConvert; Archive->Read( fLODDistance, _T("LODDistance") ); IArchive *MemArchive; CHashString memType(_T("Memory")); CREATEARCHIVE caOut; caOut.mode = 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) { static DWORD msgHash_SetFileVersion = CHashString(_T("SetFileVersion")).GetUniqueID(); m_ToolBox->SendMessage(msgHash_SetFileVersion, sizeof(IHashString), &oldVersion); return true; } MemArchive = caOut.archive; MemArchive->Write( szTerShaderLib, _T("TerrainShaderLibrary") ); MemArchive->Write( szTerShaderEff, _T("TerrainShaderEffect") ); MemArchive->Write( iSectorRes, _T("SectorResolution") ); MemArchive->Write( fSectorSize, _T("SectorSize") ); MemArchive->Write( fZScale, _T("ZScale") ); MemArchive->Write( fLODDistance, _T("LODDistance") ); CREATESTREAM cs; cs.streamData = caOut.streamData; cs.streamSize = caOut.streamSize; cs.mode = STREAM_MODE_READ; static DWORD msgHash_CreateStream_Memory = CHashString(_T("CreateStream_Memory")).GetUniqueID(); if (m_ToolBox->SendMessage(msgHash_CreateStream_Memory, sizeof(CREATESTREAM), &cs) != MSG_HANDLED) { static DWORD msgHash_SetFileVersion = CHashString(_T("SetFileVersion")).GetUniqueID(); m_ToolBox->SendMessage(msgHash_SetFileVersion, sizeof(IHashString), &oldVersion); return true; } MemArchive->Init(cs.openStream); sop.name = &hszName; sop.archive = MemArchive; static DWORD msgHash_SerializeObject = CHashString(_T("SerializeObject")).GetUniqueID(); m_ToolBox->SendMessage(msgHash_SerializeObject, sizeof(SERIALIZEOBJECTPARAMS), &sop, NULL, NULL); MemArchive->Close(); } else { sop.name = &hszName; sop.archive = Archive; static DWORD msgHash_SerializeObject = CHashString(_T("SerializeObject")).GetUniqueID(); m_ToolBox->SendMessage(msgHash_SerializeObject, sizeof(SERIALIZEOBJECTPARAMS), &sop, NULL, NULL); } } else { sop.name = &hszName; sop.archive = Archive; static DWORD msgHash_SerializeObject = CHashString(_T("SerializeObject")).GetUniqueID(); m_ToolBox->SendMessage(msgHash_SerializeObject, sizeof(SERIALIZEOBJECTPARAMS), &sop, NULL, NULL); } iop.name = &hszName; static DWORD msgHash_InitObject = CHashString(_T("InitObject")).GetUniqueID(); m_ToolBox->SendMessage(msgHash_InitObject, sizeof(INITOBJECTPARAMS), &iop, NULL, NULL); elapsedTime += timer->GetRealTime() - lastLoadTime; lastLoadTime = timer->GetRealTime(); if (elapsedTime > secondsPerFrame) { elapsedTime = 0.0f; pbp.currentPosition = Archive->GetCurrentNodePosition(); pbp.totalSize = numNodes; m_ToolBox->SendMessage(msgHash_LoadingUpdate, sizeof(LOADINGUPDATEPARAMS), &pbp); } } pbp.currentPosition = 0; pbp.totalSize = 0; m_ToolBox->SendMessage(msgHash_LoadingUpdate, sizeof(LOADINGUPDATEPARAMS), &pbp); Archive->Close(); static DWORD msgHash_SetFileVersion = CHashString(_T("SetFileVersion")).GetUniqueID(); m_ToolBox->SendMessage(msgHash_SetFileVersion, sizeof(IHashString), &oldVersion); return MSG_HANDLED_STOP; }
bool COptionTreeWrapper::CreateTree(const StdString &compType, CHashString compName) { CHashString OptionTreeItemType(_T("")); VIEWOBJECTLIST *vol; CHashString streamType(_T("Memory")); // type of archive to create CREATEARCHIVE ca; ca.streamSize = 0; ca.streamData = NULL; ca.mode = STREAM_MODE_WRITE | STREAM_MODE_READ; ca.streamType = &streamType; static DWORD msgHash_CreateXMLArchiveStream = CHashString(_T("CreateXMLArchiveStream")).GetUniqueID(); DWORD retVal = m_ToolBox->SendMessage(msgHash_CreateXMLArchiveStream, sizeof(CREATEARCHIVE), &ca); if (retVal != MSG_HANDLED) { m_ToolBox->Log( LOGERROR, _T("%s(%i): Failed to create archive."), __FILE__, __LINE__ ); return false; } IXMLArchive *MemArchive = (IXMLArchive*)ca.archive; MemArchive->SetIsWriting( true ); GETSCHEMAPARAMS schemaparams; schemaparams.ar = MemArchive; static DWORD msgHash_GetSchema = CHashString(_T("GetSchema")).GetUniqueID(); if (m_ToolBox->SendMessage(msgHash_GetSchema, sizeof(schemaparams), &schemaparams, &compName, &CHashString(compType) ) == MSG_HANDLED) { MemArchive->SetIsWriting( false ); StdString compType; MemArchive->GetNode(compType); vol = m_ControlSchema.AddSchemaFromArchive( compType, MemArchive ); } MemArchive->Close(); vol = m_ControlSchema.GetViewObjectList(compType); if (vol == NULL) { // warning, component type is unknown StdString error = _T("Component type of this type is unknown: "); error += compType; ::MessageBox(NULL, error, _T("INVALID OPERATION"), MB_OK); return false; } VIEWOBJECTLIST::iterator volIter = vol->begin(); for(; volIter != vol->end(); volIter++) { ViewFormatObject *vo; vo = *volIter; OptionTreeItemType = vo->GetViewType().c_str(); MAPTYPETOITEMFUNC::iterator mttifIter; // find the map from basicType to write option tree item mttifIter = m_TreeItemCreateFuncs.find(OptionTreeItemType.GetUniqueID()); if (mttifIter == m_TreeItemCreateFuncs.end()) { // warning, continue.... // Sorry, that type of item is not known! StdString error = _T("COptionTreeItem of this type is unknown: "); error += OptionTreeItemType.GetString(); ::MessageBox(NULL, error, _T("INVALID OPERATION"), MB_OK); continue; } OTCREATEITEMFUNC funcPtr = mttifIter->second; (this->*funcPtr)(compName, vo, m_mTrees[compName.GetUniqueID()].m_Root); } m_mTrees[compName.GetUniqueID()].m_Tree->ExpandAllItems(); m_mViewOList[compName.GetUniqueID()].push_back(vol); return true; }
void CWorldEventToolPal::WorldEventCreate() { static DWORD msgHash_GetComponentType = CHashString(_T("GetComponentType")).GetUniqueID(); static DWORD msgHash_FindObject = CHashString(_T("FindObject")).GetUniqueID(); static DWORD msgHash_CreateObject = CHashString(_T("CreateObject")).GetUniqueID(); static DWORD msgHash_AddObject = CHashString(_T("AddObject")).GetUniqueID(); static DWORD msgHash_SerializeObject = CHashString(_T("SerializeObject")).GetUniqueID(); static DWORD msgHash_InitObject = CHashString(_T("InitObject")).GetUniqueID(); static DWORD msgHash_CreateArchive = CHashString(_T("CreateArchive")).GetUniqueID(); static CHashString Hash_ParentName = CHashString(_T("World")); static CHashString Hash_Type = CHashString(_T("CWorldEvent")); CString buf; m_Name.GetLBText(m_Name.GetCurSel(), buf); CHashString hszName((TCHAR*)buf.GetBuffer()); FINDOBJECTPARAMS param; param.hszName = &hszName; DWORD result = m_ToolBox->SendMessage(msgHash_FindObject, sizeof(FINDOBJECTPARAMS), ¶m); // world event exists, must update it if( param.bFound == true ) { GETCOMPONENTTYPEPARAMS gctp; gctp.name = &hszName; m_ToolBox->SendMessage(msgHash_GetComponentType, sizeof(gctp), &gctp); if ( (gctp.componenttype != NULL) && (gctp.componenttype->GetUniqueID() == Hash_Type.GetUniqueID()) ) { CREATEARCHIVE ca; CHashString streamType(_T("Memory")); ca.streamData = NULL; ca.streamSize = 0; ca.mode = STREAM_MODE_WRITE | STREAM_MODE_READ; ca.streamType = &streamType; m_ToolBox->SendMessage(msgHash_CreateArchive, sizeof(CREATEARCHIVE), &ca, NULL, NULL); IArchive *MemArchive = (ca.archive); m_TriggerName.GetWindowText( buf ); MemArchive->Write( (TCHAR*)buf.GetBuffer() ); m_EntityName.GetWindowText( buf ); MemArchive->Write( (TCHAR*)buf.GetBuffer() ); m_EntityType.GetWindowText( buf ); MemArchive->Write( (TCHAR*)buf.GetBuffer() ); m_EventName.GetWindowText( buf ); MemArchive->Write( (TCHAR*)buf.GetBuffer() ); m_EventParam.GetWindowText( buf ); MemArchive->Write( (TCHAR*)buf.GetBuffer() ); SERIALIZEOBJECTPARAMS sop; sop.name = &hszName; sop.archive = MemArchive; m_ToolBox->SendMessage(msgHash_SerializeObject, sizeof(SERIALIZEOBJECTPARAMS), &sop, NULL, NULL); } } // world event doesn't exist, must create it else { CREATEOBJECTPARAMS cop; cop.parentName = &Hash_ParentName; cop.typeName = &Hash_Type; cop.name = &hszName; m_ToolBox->SendMessage(msgHash_CreateObject, sizeof(CREATEOBJECTPARAMS), &cop, NULL, NULL); m_ToolBox->SendMessage(msgHash_AddObject, sizeof(cop), &cop, NULL, NULL); CREATEARCHIVE ca; CHashString streamType(_T("Memory")); ca.streamData = NULL; ca.mode = STREAM_MODE_WRITE | STREAM_MODE_READ; ca.streamType = &streamType; m_ToolBox->SendMessage(msgHash_CreateArchive, sizeof(CREATEARCHIVE), &ca, NULL, NULL); IArchive *MemArchive = (ca.archive); m_TriggerName.GetWindowText( buf ); MemArchive->Write( (TCHAR*)buf.GetBuffer() ); m_EntityName.GetWindowText( buf ); MemArchive->Write( (TCHAR*)buf.GetBuffer() ); m_EntityType.GetWindowText( buf ); MemArchive->Write( (TCHAR*)buf.GetBuffer() ); m_EventName.GetWindowText( buf ); MemArchive->Write( (TCHAR*)buf.GetBuffer() ); m_EventParam.GetWindowText( buf ); MemArchive->Write( (TCHAR*)buf.GetBuffer() ); SERIALIZEOBJECTPARAMS sop; sop.name = &hszName; sop.archive = MemArchive; m_ToolBox->SendMessage(msgHash_SerializeObject, sizeof(SERIALIZEOBJECTPARAMS), &sop, NULL, NULL); INITOBJECTPARAMS iop; iop.name = &hszName; m_ToolBox->SendMessage(msgHash_InitObject, sizeof(INITOBJECTPARAMS), &iop, NULL, NULL); } }
DWORD CShaderEffectLoader::OnLoadFile(DWORD size, void *params) { VERIFY_MESSAGE_SIZE(size, sizeof(TCHAR *)); TCHAR *pFileName = (TCHAR *)params; if( _tcslen( pFileName ) == 0 ) { m_ToolBox->Log( LOGWARNING, _T("Shader File is empty string") ); return MSG_ERROR; } StdString szFileName(pFileName); szFileName.MakeSafeFileName(); CHashString effectname( szFileName ); // only load an effect file once static DWORD msgHash_FindObject = CHashString(_T("FindObject")).GetUniqueID(); FINDOBJECTPARAMS param; param.hszName = &effectname; m_ToolBox->SendMessage(msgHash_FindObject, sizeof(FINDOBJECTPARAMS), ¶m ); if ( param.bFound == true ) { // effect already loaded return MSG_HANDLED_STOP; } IArchive *MemArchive; // hash the file name CHashString streamType(_T("File")); // create a new archive and load the file CREATEARCHIVE ca; DWORD retVal; ca.streamData = pFileName; ca.mode = STREAM_MODE_READ; ca.streamType = &streamType; // call the Archive factory to create an XML archive static DWORD msgHash_CreateXMLArchive = CHashString(_T("CreateXMLArchive")).GetUniqueID(); if (retVal = m_ToolBox->SendMessage(msgHash_CreateXMLArchive, sizeof(CREATEARCHIVE), &ca) != MSG_HANDLED) { m_ToolBox->Log( LOGWARNING, _T("SHADEREFFECTLOADER: %s\n\tCould not create XML Archive\n"), pFileName ); return MSG_ERROR; } MemArchive = dynamic_cast<IXMLArchive *>(ca.archive); ///create the cal model CREATEOBJECTPARAMS cop; INITOBJECTPARAMS iop; SERIALIZEOBJECTPARAMS sop; CHashString hszParentName( _T("World") ); CHashString hszTypeName(_T("CEffect")); cop.parentName = &hszParentName; cop.typeName = &hszTypeName; cop.name = &effectname; static DWORD msgHash_CreateObject = CHashString(_T("CreateObject")).GetUniqueID(); DWORD retval = m_ToolBox->SendMessage(msgHash_CreateObject, sizeof(CREATEOBJECTPARAMS), &cop, NULL, NULL); sop.name = &effectname; sop.archive = MemArchive; static DWORD msgHash_SerializeObject = CHashString(_T("SerializeObject")).GetUniqueID(); m_ToolBox->SendMessage(msgHash_SerializeObject, sizeof(SERIALIZEOBJECTPARAMS), &sop, NULL, NULL); iop.name = &effectname; if( retval == MSG_HANDLED ) { static DWORD msgHash_InitObject = CHashString(_T("InitObject")).GetUniqueID(); retval = m_ToolBox->SendMessage(msgHash_InitObject, sizeof(INITOBJECTPARAMS), &iop, NULL, NULL); } MemArchive->Close(); CREATEEFFECTINTERFACE addmsg; addmsg.m_Name = &effectname; static DWORD msgHash_AddEffect = CHashString(_T("AddEffect")).GetUniqueID(); m_ToolBox->SendMessage(msgHash_AddEffect, sizeof( CREATEEFFECTINTERFACE ), &addmsg ); return MSG_HANDLED_STOP; }