C++ DataStreamPtr::read方法代码示例

 // ----------------------------------------------------------------------
 std::string FontSerializer::loadString(Ogre::DataStreamPtr& stream)
 {
     uint16 strsize;
     stream->read(&strsize, sizeof(uint16));
     char * stringbuffer = new char[strsize+1];
     stream->read((char*)stringbuffer, strsize);
     stringbuffer[strsize] = '\0';
     std::string rstring = stringbuffer;
     delete[] stringbuffer;
     return rstring;
 }

void FvFTDTerrainPageSerializerImpl::ReadLayerMap(Ogre::DataStreamPtr &spStream, 
												  FvTerrainPage *pkDest, FvUInt32 uiLayerIndex)
{
	FTDLayerMapHeader kHeader;
	spStream->read(&kHeader,sizeof(FTDLayerMapHeader));
	FvTerrainPage::TextureLayerPtr spLayer = new FvTerrainPage::TextureLayer;

	FvUInt32 uiNameSize;
	spStream->read(&uiNameSize,sizeof(FvUInt32));

	char acTextureName[256];
	FV_ASSERT(uiNameSize < 256);
	spStream->read(acTextureName,uiNameSize);
	acTextureName[uiNameSize] = 0;
	spLayer->m_kTextureName = acTextureName;

	if(kHeader.m_uiVersion == VERSION_PNG)
	{
		spLayer->m_pkBlends = new Ogre::Image;
		spLayer->m_pkBlends->load(spStream,"png");
	}
	if(kHeader.m_uiVersion == VERSION_DDS)
	{
		spLayer->m_pkBlends = new Ogre::Image;
		spLayer->m_pkBlends->load(spStream,"dds");
	}

	FV_ASSERT(spLayer->m_pkBlends);

	try
	{
		spLayer->m_spTexture = Ogre::TextureManager::getSingleton().load(spLayer->m_kTextureName,
			pkDest->m_spTerrainSettings->TextureGroup());
	}
	catch (...){}

	if(spLayer->m_spTexture.isNull())
	{
		FV_ERROR_MSG("FvFTDTerrainPageSerializerImpl::ReadLayerMap texture %s not exist",
			spLayer->m_kTextureName.c_str());
	}

	spLayer->m_uiWidth = kHeader.m_uiWidth;
	spLayer->m_uiHeight = kHeader.m_uiHeight;
	memcpy(&spLayer->m_kUProjection, kHeader.m_kUProjection, sizeof(Ogre::Vector4)); 
	memcpy(&spLayer->m_kVProjection, kHeader.m_kVProjection, sizeof(Ogre::Vector4)); 

	pkDest->m_kTextureLayers.push_back(spLayer);
}

//----------------------------------------------------------------------------//
size_t OggBuffer::vorbisRead(void *ptr, size_t byteSize, size_t sizeToRead, void *datasource )
{
	size_t				spaceToEOF;			// How much more we can read till we hit the EOF marker
	size_t				actualSizeToRead;	// How much data we are actually going to read from memory
	Ogre::DataStreamPtr	vorbisData;			// Our vorbis data, for the typecast

	// Get the data in the right format
	vorbisData = *(Ogre::DataStreamPtr*)datasource;

	// Calculate how much we need to read.  This can be sizeToRead*byteSize or less depending on how near the EOF marker we are
	spaceToEOF = vorbisData->size() - vorbisData->tell();
	if ((sizeToRead * byteSize) < spaceToEOF)
		actualSizeToRead = (sizeToRead * byteSize);
	else
		actualSizeToRead = spaceToEOF;	
	
	// A simple copy of the data from memory to the datastruct that the vorbis libs will use
	if (actualSizeToRead)
	{
		// Copy the data from the start of the file PLUS how much we have already read in
		vorbisData->read(ptr, actualSizeToRead);
	}

	// Return how much we read (in the same way fread would)
	return actualSizeToRead;
}

 //---------------------------------------------------------------------
 void
 BackgroundFileSerializer::readPallete( Ogre::DataStreamPtr &stream
                                       ,BackgroundFile *pDest )
 {
     readSectionHeader( stream, SECTION_NAME_PALETTE );
     stream->read( pDest->getPalette().data(), BackgroundFile::PALETTE_ENTRY_COUNT );
 }

    //---------------------------------------------------------------------
    void
    BackgroundFileSerializer::readObject( Ogre::DataStreamPtr &stream, Page &pDest )
    {
        read2ByteBool( stream, pDest.enabled );
        if( !pDest.enabled ) return;

        readShort( stream, pDest.unknown_02 );
        readShort( stream, pDest.value_size );
        if( pDest.value_size != 1 && pDest.value_size != 2 )
        {
            OGRE_EXCEPT(Ogre::Exception::ERR_INVALIDPARAMS
                ,"Page value_size other then 1 and 2 is not supported"
                ,"BackgroundFileSerializer::readObject" );
        }

        size_t color_count( BackgroundFile::PAGE_DATA_SIZE );
        pDest.colors.clear();
        pDest.data.clear();

        if( pDest.value_size == 2 )
        {
            pDest.colors.reserve( color_count );
            for( size_t i( color_count ); i--; )
            {
                Color colourDest;
                readObject( stream, colourDest );
                pDest.colors.push_back( colourDest );
            }
        }
        else
        {
            pDest.data.resize( color_count );
            stream->read( &pDest.data[0], color_count );
        }
    }

 std::string getString(size_t length)
 {
     std::string str;
     str.resize(length);
     if(inp->read(&str[0], length) != length)
         return std::string();
     return str.substr(0, str.find('\0'));
 }

