OGRE-Next: Ogre::NULLStagingBuffer Class Reference

| OGRE-Next 3.0.0 Object-Oriented Graphics Rendering Engine

Loading...
Searching...
No Matches
Ogre::NULLStagingBuffer Class Referencefinal

A staging buffer is a buffer that resides on the GPU and be written to/from both CPU & GPU However the access in both cases is limited. More...

`#include <OgreNULLStagingBuffer.h>`

Inheritance diagram for Ogre::NULLStagingBuffer:
[legend]

## Public Member Functions
| NULLStagingBuffer (size_t internalBufferStart, size_t sizeBytes, VaoManager *vaoManager, bool uploadOnly)
| ~NULLStagingBuffer () override
size_t | _asyncDownload (BufferPacked *source, size_t srcOffset, size_t srcLength) override
| Copies the GPU data in BufferPacked to the StagingBuffer so that it can be later read by the CPU using an AsyncTicket.
StagingStallType | uploadWillStall (size_t sizeBytes) override
| Returns true if our next call to map() with the same parameters will stall.
Public Member Functions inherited from Ogre::StagingBuffer
| StagingBuffer (size_t internalBufferStart, size_t sizeBytes, VaoManager *vaoManager, bool uploadOnly)
virtual | ~StagingBuffer ()
virtual void | _cancelDownload (size_t offset, size_t sizeBytes)
| Releases memory assigned to a download that hasn't been mapped yet, to make space for another _asyncDownload call.
const void * | _mapForRead (size_t offset, size_t sizeBytes)
| Maps the buffer for read acces for the CPU.
void | addReferenceCount ()
| Adds a reference count to the StagingBuffer.
virtual bool | canDownload (size_t length) const
| Checks if this staging buffer has enough free space to use _asyncDownload.
uint64 | getLastUsedTimestamp () const
| Returns the time in millisecond when the ref. count became 0.
uint32 | getLifetimeThreshold () const
| Returns the time in milliseconds in which a StagingBuffer should live with a reference count of 0 before being deleted.
MappingState | getMappingState () const
size_t | getMaxSize ()
int16 | getReferenceCount () const
uint32 | getUnfencedTimeThreshold () const
| Returns the time in milliseconds in which a StagingBuffer should hazards unfenced while with a reference count of 0.
bool | getUploadOnly () const
| When true, this buffer can only be used for uploading to GPU.
void * | map (size_t sizeBytes)
| Maps the given amount of bytes.
void | removeReferenceCount ()
| Decreases the reference count by one.
void | unmap (const Destination &destination)
| Unmaps the mapped region and copies the data to the given region.
void | unmap (const Destination *destinations, size_t numDestinations)
void | unmap (const DestinationVec &destinations)
| Unmaps the mapped region and copies the data to multiple buffers.

## Additional Inherited Members
Public Types inherited from Ogre::StagingBuffer
typedef vector< Destination >::type | DestinationVec

## Detailed Description

A staging buffer is a buffer that resides on the GPU and be written to/from both CPU & GPU However the access in both cases is limited.

GPUs can only copy (i.e. memcpy) to another real buffer (can't be used directly as i.e. texture or vertex buffer) and CPUs can only map it. In other words, a staging buffer is an intermediate buffer to transfer data between CPU & GPU

## Constructor & Destructor Documentation

## ◆ NULLStagingBuffer()

Ogre::NULLStagingBuffer::NULLStagingBuffer | ( | size_t | internalBufferStart,
|  | size_t | sizeBytes,
|  | VaoManager * | vaoManager,
|  | bool | uploadOnly )

## ◆ ~NULLStagingBuffer()

Ogre::NULLStagingBuffer::~NULLStagingBuffer | ( |  | ) |
| override

## Member Function Documentation

## ◆ _asyncDownload()

size_t Ogre::NULLStagingBuffer::_asyncDownload | ( | BufferPacked * | source,
|  | size_t | srcOffset,
|  | size_t | srcLength )
| overridevirtual

Copies the GPU data in BufferPacked to the StagingBuffer so that it can be later read by the CPU using an AsyncTicket.

See also
  AsyncTicket.

Remarks
  For internal use. May throw if it can't handle the request (i.e. requested size is too big, or too many _asyncDownload operations are pending until calling _mapForRead)

See also
  canDownload mUploadOnly must be true.

Parameters

  source | The buffer to copy from.
  srcOffset | The offset, in bytes, of the buffer to copy from.
  srcLength | The size in bytes, of the data to transfer to this staging buffer.

Returns
  The offset in bytes that will be used by

See also
  _mapForRead

Implements Ogre::StagingBuffer.

## ◆ uploadWillStall()

StagingStallType Ogre::NULLStagingBuffer::uploadWillStall | ( | size_t | sizeBytes | ) |
| overridevirtual

Returns true if our next call to map() with the same parameters will stall.

See also
  StagingStallType

Remarks
  Not all RenderSystems can accurately give this information and will always return STALL_PARTIAL (i.e. GLES2) The chances of getting a STALL_FULL get higher as sizeBytes gets closer to this->getMaxSize() mUploadOnly must be false. It is the counter side of

See also
  canDownload

Reimplemented from Ogre::StagingBuffer.

The documentation for this class was generated from the following file:

- OgreNULLStagingBuffer.h