/// [HostBuffer] is a [Buffer] which is allocated on the host (native CPU
/// resident memory) and lazily uploaded to the GPU. A [HostBuffer] can be
/// safely mutated or extended at any time on the host, and will be
/// automatically re-uploaded to the GPU the next time a GPU operation needs to
/// access it.
///
/// This is useful for efficiently chunking sparse data uploads, especially
/// ephemeral uniform data that needs to change from frame to frame.
///
/// Different platforms have different data alignment requirements for accessing
/// device buffer data. The [HostBuffer] takes these requirements into account
/// and automatically inserts padding between emplaced data if necessary.

/// 1. Create the HostBuffer.

gpu.HostBuffer transients = gpu.gpuContext.createHostBuffer();

/// 2. Append some data to it.
///    Convenient for vertices or uniforms that need to be generated on the fly.
///
///    A reference to the newly appended data is returned in the form of a
///    `BufferView`, which holds an offset into the buffer.
///    At this point, the data is given to the underlying `DeviceBuffer`.

final gpu.BufferView vertices = transients.emplace(float32(<double>[
	-0.5, 0.5, //
	0.0, -0.5, //
	0.5, 0.5, //
]));
final gpu.BufferView vertInfoData = transients.emplace(float32(<double>[
	1, 0, 0, 0, // mvp
	0, 1, 0, 0, // mvp
	0, 0, 1, 0, // mvp
	0, 0, 0, 1, // mvp
	0, 1, 0, 1, // color
]));

// ... create a RenderPass encoder and set up command state ...

/// 3. Bind the data by passing in the `BufferViews` that were just created
///    above (literally just `DeviceBuffer`s under the hood today).

encoder.bindVertexBuffer(vertices, 3);

final gpu.UniformSlot vertInfo =
  pipeline.vertexShader.getUniformSlot('VertInfo');
encoder.bindUniform(vertInfo, vertInfoData);

/// 4. When the draw is encoded, the section of the hostbuffer

encoder.draw();