Struct veloren_voxygen::render::renderer::Renderer

pub struct Renderer {

    device: Arc<Device>,
    queue: Queue,
    surface: Surface,
    surface_config: SurfaceConfiguration,
    sampler: Sampler,
    depth_sampler: Sampler,
    state: State,
    recreation_pending: Option<PipelineModes>,
    layouts: Layouts,
    locals: Locals,
    views: Views,
    noise_tex: Texture,
    quad_index_buffer_u16: Buffer<u16>,
    quad_index_buffer_u32: Buffer<u32>,
    shaders: AssetHandle<Shaders>,
    shaders_watcher: ReloadWatcher,
    pipeline_modes: PipelineModes,
    other_modes: OtherModes,
    resolution: Vec2<u32>,
    take_screenshot: Option<Box<dyn FnOnce(Result<RgbImage, String>) + Send>>,
    profiler: GpuProfiler,
    profile_times: Vec<GpuTimerScopeResult>,
    profiler_features_enabled: bool,
    ui_premultiply_uploads: BatchedUploads,
    egui_renderpass: RenderPass,
    is_minimized: bool,
    graphics_backend: String,
    intermediate_format: TextureFormat,
    present_modes: Vec<PresentMode>,
    max_texture_size: u32,
}

A type that encapsulates rendering state. Renderer is central to Voxygen’s rendering subsystem and contains any state necessary to interact with the GPU, along with pipeline state objects (PSOs) needed to renderer different kinds of models to the screen.

Fields

device: Arc<Device>

queue: Queue

surface: Surface

surface_config: SurfaceConfiguration

sampler: Sampler

depth_sampler: Sampler

state: State

recreation_pending: Option<PipelineModes>

layouts: Layouts

locals: Locals

views: Views

noise_tex: Texture

quad_index_buffer_u16: Buffer<u16>

quad_index_buffer_u32: Buffer<u32>

shaders: AssetHandle<Shaders>

shaders_watcher: ReloadWatcher

pipeline_modes: PipelineModes

other_modes: OtherModes

resolution: Vec2<u32>

take_screenshot: Option<Box<dyn FnOnce(Result<RgbImage, String>) + Send>>

profiler: GpuProfiler

profile_times: Vec<GpuTimerScopeResult>

profiler_features_enabled: bool

ui_premultiply_uploads: BatchedUploads

egui_renderpass: RenderPass

is_minimized: bool

graphics_backend: String

intermediate_format: TextureFormat

The texture format used for the intermediate rendering passes

present_modes: Vec<PresentMode>

Supported present modes.

max_texture_size: u32

Cached max texture size.

Implementations

impl Renderer

pub fn bind_globals( &self, global_model: &GlobalModel, lod_data: &LodData, ) -> GlobalsBindGroup

pub fn bind_sprite_globals( &self, global_model: &GlobalModel, lod_data: &LodData, sprite_verts: &SpriteVerts, ) -> SpriteGlobalsBindGroup

pub fn create_debug_bound_locals(&mut self, vals: &[Locals]) -> BoundLocals

pub fn create_ui_bound_locals(&mut self, vals: &[Locals]) -> BoundLocals

pub fn ui_bind_texture(&mut self, texture: &Texture) -> TextureBindGroup

pub fn create_figure_bound_locals( &mut self, locals: &[Locals], bone_data: &[BoneData], ) -> BoundLocals

pub fn create_rope_bound_locals(&mut self, locals: &[Locals]) -> BoundLocals

pub fn create_terrain_bound_locals(&mut self, locals: &[Locals]) -> BoundLocals

pub fn create_shadow_bound_locals(&mut self, locals: &[Locals]) -> BoundLocals

pub fn create_rain_occlusion_bound_locals( &mut self, locals: &[Locals], ) -> BoundLocals

pub fn figure_bind_atlas_textures( &self, col_light: Texture, ) -> AtlasTextures<Locals, FigureSpriteAtlasData>

pub fn terrain_bind_atlas_textures( &self, col_light: Texture, kinds: Texture, ) -> AtlasTextures<Locals, TerrainAtlasData>

pub fn sprite_bind_atlas_textures( &self, col_light: Texture, ) -> AtlasTextures<Locals, FigureSpriteAtlasData>

impl Renderer

pub fn new( window: &Window, mode: RenderMode, runtime: &Runtime, ) -> Result<Self, RenderError>

Create a new Renderer from a variety of backend-specific components and the window targets.

pub fn graphics_backend(&self) -> &str

Get the graphics backend being used

pub fn pipeline_creation_status(&self) -> Option<(usize, usize)>

Check the status of the intial pipeline creation Returns None if complete Returns Some((total, complete)) if in progress

pub fn pipeline_recreation_status(&self) -> Option<(usize, usize)>

Check the status the pipeline recreation Returns None if pipelines are currently not being recreated Returns Some((total, complete)) if in progress

pub fn set_render_mode(&mut self, mode: RenderMode) -> Result<(), RenderError>

Change the render mode.

