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

//----------------------------------------------------------------------------//
int OggBuffer::vorbisSeek(void *datasource, ogg_int64_t offset, int whence)
{
	size_t				spaceToEOF;
	ogg_int64_t			actualOffset;
	Ogre::DataStreamPtr	vorbisData;

	vorbisData = *(Ogre::DataStreamPtr*)datasource;

	switch (whence)
	{
	case SEEK_SET:
		if (vorbisData->size() >= offset)
			actualOffset = offset;
		else
			actualOffset = vorbisData->size();
		vorbisData->seek((int)actualOffset);
		break;
	case SEEK_CUR:
		spaceToEOF = vorbisData->size() - vorbisData->tell();
		if (offset < spaceToEOF)
			actualOffset = (offset);
		else
			actualOffset = spaceToEOF;	
		vorbisData->seek( static_cast<size_t>(vorbisData->tell() + actualOffset));
		break;
	case SEEK_END:
		vorbisData->seek(vorbisData->size());
		break;
	default:
		SoundSystem::getSingleton().logMessage("*** ERROR *** Unknown seek command in VorbisSeek");
		break;
	};

	return 0;
}

int64_t FFmpeg_Decoder::seek(void *user_data, int64_t offset, int whence)
{
    Ogre::DataStreamPtr stream = static_cast<FFmpeg_Decoder*>(user_data)->mDataStream;

    whence &= ~AVSEEK_FORCE;
    if(whence == AVSEEK_SIZE)
        return stream->size();
    if(whence == SEEK_SET)
        stream->seek(offset);
    else if(whence == SEEK_CUR)
        stream->seek(stream->tell()+offset);
    else if(whence == SEEK_END)
        stream->seek(stream->size()+offset);
    else
        return -1;

    return stream->tell();
}

int64_t OgreResource_Seek(void *user_data, int64_t offset, int whence)
{
    Ogre::DataStreamPtr stream = static_cast<VideoState*>(user_data)->stream;

    whence &= ~AVSEEK_FORCE;
    if(whence == AVSEEK_SIZE)
        return stream->size();
    if(whence == SEEK_SET)
        stream->seek((size_t)offset);
    else if(whence == SEEK_CUR)
		stream->seek((size_t)(stream->tell() + offset));
    else if(whence == SEEK_END)
		stream->seek((size_t)(stream->size() + offset));
    else
        return -1;

    return stream->tell();
}

	int		OOSStreamSeek(void *datasource, ogg_int64_t offset, int whence)
	{
		Ogre::DataStreamPtr dataStream = *reinterpret_cast<Ogre::DataStreamPtr*>(datasource);
		switch(whence)
		{
		case SEEK_SET:
			dataStream->seek(offset);
			break;
		case SEEK_END:
			dataStream->seek(dataStream->size());
			// Falling through purposefully here
		case SEEK_CUR:
			dataStream->skip(offset);
			break;
		}

		return 0;
	}

bool RocketInterface::Seek(Rocket::Core::FileHandle file, long offset, int origin)
{
    if (!file)
        return false;

    Ogre::DataStreamPtr stream = *reinterpret_cast<Ogre::DataStreamPtr*>(file);
    long pos = 0;
    size_t size = stream->size();

    if (origin == SEEK_CUR)
        pos = stream->tell() + offset;
    else if (origin == SEEK_END)
        pos = size + offset;
    else
        pos = offset;

    if (pos < 0 || pos > (long)size)
        return false;

    stream->seek((size_t)pos);
    return true;
}

