Trait gfx_core::factory::Factory [−] [src]

pub trait Factory<R: Resources> {
    fn get_capabilities(&self) -> &Capabilities;
    fn create_buffer_raw(
        &mut self, 
        _: Info
    ) -> Result<RawBuffer<R>, CreationError>;
    fn create_buffer_immutable_raw(
        &mut self, 
        data: &[u8], 
        stride: usize, 
        _: Role, 
        _: Bind
    ) -> Result<RawBuffer<R>, CreationError>;
    fn create_pipeline_state_raw(
        &mut self, 
        _: &Program<R>, 
        _: &Descriptor
    ) -> Result<RawPipelineState<R>, CreationError>;
    fn create_program(
        &mut self, 
        shader_set: &ShaderSet<R>
    ) -> Result<Program<R>, CreateProgramError>;
    fn create_shader(
        &mut self, 
        stage: Stage, 
        code: &[u8]
    ) -> Result<Shader<R>, CreateShaderError>;
    fn create_sampler(&mut self, _: 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;
    fn write_mapping<'a, 'b, T>(
        &'a mut self, 
        buf: &'b Buffer<R, T>
    ) -> Result<Writer<'b, R, T>, Error>
    where
        T: Copy;
    fn create_texture_raw(
        &mut self, 
        _: Info, 
        _: Option<ChannelType>, 
        _: Option<&[&[u8]]>
    ) -> Result<RawTexture<R>, CreationError>;
    fn view_buffer_as_shader_resource_raw(
        &mut self, 
        _: &RawBuffer<R>
    ) -> Result<RawShaderResourceView<R>, ResourceViewError>;
    fn view_buffer_as_unordered_access_raw(
        &mut self, 
        _: &RawBuffer<R>
    ) -> Result<RawUnorderedAccessView<R>, ResourceViewError>;
    fn view_texture_as_shader_resource_raw(
        &mut self, 
        _: &RawTexture<R>, 
        _: ResourceDesc
    ) -> Result<RawShaderResourceView<R>, ResourceViewError>;
    fn view_texture_as_unordered_access_raw(
        &mut self, 
        _: &RawTexture<R>
    ) -> Result<RawUnorderedAccessView<R>, ResourceViewError>;
    fn view_texture_as_render_target_raw(
        &mut self, 
        _: &RawTexture<R>, 
        _: RenderDesc
    ) -> Result<RawRenderTargetView<R>, TargetViewError>;
    fn view_texture_as_depth_stencil_raw(
        &mut self, 
        _: &RawTexture<R>, 
        _: DepthStencilDesc
    ) -> Result<RawDepthStencilView<R>, TargetViewError>;

    fn create_buffer_immutable<T: Pod>(
        &mut self, 
        data: &[T], 
        role: Role, 
        bind: Bind
    ) -> Result<Buffer<R, T>, CreationError> { ... }
    fn create_buffer<T>(
        &mut self, 
        num: usize, 
        role: Role, 
        usage: Usage, 
        bind: Bind
    ) -> Result<Buffer<R, T>, CreationError> { ... }
    fn create_shader_vertex(
        &mut self, 
        code: &[u8]
    ) -> Result<VertexShader<R>, CreateShaderError> { ... }
    fn create_shader_hull(
        &mut self, 
        code: &[u8]
    ) -> Result<HullShader<R>, CreateShaderError> { ... }
    fn create_shader_domain(
        &mut self, 
        code: &[u8]
    ) -> Result<DomainShader<R>, CreateShaderError> { ... }
    fn create_shader_geometry(
        &mut self, 
        code: &[u8]
    ) -> Result<GeometryShader<R>, CreateShaderError> { ... }
    fn create_shader_pixel(
        &mut self, 
        code: &[u8]
    ) -> Result<PixelShader<R>, CreateShaderError> { ... }
    fn create_texture<S>(
        &mut self, 
        kind: Kind, 
        levels: Level, 
        bind: Bind, 
        usage: Usage, 
        channel_hint: Option<ChannelType>
    ) -> Result<Texture<R, S>, CreationError>
    where
        S: SurfaceTyped,
    { ... }
    fn view_buffer_as_shader_resource<T>(
        &mut self, 
        buf: &Buffer<R, T>
    ) -> Result<ShaderResourceView<R, T>, ResourceViewError> { ... }
    fn view_buffer_as_unordered_access<T>(
        &mut self, 
        buf: &Buffer<R, T>
    ) -> Result<UnorderedAccessView<R, T>, ResourceViewError> { ... }
    fn view_texture_as_shader_resource<T: TextureFormat>(
        &mut self, 
        tex: &Texture<R, T::Surface>, 
        levels: (Level, Level), 
        swizzle: Swizzle
    ) -> Result<ShaderResourceView<R, T::View>, ResourceViewError> { ... }
    fn view_texture_as_unordered_access<T: TextureFormat>(
        &mut self, 
        tex: &Texture<R, T::Surface>
    ) -> Result<UnorderedAccessView<R, T::View>, ResourceViewError> { ... }
    fn view_texture_as_render_target<T: RenderFormat>(
        &mut self, 
        tex: &Texture<R, T::Surface>, 
        level: Level, 
        layer: Option<Layer>
    ) -> Result<RenderTargetView<R, T>, TargetViewError> { ... }
    fn view_texture_as_depth_stencil<T: DepthFormat>(
        &mut self, 
        tex: &Texture<R, T::Surface>, 
        level: Level, 
        layer: Option<Layer>, 
        flags: DepthStencilFlags
    ) -> Result<DepthStencilView<R, T>, TargetViewError> { ... }
    fn view_texture_as_depth_stencil_trivial<T: DepthFormat>(
        &mut self, 
        tex: &Texture<R, T::Surface>
    ) -> Result<DepthStencilView<R, T>, TargetViewError> { ... }
    fn create_texture_immutable_u8<T: TextureFormat>(
        &mut self, 
        kind: Kind, 
        data: &[&[u8]]
    ) -> Result<(Texture<R, T::Surface>, ShaderResourceView<R, T::View>), CombinedError> { ... }
    fn create_texture_immutable<T: TextureFormat>(
        &mut self, 
        kind: Kind, 
        data: &[&[T::Surface::DataType]]
    ) -> Result<(Texture<R, T::Surface>, ShaderResourceView<R, T::View>), CombinedError> { ... }
    fn create_render_target<T: RenderFormat + TextureFormat>(
        &mut self, 
        width: Size, 
        height: Size
    ) -> Result<(Texture<R, T::Surface>, ShaderResourceView<R, T::View>, RenderTargetView<R, T>), CombinedError> { ... }
    fn create_depth_stencil<T: DepthFormat + TextureFormat>(
        &mut self, 
        width: Size, 
        height: Size
    ) -> Result<(Texture<R, T::Surface>, ShaderResourceView<R, T::View>, DepthStencilView<R, T>), CombinedError> { ... }
    fn create_depth_stencil_view_only<T: DepthFormat + TextureFormat>(
        &mut self, 
        width: Size, 
        height: Size
    ) -> Result<DepthStencilView<R, T>, CombinedError> { ... }
}

A Factory is responsible for creating and managing resources for the context it was created with.

Construction and Handling

A Factory is typically created along with other objects using a helper function of the appropriate gfx_window module (e.g. gfx_window_glutin::init()).

This factory structure can then be used to create and manage different resources, like buffers, shader programs and textures. See the individual methods for more information.

Also see the FactoryExt trait inside the gfx module for additional methods.

Required Methods

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

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

Creates a new shader Program for the supplied ShaderSet.

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

Acquire a mapping Reader

See write_mapping for more information.

Acquire a mapping Writer

While holding this writer, you hold CPU-side exclusive access. Any access overlap will result in an error. Submitting commands involving this buffer to the device implicitly requires exclusive access. Additionally, further access will be stalled until execution completion.

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, ...

Provided Methods

Compiles a VertexShader from source.

Compiles a HullShader from source.

Compiles a VertexShader from source.

Compiles a GeometryShader from source.

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

Implementors