#include <device_buffer_gles.h>

Inheritance diagram for impeller::DeviceBufferGLES:

Public Types
enum class	BindingType { kArrayBuffer , kElementArrayBuffer , kUniformBuffer }

Public Member Functions
	DeviceBufferGLES (DeviceBufferDescriptor desc, std::shared_ptr< ReactorGLES > reactor, std::unique_ptr< Allocation > backing_store)

	~DeviceBufferGLES () override

const uint8_t *	GetBufferData () const

void	UpdateBufferData (const std::function< void(uint8_t *, size_t length)> &update_buffer_data)

bool	BindAndUploadDataIfNecessary (BindingType type) const

void	Flush (std::optional< Range > range=std::nullopt) const override

std::optional< GLuint >	GetHandle () const

Public Member Functions inherited from impeller::DeviceBuffer
virtual	~DeviceBuffer ()

bool	CopyHostBuffer (const uint8_t *source, Range source_range, size_t offset=0u)

const DeviceBufferDescriptor &	GetDeviceBufferDescriptor () const

virtual void	Invalidate (std::optional< Range > range=std::nullopt) const

Additional Inherited Members
Static Public Member Functions inherited from impeller::DeviceBuffer
static BufferView	AsBufferView (std::shared_ptr< DeviceBuffer > buffer)
	Create a buffer view of this entire buffer.

Static Public Member Functions inherited from impeller::BackendCast< DeviceBufferGLES, DeviceBuffer >
static DeviceBufferGLES &	Cast (DeviceBuffer &base)

static const DeviceBufferGLES &	Cast (const DeviceBuffer &base)

static DeviceBufferGLES *	Cast (DeviceBuffer *base)

static const DeviceBufferGLES *	Cast (const DeviceBuffer *base)

Protected Member Functions inherited from impeller::DeviceBuffer
	DeviceBuffer (DeviceBufferDescriptor desc)

Protected Attributes inherited from impeller::DeviceBuffer
const DeviceBufferDescriptor	desc_

Detailed Description

Definition at line 19 of file device_buffer_gles.h.

Member Enumeration Documentation

◆ BindingType

enum class impeller::DeviceBufferGLES::BindingType

strong

Enumerator
kArrayBuffer
kElementArrayBuffer
kUniformBuffer

Definition at line 35 of file device_buffer_gles.h.

                         {
    kArrayBuffer,
    kElementArrayBuffer,
    kUniformBuffer,
  };

Constructor & Destructor Documentation

◆ DeviceBufferGLES()

impeller::DeviceBufferGLES::DeviceBufferGLES	(	DeviceBufferDescriptor	desc,
		std::shared_ptr< ReactorGLES >	reactor,
		std::unique_ptr< Allocation >	backing_store
	)

Definition at line 15 of file device_buffer_gles.cc.

    : DeviceBuffer(desc),
      reactor_(std::move(reactor)),
      backing_store_(std::move(backing_store)) {}

◆ ~DeviceBufferGLES()

impeller::DeviceBufferGLES::~DeviceBufferGLES ( )

override

Definition at line 23 of file device_buffer_gles.cc.

                                    {
  if (handle_.has_value() && !handle_->IsDead()) {
    reactor_->CollectHandle(*handle_);
  }
}

Member Function Documentation

◆ BindAndUploadDataIfNecessary()

bool impeller::DeviceBufferGLES::BindAndUploadDataIfNecessary ( BindingType type ) const

Definition at line 91 of file device_buffer_gles.cc.

                                                                          {
  if (!reactor_) {
    return false;
  }
 
  if (!handle_.has_value()) {
    handle_ = reactor_->CreateUntrackedHandle(HandleType::kBuffer);
#ifdef IMPELLER_DEBUG
    if (handle_.has_value() && label_.has_value()) {
      reactor_->SetDebugLabel(*handle_, *label_);
    }
#endif
  }
 
  auto buffer = reactor_->GetGLHandle(*handle_);
  if (!buffer.has_value()) {
    return false;
  }
 
  const auto target_type = ToTarget(type);
  const auto& gl = reactor_->GetProcTable();
 
  gl.BindBuffer(target_type, buffer.value());
  if (!initialized_) {
    gl.BufferData(target_type, backing_store_->GetLength().GetByteSize(),
                  nullptr, GL_DYNAMIC_DRAW);
    initialized_ = true;
  }
 
  // Take and clear the dirty range BEFORE uploading. A Flush() from another
  // thread during the upload then merges into a fresh dirty range that the
  // next bind uploads, instead of being silently discarded by a clear that
  // runs after the upload.
  std::optional<Range> dirty;
  {
    Lock lock(dirty_range_mutex_);
    std::swap(dirty_range_, dirty);
  }
  if (dirty.has_value()) {
    gl.BufferSubData(target_type, dirty->offset, dirty->length,
                     backing_store_->GetBuffer() + dirty->offset);
  }
 
  return true;
}

References impeller::kBuffer, impeller::ToTarget(), and type.

◆ Flush()

void impeller::DeviceBufferGLES::Flush ( std::optional< Range > range = std::nullopt ) const

overridevirtual

Make any pending writes visible to the GPU.

This method must be called if the device pointer provided by [OnGetContents] is written to without using [CopyHostBuffer]. On Devices with coherent host memory, this method will not perform extra work.

If the range is not provided, the entire buffer is flushed.

Reimplemented from impeller::DeviceBuffer.

Definition at line 65 of file device_buffer_gles.cc.

                                                           {
  Lock lock(dirty_range_mutex_);
  if (!range.has_value()) {
    dirty_range_ = Range{
        0, static_cast<size_t>(backing_store_->GetLength().GetByteSize())};
  } else {
    if (dirty_range_.has_value()) {
      dirty_range_ = dirty_range_->Merge(range.value());
    } else {
      dirty_range_ = range.value();
    }
  }
}

References impeller::Range::Merge().

Referenced by impeller::testing::TEST(), and UpdateBufferData().

◆ GetBufferData()

const uint8_t * impeller::DeviceBufferGLES::GetBufferData ( ) const

Definition at line 155 of file device_buffer_gles.cc.

                                                     {
  return backing_store_->GetBuffer();
}

◆ GetHandle()

std::optional< GLuint > impeller::DeviceBufferGLES::GetHandle ( ) const

Definition at line 57 of file device_buffer_gles.cc.

                                                      {
  if (handle_.has_value()) {
    return reactor_->GetGLHandle(*handle_);
  } else {
    return std::nullopt;
  }
}

◆ UpdateBufferData()

void impeller::DeviceBufferGLES::UpdateBufferData ( const std::function< void(uint8_t *, size_t length)> & update_buffer_data )

Definition at line 159 of file device_buffer_gles.cc.

                            {
  if (update_buffer_data) {
    update_buffer_data(backing_store_->GetBuffer(),
                       backing_store_->GetLength().GetByteSize());
    Flush(Range{
        0, static_cast<size_t>(backing_store_->GetLength().GetByteSize())});
  }
}

References Flush().

Referenced by impeller::BlitCopyTextureToBufferCommandGLES::Encode().

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

impeller/renderer/backend/gles/device_buffer_gles.h
impeller/renderer/backend/gles/device_buffer_gles.cc

Public Types

Public Member Functions

Additional Inherited Members