Enum gfx_device_gl::Resources

pub enum Resources {}

Trait Implementations

impl Buffer<Resources> for CommandBuffer

fn reset(&mut self)

Reset the command buffer contents, retain the allocated storage

fn bind_pipeline_state(&mut self, pso: PipelineState)

Bind a pipeline state object

fn bind_vertex_buffers(&mut self, vbs: VertexBufferSet<Resources>)

Bind a complete set of vertex buffers

fn bind_constant_buffers(&mut self, cbs: &[ConstantBufferParam<Resources>])

Bind a complete set of constant buffers

fn bind_global_constant(&mut self, loc: Location, value: UniformValue)

Bind a global constant

fn bind_resource_views(&mut self, srvs: &[ResourceViewParam<Resources>])

Bind a complete set of shader resource views

fn bind_unordered_views(&mut self, uavs: &[UnorderedViewParam<Resources>])

Bind a complete set of unordered access views

fn bind_samplers(&mut self, ss: &[SamplerParam<Resources>])

Bind a complete set of samplers

fn bind_pixel_targets(&mut self, pts: PixelTargetSet<Resources>)

Bind a complete set of pixel targets, including multiple colors views and an optional depth/stencil view.

fn bind_index(&mut self, buf: Buffer, itype: IndexType)

Bind an index buffer

fn set_scissor(&mut self, rect: Rect)

Set scissor rectangle

fn set_ref_values(&mut self, rv: RefValues)

Set reference values for the blending and stencil front/back

fn copy_buffer(
    &mut self,
    src: Buffer,
    dst: Buffer,
    src_offset_bytes: usize,
    dst_offset_bytes: usize,
    size_bytes: usize
)

Copy part of a buffer to another

fn copy_buffer_to_texture(
    &mut self,
    src: Buffer,
    src_offset_bytes: usize,
    dst: TextureCopyRegion<NewTexture>
)

Copy part of a buffer to a texture

fn copy_texture_to_buffer(
    &mut self,
    src: TextureCopyRegion<NewTexture>,
    dst: Buffer,
    dst_offset_bytes: usize
)

Copy part of a texture to a buffer

fn copy_texture_to_texture(
    &mut self,
    src: TextureCopyRegion<NewTexture>,
    dst: TextureCopyRegion<NewTexture>
)

Copy part of one texture into another

fn update_buffer(&mut self, buf: Buffer, data: &[u8], offset_bytes: usize)

Update a vertex/index/uniform buffer

fn update_texture(&mut self, dst: TextureCopyRegion<NewTexture>, data: &[u8])

Update a texture

fn generate_mipmap(&mut self, srv: ResourceView)

fn clear_color(&mut self, target: TargetView, value: ClearColor)

Clear color target

fn clear_depth_stencil(
    &mut self,
    target: TargetView,
    depth: Option<Depth>,
    stencil: Option<Stencil>
)

fn call_draw(
    &mut self,
    start: VertexCount,
    count: VertexCount,
    instances: Option<InstanceParams>
)

Draw a primitive

fn call_draw_indexed(
    &mut self,
    start: VertexCount,
    count: VertexCount,
    base: VertexCount,
    instances: Option<InstanceParams>
)

Draw a primitive with index buffer

impl Clone for Resources

fn clone(&self) -> Resources

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for Resources

impl Debug for Resources

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

Formats the value using the given formatter.

impl Eq for Resources

impl Factory<Resources> for Factory

fn get_capabilities(&self) -> &Capabilities

Returns the capabilities of this Factory. This usually depends on the graphics API being used.

fn create_buffer_raw(
    &mut self,
    info: Info
) -> Result<RawBuffer<R>, CreationError>

fn create_buffer_immutable_raw(
    &mut self,
    data: &[u8],
    stride: usize,
    role: Role,
    bind: Bind
) -> Result<RawBuffer<R>, CreationError>

fn create_shader(
    &mut self,
    stage: Stage,
    code: &[u8]
) -> Result<Shader<R>, CreateShaderError>

Compiles a shader source into a Shader object that can be used to create a shader Program.