void MapFileSerializer::importMapFile( Ogre::DataStreamPtr& stream, WorldMapFile& dest )
{
    const auto fileSize = stream->size();
    auto numBlocks = fileSize / kWorldMapBlockSize;

    for ( unsigned int j=0; j<numBlocks; j++ )
    {

        SBlock block;

        const size_t basePos = kWorldMapBlockSize*j;
        stream->seek( basePos );

        // Read the offset to compressed data in this block
        BlockHeader header = {};
        for ( auto i=0u; i<16; i++)
        {
            readUInt32( stream, header.mCompressedDataOffsets[i] );
        }

        for ( auto i=0u; i<16; i++)
        {
            SBlockPart blockPart;

            // Go to the offset
            stream->seek( basePos + header.mCompressedDataOffsets[i] );

            // Read the size of the compressed data
            uint32 compressedDataSize = 0;
            readUInt32( stream, compressedDataSize );

            // Go back to before the compressed data size
            stream->seek( basePos + header.mCompressedDataOffsets[i] );

            // Read the compressed data into a temp buffer, including the compressed data size
            std::vector<uint8> buffer( compressedDataSize + 4 );
            stream->read(buffer.data(), buffer.size());

            // Decompress the data
            auto decompressed = LzsBuffer::Decompress(buffer);

            Ogre::MemoryDataStream decStream(decompressed.data(), decompressed.size(), false, true);

            readUInt16(decStream, blockPart.mHeader.NumberOfTriangles);
            readUInt16(decStream, blockPart.mHeader.NumberOfVertices);

            /*
            std::cout << "block: " << j
                      << " from offset " << header.mCompressedDataOffsets[i]
                      << " old size: " << buffer.size()
                      << " decompressed size is " << decompressed.size()
                      << " header is tris: " <<  blockPart.mHeader.NumberOfTriangles
                      << " verts " << blockPart.mHeader.NumberOfVertices
                      << std::endl;*/


            blockPart.mTris.resize(blockPart.mHeader.NumberOfTriangles);
            for ( int k=0; k<blockPart.mHeader.NumberOfTriangles; k++)
            {
                BlockTriangle& s = blockPart.mTris[k];

                readUInt8( decStream, s.Vertex0Index );
                readUInt8( decStream, s.Vertex1Index );
                readUInt8( decStream, s.Vertex2Index );

                readUInt8( decStream, s.WalkabilityInfo );
                //readUInt8( decStream, s.Unknown );

                readUInt8( decStream, s.uVertex0 );
                readUInt8( decStream, s.vVertex0 );

                readUInt8( decStream, s.uVertex1 );
                readUInt8( decStream, s.vVertex1 );

                readUInt8( decStream, s.uVertex2 );
                readUInt8( decStream, s.vVertex2 );

                readUInt16( decStream, s.TextureInfo );

                s.TextureInfo = s.TextureInfo & 0x1FF;

                //readUInt16( decStream, s.Location );

                /*
                std::cout << "v0: " << int(s.Vertex0Index)
                          << " v1 " << int(s.Vertex1Index)
                          << " v2 " << int(s.Vertex2Index)
                          << " walk " << int(s.WalkabilityInfo)
                          << " u1 " << int(s.uVertex1)
                          << " v1 " << int(s.vVertex1)
                          << " v2 " << int(s.uVertex2)
                          << " u2 " << int(s.vVertex2)
                          << " texture " << s.TextureInfo
                          << " locId " << s.Location
                          << std::endl;*/

            }

            blockPart.mNormal.resize( blockPart.mHeader.NumberOfVertices );
            blockPart.mVertices.resize( blockPart.mHeader.NumberOfVertices );
//.........这里部分代码省略.........

bool OgreNetworkReply::seek(qint64 pos)
{
    QNetworkReply::seek(pos);
    mDataStream->seek(pos);
    return (mDataStream->tell() == pos);
}

Ogre::Codec::DecodeResult MTGACodec::decode(Ogre::DataStreamPtr& stream) const
{
	// Read 4 character code
	mtga_header_s hdr;
	//uint32 fileType;
	stream->read(&hdr, sizeof(hdr));
	if (LodResource_Bitmap != hdr.magic)
	{
		OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, 
			"This is not a MTGA file!", "MTGACodec::decode");
	}
	
	mtga_pal_s pal[256];
	assert(stream->size() == sizeof(hdr)+hdr.uncompressedSize + sizeof(pal));

	stream->seek(sizeof(mtga_header_s)+hdr.uncompressedSize);
	stream->read(pal,sizeof(pal));

	bool isTransparent = false;
	mtga_pal_s& clr = pal[0];
	if( (clr.r == 0 && clr.g >250 && clr.b > 250) || (clr.r > 250 && clr.g ==0 && clr.b > 250))
		isTransparent = true;


	Ogre::ImageCodec::ImageData* imgData = OGRE_NEW Ogre::ImageCodec::ImageData();
	imgData->format = PF_BYTE_BGRA;
	imgData->width = hdr.width;
	imgData->height = hdr.height;
	imgData->num_mipmaps = 3;
	imgData->depth = 1;

	imgData->size = Image::calculateSize(imgData->num_mipmaps, 1, 
			imgData->width, imgData->height, imgData->depth, imgData->format);
	
	Ogre::MemoryDataStreamPtr pixelData;
	
	pixelData.bind(OGRE_NEW MemoryDataStream(imgData->size));

	// Now deal with the data
	unsigned char* destPtr = pixelData->getPtr();
	stream->seek(sizeof(mtga_header_s));
	size_t width = hdr.width;
	size_t height = hdr.height;
	for(size_t mip = 0; mip <= imgData->num_mipmaps; ++mip)
	{
			for (size_t y = 0; y < height; y ++)
			{
				for (size_t x = 0; x < width; x ++)
				{
					unsigned char idx;
					stream->read(&idx,1);
					mtga_pal_s& clr = pal[idx];
					assert(destPtr-pixelData->getPtr() < imgData->size);
					
					*destPtr++ = clr.b;
					*destPtr++ = clr.g;
					*destPtr++ = clr.r;
					*destPtr++ = (idx == 0 && isTransparent)?0:255;
				}
			}
			width /=2;
			height /=2;

	}
	


	DecodeResult ret;
	ret.first = pixelData;
	ret.second = CodecDataPtr(imgData);
	return ret;
}

 void seek(size_t pos) {
     inp->seek(pos);
 }

void CollisionMesh::loadImpl (void)
{
    APP_ASSERT(masterShape==NULL);

    Ogre::DataStreamPtr file;
    try {
        file = Ogre::ResourceGroupManager::getSingleton().openResource(name.substr(1), "GRIT");
    } catch (Ogre::Exception &e) {
        GRIT_EXCEPT(e.getDescription());
    }

    std::string ext = name.substr(name.length()-5);

    uint32_t fourcc = 0;
    for (int i=0 ; i<4 ; ++i) {
        unsigned char c;
        file->read(&c, 1);
        fourcc |= c << (i*8);
    }
    file->seek(0);

    std::string dir = grit_dirname(name);

    const btVector3 ZV(0,0,0);
    const btQuaternion ZQ(0,0,0,1);

    bool compute_inertia = false;
    bool is_static = false;

    if (fourcc==0x4c4f4342) { //BCOL

        Ogre::MemoryDataStreamPtr mem = 
            Ogre::MemoryDataStreamPtr(OGRE_NEW Ogre::MemoryDataStream(name,file));

        BColFile &bcol = *reinterpret_cast<BColFile*>(mem->getPtr());

        is_static = bcol.mass == 0.0f; // static

        masterShape = new btCompoundShape();

        BColMaterialMap mmap(dir,name);

        for (unsigned i=0 ; i<bcol.hullNum ; ++i) {
            BColHull &p = *bcol.hulls(i);
            btConvexHullShape *s2 = new btConvexHullShape();
            s2->setMargin(p.margin);
            for (unsigned j=0 ; j<p.vertNum ; ++j) {
                BColVert &v = *p.verts(j);
                s2->addPoint(btVector3(v.x, v.y, v.z));
            }
            masterShape->addChildShape(btTransform(ZQ,ZV), s2);
            partMaterials.push_back(mmap(p.mat.name()));
        }

        for (unsigned i=0 ; i<bcol.boxNum ; ++i) {
            BColBox &p = *bcol.boxes(i);
            btBoxShape *s2 = new btBoxShape(btVector3(p.dx/2,p.dy/2,p.dz/2));
            s2->setMargin(p.margin);
            masterShape->addChildShape(btTransform(btQuaternion(p.qx,p.qy,p.qz,p.qw),
                                                   btVector3(p.px,p.py,p.pz)), s2);
            partMaterials.push_back(mmap(p.mat.name()));
        }

        for (unsigned i=0 ; i<bcol.cylNum ; ++i) {
            BColCyl &p = *bcol.cyls(i);
            btCylinderShape *s2 = new btCylinderShapeZ(btVector3(p.dx/2,p.dy/2,p.dz/2));
            s2->setMargin(p.margin);
            masterShape->addChildShape(btTransform(btQuaternion(p.qx,p.qy,p.qz,p.qw),
                                                   btVector3(p.px,p.py,p.pz)), s2);
            partMaterials.push_back(mmap(p.mat.name()));
        }

        for (unsigned i=0 ; i<bcol.coneNum ; ++i) {
            BColCone &p = *bcol.cones(i);
            btConeShape *s2 = new btConeShapeZ(p.radius,p.height);
            s2->setMargin(p.margin);
            masterShape->addChildShape(btTransform(btQuaternion(p.qx,p.qy,p.qz,p.qw),
                                                   btVector3(p.px,p.py,p.pz)), s2);
            partMaterials.push_back(mmap(p.mat.name()));
        }

        for (unsigned i=0 ; i<bcol.planeNum ; ++i) {
            BColPlane &p = *bcol.planes(i);
            btStaticPlaneShape *s2 = new btStaticPlaneShape(btVector3(p.nx,p.ny,p.nz),p.d);
            masterShape->addChildShape(btTransform(ZQ,ZV), s2);
            partMaterials.push_back(mmap(p.mat.name()));
        }

        for (unsigned i=0 ; i<bcol.sphereNum ; ++i) {
            BColSphere &p = *bcol.spheres(i);
            btSphereShape *s2 = new btSphereShape(p.radius);
            masterShape->addChildShape(btTransform(ZQ, btVector3(p.px,p.py,p.pz)), s2);
            partMaterials.push_back(mmap(p.mat.name()));
        }


        if (bcol.triMeshFaceNum > 0) {

            bcolVerts.resize(bcol.triMeshVertNum);
            bcolFaces.resize(bcol.triMeshFaceNum);
//.........这里部分代码省略.........