//-----------------------------------------------------------------------
void ConfigFile::loadDirect(const String& filename, const String& separators,
bool trimWhitespace)
{
#if OGRE_PLATFORM == OGRE_PLATFORM_NACL
OGRE_EXCEPT(Exception::ERR_CANNOT_WRITE_TO_FILE, "loadDirect is not supported on NaCl - tried to open: " + filename,
"ConfigFile::loadDirect");
#endif
/* Open the configuration file */
std::ifstream fp;
// Always open in binary mode
fp.open(filename.c_str(), std::ios::in | std::ios::binary);
if(!fp)
OGRE_EXCEPT(
Exception::ERR_FILE_NOT_FOUND, "'" + filename + "' file not found!", "ConfigFile::load" );
// Wrap as a stream
DataStreamPtr stream(OGRE_NEW FileStreamDataStream(filename, &fp, false));
#if OGRE_PLATFORM == OGRE_PLATFORM_SYMBIAN
// seems readLine doesn't work correctly in SYMBIAN with files
DataStreamPtr memoryStream(OGRE_NEW MemoryDataStream(stream));
stream = memoryStream;
#endif
load(stream, separators, trimWhitespace);
}
const String imageToBase64 (const Image &image)
{
MemoryBlock memoryBlock;
MemoryOutputStream memoryStream(memoryBlock,true);
PNGImageFormat png;
png.writeImageToStream (image, memoryStream);
return (memoryBlock.toBase64Encoding());
}
bool BladeRunnerEngine::saveGame(Common::WriteStream &stream, const Graphics::Surface &thumbnail) {
if (!playerHasControl() || _sceneScript->isInsideScript() || _aiScripts->isInsideScript()) {
return false;
}
Common::MemoryWriteStreamDynamic memoryStream(DisposeAfterUse::YES);
SaveFileWriteStream s(memoryStream);
s.write(thumbnail.getPixels(), SaveFileManager::kThumbnailSize);
s.writeFloat(1.0f);
_settings->save(s);
_scene->save(s);
_scene->_exits->save(s);
_scene->_regions->save(s);
_scene->_set->save(s);
for (uint i = 0; i != _gameInfo->getGlobalVarCount(); ++i) {
s.writeInt(_gameVars[i]);
}
_music->save(s);
// _audioPlayer->save(s) // zero func
// _audioSpeech->save(s) // zero func
_combat->save(s);
_gameFlags->save(s);
_items->save(s);
_sceneObjects->save(s);
_ambientSounds->save(s);
_overlays->save(s);
_spinner->save(s);
_scores->save(s);
_dialogueMenu->save(s);
_obstacles->save(s);
_actorDialogueQueue->save(s);
_waypoints->save(s);
for (uint i = 0; i != _gameInfo->getActorCount(); ++i) {
_actors[i]->save(s);
int animationState, animationFrame, animationStateNext, nextAnimation;
_aiScripts->queryAnimationState(i, &animationState, &animationFrame, &animationStateNext, &nextAnimation);
s.writeInt(animationState);
s.writeInt(animationFrame);
s.writeInt(animationStateNext);
s.writeInt(nextAnimation);
}
_actors[kActorVoiceOver]->save(s);
_policeMaze->save(s);
_crimesDatabase->save(s);
s.finalize();
stream.writeUint32LE(memoryStream.size() + 4);
stream.write(memoryStream.getData(), memoryStream.size());
stream.flush();
return true;
}
//------------------------------------------------------------------------------
roINLINE void RoGrfVersion1::populateFileListFromFileStream()
{
typedef std::list<RoGrfFilePtr> RoGrfFilePtrList;
RoGrfFilePtrList fileList;
RoCharArray buffer((size_t)mContentSize, '\0');
mFileStream.read(&buffer[0], std::streamsize(mContentSize));
size_t fileIndex = 0;
RoMemoryDataStream memoryStream(&buffer[0], (size_t)mContentSize, false);
RoDataStream& dataStream = memoryStream;
while(!dataStream.eof())
{
uint32 encodedFileNameLength;
dataStream.read(encodedFileNameLength);
encodedFileNameLength -= 2;
uint16 unknownBytes;
dataStream.read(unknownBytes);
(void)unknownBytes;
RoCharArray encodedFileName(encodedFileNameLength, '\0');
dataStream.read(&encodedFileName[0], encodedFileNameLength);
RoString fileName = decodeFileName(encodedFileName);
RoGrfFileStats fileStats;
dataStream.read(fileStats);
// Do some adjustments to make the stats right
// This is PURE mathemagic
fileStats.encryptedSize -= 37579;
fileStats.compressedSize += fileStats.originalSize + 715;
fileStats.offset += sizeof(RoGrfHeader);
fileStats.flags |= isDesEncryptedFile(fileName) ? eGrfFlag_Des : eGrfFlag_MixCrypt;
if (fileStats.isEmpty() || // file has no contents
mFileSize < fileStats.getOffsetAtEndOfFile() || // file size exceeds current GRF's file size
!fileStats.isFile()) // it's not a file
{
continue;
}
addFile(RoGrfFilePtr(new RoGrfFile(fileName, fileStats)));
}
}
bool CUP_Player::parseNextBlockTag(Common::SeekableReadStream &dataStream) {
uint32 tag = dataStream.readUint32BE();
uint32 size = dataStream.readUint32BE() - 8;
uint32 next = dataStream.pos() + size;
debug(1, "New block tag %s %d dataSize %d", tag2str(tag), size, _dataSize);
switch (tag) {
case MKTAG('F','R','A','M'):
handleFRAM(dataStream, size);
break;
case MKTAG('L','Z','S','S'):
if (handleLZSS(dataStream, size) && _outLzssBufSize != 0) {
Common::MemoryReadStream memoryStream(_outLzssBufData, _outLzssBufSize);
parseNextBlockTag(memoryStream);
}
break;
case MKTAG('R','A','T','E'):
handleRATE(dataStream, size);
break;
case MKTAG('R','G','B','S'):
handleRGBS(dataStream, size);
break;
case MKTAG('S','N','D','E'):
handleSNDE(dataStream, size);
break;
case MKTAG('T','O','I','L'):
handleTOIL(dataStream, size);
break;
case MKTAG('S','R','L','E'):
handleSRLE(dataStream, size);
break;
case MKTAG('B','L','O','K'):
_dataSize -= size + 8;
return false;
case MKTAG('W','R','L','E'):
// this is never triggered
default:
warning("Unhandled tag %s", tag2str(tag));
break;
}
dataStream.seek(next);
return true;
}
std::shared_ptr<AbstractImage> loadFromMemory(const void* data, std::size_t length, PixelFormat pixelFormat) const
{
MemoryStream memoryStream(data, length);
return loadFromStream<T>(memoryStream, pixelFormat);
}
