wip

Author: gw3583

webrender/res/prim_shared.glsl

@@ -55,6 +55,7 @@ uniform sampler2D sData16;
 uniform sampler2D sData32;
 uniform sampler2D sData64;
 uniform sampler2D sData128;
+uniform sampler2D sResourceRects;
 
 ivec2 get_fetch_uv(int index, int vecs_per_item) {
     int items_per_row = WR_MAX_VERTEX_TEXTURE_WIDTH / vecs_per_item;
@@ -186,16 +187,14 @@ GradientStop fetch_gradient_stop(int index) {
 
 struct Glyph {
     vec4 offset;
-    vec4 uv_rect;
 };
 
 Glyph fetch_glyph(int index) {
     Glyph glyph;
 
-    ivec2 uv = get_fetch_uv_2(index);
+    ivec2 uv = get_fetch_uv_1(index);
 
-    glyph.offset = texelFetchOffset(sData32, uv, 0, ivec2(0, 0));
-    glyph.uv_rect = texelFetchOffset(sData32, uv, 0, ivec2(1, 0));
+    glyph.offset = texelFetchOffset(sData16, uv, 0, ivec2(0, 0));
 
     return glyph;
 }
@@ -584,6 +583,20 @@ TransformVertexInfo write_transform_vertex(vec4 instance_rect,
 
 #endif //WR_FEATURE_TRANSFORM
 
+struct ResourceRect {
+    vec4 uv_rect;
+};
+
+ResourceRect fetch_resource_rect(int index) {
+    ResourceRect rect;
+
+    ivec2 uv = get_fetch_uv_1(index);
+
+    rect.uv_rect = texelFetchOffset(sResourceRects, uv, 0, ivec2(0, 0));
+
+    return rect;
+}
+
 struct Rectangle {
     vec4 color;
 };
@@ -613,18 +626,16 @@ TextRun fetch_text_run(int index) {
 }
 
 struct Image {
-    vec4 st_rect;                        // Location of the image texture in the texture atlas.
     vec4 stretch_size_and_tile_spacing;  // Size of the actual image and amount of space between
                                          //     tiled instances of this image.
 };
 
 Image fetch_image(int index) {
     Image image;
 
-    ivec2 uv = get_fetch_uv_2(index);
+    ivec2 uv = get_fetch_uv_1(index);
 
-    image.st_rect = texelFetchOffset(sData32, uv, 0, ivec2(0, 0));
-    image.stretch_size_and_tile_spacing = texelFetchOffset(sData32, uv, 0, ivec2(1, 0));
+    image.stretch_size_and_tile_spacing = texelFetchOffset(sData16, uv, 0, ivec2(0, 0));
 
     return image;
 }

webrender/res/ps_image.vs.glsl

@@ -6,6 +6,7 @@
 void main(void) {
     Primitive prim = load_primitive(gl_InstanceID);
     Image image = fetch_image(prim.prim_index);
+    ResourceRect res = fetch_resource_rect(prim.user_data.x);
 
 #ifdef WR_FEATURE_TRANSFORM
     TransformVertexInfo vi = write_transform_vertex(prim.local_rect,
@@ -24,8 +25,8 @@ void main(void) {
 
     // vUv will contain how many times this image has wrapped around the image size.
     vec2 texture_size = vec2(textureSize(sColor0, 0));
-    vec2 st0 = image.st_rect.xy / texture_size;
-    vec2 st1 = image.st_rect.zw / texture_size;
+    vec2 st0 = res.uv_rect.xy / texture_size;
+    vec2 st1 = res.uv_rect.zw / texture_size;
 
     vTextureSize = st1 - st0;
     vTextureOffset = st0;

webrender/res/ps_text_run.vs.glsl

@@ -7,7 +7,9 @@ void main(void) {
     Primitive prim = load_primitive(gl_InstanceID);
     TextRun text = fetch_text_run(prim.prim_index);
     Glyph glyph = fetch_glyph(prim.sub_index);
-    vec4 local_rect = vec4(glyph.offset.xy, (glyph.uv_rect.zw - glyph.uv_rect.xy) / uDevicePixelRatio);
+    ResourceRect res = fetch_resource_rect(prim.user_data.x);
+
+    vec4 local_rect = vec4(glyph.offset.xy, (res.uv_rect.zw - res.uv_rect.xy) / uDevicePixelRatio);
 
 #ifdef WR_FEATURE_TRANSFORM
     TransformVertexInfo vi = write_transform_vertex(local_rect,
@@ -26,8 +28,8 @@ void main(void) {
 #endif
 
     vec2 texture_size = vec2(textureSize(sColor0, 0));
-    vec2 st0 = glyph.uv_rect.xy / texture_size;
-    vec2 st1 = glyph.uv_rect.zw / texture_size;
+    vec2 st0 = res.uv_rect.xy / texture_size;
+    vec2 st1 = res.uv_rect.zw / texture_size;
 
     vColor = text.color;
     vUv = mix(st0, st1, f);

webrender/src/device.rs

@@ -1366,6 +1366,11 @@ impl Device {
                 if u_data128 != -1 {
                     gl::uniform_1i(u_data128, TextureSampler::Data128    as i32);
                 }
+
+                let u_resource_rects = gl::get_uniform_location(program.id, "sResourceRects");
+                if u_resource_rects != -1 {
+                    gl::uniform_1i(u_resource_rects, TextureSampler::ResourceRects as i32);
+                }
             }
         }
     }

webrender/src/internal_types.rs

@@ -55,7 +55,7 @@ pub enum SourceTexture {
     WebGL(u32),                         // Is actually a gl::GLuint
 
     // TODO(gw): Implement external image support via callback
-    //External(i32),
+    External(u64),
 }
 
 pub enum GLContextHandleWrapper {
@@ -213,6 +213,7 @@ pub enum TextureSampler {
     Layers,
     RenderTasks,
     Geometry,
+    ResourceRects,
 }
 
 impl TextureSampler {

webrender/src/prim_store.rs

@@ -16,6 +16,26 @@ use webrender_traits::{AuxiliaryLists, ColorF, ImageKey, ImageRendering};
 use webrender_traits::{FontRenderMode, WebGLContextId};
 use webrender_traits::{ClipRegion, FontKey, ItemRange, ComplexClipRegion, GlyphKey};
 
+#[derive(Clone)]
+pub struct TexelRect {
+    uv0: Point2D<f32>,
+    uv1: Point2D<f32>,
+}
+
+pub struct DeferredResolve {
+    resource_address: GpuStoreAddress,
+    source_texture: SourceTexture,
+}
+
+impl Default for TexelRect {
+    fn default() -> TexelRect {
+        TexelRect {
+            uv0: Point2D::zero(),
+            uv1: Point2D::zero(),
+        }
+    }
+}
+
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash, Ord, PartialOrd)]
 pub struct SpecificPrimitiveIndex(pub usize);
 
@@ -96,12 +116,11 @@ pub enum ImagePrimitiveKind {
 pub struct ImagePrimitiveCpu {
     pub kind: ImagePrimitiveKind,
     pub color_texture_id: SourceTexture,
+    pub resource_address: GpuStoreAddress,
 }
 
 #[derive(Debug, Clone)]
 pub struct ImagePrimitiveGpu {
-    pub uv0: Point2D<f32>,
-    pub uv1: Point2D<f32>,
     pub stretch_size: Size2D<f32>,
     pub tile_spacing: Size2D<f32>,
 }
@@ -191,14 +210,13 @@ pub struct TextRunPrimitiveCpu {
     pub color_texture_id: SourceTexture,
     pub color: ColorF,
     pub render_mode: FontRenderMode,
+    pub resource_address: GpuStoreAddress,
 }
 
 #[derive(Debug, Clone)]
 struct GlyphPrimitive {
     offset: Point2D<f32>,
     padding: Point2D<f32>,
-    uv0: Point2D<f32>,
-    uv1: Point2D<f32>,
 }
 
 #[derive(Debug, Clone)]
@@ -353,6 +371,9 @@ pub struct PrimitiveStore {
     pub gpu_data64: GpuStore<GpuBlock64>,
     pub gpu_data128: GpuStore<GpuBlock128>,
 
+    // Resolved resource rects.
+    pub gpu_resource_rects: GpuStore<TexelRect>,
+
     // General
     device_pixel_ratio: f32,
     prims_to_resolve: Vec<PrimitiveIndex>,
@@ -372,6 +393,7 @@ impl PrimitiveStore {
             gpu_data32: GpuStore::new(),
             gpu_data64: GpuStore::new(),
             gpu_data128: GpuStore::new(),
+            gpu_resource_rects: GpuStore::new(),
             device_pixel_ratio: device_pixel_ratio,
             prims_to_resolve: Vec::new(),
         }
@@ -425,9 +447,10 @@ impl PrimitiveStore {
 
                 metadata
             }
-            PrimitiveContainer::TextRun(text_cpu, text_gpu) => {
+            PrimitiveContainer::TextRun(mut text_cpu, text_gpu) => {
                 let gpu_address = self.gpu_data16.push(text_gpu);
-                let gpu_glyphs_address = self.gpu_data32.alloc(text_cpu.glyph_range.length);
+                let gpu_glyphs_address = self.gpu_data16.alloc(text_cpu.glyph_range.length);
+                text_cpu.resource_address = self.gpu_resource_rects.alloc(text_cpu.glyph_range.length);
 
                 let metadata = PrimitiveMetadata {
                     is_opaque: false,
@@ -445,8 +468,10 @@ impl PrimitiveStore {
                 self.cpu_text_runs.push(text_cpu);
                 metadata
             }
-            PrimitiveContainer::Image(image_cpu, image_gpu) => {
-                let gpu_address = self.gpu_data32.push(image_gpu);
+            PrimitiveContainer::Image(mut image_cpu, image_gpu) => {
+                image_cpu.resource_address = self.gpu_resource_rects.alloc(1);
+
+                let gpu_address = self.gpu_data16.push(image_gpu);
 
                 let metadata = PrimitiveMetadata {
                     is_opaque: false,
@@ -564,12 +589,14 @@ impl PrimitiveStore {
         PrimitiveIndex(prim_index)
     }
 
-    pub fn resolve_primitives(&mut self, resource_cache: &ResourceCache) {
+    pub fn resolve_primitives(&mut self, resource_cache: &ResourceCache) -> Vec<DeferredResolve> {
+        let mut deferred_resolves = Vec::new();
+
         for prim_index in self.prims_to_resolve.drain(..) {
             let metadata = &mut self.cpu_metadata[prim_index.0];
 
             if let &PrimitiveClipSource::Region(ClipRegion { image_mask: Some(mask), .. }) = metadata.clip_source.as_ref() {
-                let tex_cache = resource_cache.get_image(mask.image, ImageRendering::Auto);
+                let tex_cache = resource_cache.get_image(mask.image, ImageRendering::Auto).expect("masks shouldn't be external!");
                 metadata.mask_texture_id = tex_cache.texture_id;
                 if let Some(address) = metadata.clip_index {
                     let clip_data = self.gpu_data32.get_slice_mut(address, 6);
@@ -590,44 +617,56 @@ impl PrimitiveStore {
                 PrimitiveKind::TextRun => {
                     let text = &mut self.cpu_text_runs[metadata.cpu_prim_index.0];
 
-                    let dest_glyphs = self.gpu_data32.get_slice_mut(metadata.gpu_data_address,
-                                                                    text.glyph_range.length);
+                    let dest_rects = self.gpu_resource_rects.get_slice_mut(text.resource_address,
+                                                                           text.glyph_range.length);
 
                     let texture_id = resource_cache.get_glyphs(text.font_key,
                                                                text.font_size,
                                                                &text.glyph_indices,
                                                                text.render_mode, |index, uv0, uv1| {
-                        let dest_glyph = &mut dest_glyphs[index];
-                        let dest: &mut GlyphPrimitive = unsafe {
-                            mem::transmute(dest_glyph)
-                        };
-                        dest.uv0 = uv0;
-                        dest.uv1 = uv1;
+                        let dest_rect = &mut dest_rects[index];
+                        dest_rect.uv0 = uv0;
+                        dest_rect.uv1 = uv1;
                     });
 
                     text.color_texture_id = texture_id;
                 }
                 PrimitiveKind::Image => {
                     let image_cpu = &mut self.cpu_images[metadata.cpu_prim_index.0];
-                    let image_gpu: &mut ImagePrimitiveGpu = unsafe {
-                        mem::transmute(self.gpu_data32.get_mut(metadata.gpu_prim_index))
-                    };
 
-                    let cache_item = match image_cpu.kind {
+                    match image_cpu.kind {
                         ImagePrimitiveKind::Image(image_key, image_rendering, _) => {
-                            resource_cache.get_image(image_key, image_rendering)
+                            match resource_cache.get_image(image_key, image_rendering) {
+                                Ok(cache_item) => {
+                                    let resource_rect = self.gpu_resource_rects.get_mut(image_cpu.resource_address);
+                                    resource_rect.uv0 = cache_item.uv0;
+                                    resource_rect.uv1 = cache_item.uv1;
+                                    image_cpu.color_texture_id = cache_item.texture_id;
+                                }
+                                Err(source_texture) => {
+                                    // This is an external texture - we will add it to
+                                    // the deferred resolves list to be patched by
+                                    // the render thread...
+                                    deferred_resolves.push(DeferredResolve {
+                                        resource_address: image_cpu.resource_address,
+                                        source_texture: source_texture,
+                                    });
+                                }
+                            }
                         }
                         ImagePrimitiveKind::WebGL(context_id) => {
-                            resource_cache.get_webgl_texture(&context_id)
+                            let cache_item = resource_cache.get_webgl_texture(&context_id);
+                            let resource_rect = self.gpu_resource_rects.get_mut(image_cpu.resource_address);
+                            resource_rect.uv0 = cache_item.uv0;
+                            resource_rect.uv1 = cache_item.uv1;
+                            image_cpu.color_texture_id = cache_item.texture_id;
                         }
-                    };
-
-                    image_cpu.color_texture_id = cache_item.texture_id;
-                    image_gpu.uv0 = cache_item.uv0;
-                    image_gpu.uv1 = cache_item.uv1;
+                    }
                 }
             }
         }
+
+        deferred_resolves
     }
 
     pub fn get_bounding_rect(&self, index: PrimitiveIndex) -> &Option<DeviceRect> {
@@ -747,7 +786,7 @@ impl PrimitiveStore {
                     debug_assert!(metadata.gpu_data_count == text.glyph_range.length as i32);
                     debug_assert!(text.glyph_indices.is_empty());
                     let src_glyphs = auxiliary_lists.glyph_instances(&text.glyph_range);
-                    let dest_glyphs = self.gpu_data32.get_slice_mut(metadata.gpu_data_address,
+                    let dest_glyphs = self.gpu_data16.get_slice_mut(metadata.gpu_data_address,
                                                                     text.glyph_range.length);
                     let mut glyph_key = GlyphKey::new(text.font_key,
                                                       text.font_size,
@@ -776,9 +815,7 @@ impl PrimitiveStore {
                                                          Size2D::new(width, height));
                         local_rect = local_rect.union(&local_glyph_rect);
 
-                        dest_glyphs[actual_glyph_count] = GpuBlock32::from(GlyphPrimitive {
-                            uv0: Point2D::zero(),
-                            uv1: Point2D::zero(),
+                        dest_glyphs[actual_glyph_count] = GpuBlock16::from(GlyphPrimitive {
                             padding: Point2D::zero(),
                             offset: local_glyph_rect.origin,
                         });
@@ -918,6 +955,22 @@ impl From<InstanceRect> for GpuBlock16 {
     }
 }
 
+impl From<ImagePrimitiveGpu> for GpuBlock16 {
+    fn from(data: ImagePrimitiveGpu) -> GpuBlock16 {
+        unsafe {
+            mem::transmute::<ImagePrimitiveGpu, GpuBlock16>(data)
+        }
+    }
+}
+
+impl From<GlyphPrimitive> for GpuBlock16 {
+    fn from(data: GlyphPrimitive) -> GpuBlock16 {
+        unsafe {
+            mem::transmute::<GlyphPrimitive, GpuBlock16>(data)
+        }
+    }
+}
+
 #[derive(Clone)]
 pub struct GpuBlock32 {
     data: [f32; 8],
@@ -947,22 +1000,6 @@ impl From<GradientStop> for GpuBlock32 {
     }
 }
 
-impl From<GlyphPrimitive> for GpuBlock32 {
-    fn from(data: GlyphPrimitive) -> GpuBlock32 {
-        unsafe {
-            mem::transmute::<GlyphPrimitive, GpuBlock32>(data)
-        }
-    }
-}
-
-impl From<ImagePrimitiveGpu> for GpuBlock32 {
-    fn from(data: ImagePrimitiveGpu) -> GpuBlock32 {
-        unsafe {
-            mem::transmute::<ImagePrimitiveGpu, GpuBlock32>(data)
-        }
-    }
-}
-
 impl From<ClipRect> for GpuBlock32 {
     fn from(data: ClipRect) -> GpuBlock32 {
         unsafe {