Struct RenderContext 

pub struct RenderContext {
    pub instance: Instance,
    pub adapter: Adapter,
    pub device: Device,
    pub queue: Queue,
    /* private fields */
}

The heart of mew. Bundles all necessary wgpu handles and takes care of constructing buffers, bind groups, & pipelines with a single function call.

Fields

instance: Instance

adapter: Adapter

device: Device

queue: Queue

Implementations

impl RenderContext

pub fn new( instance: Instance, adapter: Adapter, device: Device, queue: Queue, ) -> Self

Build a context manually by providing the wgpu::Instance, wgpu::Adapter, wgpu::Device, and wgpu::Queue.

You can build this directly , but a RenderContextBuilder takes care of the annoying stuff for you.

pub fn new_buffer<BUFFER: MewBuffer>(&self, inner_size: u64) -> BUFFER

Build a new buffer with an internal capacity to fit its internal type.

The type of buffer it makes is determined by its type parameter.

buffer! { SomeBuffer <InternalType> as STORAGE | COPY_DST }
let buffer: SomeBuffer = context.new_buffer(10);
assert_eq!(buffer.size() as usize, size_of::<InternalType>() * 10);

pub fn new_sampler<SAMPLER: MewSampler>(&self) -> SAMPLER

Build a new sampler.

The type of sampler it makes is determined by its type parameter.

sampler! { SomeSampler as Filtering }
let sampler: SomeSampler = context.new_sampler();

pub fn new_texture<TEXTURE: MewTexture>( &self, inner_size: (u32, u32, u32), format: TextureFormat, ) -> TEXTURE

Build a new sampler with dimensions and a wgpu::TextureFormat.

The type of texture it makes is determined by its type parameter.

texture! { SomeTexture { ... } }
let texture: SomeTexture = context.new_texture((64, 64, 1), wgpu::TextureFormat::Rgba8Unorm);

pub fn new_bind_group<BIND: MewBindGroup + 'static>( &self, buffers: BIND::BufferSet, ) -> BIND

Build a new buffer with a tuple of its bind groups.

The type of bind group it makes is determined by its type parameter.

bind_group! { StuffBindGroup [
    0 buffer_one @ VERTEX => SomeBuffer,
    1 other_buffer @ FRAGMENT => SomeOtherBuffer,
] }
let bind_group: SomeBindGroup = render_context.new_bind_group((buffer, other_buffer));

pub fn new_pipeline<PIPE: MewPipeline + 'static>( &self, surface_fmt: TextureFormat, shader: &ShaderModule, vertex_entry: Option<&str>, fragment_entry: Option<&str>, ) -> PIPE

Build a new pipeline given a wgpu::TextureFormat, a wgpu::ShaderModule (that you need to construct yourself), and the shader’s entry points (or None if you only have one entry point).

The type of pipeline it makes is determined by its type parameter.

pipeline! { Pipeline { ... } }
let pipeline: Pipeline = render_context.new_pipeline(wgpu::Rgba8Unorm, shader, Some("vs_main"), None);

Trait Implementations

impl Debug for RenderContext

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.