size_t RocketInterface::Read(void* buffer, size_t size, Rocket::Core::FileHandle file)
{
    if (!file)
        return 0;

    Ogre::DataStreamPtr stream = *reinterpret_cast<Ogre::DataStreamPtr*>(file);
    return stream->read(buffer, size);
}

// OgreScriptBuilder
int OgreScriptBuilder::LoadScriptSection(const char* full_path_cstr)
{
    // Get filename - required to retrieve file from OGRe's resource system.
    //  This function received filename in older AngelScript versions, but now receives full path
    //      (reconstructed wrong by CScriptBuilder because it doesn't know about OGRE's ZIP files).
    //  TODO: Refactor the entire script building logic 
    //      - create fully RoR-custom builder instead of hacked stock CScriptBuilder + our overload. ~ only_a_ptr, 08/2017

    std::string full_path(full_path_cstr);
    std::string filename;
    size_t slash_pos = full_path.rfind('/'); // AngelScript always uses forward slashes in paths.
    if (slash_pos != std::string::npos)
    {
        filename = full_path.substr(slash_pos+1);
    }
    else
    {
        filename = full_path;
    }

    Ogre::DataStreamPtr ds;
    try
    {
        ds = Ogre::ResourceGroupManager::getSingleton().openResource(filename, Ogre::ResourceGroupManager::AUTODETECT_RESOURCE_GROUP_NAME);
                 //TODO: do not use `AUTODETECT_RESOURCE_GROUP_NAME`, use specific group, lookups are slow!
                 //see also https://github.com/OGRECave/ogre/blob/master/Docs/1.10-Notes.md#resourcemanager-strict-mode ~ only_a_ptr, 08/2017
    }
    catch (Ogre::Exception e)
    {
        LOG("[RoR|Scripting] exception upon loading script file '"+filename+"', message: " + e.getFullDescription());
        return -1;
    }
    // In some cases (i.e. when fed a full path with '/'-s on Windows), `openResource()` will silently return NULL for datastream. ~ only_a_ptr, 08/2017
    if (ds.isNull())
    {
        LOG("[RoR|Scripting] Failed to load file '"+filename+"', reason unknown.");
        return -1;
    }

    // Read the entire file
    std::string code;
    code.resize(ds->size());
    ds->read(&code[0], ds->size());

    // hash it
    {
        char hash_result[250];
        memset(hash_result, 0, 249);
        RoR::CSHA1 sha1;
        sha1.UpdateHash((uint8_t *)code.c_str(), (uint32_t)code.size());
        sha1.Final();
        sha1.ReportHash(hash_result, RoR::CSHA1::REPORT_HEX_SHORT);
        hash = Ogre::String(hash_result);
    }

    return ProcessScriptSection(code.c_str(), code.length(), filename.c_str(), 0);
}

    void GlobalMap::write(ESM::GlobalMap& map)
    {
        map.mBounds.mMinX = mMinX;
        map.mBounds.mMaxX = mMaxX;
        map.mBounds.mMinY = mMinY;
        map.mBounds.mMaxY = mMaxY;

        Ogre::DataStreamPtr encoded = mOverlayImage.encode("png");
        map.mImageData.resize(encoded->size());
        encoded->read(&map.mImageData[0], encoded->size());
    }

