Line data Source code
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 : /* Generated with cbindgen:0.1.13 */
6 :
7 : /* DO NOT MODIFY THIS MANUALLY! This file was generated using cbindgen.
8 : * To generate this file:
9 : * 1. Get the latest cbindgen using `cargo install --force cbindgen`
10 : * a. Alternatively, you can clone `https://github.com/rlhunt/cbindgen` and use a tagged release
11 : * 2. Run `cbindgen toolkit/library/rust/ --crate webrender_bindings -o gfx/webrender_bindings/webrender_ffi_generated.h`
12 : */
13 :
14 : #include <cstdint>
15 : #include <cstdlib>
16 :
17 : extern "C" {
18 :
19 : enum class WrBorderStyle : uint32_t {
20 : None = 0,
21 : Solid = 1,
22 : Double = 2,
23 : Dotted = 3,
24 : Dashed = 4,
25 : Hidden = 5,
26 : Groove = 6,
27 : Ridge = 7,
28 : Inset = 8,
29 : Outset = 9,
30 :
31 : Sentinel /* this must be last for serialization purposes. */
32 : };
33 :
34 : enum class WrBoxShadowClipMode : uint32_t {
35 : None = 0,
36 : Outset = 1,
37 : Inset = 2,
38 :
39 : Sentinel /* this must be last for serialization purposes. */
40 : };
41 :
42 : enum class WrExternalImageBufferType : uint32_t {
43 : Texture2DHandle = 0,
44 : TextureRectHandle = 1,
45 : TextureExternalHandle = 2,
46 : ExternalBuffer = 3,
47 :
48 : Sentinel /* this must be last for serialization purposes. */
49 : };
50 :
51 : enum class WrExternalImageType : uint32_t {
52 : NativeTexture = 0,
53 : RawData = 1,
54 :
55 : Sentinel /* this must be last for serialization purposes. */
56 : };
57 :
58 : enum class WrFilterOpType : uint32_t {
59 : Blur = 0,
60 : Brightness = 1,
61 : Contrast = 2,
62 : Grayscale = 3,
63 : HueRotate = 4,
64 : Invert = 5,
65 : Opacity = 6,
66 : Saturate = 7,
67 : Sepia = 8,
68 :
69 : Sentinel /* this must be last for serialization purposes. */
70 : };
71 :
72 : enum class WrGradientExtendMode : uint32_t {
73 : Clamp = 0,
74 : Repeat = 1,
75 :
76 : Sentinel /* this must be last for serialization purposes. */
77 : };
78 :
79 : enum class WrImageFormat : uint32_t {
80 : Invalid = 0,
81 : A8 = 1,
82 : RGB8 = 2,
83 : BGRA8 = 3,
84 : RGBAF32 = 4,
85 : RG8 = 5,
86 :
87 : Sentinel /* this must be last for serialization purposes. */
88 : };
89 :
90 : enum class WrImageRendering : uint32_t {
91 : Auto = 0,
92 : CrispEdges = 1,
93 : Pixelated = 2,
94 :
95 : Sentinel /* this must be last for serialization purposes. */
96 : };
97 :
98 : enum class WrMixBlendMode : uint32_t {
99 : Normal = 0,
100 : Multiply = 1,
101 : Screen = 2,
102 : Overlay = 3,
103 : Darken = 4,
104 : Lighten = 5,
105 : ColorDodge = 6,
106 : ColorBurn = 7,
107 : HardLight = 8,
108 : SoftLight = 9,
109 : Difference = 10,
110 : Exclusion = 11,
111 : Hue = 12,
112 : Saturation = 13,
113 : Color = 14,
114 : Luminosity = 15,
115 :
116 : Sentinel /* this must be last for serialization purposes. */
117 : };
118 :
119 : enum class WrRepeatMode : uint32_t {
120 : Stretch = 0,
121 : Repeat = 1,
122 : Round = 2,
123 : Space = 3,
124 :
125 : Sentinel /* this must be last for serialization purposes. */
126 : };
127 :
128 : enum class WrTransformStyle : uint32_t {
129 : Flat = 0,
130 : Preserve3D = 1,
131 :
132 : Sentinel /* this must be last for serialization purposes. */
133 : };
134 :
135 : enum class WrYuvColorSpace : uint32_t {
136 : Rec601 = 0,
137 : Rec709 = 1,
138 :
139 : Sentinel /* this must be last for serialization purposes. */
140 : };
141 :
142 : struct WrAPI;
143 :
144 : struct WrRenderedEpochs;
145 :
146 : struct WrRenderer;
147 :
148 : struct WrState;
149 :
150 : struct WrThreadPool;
151 :
152 : struct WrImageKey {
153 : uint32_t mNamespace;
154 : uint32_t mHandle;
155 :
156 0 : bool operator==(const WrImageKey& aOther) const {
157 0 : return mNamespace == aOther.mNamespace &&
158 0 : mHandle == aOther.mHandle;
159 : }
160 : };
161 :
162 0 : struct WrImageDescriptor {
163 : WrImageFormat format;
164 : uint32_t width;
165 : uint32_t height;
166 : uint32_t stride;
167 : bool is_opaque;
168 :
169 : bool operator==(const WrImageDescriptor& aOther) const {
170 : return format == aOther.format &&
171 : width == aOther.width &&
172 : height == aOther.height &&
173 : stride == aOther.stride &&
174 : is_opaque == aOther.is_opaque;
175 : }
176 : };
177 :
178 : struct WrByteSlice {
179 : const uint8_t *buffer;
180 : size_t len;
181 :
182 : bool operator==(const WrByteSlice& aOther) const {
183 : return buffer == aOther.buffer &&
184 : len == aOther.len;
185 : }
186 : };
187 :
188 : struct WrExternalImageId {
189 : uint64_t mHandle;
190 :
191 0 : bool operator==(const WrExternalImageId& aOther) const {
192 0 : return mHandle == aOther.mHandle;
193 : }
194 : };
195 :
196 : struct WrFontKey {
197 : uint32_t mNamespace;
198 : uint32_t mHandle;
199 :
200 : bool operator==(const WrFontKey& aOther) const {
201 : return mNamespace == aOther.mNamespace &&
202 : mHandle == aOther.mHandle;
203 : }
204 : };
205 :
206 : struct WrEpoch {
207 : uint32_t mHandle;
208 :
209 0 : bool operator==(const WrEpoch& aOther) const {
210 0 : return mHandle == aOther.mHandle;
211 : }
212 : bool operator<(const WrEpoch& aOther) const {
213 : return mHandle < aOther.mHandle;
214 : }
215 0 : bool operator<=(const WrEpoch& aOther) const {
216 0 : return mHandle <= aOther.mHandle;
217 : }
218 : };
219 :
220 : struct WrPipelineId {
221 : uint32_t mNamespace;
222 : uint32_t mHandle;
223 :
224 0 : bool operator==(const WrPipelineId& aOther) const {
225 0 : return mNamespace == aOther.mNamespace &&
226 0 : mHandle == aOther.mHandle;
227 : }
228 : };
229 :
230 : struct WrSize {
231 : float width;
232 : float height;
233 :
234 : bool operator==(const WrSize& aOther) const {
235 : return width == aOther.width &&
236 : height == aOther.height;
237 : }
238 : };
239 :
240 : struct WrBuiltDisplayListDescriptor {
241 : uint64_t builder_start_time;
242 : uint64_t builder_finish_time;
243 :
244 : bool operator==(const WrBuiltDisplayListDescriptor& aOther) const {
245 : return builder_start_time == aOther.builder_start_time &&
246 : builder_finish_time == aOther.builder_finish_time;
247 : }
248 : };
249 :
250 : struct WrVecU8 {
251 : uint8_t *data;
252 : size_t length;
253 : size_t capacity;
254 :
255 : bool operator==(const WrVecU8& aOther) const {
256 : return data == aOther.data &&
257 : length == aOther.length &&
258 : capacity == aOther.capacity;
259 : }
260 : };
261 :
262 : struct WrOpacityProperty {
263 : uint64_t id;
264 : float opacity;
265 :
266 : bool operator==(const WrOpacityProperty& aOther) const {
267 : return id == aOther.id &&
268 : opacity == aOther.opacity;
269 : }
270 : };
271 :
272 : struct WrMatrix {
273 : float values[16];
274 : };
275 :
276 : struct WrTransformProperty {
277 : uint64_t id;
278 : WrMatrix transform;
279 : };
280 :
281 : struct WrIdNamespace {
282 : uint32_t mHandle;
283 :
284 : bool operator==(const WrIdNamespace& aOther) const {
285 : return mHandle == aOther.mHandle;
286 : }
287 : bool operator<(const WrIdNamespace& aOther) const {
288 : return mHandle < aOther.mHandle;
289 : }
290 : bool operator<=(const WrIdNamespace& aOther) const {
291 : return mHandle <= aOther.mHandle;
292 : }
293 : };
294 :
295 : struct WrColor {
296 : float r;
297 : float g;
298 : float b;
299 : float a;
300 :
301 : bool operator==(const WrColor& aOther) const {
302 : return r == aOther.r &&
303 : g == aOther.g &&
304 : b == aOther.b &&
305 : a == aOther.a;
306 : }
307 : };
308 :
309 : struct WrRect {
310 : float x;
311 : float y;
312 : float width;
313 : float height;
314 :
315 : bool operator==(const WrRect& aOther) const {
316 : return x == aOther.x &&
317 : y == aOther.y &&
318 : width == aOther.width &&
319 : height == aOther.height;
320 : }
321 : };
322 :
323 : struct WrBorderWidths {
324 : float left;
325 : float top;
326 : float right;
327 : float bottom;
328 :
329 : bool operator==(const WrBorderWidths& aOther) const {
330 : return left == aOther.left &&
331 : top == aOther.top &&
332 : right == aOther.right &&
333 : bottom == aOther.bottom;
334 : }
335 : };
336 :
337 : struct WrBorderSide {
338 : WrColor color;
339 : WrBorderStyle style;
340 :
341 : bool operator==(const WrBorderSide& aOther) const {
342 : return color == aOther.color &&
343 : style == aOther.style;
344 : }
345 : };
346 :
347 : struct WrBorderRadius {
348 : WrSize top_left;
349 : WrSize top_right;
350 : WrSize bottom_left;
351 : WrSize bottom_right;
352 :
353 : bool operator==(const WrBorderRadius& aOther) const {
354 : return top_left == aOther.top_left &&
355 : top_right == aOther.top_right &&
356 : bottom_left == aOther.bottom_left &&
357 : bottom_right == aOther.bottom_right;
358 : }
359 : };
360 :
361 : struct WrPoint {
362 : float x;
363 : float y;
364 :
365 : bool operator==(const WrPoint& aOther) const {
366 : return x == aOther.x &&
367 : y == aOther.y;
368 : }
369 : };
370 :
371 : struct WrGradientStop {
372 : float offset;
373 : WrColor color;
374 :
375 : bool operator==(const WrGradientStop& aOther) const {
376 : return offset == aOther.offset &&
377 : color == aOther.color;
378 : }
379 : };
380 :
381 : struct WrSideOffsets2Df32 {
382 : float top;
383 : float right;
384 : float bottom;
385 : float left;
386 :
387 : bool operator==(const WrSideOffsets2Df32& aOther) const {
388 : return top == aOther.top &&
389 : right == aOther.right &&
390 : bottom == aOther.bottom &&
391 : left == aOther.left;
392 : }
393 : };
394 :
395 : struct WrSideOffsets2Du32 {
396 : uint32_t top;
397 : uint32_t right;
398 : uint32_t bottom;
399 : uint32_t left;
400 :
401 : bool operator==(const WrSideOffsets2Du32& aOther) const {
402 : return top == aOther.top &&
403 : right == aOther.right &&
404 : bottom == aOther.bottom &&
405 : left == aOther.left;
406 : }
407 : };
408 :
409 : struct WrNinePatchDescriptor {
410 : uint32_t width;
411 : uint32_t height;
412 : WrSideOffsets2Du32 slice;
413 :
414 : bool operator==(const WrNinePatchDescriptor& aOther) const {
415 : return width == aOther.width &&
416 : height == aOther.height &&
417 : slice == aOther.slice;
418 : }
419 : };
420 :
421 : struct WrComplexClipRegion {
422 : WrRect rect;
423 : WrBorderRadius radii;
424 :
425 : bool operator==(const WrComplexClipRegion& aOther) const {
426 : return rect == aOther.rect &&
427 : radii == aOther.radii;
428 : }
429 : };
430 :
431 : struct WrImageMask {
432 : WrImageKey image;
433 : WrRect rect;
434 : bool repeat;
435 :
436 : bool operator==(const WrImageMask& aOther) const {
437 : return image == aOther.image &&
438 : rect == aOther.rect &&
439 : repeat == aOther.repeat;
440 : }
441 : };
442 :
443 : struct WrFilterOp {
444 : WrFilterOpType filter_type;
445 : float argument;
446 :
447 : bool operator==(const WrFilterOp& aOther) const {
448 : return filter_type == aOther.filter_type &&
449 : argument == aOther.argument;
450 : }
451 : };
452 :
453 : struct WrGlyphInstance {
454 : uint32_t index;
455 : WrPoint point;
456 :
457 : bool operator==(const WrGlyphInstance& aOther) const {
458 : return index == aOther.index &&
459 : point == aOther.point;
460 : }
461 : };
462 :
463 : struct MutByteSlice {
464 : uint8_t *buffer;
465 : size_t len;
466 :
467 : bool operator==(const MutByteSlice& aOther) const {
468 : return buffer == aOther.buffer &&
469 : len == aOther.len;
470 : }
471 : };
472 :
473 : struct WrWindowId {
474 : uint64_t mHandle;
475 :
476 : bool operator==(const WrWindowId& aOther) const {
477 : return mHandle == aOther.mHandle;
478 : }
479 0 : bool operator<(const WrWindowId& aOther) const {
480 0 : return mHandle < aOther.mHandle;
481 : }
482 : bool operator<=(const WrWindowId& aOther) const {
483 : return mHandle <= aOther.mHandle;
484 : }
485 : };
486 :
487 : struct WrExternalImage {
488 : WrExternalImageType image_type;
489 : uint32_t handle;
490 : float u0;
491 : float v0;
492 : float u1;
493 : float v1;
494 : const uint8_t *buff;
495 : size_t size;
496 :
497 : bool operator==(const WrExternalImage& aOther) const {
498 : return image_type == aOther.image_type &&
499 : handle == aOther.handle &&
500 : u0 == aOther.u0 &&
501 : v0 == aOther.v0 &&
502 : u1 == aOther.u1 &&
503 : v1 == aOther.v1 &&
504 : buff == aOther.buff &&
505 : size == aOther.size;
506 : }
507 : };
508 :
509 : typedef WrExternalImage (*LockExternalImageCallback)(void*, WrExternalImageId, uint8_t);
510 :
511 : typedef void (*UnlockExternalImageCallback)(void*, WrExternalImageId, uint8_t);
512 :
513 : struct WrExternalImageHandler {
514 : void *external_image_obj;
515 : LockExternalImageCallback lock_func;
516 : UnlockExternalImageCallback unlock_func;
517 :
518 : bool operator==(const WrExternalImageHandler& aOther) const {
519 : return external_image_obj == aOther.external_image_obj &&
520 : lock_func == aOther.lock_func &&
521 : unlock_func == aOther.unlock_func;
522 : }
523 : };
524 :
525 : /* DO NOT MODIFY THIS MANUALLY! This file was generated using cbindgen.
526 : * To generate this file:
527 : * 1. Get the latest cbindgen using `cargo install --force cbindgen`
528 : * a. Alternatively, you can clone `https://github.com/rlhunt/cbindgen` and use a tagged release
529 : * 2. Run `cbindgen toolkit/library/rust/ --crate webrender_bindings -o gfx/webrender_bindings/webrender_ffi_generated.h`
530 : */
531 :
532 : WR_INLINE
533 : void wr_api_add_blob_image(WrAPI *aApi,
534 : WrImageKey aImageKey,
535 : const WrImageDescriptor *aDescriptor,
536 : WrByteSlice aBytes)
537 : WR_FUNC;
538 :
539 : WR_INLINE
540 : void wr_api_add_external_image(WrAPI *aApi,
541 : WrImageKey aImageKey,
542 : const WrImageDescriptor *aDescriptor,
543 : WrExternalImageId aExternalImageId,
544 : WrExternalImageBufferType aBufferType,
545 : uint8_t aChannelIndex)
546 : WR_FUNC;
547 :
548 : WR_INLINE
549 : void wr_api_add_external_image_buffer(WrAPI *aApi,
550 : WrImageKey aImageKey,
551 : const WrImageDescriptor *aDescriptor,
552 : WrExternalImageId aExternalImageId)
553 : WR_FUNC;
554 :
555 : WR_INLINE
556 : void wr_api_add_image(WrAPI *aApi,
557 : WrImageKey aImageKey,
558 : const WrImageDescriptor *aDescriptor,
559 : WrByteSlice aBytes)
560 : WR_FUNC;
561 :
562 : WR_INLINE
563 : void wr_api_add_raw_font(WrAPI *aApi,
564 : WrFontKey aKey,
565 : uint8_t *aFontBuffer,
566 : size_t aBufferSize,
567 : uint32_t aIndex)
568 : WR_FUNC;
569 :
570 : WR_INLINE
571 : void wr_api_clear_root_display_list(WrAPI *aApi,
572 : WrEpoch aEpoch,
573 : WrPipelineId aPipelineId)
574 : WR_FUNC;
575 :
576 : WR_INLINE
577 : void wr_api_delete(WrAPI *aApi)
578 : WR_DESTRUCTOR_SAFE_FUNC;
579 :
580 : WR_INLINE
581 : void wr_api_delete_font(WrAPI *aApi,
582 : WrFontKey aKey)
583 : WR_FUNC;
584 :
585 : WR_INLINE
586 : void wr_api_delete_image(WrAPI *aApi,
587 : WrImageKey aKey)
588 : WR_FUNC;
589 :
590 : WR_INLINE
591 : void wr_api_finalize_builder(WrState *aState,
592 : WrSize *aContentSize,
593 : WrBuiltDisplayListDescriptor *aDlDescriptor,
594 : WrVecU8 *aDlData)
595 : WR_FUNC;
596 :
597 : WR_INLINE
598 : void wr_api_generate_frame(WrAPI *aApi)
599 : WR_FUNC;
600 :
601 : WR_INLINE
602 : void wr_api_generate_frame_with_properties(WrAPI *aApi,
603 : const WrOpacityProperty *aOpacityArray,
604 : size_t aOpacityCount,
605 : const WrTransformProperty *aTransformArray,
606 : size_t aTransformCount)
607 : WR_FUNC;
608 :
609 : WR_INLINE
610 : WrIdNamespace wr_api_get_namespace(WrAPI *aApi)
611 : WR_FUNC;
612 :
613 : WR_INLINE
614 : void wr_api_send_external_event(WrAPI *aApi,
615 : size_t aEvt)
616 : WR_DESTRUCTOR_SAFE_FUNC;
617 :
618 : WR_INLINE
619 : void wr_api_set_root_display_list(WrAPI *aApi,
620 : WrColor aColor,
621 : WrEpoch aEpoch,
622 : float aViewportWidth,
623 : float aViewportHeight,
624 : WrPipelineId aPipelineId,
625 : WrSize aContentSize,
626 : WrBuiltDisplayListDescriptor aDlDescriptor,
627 : uint8_t *aDlData,
628 : size_t aDlSize)
629 : WR_FUNC;
630 :
631 : WR_INLINE
632 : void wr_api_set_root_pipeline(WrAPI *aApi,
633 : WrPipelineId aPipelineId)
634 : WR_FUNC;
635 :
636 : WR_INLINE
637 : void wr_api_set_window_parameters(WrAPI *aApi,
638 : int32_t aWidth,
639 : int32_t aHeight)
640 : WR_FUNC;
641 :
642 : WR_INLINE
643 : void wr_api_update_image(WrAPI *aApi,
644 : WrImageKey aKey,
645 : const WrImageDescriptor *aDescriptor,
646 : WrByteSlice aBytes)
647 : WR_FUNC;
648 :
649 : WR_INLINE
650 : void wr_dp_begin(WrState *aState,
651 : uint32_t aWidth,
652 : uint32_t aHeight)
653 : WR_FUNC;
654 :
655 : WR_INLINE
656 : void wr_dp_end(WrState *aState)
657 : WR_FUNC;
658 :
659 : WR_INLINE
660 : void wr_dp_pop_clip(WrState *aState)
661 : WR_FUNC;
662 :
663 : WR_INLINE
664 : void wr_dp_pop_clip_and_scroll_info(WrState *aState)
665 : WR_FUNC;
666 :
667 : WR_INLINE
668 : void wr_dp_pop_scroll_layer(WrState *aState)
669 : WR_FUNC;
670 :
671 : WR_INLINE
672 : void wr_dp_pop_stacking_context(WrState *aState)
673 : WR_FUNC;
674 :
675 : WR_INLINE
676 : void wr_dp_push_border(WrState *aState,
677 : WrRect aRect,
678 : WrRect aClip,
679 : WrBorderWidths aWidths,
680 : WrBorderSide aTop,
681 : WrBorderSide aRight,
682 : WrBorderSide aBottom,
683 : WrBorderSide aLeft,
684 : WrBorderRadius aRadius)
685 : WR_FUNC;
686 :
687 : WR_INLINE
688 : void wr_dp_push_border_gradient(WrState *aState,
689 : WrRect aRect,
690 : WrRect aClip,
691 : WrBorderWidths aWidths,
692 : WrPoint aStartPoint,
693 : WrPoint aEndPoint,
694 : const WrGradientStop *aStops,
695 : size_t aStopsCount,
696 : WrGradientExtendMode aExtendMode,
697 : WrSideOffsets2Df32 aOutset)
698 : WR_FUNC;
699 :
700 : WR_INLINE
701 : void wr_dp_push_border_image(WrState *aState,
702 : WrRect aRect,
703 : WrRect aClip,
704 : WrBorderWidths aWidths,
705 : WrImageKey aImage,
706 : WrNinePatchDescriptor aPatch,
707 : WrSideOffsets2Df32 aOutset,
708 : WrRepeatMode aRepeatHorizontal,
709 : WrRepeatMode aRepeatVertical)
710 : WR_FUNC;
711 :
712 : WR_INLINE
713 : void wr_dp_push_border_radial_gradient(WrState *aState,
714 : WrRect aRect,
715 : WrRect aClip,
716 : WrBorderWidths aWidths,
717 : WrPoint aCenter,
718 : WrSize aRadius,
719 : const WrGradientStop *aStops,
720 : size_t aStopsCount,
721 : WrGradientExtendMode aExtendMode,
722 : WrSideOffsets2Df32 aOutset)
723 : WR_FUNC;
724 :
725 : WR_INLINE
726 : void wr_dp_push_box_shadow(WrState *aState,
727 : WrRect aRect,
728 : WrRect aClip,
729 : WrRect aBoxBounds,
730 : WrPoint aOffset,
731 : WrColor aColor,
732 : float aBlurRadius,
733 : float aSpreadRadius,
734 : float aBorderRadius,
735 : WrBoxShadowClipMode aClipMode)
736 : WR_FUNC;
737 :
738 : WR_INLINE
739 : void wr_dp_push_built_display_list(WrState *aState,
740 : WrBuiltDisplayListDescriptor aDlDescriptor,
741 : WrVecU8 *aDlData)
742 : WR_FUNC;
743 :
744 : WR_INLINE
745 : uint64_t wr_dp_push_clip(WrState *aState,
746 : WrRect aRect,
747 : const WrComplexClipRegion *aComplex,
748 : size_t aComplexCount,
749 : const WrImageMask *aMask)
750 : WR_FUNC;
751 :
752 : WR_INLINE
753 : void wr_dp_push_clip_and_scroll_info(WrState *aState,
754 : uint64_t aScrollId,
755 : const uint64_t *aClipId)
756 : WR_FUNC;
757 :
758 : WR_INLINE
759 : void wr_dp_push_iframe(WrState *aState,
760 : WrRect aRect,
761 : WrPipelineId aPipelineId)
762 : WR_FUNC;
763 :
764 : WR_INLINE
765 : void wr_dp_push_image(WrState *aState,
766 : WrRect aBounds,
767 : WrRect aClip,
768 : WrSize aStretchSize,
769 : WrSize aTileSpacing,
770 : WrImageRendering aImageRendering,
771 : WrImageKey aKey)
772 : WR_FUNC;
773 :
774 : WR_INLINE
775 : void wr_dp_push_linear_gradient(WrState *aState,
776 : WrRect aRect,
777 : WrRect aClip,
778 : WrPoint aStartPoint,
779 : WrPoint aEndPoint,
780 : const WrGradientStop *aStops,
781 : size_t aStopsCount,
782 : WrGradientExtendMode aExtendMode,
783 : WrSize aTileSize,
784 : WrSize aTileSpacing)
785 : WR_FUNC;
786 :
787 : WR_INLINE
788 : void wr_dp_push_radial_gradient(WrState *aState,
789 : WrRect aRect,
790 : WrRect aClip,
791 : WrPoint aCenter,
792 : WrSize aRadius,
793 : const WrGradientStop *aStops,
794 : size_t aStopsCount,
795 : WrGradientExtendMode aExtendMode,
796 : WrSize aTileSize,
797 : WrSize aTileSpacing)
798 : WR_FUNC;
799 :
800 : WR_INLINE
801 : void wr_dp_push_rect(WrState *aState,
802 : WrRect aRect,
803 : WrRect aClip,
804 : WrColor aColor)
805 : WR_FUNC;
806 :
807 : WR_INLINE
808 : void wr_dp_push_scroll_layer(WrState *aState,
809 : uint64_t aScrollId,
810 : WrRect aContentRect,
811 : WrRect aClipRect)
812 : WR_FUNC;
813 :
814 : WR_INLINE
815 : void wr_dp_push_stacking_context(WrState *aState,
816 : WrRect aBounds,
817 : uint64_t aAnimationId,
818 : const float *aOpacity,
819 : const WrMatrix *aTransform,
820 : WrTransformStyle aTransformStyle,
821 : WrMixBlendMode aMixBlendMode,
822 : const WrFilterOp *aFilters,
823 : size_t aFilterCount)
824 : WR_FUNC;
825 :
826 : WR_INLINE
827 : void wr_dp_push_text(WrState *aState,
828 : WrRect aBounds,
829 : WrRect aClip,
830 : WrColor aColor,
831 : WrFontKey aFontKey,
832 : const WrGlyphInstance *aGlyphs,
833 : uint32_t aGlyphCount,
834 : float aGlyphSize)
835 : WR_FUNC;
836 :
837 : WR_INLINE
838 : void wr_dp_push_yuv_NV12_image(WrState *aState,
839 : WrRect aBounds,
840 : WrRect aClip,
841 : WrImageKey aImageKey0,
842 : WrImageKey aImageKey1,
843 : WrYuvColorSpace aColorSpace,
844 : WrImageRendering aImageRendering)
845 : WR_FUNC;
846 :
847 : WR_INLINE
848 : void wr_dp_push_yuv_interleaved_image(WrState *aState,
849 : WrRect aBounds,
850 : WrRect aClip,
851 : WrImageKey aImageKey0,
852 : WrYuvColorSpace aColorSpace,
853 : WrImageRendering aImageRendering)
854 : WR_FUNC;
855 :
856 : WR_INLINE
857 : void wr_dp_push_yuv_planar_image(WrState *aState,
858 : WrRect aBounds,
859 : WrRect aClip,
860 : WrImageKey aImageKey0,
861 : WrImageKey aImageKey1,
862 : WrImageKey aImageKey2,
863 : WrYuvColorSpace aColorSpace,
864 : WrImageRendering aImageRendering)
865 : WR_FUNC;
866 :
867 : WR_INLINE
868 : void wr_rendered_epochs_delete(WrRenderedEpochs *aPipelineEpochs)
869 : WR_DESTRUCTOR_SAFE_FUNC;
870 :
871 : WR_INLINE
872 : bool wr_rendered_epochs_next(WrRenderedEpochs *aPipelineEpochs,
873 : WrPipelineId *aOutPipeline,
874 : WrEpoch *aOutEpoch)
875 : WR_FUNC;
876 :
877 : WR_INLINE
878 : bool wr_renderer_current_epoch(WrRenderer *aRenderer,
879 : WrPipelineId aPipelineId,
880 : WrEpoch *aOutEpoch)
881 : WR_FUNC;
882 :
883 : WR_INLINE
884 : void wr_renderer_delete(WrRenderer *aRenderer)
885 : WR_DESTRUCTOR_SAFE_FUNC;
886 :
887 : WR_INLINE
888 : WrRenderedEpochs *wr_renderer_flush_rendered_epochs(WrRenderer *aRenderer)
889 : WR_FUNC;
890 :
891 : WR_INLINE
892 : void wr_renderer_readback(WrRenderer *aRenderer,
893 : uint32_t aWidth,
894 : uint32_t aHeight,
895 : uint8_t *aDstBuffer,
896 : size_t aBufferSize)
897 : WR_FUNC;
898 :
899 : WR_INLINE
900 : void wr_renderer_render(WrRenderer *aRenderer,
901 : uint32_t aWidth,
902 : uint32_t aHeight)
903 : WR_FUNC;
904 :
905 : WR_INLINE
906 : void wr_renderer_set_external_image_handler(WrRenderer *aRenderer,
907 : WrExternalImageHandler *aExternalImageHandler)
908 : WR_FUNC;
909 :
910 : WR_INLINE
911 : void wr_renderer_set_profiler_enabled(WrRenderer *aRenderer,
912 : bool aEnabled)
913 : WR_FUNC;
914 :
915 : WR_INLINE
916 : void wr_renderer_update(WrRenderer *aRenderer)
917 : WR_FUNC;
918 :
919 : WR_INLINE
920 : void wr_scroll_layer_with_id(WrAPI *aApi,
921 : WrPipelineId aPipelineId,
922 : uint64_t aScrollId,
923 : WrPoint aNewScrollOrigin)
924 : WR_FUNC;
925 :
926 : WR_INLINE
927 : void wr_state_delete(WrState *aState)
928 : WR_DESTRUCTOR_SAFE_FUNC;
929 :
930 : WR_INLINE
931 : WrState *wr_state_new(WrPipelineId aPipelineId,
932 : WrSize aContentSize)
933 : WR_FUNC;
934 :
935 : WR_INLINE
936 : void wr_thread_pool_delete(WrThreadPool *aThreadPool)
937 : WR_DESTRUCTOR_SAFE_FUNC;
938 :
939 : WR_INLINE
940 : WrThreadPool *wr_thread_pool_new()
941 : WR_FUNC;
942 :
943 : WR_INLINE
944 : void wr_vec_u8_free(WrVecU8 aV)
945 : WR_FUNC;
946 :
947 : WR_INLINE
948 : bool wr_window_new(WrWindowId aWindowId,
949 : uint32_t aWindowWidth,
950 : uint32_t aWindowHeight,
951 : void *aGlContext,
952 : WrThreadPool *aThreadPool,
953 : bool aEnableProfiler,
954 : WrAPI **aOutApi,
955 : WrRenderer **aOutRenderer)
956 : WR_FUNC;
957 :
958 : } // extern "C"
959 :
960 : /* DO NOT MODIFY THIS MANUALLY! This file was generated using cbindgen.
961 : * To generate this file:
962 : * 1. Get the latest cbindgen using `cargo install --force cbindgen`
963 : * a. Alternatively, you can clone `https://github.com/rlhunt/cbindgen` and use a tagged release
964 : * 2. Run `cbindgen toolkit/library/rust/ --crate webrender_bindings -o gfx/webrender_bindings/webrender_ffi_generated.h`
965 : */
|
