-
Notifications
You must be signed in to change notification settings - Fork 54
/
composite.rs
872 lines (780 loc) · 32.1 KB
/
composite.rs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
/* 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
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use api::{ColorF, YuvColorSpace, YuvFormat, ImageRendering};
use api::units::{DeviceRect, DeviceIntSize, DeviceIntRect, DeviceIntPoint, WorldRect};
use api::units::{DevicePixelScale, DevicePoint, PictureRect, TexelRect};
use crate::batch::{resolve_image, get_buffer_kind};
use crate::gpu_cache::GpuCache;
use crate::gpu_types::{ZBufferId, ZBufferIdGenerator};
use crate::internal_types::TextureSource;
use crate::picture::{ImageDependency, ResolvedSurfaceTexture, TileCacheInstance, TileSurface};
use crate::prim_store::DeferredResolve;
use crate::renderer::ImageBufferKind;
use crate::resource_cache::{ImageRequest, ResourceCache};
use std::{ops, u64};
/*
Types and definitions related to compositing picture cache tiles
and/or OS compositor integration.
*/
/// Describes details of an operation to apply to a native surface
#[derive(Debug, Clone)]
#[cfg_attr(feature = "capture", derive(Serialize))]
#[cfg_attr(feature = "replay", derive(Deserialize))]
pub enum NativeSurfaceOperationDetails {
CreateSurface {
id: NativeSurfaceId,
virtual_offset: DeviceIntPoint,
tile_size: DeviceIntSize,
is_opaque: bool,
},
DestroySurface {
id: NativeSurfaceId,
},
CreateTile {
id: NativeTileId,
},
DestroyTile {
id: NativeTileId,
}
}
/// Describes an operation to apply to a native surface
#[derive(Debug, Clone)]
#[cfg_attr(feature = "capture", derive(Serialize))]
#[cfg_attr(feature = "replay", derive(Deserialize))]
pub struct NativeSurfaceOperation {
pub details: NativeSurfaceOperationDetails,
}
/// Describes the source surface information for a tile to be composited. This
/// is the analog of the TileSurface type, with target surface information
/// resolved such that it can be used by the renderer.
#[cfg_attr(feature = "capture", derive(Serialize))]
#[cfg_attr(feature = "replay", derive(Deserialize))]
pub enum CompositeTileSurface {
Texture {
surface: ResolvedSurfaceTexture,
},
Color {
color: ColorF,
},
Clear,
ExternalSurface {
external_surface_index: ResolvedExternalSurfaceIndex,
},
}
/// The surface format for a tile being composited.
#[derive(Debug, Copy, Clone, PartialEq)]
pub enum CompositeSurfaceFormat {
Rgba,
Yuv,
}
/// Describes the geometry and surface of a tile to be composited
#[cfg_attr(feature = "capture", derive(Serialize))]
#[cfg_attr(feature = "replay", derive(Deserialize))]
pub struct CompositeTile {
pub surface: CompositeTileSurface,
pub rect: DeviceRect,
pub clip_rect: DeviceRect,
pub dirty_rect: DeviceRect,
pub valid_rect: DeviceRect,
pub z_id: ZBufferId,
}
/// Describes information about drawing a primitive as a compositor surface.
/// For now, we support only YUV images as compositor surfaces, but in future
/// this will also support RGBA images.
pub struct ExternalSurfaceDescriptor {
pub local_rect: PictureRect,
pub world_rect: WorldRect,
pub device_rect: DeviceRect,
pub clip_rect: DeviceRect,
pub image_dependencies: [ImageDependency; 3],
pub image_rendering: ImageRendering,
pub yuv_color_space: YuvColorSpace,
pub yuv_format: YuvFormat,
pub yuv_rescale: f32,
pub z_id: ZBufferId,
/// If native compositing is enabled, the native compositor surface handle.
/// Otherwise, this will be None
pub native_surface_id: Option<NativeSurfaceId>,
/// If the native surface needs to be updated, this will contain the size
/// of the native surface as Some(size). If not dirty, this is None.
pub update_params: Option<DeviceIntSize>,
}
/// Information about a plane in a YUV surface.
#[cfg_attr(feature = "capture", derive(Serialize))]
#[cfg_attr(feature = "replay", derive(Deserialize))]
pub struct YuvPlaneDescriptor {
pub texture: TextureSource,
pub texture_layer: i32,
pub uv_rect: TexelRect,
}
impl YuvPlaneDescriptor {
fn invalid() -> Self {
YuvPlaneDescriptor {
texture: TextureSource::Invalid,
texture_layer: 0,
uv_rect: TexelRect::invalid(),
}
}
}
#[cfg_attr(feature = "capture", derive(Serialize))]
#[cfg_attr(feature = "replay", derive(Deserialize))]
#[derive(Debug, Copy, Clone)]
pub struct ResolvedExternalSurfaceIndex(pub usize);
/// An ExternalSurfaceDescriptor that has had image keys
/// resolved to texture handles. This contains all the
/// information that the compositor step in renderer
/// needs to know.
#[cfg_attr(feature = "capture", derive(Serialize))]
#[cfg_attr(feature = "replay", derive(Deserialize))]
pub struct ResolvedExternalSurface {
// YUV specific information
pub image_dependencies: [ImageDependency; 3],
pub yuv_planes: [YuvPlaneDescriptor; 3],
pub yuv_color_space: YuvColorSpace,
pub yuv_format: YuvFormat,
pub yuv_rescale: f32,
pub image_buffer_kind: ImageBufferKind,
// Update information for a native surface if it's dirty
pub update_params: Option<(NativeSurfaceId, DeviceIntSize)>,
}
/// Public interface specified in `RendererOptions` that configures
/// how WR compositing will operate.
pub enum CompositorConfig {
/// Let WR draw tiles via normal batching. This requires no special OS support.
Draw {
/// If this is zero, a full screen present occurs at the end of the
/// frame. This is the simplest and default mode. If this is non-zero,
/// then the operating system supports a form of 'partial present' where
/// only dirty regions of the framebuffer need to be updated.
max_partial_present_rects: usize,
},
/// Use a native OS compositor to draw tiles. This requires clients to implement
/// the Compositor trait, but can be significantly more power efficient on operating
/// systems that support it.
Native {
/// The maximum number of dirty rects that can be provided per compositor
/// surface update. If this is zero, the entire compositor surface for
/// a given tile will be drawn if it's dirty.
max_update_rects: usize,
/// A client provided interface to a native / OS compositor.
compositor: Box<dyn Compositor>,
}
}
impl CompositorConfig {
pub fn compositor(&mut self) -> Option<&mut Box<dyn Compositor>> {
match self {
CompositorConfig::Native { ref mut compositor, .. } => {
Some(compositor)
}
CompositorConfig::Draw { .. } => {
None
}
}
}
}
impl Default for CompositorConfig {
/// Default compositor config is full present without partial present.
fn default() -> Self {
CompositorConfig::Draw {
max_partial_present_rects: 0,
}
}
}
/// This is a representation of `CompositorConfig` without the `Compositor` trait
/// present. This allows it to be freely copied to other threads, such as the render
/// backend where the frame builder can access it.
#[cfg_attr(feature = "capture", derive(Serialize))]
#[cfg_attr(feature = "replay", derive(Deserialize))]
#[derive(Debug, Copy, Clone, PartialEq)]
pub enum CompositorKind {
/// WR handles compositing via drawing.
Draw {
/// Partial present support.
max_partial_present_rects: usize,
},
/// Native OS compositor.
Native {
/// Maximum dirty rects per compositor surface.
max_update_rects: usize,
/// The virtual surface size used by underlying platform.
virtual_surface_size: i32,
},
}
impl Default for CompositorKind {
/// Default compositor config is full present without partial present.
fn default() -> Self {
CompositorKind::Draw {
max_partial_present_rects: 0,
}
}
}
impl CompositorKind {
pub fn get_virtual_surface_size(&self) -> i32 {
match self {
CompositorKind::Draw { .. } => 0,
CompositorKind::Native { virtual_surface_size, .. } => *virtual_surface_size,
}
}
}
/// Information about an opaque surface used to occlude tiles.
#[cfg_attr(feature = "capture", derive(Serialize))]
#[cfg_attr(feature = "replay", derive(Deserialize))]
struct Occluder {
z_id: ZBufferId,
device_rect: DeviceIntRect,
}
/// Describes the properties that identify a tile composition uniquely.
#[cfg_attr(feature = "capture", derive(Serialize))]
#[cfg_attr(feature = "replay", derive(Deserialize))]
#[derive(PartialEq, Clone)]
pub struct CompositeSurfaceDescriptor {
pub surface_id: Option<NativeSurfaceId>,
pub offset: DevicePoint,
pub clip_rect: DeviceRect,
// A list of image keys and generations that this compositor surface
// depends on. This avoids composites being skipped when the only
// thing that has changed is the generation of an compositor surface
// image dependency.
pub image_dependencies: [ImageDependency; 3],
}
/// Describes surface properties used to composite a frame. This
/// is used to compare compositions between frames.
#[cfg_attr(feature = "capture", derive(Serialize))]
#[cfg_attr(feature = "replay", derive(Deserialize))]
#[derive(PartialEq, Clone)]
pub struct CompositeDescriptor {
pub surfaces: Vec<CompositeSurfaceDescriptor>,
}
impl CompositeDescriptor {
/// Construct an empty descriptor.
pub fn empty() -> Self {
CompositeDescriptor {
surfaces: Vec::new(),
}
}
}
/// The list of tiles to be drawn this frame
#[cfg_attr(feature = "capture", derive(Serialize))]
#[cfg_attr(feature = "replay", derive(Deserialize))]
pub struct CompositeState {
// TODO(gw): Consider splitting up CompositeState into separate struct types depending
// on the selected compositing mode. Many of the fields in this state struct
// are only applicable to either Native or Draw compositing mode.
/// List of opaque tiles to be drawn by the Draw compositor.
pub opaque_tiles: Vec<CompositeTile>,
/// List of alpha tiles to be drawn by the Draw compositor.
pub alpha_tiles: Vec<CompositeTile>,
/// List of clear tiles to be drawn by the Draw compositor.
pub clear_tiles: Vec<CompositeTile>,
/// List of primitives that were promoted to be compositor surfaces.
pub external_surfaces: Vec<ResolvedExternalSurface>,
/// Used to generate z-id values for tiles in the Draw compositor mode.
pub z_generator: ZBufferIdGenerator,
// If false, we can't rely on the dirty rects in the CompositeTile
// instances. This currently occurs during a scroll event, as a
// signal to refresh the whole screen. This is only a temporary
// measure until we integrate with OS compositors. In the meantime
// it gives us the ability to partial present for any non-scroll
// case as a simple win (e.g. video, animation etc).
pub dirty_rects_are_valid: bool,
/// The kind of compositor for picture cache tiles (e.g. drawn by WR, or OS compositor)
pub compositor_kind: CompositorKind,
/// Picture caching may be disabled dynamically, based on debug flags, pinch zoom etc.
pub picture_caching_is_enabled: bool,
/// The overall device pixel scale, used for tile occlusion conversions.
global_device_pixel_scale: DevicePixelScale,
/// List of registered occluders
occluders: Vec<Occluder>,
/// Description of the surfaces and properties that are being composited.
pub descriptor: CompositeDescriptor,
}
impl CompositeState {
/// Construct a new state for compositing picture tiles. This is created
/// during each frame construction and passed to the renderer.
pub fn new(
compositor_kind: CompositorKind,
mut picture_caching_is_enabled: bool,
global_device_pixel_scale: DevicePixelScale,
) -> Self {
// The native compositor interface requires picture caching to work, so
// force it here and warn if it was disabled.
if let CompositorKind::Native { .. } = compositor_kind {
if !picture_caching_is_enabled {
warn!("Picture caching cannot be disabled in native compositor config");
}
picture_caching_is_enabled = true;
}
CompositeState {
opaque_tiles: Vec::new(),
alpha_tiles: Vec::new(),
clear_tiles: Vec::new(),
z_generator: ZBufferIdGenerator::new(0),
dirty_rects_are_valid: true,
compositor_kind,
picture_caching_is_enabled,
global_device_pixel_scale,
occluders: Vec::new(),
descriptor: CompositeDescriptor::empty(),
external_surfaces: Vec::new(),
}
}
/// Register an occluder during picture cache updates that can be
/// used during frame building to occlude tiles.
pub fn register_occluder(
&mut self,
z_id: ZBufferId,
rect: WorldRect,
) {
let device_rect = (rect * self.global_device_pixel_scale).round().to_i32();
self.occluders.push(Occluder {
device_rect,
z_id,
});
}
/// Returns true if a tile with the specified rectangle and z_id
/// is occluded by an opaque surface in front of it.
pub fn is_tile_occluded(
&self,
z_id: ZBufferId,
device_rect: DeviceRect,
) -> bool {
// It's often the case that a tile is only occluded by considering multiple
// picture caches in front of it (for example, the background tiles are
// often occluded by a combination of the content slice + the scrollbar slices).
// The basic algorithm is:
// For every occluder:
// If this occluder is in front of the tile we are querying:
// Clip the occluder rectangle to the query rectangle.
// Calculate the total non-overlapping area of those clipped occluders.
// If the cumulative area of those occluders is the same as the area of the query tile,
// Then the entire tile must be occluded and can be skipped during rasterization and compositing.
// Get the reference area we will compare against.
let device_rect = device_rect.round().to_i32();
let ref_area = device_rect.size.width * device_rect.size.height;
// Calculate the non-overlapping area of the valid occluders.
let cover_area = area_of_occluders(&self.occluders, z_id, &device_rect);
debug_assert!(cover_area <= ref_area);
// Check if the tile area is completely covered
ref_area == cover_area
}
/// Add a picture cache to be composited
pub fn push_surface(
&mut self,
tile_cache: &TileCacheInstance,
device_clip_rect: DeviceRect,
global_device_pixel_scale: DevicePixelScale,
resource_cache: &ResourceCache,
gpu_cache: &mut GpuCache,
deferred_resolves: &mut Vec<DeferredResolve>,
) {
let mut visible_opaque_tile_count = 0;
let mut visible_alpha_tile_count = 0;
for tile in tile_cache.tiles.values() {
if !tile.is_visible {
// This can occur when a tile is found to be occluded during frame building.
continue;
}
let device_rect = (tile.world_tile_rect * global_device_pixel_scale).round();
let surface = tile.surface.as_ref().expect("no tile surface set!");
let (surface, is_opaque) = match surface {
TileSurface::Color { color } => {
(CompositeTileSurface::Color { color: *color }, true)
}
TileSurface::Clear => {
(CompositeTileSurface::Clear, false)
}
TileSurface::Texture { descriptor, .. } => {
let surface = descriptor.resolve(resource_cache, tile_cache.current_tile_size);
(
CompositeTileSurface::Texture { surface },
tile.is_opaque || tile_cache.is_opaque(),
)
}
};
if is_opaque {
visible_opaque_tile_count += 1;
} else {
visible_alpha_tile_count += 1;
}
let tile = CompositeTile {
surface,
rect: device_rect,
valid_rect: tile.device_valid_rect.translate(-device_rect.origin.to_vector()),
dirty_rect: tile.device_dirty_rect.translate(-device_rect.origin.to_vector()),
clip_rect: device_clip_rect,
z_id: tile.z_id,
};
self.push_tile(tile, is_opaque);
}
// Add opaque surface before any compositor surfaces
if visible_opaque_tile_count > 0 {
self.descriptor.surfaces.push(
CompositeSurfaceDescriptor {
surface_id: tile_cache.native_surface.as_ref().map(|s| s.opaque),
offset: tile_cache.device_position,
clip_rect: device_clip_rect,
image_dependencies: [ImageDependency::INVALID; 3],
}
);
}
// For each compositor surface that was promoted, build the
// information required for the compositor to draw it
for external_surface in &tile_cache.external_surfaces {
let mut yuv_planes = [
YuvPlaneDescriptor::invalid(),
YuvPlaneDescriptor::invalid(),
YuvPlaneDescriptor::invalid(),
];
// Step through the image keys, and build a yuv plane descriptor for each
let required_plane_count = external_surface.yuv_format.get_plane_num();
let mut valid_plane_count = 0;
for i in 0 .. required_plane_count {
let key = external_surface.image_dependencies[i].key;
let plane = &mut yuv_planes[i];
let request = ImageRequest {
key,
rendering: external_surface.image_rendering,
tile: None,
};
let cache_item = resolve_image(
request,
resource_cache,
gpu_cache,
deferred_resolves,
);
if cache_item.texture_id != TextureSource::Invalid {
valid_plane_count += 1;
*plane = YuvPlaneDescriptor {
texture: cache_item.texture_id,
texture_layer: cache_item.texture_layer,
uv_rect: cache_item.uv_rect.into(),
};
}
}
// Check if there are valid images added for each YUV plane
if valid_plane_count < required_plane_count {
warn!("Warnings: skip a YUV compositor surface, found {}/{} valid images",
valid_plane_count,
required_plane_count,
);
continue;
}
let clip_rect = external_surface
.clip_rect
.intersection(&device_clip_rect)
.unwrap_or_else(DeviceRect::zero);
// Get a new z_id for each compositor surface, to ensure correct ordering
// when drawing with the simple (Draw) compositor.
let surface = CompositeTileSurface::ExternalSurface {
external_surface_index: ResolvedExternalSurfaceIndex(self.external_surfaces.len()),
};
// If the external surface descriptor reports that the native surface
// needs to be updated, create an update params tuple for the renderer
// to use.
let update_params = external_surface.update_params.map(|surface_size| {
(
external_surface.native_surface_id.expect("bug: no native surface!"),
surface_size
)
});
self.external_surfaces.push(ResolvedExternalSurface {
yuv_color_space: external_surface.yuv_color_space,
yuv_format: external_surface.yuv_format,
yuv_rescale: external_surface.yuv_rescale,
image_buffer_kind: get_buffer_kind(yuv_planes[0].texture),
image_dependencies: external_surface.image_dependencies,
yuv_planes,
update_params,
});
let tile = CompositeTile {
surface,
rect: external_surface.device_rect,
valid_rect: external_surface.device_rect.translate(-external_surface.device_rect.origin.to_vector()),
dirty_rect: external_surface.device_rect.translate(-external_surface.device_rect.origin.to_vector()),
clip_rect,
z_id: external_surface.z_id,
};
// Add a surface descriptor for each compositor surface. For the Draw
// compositor, this is used to avoid composites being skipped by adding
// a dependency on the compositor surface external image keys / generations.
self.descriptor.surfaces.push(
CompositeSurfaceDescriptor {
surface_id: external_surface.native_surface_id,
offset: tile.rect.origin,
clip_rect: tile.clip_rect,
image_dependencies: external_surface.image_dependencies,
}
);
self.push_tile(tile, true);
}
// Add alpha / overlay tiles after compositor surfaces
if visible_alpha_tile_count > 0 {
self.descriptor.surfaces.push(
CompositeSurfaceDescriptor {
surface_id: tile_cache.native_surface.as_ref().map(|s| s.alpha),
offset: tile_cache.device_position,
clip_rect: device_clip_rect,
image_dependencies: [ImageDependency::INVALID; 3],
}
);
}
}
/// Add a tile to the appropriate array, depending on tile properties and compositor mode.
fn push_tile(
&mut self,
tile: CompositeTile,
is_opaque: bool,
) {
match tile.surface {
CompositeTileSurface::Color { .. } => {
// Color tiles are, by definition, opaque. We might support non-opaque color
// tiles if we ever find pages that have a lot of these.
self.opaque_tiles.push(tile);
}
CompositeTileSurface::Clear => {
// Clear tiles have a special bucket
self.clear_tiles.push(tile);
}
CompositeTileSurface::Texture { .. } => {
// Texture surfaces get bucketed by opaque/alpha, for z-rejection
// on the Draw compositor mode.
if is_opaque {
self.opaque_tiles.push(tile);
} else {
self.alpha_tiles.push(tile);
}
}
CompositeTileSurface::ExternalSurface { .. } => {
self.opaque_tiles.push(tile);
}
}
}
}
/// An arbitrary identifier for a native (OS compositor) surface
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, Eq, PartialEq)]
#[cfg_attr(feature = "capture", derive(Serialize))]
#[cfg_attr(feature = "replay", derive(Deserialize))]
pub struct NativeSurfaceId(pub u64);
impl NativeSurfaceId {
/// A special id for the native surface that is used for debug / profiler overlays.
pub const DEBUG_OVERLAY: NativeSurfaceId = NativeSurfaceId(u64::MAX);
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, Eq, PartialEq)]
#[cfg_attr(feature = "capture", derive(Serialize))]
#[cfg_attr(feature = "replay", derive(Deserialize))]
pub struct NativeTileId {
pub surface_id: NativeSurfaceId,
pub x: i32,
pub y: i32,
}
impl NativeTileId {
/// A special id for the native surface that is used for debug / profiler overlays.
pub const DEBUG_OVERLAY: NativeTileId = NativeTileId {
surface_id: NativeSurfaceId::DEBUG_OVERLAY,
x: 0,
y: 0,
};
}
/// Information about a bound surface that the native compositor
/// returns to WR.
#[repr(C)]
#[derive(Copy, Clone)]
pub struct NativeSurfaceInfo {
/// An offset into the surface that WR should draw. Some compositing
/// implementations (notably, DirectComposition) use texture atlases
/// when the surface sizes are small. In this case, an offset can
/// be returned into the larger texture where WR should draw. This
/// can be (0, 0) if texture atlases are not used.
pub origin: DeviceIntPoint,
/// The ID of the FBO that WR should bind to, in order to draw to
/// the bound surface. On Windows (ANGLE) this will always be 0,
/// since creating a p-buffer sets the default framebuffer to
/// be the DirectComposition surface. On Mac, this will be non-zero,
/// since it identifies the IOSurface that has been bound to draw to.
// TODO(gw): This may need to be a larger / different type for WR
// backends that are not GL.
pub fbo_id: u32,
}
#[repr(C)]
pub struct CompositorCapabilities {
pub virtual_surface_size: i32,
}
/// Defines an interface to a native (OS level) compositor. If supplied
/// by the client application, then picture cache slices will be
/// composited by the OS compositor, rather than drawn via WR batches.
pub trait Compositor {
/// Create a new OS compositor surface with the given properties.
fn create_surface(
&mut self,
id: NativeSurfaceId,
virtual_offset: DeviceIntPoint,
tile_size: DeviceIntSize,
is_opaque: bool,
);
/// Destroy the surface with the specified id. WR may call this
/// at any time the surface is no longer required (including during
/// renderer deinit). It's the responsibility of the embedder
/// to ensure that the surface is only freed once the GPU is
/// no longer using the surface (if this isn't already handled
/// by the operating system).
fn destroy_surface(
&mut self,
id: NativeSurfaceId,
);
/// Create a new OS compositor tile with the given properties.
fn create_tile(
&mut self,
id: NativeTileId,
);
/// Destroy an existing compositor tile.
fn destroy_tile(
&mut self,
id: NativeTileId,
);
/// Bind this surface such that WR can issue OpenGL commands
/// that will target the surface. Returns an (x, y) offset
/// where WR should draw into the surface. This can be set
/// to (0, 0) if the OS doesn't use texture atlases. The dirty
/// rect is a local surface rect that specifies which part
/// of the surface needs to be updated. If max_update_rects
/// in CompositeConfig is 0, this will always be the size
/// of the entire surface. The returned offset is only
/// relevant to compositors that store surfaces in a texture
/// atlas (that is, WR expects that the dirty rect doesn't
/// affect the coordinates of the returned origin).
fn bind(
&mut self,
id: NativeTileId,
dirty_rect: DeviceIntRect,
valid_rect: DeviceIntRect,
) -> NativeSurfaceInfo;
/// Unbind the surface. This is called by WR when it has
/// finished issuing OpenGL commands on the current surface.
fn unbind(
&mut self,
);
/// Begin the frame
fn begin_frame(&mut self);
/// Add a surface to the visual tree to be composited. Visuals must
/// be added every frame, between the begin/end transaction call. The
/// z-order of the surfaces is determined by the order they are added
/// to the visual tree.
// TODO(gw): Adding visuals every frame makes the interface simple,
// but may have performance implications on some compositors?
// We might need to change the interface to maintain a visual
// tree that can be mutated?
// TODO(gw): We might need to add a concept of a hierachy in future.
// TODO(gw): In future, expand to support a more complete transform matrix.
fn add_surface(
&mut self,
id: NativeSurfaceId,
position: DeviceIntPoint,
clip_rect: DeviceIntRect,
);
/// Commit any changes in the compositor tree for this frame. WR calls
/// this once when all surface and visual updates are complete, to signal
/// that the OS composite transaction should be applied.
fn end_frame(&mut self);
/// Enable/disable native compositor usage
fn enable_native_compositor(&mut self, enable: bool);
/// Get the capabilities struct for this compositor. This is used to
/// specify what features a compositor supports, depending on the
/// underlying platform
fn get_capabilities(&self) -> CompositorCapabilities;
}
/// Return the total area covered by a set of occluders, accounting for
/// overlapping areas between those rectangles.
fn area_of_occluders(
occluders: &[Occluder],
z_id: ZBufferId,
clip_rect: &DeviceIntRect,
) -> i32 {
// This implementation is based on the article https://leetcode.com/articles/rectangle-area-ii/.
// This is not a particularly efficient implementation (it skips building segment trees), however
// we typically use this where the length of the rectangles array is < 10, so simplicity is more important.
let mut area = 0;
// Whether this event is the start or end of a rectangle
#[derive(Debug)]
enum EventKind {
Begin,
End,
}
// A list of events on the y-axis, with the rectangle range that it affects on the x-axis
#[derive(Debug)]
struct Event {
y: i32,
x_range: ops::Range<i32>,
kind: EventKind,
}
impl Event {
fn new(y: i32, kind: EventKind, x0: i32, x1: i32) -> Self {
Event {
y,
x_range: ops::Range {
start: x0,
end: x1,
},
kind,
}
}
}
// Step through each rectangle and build the y-axis event list
let mut events = Vec::with_capacity(occluders.len() * 2);
for occluder in occluders {
// Only consider occluders in front of this rect
if occluder.z_id.0 > z_id.0 {
// Clip the source rect to the rectangle we care about, since we only
// want to record area for the tile we are comparing to.
if let Some(rect) = occluder.device_rect.intersection(clip_rect) {
let x0 = rect.origin.x;
let x1 = x0 + rect.size.width;
events.push(Event::new(rect.origin.y, EventKind::Begin, x0, x1));
events.push(Event::new(rect.origin.y + rect.size.height, EventKind::End, x0, x1));
}
}
}
// If we didn't end up with any valid events, the area must be 0
if events.is_empty() {
return 0;
}
// Sort the events by y-value
events.sort_by_key(|e| e.y);
let mut active: Vec<ops::Range<i32>> = Vec::new();
let mut cur_y = events[0].y;
// Step through each y interval
for event in &events {
// This is the dimension of the y-axis we are accumulating areas for
let dy = event.y - cur_y;
// If we have active events covering x-ranges in this y-interval, process them
if dy != 0 && !active.is_empty() {
assert!(dy > 0);
// Step through the x-ranges, ordered by x0 of each event
active.sort_by_key(|i| i.start);
let mut query = 0;
let mut cur = active[0].start;
// Accumulate the non-overlapping x-interval that contributes to area for this y-interval.
for interval in &active {
cur = interval.start.max(cur);
query += (interval.end - cur).max(0);
cur = cur.max(interval.end);
}
// Accumulate total area for this y-interval
area += query * dy;
}
// Update the active events list
match event.kind {
EventKind::Begin => {
active.push(event.x_range.clone());
}
EventKind::End => {
let index = active.iter().position(|i| *i == event.x_range).unwrap();
active.remove(index);
}
}
cur_y = event.y;
}
area
}