//-----------------------------------------------------------------------
void ExpatParser::parseXMLFile(XMLHandler& handler,
                               const Ogre::String& xmlName, const Ogre::String& xmlResourceGroup,
                               const Ogre::String& schemaName, const Ogre::String& schemaResourceGroup)
{
    XML_Parser parser = XML_ParserCreate(NULL);

    try
    {
        MyUserData myUserData;
        myUserData.handler = &handler;
        if (_locale.get())
            myUserData.converter = boost::bind(&expat_to_local, _1, _2, boost::ref(*_locale));
        else
            myUserData.converter = boost::bind(&expat_to_local_win32, _1, _2, boost::ref(_buffer));

        XML_SetUserData(parser, &myUserData);
        XML_SetElementHandler(parser, expatStartElementHandler, expatEndElementHandler);
        XML_SetCharacterDataHandler(parser, expatCharacterDataHandler);

        const size_t MaxBufferSize = 64*1024;
        Ogre::DataStreamPtr dataStream = Ogre::ResourceGroupManager::getSingleton().openResource(xmlName, xmlResourceGroup);
        bool done;
        do
        {
            void* buffer = XML_GetBuffer(parser, MaxBufferSize);
            if (!buffer)
            {
                OGRE_EXCEPT(Ogre::Exception::ERR_INTERNAL_ERROR,
                            "Can't allocate buffer while parse XML file '" + xmlName + "'.",
                            "ExpatParser::parseXMLFile");
            }

            size_t count = dataStream->read(buffer, MaxBufferSize);
            done = dataStream->eof();

            if (XML_ParseBuffer(parser, count, done) != XML_STATUS_OK)
            {
                OGRE_EXCEPT(Ogre::Exception::ERR_INTERNAL_ERROR,
                            "An error occurred while parsing XML file '" + xmlName +
                            "' at line " + Ogre::StringConverter::toString(XML_GetCurrentLineNumber(parser)) +
                            ". Additional information: " + XML_ErrorString(XML_GetErrorCode(parser)),
                            "ExpatParser::parseXMLFile");
            }
        } while (!done);
    }
    catch(...)
    {
        XML_ParserFree(parser);
        throw;
    }

    XML_ParserFree(parser);
}

/*void TestStream()
{
	//String fname( "../../media/packs/chiropteraDM.txt");
	std::ifstream* roStream = new std::ifstream;
	roStream ->open	("../../media/packs/chiropteraDM.txt", std::ios::in | std::ios::binary);
	//fptr =  new FileStreamDataStream("tt", roStream, true);
	//fstrm = DataStreamPtr(fptr);
	DataStreamPtr ss = DataStreamPtr(new LodDataStream( Ogre::SharedPtr<std::ifstream>(roStream),	0x203,500));
	std::cout <<  ss -> size() << endl;
	while(!ss->eof())
	{
		cout << ss->getLine(false) << endl;
	}
	cout << 
		ss->getAsString() 
		<< endl;
}*/
void SaveStreamToFile(const Ogre::String& fname, Ogre::DataStreamPtr data)
{
	char*buff = new char[data->size()];
	std::ios::openmode mode = std::ios::binary | std::ios::out;
	std::ofstream rwStream;
	data->read(buff,data->size());
	rwStream.open(fname, mode);
	rwStream.write(buff,data->size());
	rwStream.close();
	delete[] buff;
	std::cout << "Saved: " << fname << " size: "<<data->size() << std::endl;
}

 //--------------------------------------------------------------------------
 void
 FLevelFileSerializer::readSectionData( Ogre::DataStreamPtr &stream
                                       ,Ogre::DataStreamPtr &out_buffer )
 {
     uint32 length( 0 );
     readInt( stream, length );
     // TODO: implement SubDataStream class to restrict access size etc
     // so we don't have to copy the whole memory
     Ogre::MemoryDataStream *buffer( new Ogre::MemoryDataStream( length ) );
     stream->read( buffer->getPtr(), length );
     out_buffer = Ogre::DataStreamPtr( buffer );
 }