pub fn pipeline_modes(&self) -> &PipelineModes

Get the pipelines mode.

pub fn present_modes(&self) -> &[PresentMode]

Get the supported present modes.

pub fn timings(&self) -> Vec<(u8, &str, f64)>

Get the current profiling times Nested timings immediately follow their parent Returns Vec<(how nested this timing is, label, length in seconds)>

pub fn on_resize(&mut self, dims: Vec2<u32>)

Resize internal render targets to match window render target dimensions.

pub fn maintain(&self)

fn create_rt_views( device: &Device, size: (u32, u32), pipeline_modes: &PipelineModes, other_modes: &OtherModes, format: TextureFormat, ) -> (Views, [Vec2<f32>; 5])

Create render target views

pub fn resolution(&self) -> Vec2<u32>

Get the resolution of the render target.

pub fn get_shadow_resolution(&self) -> (Vec2<u32>, Vec2<u32>)

Get the resolution of the shadow render target.

pub fn start_recording_frame<'a>( &'a mut self, globals: &'a GlobalsBindGroup, ) -> Result<Option<Drawer<'a>>, RenderError>

NOTE: Supported by Vulkan (by default), DirectX 10+ (it seems–it’s hard to find proof of this, but Direct3D 10 apparently does it by default, and 11 definitely does, so I assume it’s natively supported by DirectX itself), OpenGL 3.2+, and Metal (done by default). While there may be some GPUs that don’t quite support it correctly, the impact is relatively small, so there is no reason not to enable it where available. Start recording the frame When the returned Drawer is dropped the recorded draw calls will be submitted to the queue If there is an intermittent issue with the swap chain then Ok(None) will be returned

fn recreate_pipelines(&mut self, pipeline_modes: PipelineModes)

Recreate the pipelines

pub fn create_consts<T: Copy + Pod>(&mut self, vals: &[T]) -> Consts<T>

Create a new set of constants with the provided values.

pub fn create_consts_inner<T: Copy + Pod>( device: &Device, queue: &Queue, vals: &[T], ) -> Consts<T>

pub fn update_consts<T: Copy + Pod>(&self, consts: &mut Consts<T>, vals: &[T])

Update a set of constants with the provided values.

pub fn update_clouds_locals(&mut self, new_val: Locals)

pub fn update_postprocess_locals(&mut self, new_val: Locals)

pub fn create_instances<T: Copy + Pod>(&mut self, vals: &[T]) -> Instances<T>

Create a new set of instances with the provided values.

pub(super) fn ensure_sufficient_index_length<V: Vertex>( &mut self, vert_length: usize, )

Ensure that the quad index buffer is large enough for a quad vertex buffer with this many vertices

pub fn create_sprite_verts(&mut self, mesh: Mesh<Vertex>) -> SpriteVerts

pub fn create_model<V: Vertex>(&mut self, mesh: &Mesh<V>) -> Option<Model<V>>

Create a new model from the provided mesh. If the provided mesh is empty this returns None

pub fn create_dynamic_model<V: Vertex>( &mut self, size: usize, ) -> DynamicModel<V>

Create a new dynamic model with the specified size.

pub fn update_model<V: Vertex>( &self, model: &DynamicModel<V>, mesh: &Mesh<V>, offset: usize, )

Update a dynamic model with a mesh and a offset.

pub fn max_texture_size(&self) -> u32

Return the maximum supported texture size.

pub fn create_texture_with_data_raw( &mut self, texture_info: &TextureDescriptor<'_>, view_info: &TextureViewDescriptor<'_>, sampler_info: &SamplerDescriptor<'_>, data: &[u8], ) -> Texture

Create a new immutable texture from the provided image.

Panics

If the provided data doesn’t completely fill the texture this function will panic.

pub fn create_texture_raw( &mut self, texture_info: &TextureDescriptor<'_>, view_info: &TextureViewDescriptor<'_>, sampler_info: &SamplerDescriptor<'_>, ) -> Texture

Create a new raw texture.

pub fn create_texture( &mut self, image: &DynamicImage, filter_method: Option<FilterMode>, address_mode: Option<AddressMode>, ) -> Result<Texture, RenderError>

Create a new texture from the provided image.

pub fn create_dynamic_texture(&mut self, dims: Vec2<u32>) -> Texture

Create a new dynamic texture with the specified dimensions.

Currently only supports Rgba8Srgb.

pub fn update_texture<T: Pod>( &mut self, texture: &Texture, offset: [u32; 2], size: [u32; 2], data: &[T], )

Update a texture with the provided offset, size, and data.

pub fn ui_premultiply_upload( &mut self, target_texture: &Arc<Texture>, batch: UploadBatchId, image: &RgbaImage, offset: Vec2<u16>, ) -> UploadBatchId

See docs on ui::BatchedUploads::submit.

pub fn create_screenshot( &mut self, screenshot_handler: impl FnOnce(Result<RgbImage, String>) + Send + 'static, )

Queue to obtain a screenshot on the next frame render