fn create_program(
    &mut self,
    shader_set: &ShaderSet<R>
) -> Result<Program<R>, CreateProgramError>

Creates a new shader Program for the supplied ShaderSet.

fn create_pipeline_state_raw(
    &mut self,
    program: &Program<R>,
    desc: &Descriptor
) -> Result<RawPipelineState<R>, CreationError>

Creates a new RawPipelineState. To create a safely typed PipelineState, see the FactoryExt trait and pso module, both in the gfx crate.

fn create_texture_raw(
    &mut self,
    desc: Info,
    hint: Option<ChannelType>,
    data_opt: Option<(&[&[u8]], Mipmap)>
) -> Result<RawTexture<R>, CreationError>

Create a new empty raw texture with no data. The channel type parameter is a hint, required to assist backends that have no concept of typeless formats (OpenGL). The initial data, if given, has to be provided for all mip levels and slices: Slice0.Mip0, Slice0.Mip1, …, Slice1.Mip0, …

fn view_buffer_as_shader_resource_raw(
    &mut self,
    hbuf: &RawBuffer<R>,
    format: Format
) -> Result<RawShaderResourceView<R>, ResourceViewError>

fn view_buffer_as_unordered_access_raw(
    &mut self,
    _hbuf: &RawBuffer<R>
) -> Result<RawUnorderedAccessView<R>, ResourceViewError>

fn view_texture_as_shader_resource_raw(
    &mut self,
    htex: &RawTexture<R>,
    desc: ResourceDesc
) -> Result<RawShaderResourceView<R>, ResourceViewError>

fn view_texture_as_unordered_access_raw(
    &mut self,
    _htex: &RawTexture<R>
) -> Result<RawUnorderedAccessView<R>, ResourceViewError>

fn view_texture_as_render_target_raw(
    &mut self,
    htex: &RawTexture<R>,
    desc: RenderDesc
) -> Result<RawRenderTargetView<R>, TargetViewError>

fn view_texture_as_depth_stencil_raw(
    &mut self,
    htex: &RawTexture<R>,
    desc: DepthStencilDesc
) -> Result<RawDepthStencilView<R>, TargetViewError>

fn create_sampler(&mut self, info: SamplerInfo) -> Sampler<R>

fn read_mapping<'a, 'b, T>(
    &'a mut self,
    buf: &'b Buffer<R, T>
) -> Result<Reader<'b, R, T>, Error> where
    T: Copy, 

Acquire a mapping Reader

fn write_mapping<'a, 'b, T>(
    &'a mut self,
    buf: &'b Buffer<R, T>
) -> Result<Writer<'b, R, T>, Error> where
    T: Copy, 

Acquire a mapping Writer

pub fn create_buffer_immutable<T>(
    &mut self,
    data: &[T],
    role: Role,
    bind: Bind
) -> Result<Buffer<R, T>, CreationError> where
    T: Pod, 

pub fn create_buffer<T>(
    &mut self,
    num: usize,
    role: Role,
    usage: Usage,
    bind: Bind
) -> Result<Buffer<R, T>, CreationError>

pub fn create_shader_vertex(
    &mut self,
    code: &[u8]
) -> Result<VertexShader<R>, CreateShaderError>

Compiles a VertexShader from source.

pub fn create_shader_hull(
    &mut self,
    code: &[u8]
) -> Result<HullShader<R>, CreateShaderError>

Compiles a HullShader from source.

pub fn create_shader_domain(
    &mut self,
    code: &[u8]
) -> Result<DomainShader<R>, CreateShaderError>

Compiles a VertexShader from source.

pub fn create_shader_geometry(
    &mut self,
    code: &[u8]
) -> Result<GeometryShader<R>, CreateShaderError>

Compiles a GeometryShader from source.

pub fn create_shader_pixel(
    &mut self,
    code: &[u8]
) -> Result<PixelShader<R>, CreateShaderError>

Compiles a PixelShader from source. This is the same as what some APIs call a fragment shader.

pub fn create_texture<S>(
    &mut self,
    kind: Kind,
    levels: u8,
    bind: Bind,
    usage: Usage,
    channel_hint: Option<ChannelType>
) -> Result<Texture<R, S>, CreationError> where
    S: SurfaceTyped, 

