image_source.rs (4277B)
1 /* This Source Code Form is subject to the terms of the Mozilla Public 2 * License, v. 2.0. If a copy of the MPL was not distributed with this 3 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ 4 5 //! This module contains the logic to obtain a primitive's source texture and uv rect. 6 //! 7 //! Currently this is a somewhat involved process because the code grew into having ad-hoc 8 //! ways to store this information depending on how the image data is produced. The goal 9 //! is for any textured primitive to be able to read from any source (texture cache, render 10 //! tasks, etc.) without primitive-specific code. 11 12 use crate::api::ExternalImageType; 13 use crate::api::units::*; 14 use crate::prim_store::DeferredResolve; 15 use crate::renderer::BLOCKS_PER_UV_RECT; 16 use crate::render_task_cache::RenderTaskCacheEntryHandle; 17 use crate::renderer::GpuBufferBuilderF; 18 use crate::resource_cache::{ResourceCache, ImageRequest, CacheItem}; 19 use crate::internal_types::{TextureSource, TextureSourceExternal, DeferredResolveIndex, FrameVec}; 20 21 /// Resolve a resource cache's imagre request into a texture cache item. 22 pub fn resolve_image( 23 request: ImageRequest, 24 resource_cache: &ResourceCache, 25 gpu_buffer: &mut GpuBufferBuilderF, 26 deferred_resolves: &mut FrameVec<DeferredResolve>, 27 is_composited: bool, 28 ) -> CacheItem { 29 match resource_cache.get_image_properties(request.key) { 30 Some(image_properties) => { 31 // Check if an external image that needs to be resolved 32 // by the render thread. 33 match image_properties.external_image { 34 Some(external_image) => { 35 // This is an external texture - we will add it to 36 // the deferred resolves list to be patched by 37 // the render thread... 38 let uv_rect_address = gpu_buffer.reserve_renderer_deferred_blocks(BLOCKS_PER_UV_RECT); 39 40 let deferred_resolve_index = DeferredResolveIndex(deferred_resolves.len() as u32); 41 42 let image_buffer_kind = match external_image.image_type { 43 ExternalImageType::TextureHandle(target) => { 44 target 45 } 46 ExternalImageType::Buffer => { 47 // The ExternalImageType::Buffer should be handled by resource_cache. 48 // It should go through the non-external case. 49 panic!("Unexpected non-texture handle type"); 50 } 51 }; 52 53 let cache_item = CacheItem { 54 texture_id: TextureSource::External(TextureSourceExternal { 55 index: deferred_resolve_index, 56 kind: image_buffer_kind, 57 normalized_uvs: external_image.normalized_uvs, 58 }), 59 uv_rect_handle: uv_rect_address, 60 uv_rect: DeviceIntRect::from_size( 61 image_properties.descriptor.size, 62 ), 63 user_data: [0.0; 4], 64 }; 65 66 deferred_resolves.push(DeferredResolve { 67 image_properties, 68 handle: uv_rect_address, 69 rendering: request.rendering, 70 is_composited, 71 }); 72 73 cache_item 74 } 75 None => { 76 if let Ok(cache_item) = resource_cache.get_cached_image(request) { 77 cache_item 78 } else { 79 // There is no usable texture entry for the image key. Just return an invalid texture here. 80 CacheItem::invalid() 81 } 82 } 83 } 84 } 85 None => { 86 CacheItem::invalid() 87 } 88 } 89 } 90 91 pub fn resolve_cached_render_task( 92 handle: &RenderTaskCacheEntryHandle, 93 resource_cache: &ResourceCache, 94 ) -> CacheItem { 95 let rt_cache_entry = resource_cache 96 .get_cached_render_task(&handle); 97 98 resource_cache.get_texture_cache_item(&rt_cache_entry.handle).unwrap() 99 }