qint64 OgreNetworkReply::readData(char *data, qint64 maxSize)
{
    if (mDataStream.isNull()) {
        setErrorString("This network request is closed.");
        return -1;
    }

    if (mDataStream->eof())
        return -1;

    return mDataStream->read(data, maxSize);
}

/*
void TextureAsset::RegenerateAllMipLevels()
{
    if (ogreTexture.isNull())
        return;

///\todo This function does not quite work, since ogreTexture->getNumMipmaps() will return 0 to denote a "full mipmap chain".

    for(int f = 0; f < ogreTexture->getNumFaces(); ++f)
        for(int i = 1; i < ogreTexture->getNumMipmaps(); ++i)
        {
            Ogre::HardwarePixelBufferSharedPtr src = ogreTexture->getBuffer(f, i-1);
            Ogre::Box srcSize(0, 0, src->getWidth(), src->getHeight());
            Ogre::HardwarePixelBufferSharedPtr dst = ogreTexture->getBuffer(f, i);
            Ogre::Box dstSize(0, 0, dst->getWidth(), dst->getHeight());
            dst->blit(src, srcSize, dstSize);
        }
}
*/
bool TextureAsset::SerializeTo(std::vector<u8> &data, const QString &serializationParameters) const
{
    if (ogreTexture.isNull())
    {
        LogWarning("SerializeTo: Called on an unloaded texture \"" + Name().toStdString() + "\".");
        return false;
    }

    try
    {
        Ogre::Image new_image;
                
        // From Ogre 1.7 Texture::convertToImage()
        size_t numMips = 1;
        size_t dataSize = Ogre::Image::calculateSize(numMips,
            ogreTexture->getNumFaces(), ogreTexture->getWidth(), ogreTexture->getHeight(), ogreTexture->getDepth(), ogreTexture->getFormat());
        void* pixData = OGRE_MALLOC(dataSize, Ogre::MEMCATEGORY_GENERAL);
        // if there are multiple faces and mipmaps we must pack them into the data
        // faces, then mips
        void* currentPixData = pixData;
        for (size_t face = 0; face < ogreTexture->getNumFaces(); ++face)
        {
            for (size_t mip = 0; mip < numMips; ++mip)
            {
                size_t mipDataSize = Ogre::PixelUtil::getMemorySize(ogreTexture->getWidth(), ogreTexture->getHeight(), ogreTexture->getDepth(), ogreTexture->getFormat());
                Ogre::PixelBox pixBox(ogreTexture->getWidth(), ogreTexture->getHeight(), ogreTexture->getDepth(), ogreTexture->getFormat(), currentPixData);
                ogreTexture->getBuffer(face, mip)->blitToMemory(pixBox);
                currentPixData = (void*)((char*)currentPixData + mipDataSize);
            }
        }
        // load, and tell Image to delete the memory when it's done.
        new_image.loadDynamicImage((Ogre::uchar*)pixData, ogreTexture->getWidth(), ogreTexture->getHeight(), ogreTexture->getDepth(), ogreTexture->getFormat(), true, 
            ogreTexture->getNumFaces(), numMips - 1);

        Ogre::DataStreamPtr imageStream = new_image.encode(serializationParameters.toStdString());
        if (imageStream.get() && imageStream->size() > 0)
        {
            data.resize(imageStream->size());
            imageStream->read(&data[0], data.size());
        }
    } catch (std::exception &e)
    {
        LogError("SerializeTo: Failed to export Ogre texture " + Name().toStdString() + ":");
        if (e.what())
            OgreRenderer::OgreRenderingModule::LogError(e.what());
        return false;
    }
    return true;
}

    Resource::DataStreamPtr ResourceManager::OpenAssetStream(const String& AssetName, const String& AssetGroup)
    {
        /// @todo This entire method is a bit of a hack.  When the resource system gets refactored it should go through our archives or whatever equivalent.
        /// Since we currently have to put up with Ogre's system, we'll use it for now as a hack.

        NamedDataStreamIterator StreamIt = this->NamedDataStreams.find(AssetName);
        if( StreamIt != this->NamedDataStreams.end() )
            return (*StreamIt).second;

        Ogre::DataStreamPtr OgreStream = this->OgreResource->openResource(AssetName,AssetGroup);
        Char8* AssetBuffer = new Char8[ OgreStream->size() ];
        OgreStream->read( (void*)AssetBuffer, OgreStream->size() );

        return this->CreateDataStream(AssetName,AssetBuffer,OgreStream->size());
    }