Source code
Revision control
Copy as Markdown
Other Tools
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
//! This module contains the logic to obtain a primitive's source texture and uv rect.
//!
//! Currently this is a somewhat involved process because the code grew into having ad-hoc
//! ways to store this information depending on how the image data is produced. The goal
//! is for any textured primitive to be able to read from any source (texture cache, render
//! tasks, etc.) without primitive-specific code.
use crate::api::ExternalImageType;
use crate::api::units::*;
use crate::gpu_cache::GpuCache;
use crate::prim_store::DeferredResolve;
use crate::renderer::BLOCKS_PER_UV_RECT;
use crate::render_task_cache::RenderTaskCacheEntryHandle;
use crate::resource_cache::{ResourceCache, ImageRequest, CacheItem};
use crate::internal_types::{TextureSource, DeferredResolveIndex};
/// Resolve a resource cache's imagre request into a texture cache item.
pub fn resolve_image(
request: ImageRequest,
resource_cache: &ResourceCache,
gpu_cache: &mut GpuCache,
deferred_resolves: &mut Vec<DeferredResolve>,
) -> CacheItem {
match resource_cache.get_image_properties(request.key) {
Some(image_properties) => {
// Check if an external image that needs to be resolved
// by the render thread.
match image_properties.external_image {
Some(external_image) => {
// This is an external texture - we will add it to
// the deferred resolves list to be patched by
// the render thread...
let cache_handle = gpu_cache.push_deferred_per_frame_blocks(BLOCKS_PER_UV_RECT);
let deferred_resolve_index = DeferredResolveIndex(deferred_resolves.len() as u32);
let image_buffer_kind = match external_image.image_type {
ExternalImageType::TextureHandle(target) => {
target
}
ExternalImageType::Buffer => {
// The ExternalImageType::Buffer should be handled by resource_cache.
// It should go through the non-external case.
panic!("Unexpected non-texture handle type");
}
};
let cache_item = CacheItem {
texture_id: TextureSource::External(deferred_resolve_index, image_buffer_kind),
uv_rect_handle: cache_handle,
uv_rect: DeviceIntRect::from_size(
image_properties.descriptor.size,
),
user_data: [0.0; 4],
};
deferred_resolves.push(DeferredResolve {
image_properties,
address: gpu_cache.get_address(&cache_handle),
rendering: request.rendering,
});
cache_item
}
None => {
if let Ok(cache_item) = resource_cache.get_cached_image(request) {
cache_item
} else {
// There is no usable texture entry for the image key. Just return an invalid texture here.
CacheItem::invalid()
}
}
}
}
None => {
CacheItem::invalid()
}
}
}
pub fn resolve_cached_render_task(
handle: &RenderTaskCacheEntryHandle,
resource_cache: &ResourceCache,
) -> CacheItem {
let rt_cache_entry = resource_cache
.get_cached_render_task(&handle);
resource_cache.get_texture_cache_item(&rt_cache_entry.handle)
}