pub fn view_buffer_as_shader_resource<T>(
    &mut self,
    buf: &Buffer<R, T>
) -> Result<ShaderResourceView<R, T>, ResourceViewError> where
    T: Formatted, 

pub fn view_buffer_as_unordered_access<T>(
    &mut self,
    buf: &Buffer<R, T>
) -> Result<UnorderedAccessView<R, T>, ResourceViewError>

pub fn view_texture_as_shader_resource<T>(
    &mut self,
    tex: &Texture<R, <T as Formatted>::Surface>,
    levels: (u8, u8),
    swizzle: Swizzle
) -> Result<ShaderResourceView<R, <T as Formatted>::View>, ResourceViewError> where
    T: TextureFormat, 

pub fn view_texture_as_unordered_access<T>(
    &mut self,
    tex: &Texture<R, <T as Formatted>::Surface>
) -> Result<UnorderedAccessView<R, <T as Formatted>::View>, ResourceViewError> where
    T: TextureFormat, 

pub fn view_texture_as_render_target<T>(
    &mut self,
    tex: &Texture<R, <T as Formatted>::Surface>,
    level: u8,
    layer: Option<u16>
) -> Result<RenderTargetView<R, T>, TargetViewError> where
    T: RenderFormat, 

pub fn view_texture_as_depth_stencil<T>(
    &mut self,
    tex: &Texture<R, <T as Formatted>::Surface>,
    level: u8,
    layer: Option<u16>,
    flags: DepthStencilFlags
) -> Result<DepthStencilView<R, T>, TargetViewError> where
    T: DepthFormat, 

pub fn view_texture_as_depth_stencil_trivial<T>(
    &mut self,
    tex: &Texture<R, <T as Formatted>::Surface>
) -> Result<DepthStencilView<R, T>, TargetViewError> where
    T: DepthFormat, 

pub fn create_texture_immutable_u8<T>(
    &mut self,
    kind: Kind,
    mipmap: Mipmap,
    data: &[&[u8]]
) -> Result<(Texture<R, <T as Formatted>::Surface>, ShaderResourceView<R, <T as Formatted>::View>), CombinedError> where
    T: TextureFormat, 

pub fn create_texture_immutable<T>(
    &mut self,
    kind: Kind,
    mipmap: Mipmap,
    data: &[&[<<T as Formatted>::Surface as SurfaceTyped>::DataType]]
) -> Result<(Texture<R, <T as Formatted>::Surface>, ShaderResourceView<R, <T as Formatted>::View>), CombinedError> where
    T: TextureFormat, 

pub fn create_render_target<T>(
    &mut self,
    width: u16,
    height: u16
) -> Result<(Texture<R, <T as Formatted>::Surface>, ShaderResourceView<R, <T as Formatted>::View>, RenderTargetView<R, T>), CombinedError> where
    T: RenderFormat + TextureFormat, 

pub fn create_depth_stencil<T>(
    &mut self,
    width: u16,
    height: u16
) -> Result<(Texture<R, <T as Formatted>::Surface>, ShaderResourceView<R, <T as Formatted>::View>, DepthStencilView<R, T>), CombinedError> where
    T: DepthFormat + TextureFormat, 

pub fn create_depth_stencil_view_only<T>(
    &mut self,
    width: u16,
    height: u16
) -> Result<DepthStencilView<R, T>, CombinedError> where
    T: DepthFormat + TextureFormat, 

impl Hash for Resources

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

pub fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl PartialEq<Resources> for Resources

fn eq(&self, other: &Resources) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]

pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl Resources for Resources

type Buffer = Buffer

type Shader = Shader

type Program = Program

type PipelineStateObject = PipelineState

type Texture = NewTexture

type RenderTargetView = TargetView

type DepthStencilView = TargetView

type ShaderResourceView = ResourceView

type UnorderedAccessView = ()

type Sampler = FatSampler

type Fence = Fence

type Mapping = MappingGate

impl StructuralEq for Resources

impl StructuralPartialEq for Resources