1 // Licensed under the Apache License, Version 2.0
2 // <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
3 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
4 // All files in the project carrying such notice may not be copied, modified, or distributed
5 // except according to those terms.
6 //! Mappings for the contents of dcomp.h
7 use ctypes::{c_float, c_int, c_void};
8 use shared::d3d9types::D3DMATRIX;
9 use shared::dcomptypes::{
10     DCOMPOSITION_BACKFACE_VISIBILITY, DCOMPOSITION_BITMAP_INTERPOLATION_MODE,
11     DCOMPOSITION_BORDER_MODE, DCOMPOSITION_COMPOSITE_MODE, DCOMPOSITION_DEPTH_MODE,
12     DCOMPOSITION_FRAME_STATISTICS, DCOMPOSITION_OPACITY_MODE
13 };
14 use shared::dxgi::IDXGIDevice;
15 use shared::dxgi1_2::DXGI_ALPHA_MODE;
16 use shared::dxgiformat::DXGI_FORMAT;
17 use shared::guiddef::REFIID;
18 use shared::minwindef::{BOOL, DWORD, UINT};
19 use shared::ntdef::{HANDLE, HRESULT};
20 use shared::windef::{HWND, POINT, RECT};
21 use um::d2d1::{D2D1_COLOR_F, D2D1_MATRIX_3X2_F};
22 use um::d2d1_1::{D2D1_COMPOSITE_MODE, D2D1_MATRIX_5X4_F, D2D1_VECTOR_2F, D2D1_VECTOR_4F};
23 use um::d2d1effects::{
24     D2D1_2DAFFINETRANSFORM_INTERPOLATION_MODE, D2D1_BLEND_MODE, D2D1_BORDER_MODE,
25     D2D1_COLORMATRIX_ALPHA_MODE, D2D1_TURBULENCE_NOISE
26 };
27 use um::d2dbasetypes::{D2D_MATRIX_3X2_F, D2D_MATRIX_4X4_F, D2D_RECT_F};
28 use um::d3dcommon::D3D_FEATURE_LEVEL;
29 use um::dcompanimation::IDCompositionAnimation;
30 use um::minwinbase::SECURITY_ATTRIBUTES;
31 use um::unknwnbase::{IUnknown, IUnknownVtbl};
32 extern "system" {
DCompositionCreateDevice( dxgiDevice: *const IDXGIDevice, iid: REFIID, dcompositionDevice: *mut *mut c_void, ) -> HRESULT33     pub fn DCompositionCreateDevice(
34         dxgiDevice: *const IDXGIDevice,
35         iid: REFIID,
36         dcompositionDevice: *mut *mut c_void,
37     ) -> HRESULT;
DCompositionCreateDevice2( renderingDevice: *const IUnknown, iid: REFIID, dcompositionDevice: *mut *mut c_void, ) -> HRESULT38     pub fn DCompositionCreateDevice2(
39         renderingDevice: *const IUnknown,
40         iid: REFIID,
41         dcompositionDevice: *mut *mut c_void,
42     ) -> HRESULT;
DCompositionCreateDevice3( renderingDevice: *const IUnknown, iid: REFIID, dcompositionDevice: *mut *mut c_void, ) -> HRESULT43     pub fn DCompositionCreateDevice3(
44         renderingDevice: *const IUnknown,
45         iid: REFIID,
46         dcompositionDevice: *mut *mut c_void,
47     ) -> HRESULT;
DCompositionGetFrameStatistics( statistics: *const DCOMPOSITION_FRAME_STATISTICS, minSafeFeaturelLevel: *const D3D_FEATURE_LEVEL, maxHardwareFeaturelLevel: *const D3D_FEATURE_LEVEL, ) -> HRESULT48     pub fn DCompositionGetFrameStatistics(
49         statistics: *const DCOMPOSITION_FRAME_STATISTICS,
50         minSafeFeaturelLevel: *const D3D_FEATURE_LEVEL,
51         maxHardwareFeaturelLevel: *const D3D_FEATURE_LEVEL,
52     ) -> HRESULT;
DCompositionCreateSurfaceHandle( desiredAccess: DWORD, securityAttributes: *const SECURITY_ATTRIBUTES, surfaceHandle: *mut HANDLE, ) -> HRESULT53     pub fn DCompositionCreateSurfaceHandle(
54         desiredAccess: DWORD,
55         securityAttributes: *const SECURITY_ATTRIBUTES,
56         surfaceHandle: *mut HANDLE,
57     ) -> HRESULT;
DCompositionAttachMouseWheelToHwnd( visual: *const IDCompositionVisual, hwnd: HWND, enable: BOOL, ) -> HRESULT58     pub fn DCompositionAttachMouseWheelToHwnd(
59         visual: *const IDCompositionVisual,
60         hwnd: HWND,
61         enable: BOOL,
62     ) -> HRESULT;
DCompositionAttachMouseDragToHwnd( visual: *const IDCompositionVisual, hwnd: HWND, enable: BOOL, ) -> HRESULT63     pub fn DCompositionAttachMouseDragToHwnd(
64         visual: *const IDCompositionVisual,
65         hwnd: HWND,
66         enable: BOOL,
67     ) -> HRESULT;
68 }
69 RIDL!{#[uuid(0xc37ea93a, 0xe7aa, 0x450d, 0xb1, 0x6f, 0x97, 0x46, 0xcb, 0x04, 0x07, 0xf3)]
70 interface IDCompositionDevice(IDCompositionDeviceVtbl): IUnknown(IUnknownVtbl) {
71     fn Commit() -> HRESULT,
72     fn WaitForCommitCompletion() -> HRESULT,
73     fn GetFrameStatistics(
74         statistics: *mut DCOMPOSITION_FRAME_STATISTICS,
75     ) -> HRESULT,
76     fn CreateTargetForHwnd(
77         hwnd: HWND,
78         topmost: BOOL,
79         target: *mut *mut IDCompositionTarget,
80     ) -> HRESULT,
81     fn CreateVisual(
82         visual: *mut *mut IDCompositionVisual,
83     ) -> HRESULT,
84     fn CreateSurface(
85         width: UINT,
86         height: UINT,
87         pixelFormat: DXGI_FORMAT,
88         alphaMode: DXGI_ALPHA_MODE,
89         surface: *mut *mut IDCompositionSurface,
90     ) -> HRESULT,
91     fn CreateVirtualSurface(
92         initialWidth: UINT,
93         initialHeight: UINT,
94         pixelFormat: DXGI_FORMAT,
95         alphaMode: DXGI_ALPHA_MODE,
96         virtualSurface: *mut *mut IDCompositionVirtualSurface,
97     ) -> HRESULT,
98     fn CreateSurfaceFromHandle(
99         handle: HANDLE,
100         mutsurface: *mut *mut IUnknown,
101     ) -> HRESULT,
102     fn CreateSurfaceFromHwnd(
103         hwnd: HWND,
104         mutsurface: *mut *mut IUnknown,
105     ) -> HRESULT,
106     fn CreateTranslateTransform(
107         translateTransform: *mut *mut IDCompositionTranslateTransform,
108     ) -> HRESULT,
109     fn CreateScaleTransform(
110         scaleTransform: *mut *mut IDCompositionScaleTransform,
111     ) -> HRESULT,
112     fn CreateRotateTransform(
113         rotateTransform: *mut *mut IDCompositionRotateTransform,
114     ) -> HRESULT,
115     fn CreateSkewTransform(
116         skewTransform: *mut *mut IDCompositionSkewTransform,
117     ) -> HRESULT,
118     fn CreateMatrixTransform(
119         matrixTransform: *mut *mut IDCompositionMatrixTransform,
120     ) -> HRESULT,
121     fn CreateTransformGroup(
122         transforms: *const *const IDCompositionTransform,
123         elements: UINT,
124         transformGroup: *mut *mut IDCompositionTransform,
125     ) -> HRESULT,
126     fn CreateTranslateTransform3D(
127         translateTransform3D: *mut *mut IDCompositionTranslateTransform3D,
128     ) -> HRESULT,
129     fn CreateScaleTransform3D(
130         scaleTransform3D: *mut *mut IDCompositionScaleTransform3D,
131     ) -> HRESULT,
132     fn CreateRotateTransform3D(
133         rotateTransform3D: *mut *mut IDCompositionRotateTransform3D,
134     ) -> HRESULT,
135     fn CreateMatrixTransform3D(
136         matrixTransform3D: *mut *mut IDCompositionMatrixTransform3D,
137     ) -> HRESULT,
138     fn CreateTransform3DGroup(
139         transforms3D: *const *const IDCompositionTransform3D,
140         elements: UINT,
141         transform3DGroup: *mut *mut IDCompositionTransform3D,
142     ) -> HRESULT,
143     fn CreateEffectGroup(
144         effectGroup: *mut *mut IDCompositionEffectGroup,
145     ) -> HRESULT,
146     fn CreateRectangleClip(
147         clip: *mut *mut IDCompositionRectangleClip,
148     ) -> HRESULT,
149     fn CreateAnimation(
150         animation: *mut *mut IDCompositionAnimation,
151     ) -> HRESULT,
152     fn CheckDeviceState(
153         pfValid: *mut BOOL,
154     ) -> HRESULT,
155 }}
156 RIDL!{#[uuid(0xeacdd04c, 0x117e, 0x4e17, 0x88, 0xf4, 0xd1, 0xb1, 0x2b, 0x0e, 0x3d, 0x89)]
157 interface IDCompositionTarget(IDCompositionTargetVtbl): IUnknown(IUnknownVtbl) {
158     fn SetRoot(
159         visual: *const IDCompositionVisual,
160     ) -> HRESULT,
161 }}
162 RIDL!{#[uuid(0x4d93059d, 0x097b, 0x4651, 0x9a, 0x60, 0xf0, 0xf2, 0x51, 0x16, 0xe2, 0xf3)]
163 interface IDCompositionVisual(IDCompositionVisualVtbl): IUnknown(IUnknownVtbl) {
164     fn SetOffsetX_2(
165         animation: *const IDCompositionAnimation,
166     ) -> HRESULT,
167     fn SetOffsetX_1(
168         offsetX: c_float,
169     ) -> HRESULT,
170     fn SetOffsetY_2(
171         animation: *const IDCompositionAnimation,
172     ) -> HRESULT,
173     fn SetOffsetY_1(
174         offsetY: c_float,
175     ) -> HRESULT,
176     fn SetTransform_2(
177         transform: *const IDCompositionTransform,
178     ) -> HRESULT,
179     fn SetTransform_1(
180         matrix: *const D2D_MATRIX_3X2_F,
181     ) -> HRESULT,
182     fn SetTransformParent(
183         visual: *const IDCompositionVisual,
184     ) -> HRESULT,
185     fn SetEffect(
186         effect: *const IDCompositionEffect,
187     ) -> HRESULT,
188     fn SetBitmapInterpolationMode(
189         interpolationMode: DCOMPOSITION_BITMAP_INTERPOLATION_MODE,
190     ) -> HRESULT,
191     fn SetBorderMode(
192         borderMode: DCOMPOSITION_BORDER_MODE,
193     ) -> HRESULT,
194     fn SetClip_2(
195         clip: *const IDCompositionClip,
196     ) -> HRESULT,
197     fn SetClip_1(
198         rect: *const D2D_RECT_F,
199     ) -> HRESULT,
200     fn SetContent(
201         content: *const IUnknown,
202     ) -> HRESULT,
203     fn AddVisual(
204         visual: *const IDCompositionVisual,
205         insertAbove: BOOL,
206         referenceVisual: *const IDCompositionVisual,
207     ) -> HRESULT,
208     fn RemoveVisual(
209         visual: *const IDCompositionVisual,
210     ) -> HRESULT,
211     fn RemoveAllVisuals() -> HRESULT,
212     fn SetCompositeMode(
213         compositeMode: DCOMPOSITION_COMPOSITE_MODE,
214     ) -> HRESULT,
215 }}
216 RIDL!{#[uuid(0xec81b08f, 0xbfcb, 0x4e8d, 0xb1, 0x93, 0xa9, 0x15, 0x58, 0x79, 0x99, 0xe8)]
217 interface IDCompositionEffect(IDCompositionEffectVtbl): IUnknown(IUnknownVtbl) {}}
218 RIDL!{#[uuid(0x71185722, 0x246b, 0x41f2, 0xaa, 0xd1, 0x04, 0x43, 0xf7, 0xf4, 0xbf, 0xc2)]
219 interface IDCompositionTransform3D(IDCompositionTransform3DVtbl):
220     IDCompositionEffect(IDCompositionEffectVtbl) {}}
221 RIDL!{#[uuid(0xfd55faa7, 0x37e0, 0x4c20, 0x95, 0xd2, 0x9b, 0xe4, 0x5b, 0xc3, 0x3f, 0x55)]
222 interface IDCompositionTransform(IDCompositionTransformVtbl):
223     IDCompositionTransform3D(IDCompositionTransform3DVtbl) {}}
224 RIDL!{#[uuid(0x06791122, 0xc6f0, 0x417d, 0x83, 0x23, 0x26, 0x9e, 0x98, 0x7f, 0x59, 0x54)]
225 interface IDCompositionTranslateTransform(IDCompositionTranslateTransformVtbl):
226     IDCompositionTransform(IDCompositionTransformVtbl) {
227     fn SetOffsetX_2(
228         animation: *const IDCompositionAnimation,
229     ) -> HRESULT,
230     fn SetOffsetX_1(
231         offsetX: c_float,
232     ) -> HRESULT,
233     fn SetOffsetY_2(
234         animation: *const IDCompositionAnimation,
235     ) -> HRESULT,
236     fn SetOffsetY_1(
237         offsetY: c_float,
238     ) -> HRESULT,
239 }}
240 RIDL!{#[uuid(0x71fde914, 0x40ef, 0x45ef, 0xbd, 0x51, 0x68, 0xb0, 0x37, 0xc3, 0x39, 0xf9)]
241 interface IDCompositionScaleTransform(IDCompositionScaleTransformVtbl):
242     IDCompositionTransform(IDCompositionTransformVtbl) {
243     fn SetScaleX_2(
244         animation: *const IDCompositionAnimation,
245     ) -> HRESULT,
246     fn SetScaleX_1(
247         scaleX: c_float,
248     ) -> HRESULT,
249     fn SetScaleY_2(
250         animation: *const IDCompositionAnimation,
251     ) -> HRESULT,
252     fn SetScaleY_1(
253         scaleY: c_float,
254     ) -> HRESULT,
255     fn SetCenterX_2(
256         animation: *const IDCompositionAnimation,
257     ) -> HRESULT,
258     fn SetCenterX_1(
259         centerX: c_float,
260     ) -> HRESULT,
261     fn SetCenterY_2(
262         animation: *const IDCompositionAnimation,
263     ) -> HRESULT,
264     fn SetCenterY_1(
265         centerY: c_float,
266     ) -> HRESULT,
267 }}
268 RIDL!{#[uuid(0x641ed83c, 0xae96, 0x46c5, 0x90, 0xdc, 0x32, 0x77, 0x4c, 0xc5, 0xc6, 0xd5)]
269 interface IDCompositionRotateTransform(IDCompositionRotateTransformVtbl):
270     IDCompositionTransform(IDCompositionTransformVtbl) {
271     fn SetAngle_2(
272         animation: *const IDCompositionAnimation,
273     ) -> HRESULT,
274     fn SetAngle_1(
275         angle: c_float,
276     ) -> HRESULT,
277     fn SetCenterX_2(
278         animation: *const IDCompositionAnimation,
279     ) -> HRESULT,
280     fn SetCenterX_1(
281         centerX: c_float,
282     ) -> HRESULT,
283     fn SetCenterY_2(
284         animation: *const IDCompositionAnimation,
285     ) -> HRESULT,
286     fn SetCenterY_1(
287         centerY: c_float,
288     ) -> HRESULT,
289 }}
290 RIDL!{#[uuid(0xe57aa735, 0xdcdb, 0x4c72, 0x9c, 0x61, 0x05, 0x91, 0xf5, 0x88, 0x89, 0xee)]
291 interface IDCompositionSkewTransform(IDCompositionSkewTransformVtbl):
292     IDCompositionTransform(IDCompositionTransformVtbl) {
293     fn SetAngleX_2(
294         animation: *const IDCompositionAnimation,
295     ) -> HRESULT,
296     fn SetAngleX_1(
297         angleX: c_float,
298     ) -> HRESULT,
299     fn SetAngleY_2(
300         animation: *const IDCompositionAnimation,
301     ) -> HRESULT,
302     fn SetAngleY_1(
303         angleY: c_float,
304     ) -> HRESULT,
305     fn SetCenterX_2(
306         animation: *const IDCompositionAnimation,
307     ) -> HRESULT,
308     fn SetCenterX_1(
309         centerX: c_float,
310     ) -> HRESULT,
311     fn SetCenterY_2(
312         animation: *const IDCompositionAnimation,
313     ) -> HRESULT,
314     fn SetCenterY_1(
315         centerY: c_float,
316     ) -> HRESULT,
317 }}
318 RIDL!{#[uuid(0x16cdff07, 0xc503, 0x419c, 0x83, 0xf2, 0x09, 0x65, 0xc7, 0xaf, 0x1f, 0xa6)]
319 interface IDCompositionMatrixTransform(IDCompositionMatrixTransformVtbl):
320     IDCompositionTransform(IDCompositionTransformVtbl) {
321     fn SetMatrix(
322         matrix: *const D2D_MATRIX_3X2_F,
323     ) -> HRESULT,
324     fn SetMatrixElement_2(
325         row: c_int,
326         column: c_int,
327         animation: *const IDCompositionAnimation,
328     ) -> HRESULT,
329     fn SetMatrixElement_1(
330         row: c_int,
331         column: c_int,
332         value: c_float,
333     ) -> HRESULT,
334 }}
335 RIDL!{#[uuid(0xa7929a74, 0xe6b2, 0x4bd6, 0x8b, 0x95, 0x40, 0x40, 0x11, 0x9c, 0xa3, 0x4d)]
336 interface IDCompositionEffectGroup(IDCompositionEffectGroupVtbl):
337     IDCompositionEffect(IDCompositionEffectVtbl) {
338     fn SetOpacity_2(
339         animation: *const IDCompositionAnimation,
340     ) -> HRESULT,
341     fn SetOpacity_1(
342         opacity: c_float,
343     ) -> HRESULT,
344     fn SetTransform3D(
345         transform3D: *const IDCompositionTransform3D,
346     ) -> HRESULT,
347 }}
348 RIDL!{#[uuid(0x91636d4b, 0x9ba1, 0x4532, 0xaa, 0xf7, 0xe3, 0x34, 0x49, 0x94, 0xd7, 0x88)]
349 interface IDCompositionTranslateTransform3D(IDCompositionTranslateTransform3DVtbl):
350     IDCompositionTransform3D(IDCompositionTransform3DVtbl) {
351     fn SetOffsetX_2(
352         animation: *const IDCompositionAnimation,
353     ) -> HRESULT,
354     fn SetOffsetX_1(
355         offsetX: c_float,
356     ) -> HRESULT,
357     fn SetOffsetY_2(
358         animation: *const IDCompositionAnimation,
359     ) -> HRESULT,
360     fn SetOffsetY_1(
361         offsetY: c_float,
362     ) -> HRESULT,
363     fn SetOffsetZ_2(
364         animation: *const IDCompositionAnimation,
365     ) -> HRESULT,
366     fn SetOffsetZ_1(
367         offsetZ: c_float,
368     ) -> HRESULT,
369 }}
370 RIDL!{#[uuid(0x2a9e9ead, 0x364b, 0x4b15, 0xa7, 0xc4, 0xa1, 0x99, 0x7f, 0x78, 0xb3, 0x89)]
371 interface IDCompositionScaleTransform3D(IDCompositionScaleTransform3DVtbl):
372     IDCompositionTransform3D(IDCompositionTransform3DVtbl) {
373     fn SetScaleX_2(
374         animation: *const IDCompositionAnimation,
375     ) -> HRESULT,
376     fn SetScaleX_1(
377         scaleX: c_float,
378     ) -> HRESULT,
379     fn SetScaleY_2(
380         animation: *const IDCompositionAnimation,
381     ) -> HRESULT,
382     fn SetScaleY_1(
383         scaleY: c_float,
384     ) -> HRESULT,
385     fn SetScaleZ_2(
386         animation: *const IDCompositionAnimation,
387     ) -> HRESULT,
388     fn SetScaleZ_1(
389         scaleZ: c_float,
390     ) -> HRESULT,
391     fn SetCenterX_2(
392         animation: *const IDCompositionAnimation,
393     ) -> HRESULT,
394     fn SetCenterX_1(
395         centerX: c_float,
396     ) -> HRESULT,
397     fn SetCenterY_2(
398         animation: *const IDCompositionAnimation,
399     ) -> HRESULT,
400     fn SetCenterY_1(
401         centerY: c_float,
402     ) -> HRESULT,
403     fn SetCenterZ_2(
404         animation: *const IDCompositionAnimation,
405     ) -> HRESULT,
406     fn SetCenterZ_1(
407         centerZ: c_float,
408     ) -> HRESULT,
409 }}
410 RIDL!{#[uuid(0xd8f5b23f, 0xd429, 0x4a91, 0xb5, 0x5a, 0xd2, 0xf4, 0x5f, 0xd7, 0x5b, 0x18)]
411 interface IDCompositionRotateTransform3D(IDCompositionRotateTransform3DVtbl):
412     IDCompositionTransform3D(IDCompositionTransform3DVtbl) {
413     fn SetAngle_2(
414         animation: *const IDCompositionAnimation,
415     ) -> HRESULT,
416     fn SetAngle_1(
417         angle: c_float,
418     ) -> HRESULT,
419     fn SetAxisX_2(
420         animation: *const IDCompositionAnimation,
421     ) -> HRESULT,
422     fn SetAxisX_1(
423         axisX: c_float,
424     ) -> HRESULT,
425     fn SetAxisY_2(
426         animation: *const IDCompositionAnimation,
427     ) -> HRESULT,
428     fn SetAxisY_1(
429         axisY: c_float,
430     ) -> HRESULT,
431     fn SetAxisZ_2(
432         animation: *const IDCompositionAnimation,
433     ) -> HRESULT,
434     fn SetAxisZ_1(
435         axisZ: c_float,
436     ) -> HRESULT,
437     fn SetCenterX_2(
438         animation: *const IDCompositionAnimation,
439     ) -> HRESULT,
440     fn SetCenterX_1(
441         centerX: c_float,
442     ) -> HRESULT,
443     fn SetCenterY_2(
444         animation: *const IDCompositionAnimation,
445     ) -> HRESULT,
446     fn SetCenterY_1(
447         centerY: c_float,
448     ) -> HRESULT,
449     fn SetCenterZ_2(
450         animation: *const IDCompositionAnimation,
451     ) -> HRESULT,
452     fn SetCenterZ_1(
453         centerZ: c_float,
454     ) -> HRESULT,
455 }}
456 RIDL!{#[uuid(0x4b3363f0, 0x643b, 0x41b7, 0xb6, 0xe0, 0xcc, 0xf2, 0x2d, 0x34, 0x46, 0x7c)]
457 interface IDCompositionMatrixTransform3D(IDCompositionMatrixTransform3DVtbl):
458     IDCompositionTransform3D(IDCompositionTransform3DVtbl) {
459     fn SetMatrix(
460         matrix: *const D3DMATRIX,
461     ) -> HRESULT,
462     fn SetMatrixElement_2(
463         row: c_int,
464         column: c_int,
465         animation: *const IDCompositionAnimation,
466     ) -> HRESULT,
467     fn SetMatrixElement_1(
468         row: c_int,
469         column: c_int,
470         value: c_float,
471     ) -> HRESULT,
472 }}
473 RIDL!{#[uuid(0x64ac3703, 0x9d3f, 0x45ec, 0xa1, 0x09, 0x7c, 0xac, 0x0e, 0x7a, 0x13, 0xa7)]
474 interface IDCompositionClip(IDCompositionClipVtbl): IUnknown(IUnknownVtbl) {}}
475 RIDL!{#[uuid(0x9842ad7d, 0xd9cf, 0x4908, 0xae, 0xd7, 0x48, 0xb5, 0x1d, 0xa5, 0xe7, 0xc2)]
476 interface IDCompositionRectangleClip(IDCompositionRectangleClipVtbl):
477     IDCompositionClip(IDCompositionClipVtbl) {
478     fn SetLeft_2(
479         animation: *const IDCompositionAnimation,
480     ) -> HRESULT,
481     fn SetLeft_1(
482         left: c_float,
483     ) -> HRESULT,
484     fn SetTop_2(
485         animation: *const IDCompositionAnimation,
486     ) -> HRESULT,
487     fn SetTop_1(
488         top: c_float,
489     ) -> HRESULT,
490     fn SetRight_2(
491         animation: *const IDCompositionAnimation,
492     ) -> HRESULT,
493     fn SetRight_1(
494         right: c_float,
495     ) -> HRESULT,
496     fn SetBottom_2(
497         animation: *const IDCompositionAnimation,
498     ) -> HRESULT,
499     fn SetBottom_1(
500         bottom: c_float,
501     ) -> HRESULT,
502     fn SetTopLeftRadiusX_2(
503         animation: *const IDCompositionAnimation,
504     ) -> HRESULT,
505     fn SetTopLeftRadiusX_1(
506         radius: c_float,
507     ) -> HRESULT,
508     fn SetTopLeftRadiusY_2(
509         animation: *const IDCompositionAnimation,
510     ) -> HRESULT,
511     fn SetTopLeftRadiusY_1(
512         radius: c_float,
513     ) -> HRESULT,
514     fn SetTopRightRadiusX_2(
515         animation: *const IDCompositionAnimation,
516     ) -> HRESULT,
517     fn SetTopRightRadiusX_1(
518         radius: c_float,
519     ) -> HRESULT,
520     fn SetTopRightRadiusY_2(
521         animation: *const IDCompositionAnimation,
522     ) -> HRESULT,
523     fn SetTopRightRadiusY_1(
524         radius: c_float,
525     ) -> HRESULT,
526     fn SetBottomLeftRadiusX_2(
527         animation: *const IDCompositionAnimation,
528     ) -> HRESULT,
529     fn SetBottomLeftRadiusX_1(
530         radius: c_float,
531     ) -> HRESULT,
532     fn SetBottomLeftRadiusY_2(
533         animation: *const IDCompositionAnimation,
534     ) -> HRESULT,
535     fn SetBottomLeftRadiusY_1(
536         radius: c_float,
537     ) -> HRESULT,
538     fn SetBottomRightRadiusX_2(
539         animation: *const IDCompositionAnimation,
540     ) -> HRESULT,
541     fn SetBottomRightRadiusX_1(
542         radius: c_float,
543     ) -> HRESULT,
544     fn SetBottomRightRadiusY_2(
545         animation: *const IDCompositionAnimation,
546     ) -> HRESULT,
547     fn SetBottomRightRadiusY_1(
548         radius: c_float,
549     ) -> HRESULT,
550 }}
551 RIDL!{#[uuid(0xbb8a4953, 0x2c99, 0x4f5a, 0x96, 0xf5, 0x48, 0x19, 0x02, 0x7f, 0xa3, 0xac)]
552 interface IDCompositionSurface(IDCompositionSurfaceVtbl): IUnknown(IUnknownVtbl) {
553     fn BeginDraw(
554         updateRect: *const RECT,
555         iid: REFIID,
556         updateObject: *mut *mut c_void,
557         updateOffset: *mut POINT,
558     ) -> HRESULT,
559     fn EndDraw() -> HRESULT,
560     fn SuspendDraw() -> HRESULT,
561     fn ResumeDraw() -> HRESULT,
562     fn Scroll(
563         scrollRect: *const RECT,
564         clipRect: *const RECT,
565         offsetX: c_int,
566         offsetY: c_int,
567     ) -> HRESULT,
568 }}
569 RIDL!{#[uuid(0xae471c51, 0x5f53, 0x4a24, 0x8d, 0x3e, 0xd0, 0xc3, 0x9c, 0x30, 0xb3, 0xf0)]
570 interface IDCompositionVirtualSurface(IDCompositionVirtualSurfaceVtbl):
571     IDCompositionSurface(IDCompositionSurfaceVtbl) {
572     fn Resize(
573         width: UINT,
574         height: UINT,
575     ) -> HRESULT,
576     fn Trim(
577         rectangles: *const RECT,
578         count: UINT,
579     ) -> HRESULT,
580 }}
581 RIDL!{#[uuid(0x75f6468d, 0x1b8e, 0x447c, 0x9b, 0xc6, 0x75, 0xfe, 0xa8, 0x0b, 0x5b, 0x25)]
582 interface IDCompositionDevice2(IDCompositionDevice2Vtbl): IUnknown(IUnknownVtbl) {
583     fn Commit() -> HRESULT,
584     fn WaitForCommitCompletion() -> HRESULT,
585     fn GetFrameStatistics(
586         statistics: *mut DCOMPOSITION_FRAME_STATISTICS,
587     ) -> HRESULT,
588     fn CreateVisual(
589         visual: *mut *mut IDCompositionVisual2,
590     ) -> HRESULT,
591     fn CreateSurfaceFactory(
592         renderingDevice: *const IUnknown,
593         surfaceFactory: *mut *mut IDCompositionSurfaceFactory,
594     ) -> HRESULT,
595     fn CreateSurface(
596         width: UINT,
597         height: UINT,
598         pixelFormat: DXGI_FORMAT,
599         alphaMode: DXGI_ALPHA_MODE,
600         surface: *mut *mut IDCompositionSurface,
601     ) -> HRESULT,
602     fn CreateVirtualSurface(
603         initialWidth: UINT,
604         initialHeight: UINT,
605         pixelFormat: DXGI_FORMAT,
606         alphaMode: DXGI_ALPHA_MODE,
607         virtualSurface: *mut *mut IDCompositionVirtualSurface,
608     ) -> HRESULT,
609     fn CreateTranslateTransform(
610         translateTransform: *mut *mut IDCompositionTranslateTransform,
611     ) -> HRESULT,
612     fn CreateScaleTransform(
613         scaleTransform: *mut *mut IDCompositionScaleTransform,
614     ) -> HRESULT,
615     fn CreateRotateTransform(
616         rotateTransform: *mut *mut IDCompositionRotateTransform,
617     ) -> HRESULT,
618     fn CreateSkewTransform(
619         skewTransform: *mut *mut IDCompositionSkewTransform,
620     ) -> HRESULT,
621     fn CreateMatrixTransform(
622         matrixTransform: *mut *mut IDCompositionMatrixTransform,
623     ) -> HRESULT,
624     fn CreateTransformGroup(
625         transforms: *const *const IDCompositionTransform,
626         elements: UINT,
627         transformGroup: *mut *mut IDCompositionTransform,
628     ) -> HRESULT,
629     fn CreateTranslateTransform3D(
630         translateTransform3D: *mut *mut IDCompositionTranslateTransform3D,
631     ) -> HRESULT,
632     fn CreateScaleTransform3D(
633         scaleTransform3D: *mut *mut IDCompositionScaleTransform3D,
634     ) -> HRESULT,
635     fn CreateRotateTransform3D(
636         rotateTransform3D: *mut *mut IDCompositionRotateTransform3D,
637     ) -> HRESULT,
638     fn CreateMatrixTransform3D(
639         matrixTransform3D: *mut *mut IDCompositionMatrixTransform3D,
640     ) -> HRESULT,
641     fn CreateTransform3DGroup(
642         transforms3D: *const *const IDCompositionTransform3D,
643         elements: UINT,
644         transform3DGroup: *mut *mut IDCompositionTransform3D,
645     ) -> HRESULT,
646     fn CreateEffectGroup(
647         effectGroup: *mut *mut IDCompositionEffectGroup,
648     ) -> HRESULT,
649     fn CreateRectangleClip(
650         clip: *mut *mut IDCompositionRectangleClip,
651     ) -> HRESULT,
652     fn CreateAnimation(
653         animation: *mut *mut IDCompositionAnimation,
654     ) -> HRESULT,
655 }}
656 RIDL!{#[uuid(0x5f4633fe, 0x1e08, 0x4cb8, 0x8c, 0x75, 0xce, 0x24, 0x33, 0x3f, 0x56, 0x02)]
657 interface IDCompositionDesktopDevice(IDCompositionDesktopDeviceVtbl):
658     IDCompositionDevice2(IDCompositionDevice2Vtbl) {
659     fn CreateTargetForHwnd(
660         hwnd: HWND,
661         topmost: BOOL,
662         target: *mut *mut IDCompositionTarget,
663     ) -> HRESULT,
664     fn CreateSurfaceFromHandle(
665         handle: HANDLE,
666         surface: *mut *mut IUnknown,
667     ) -> HRESULT,
668     fn CreateSurfaceFromHwnd(
669         hwnd: HWND,
670         surface: *mut *mut IUnknown,
671     ) -> HRESULT,
672 }}
673 RIDL!{#[uuid(0xa1a3c64a, 0x224f, 0x4a81, 0x97, 0x73, 0x4f, 0x03, 0xa8, 0x9d, 0x3c, 0x6c)]
674 interface IDCompositionDeviceDebug(IDCompositionDeviceDebugVtbl): IUnknown(IUnknownVtbl) {
675     fn EnableDebugCounters() -> HRESULT,
676     fn DisableDebugCounters() -> HRESULT,
677 }}
678 RIDL!{#[uuid(0xe334bc12, 0x3937, 0x4e02, 0x85, 0xeb, 0xfc, 0xf4, 0xeb, 0x30, 0xd2, 0xc8)]
679 interface IDCompositionSurfaceFactory(IDCompositionSurfaceFactoryVtbl): IUnknown(IUnknownVtbl) {
680     fn CreateSurface(
681         width: UINT,
682         height: UINT,
683         pixelFormat: DXGI_FORMAT,
684         alphaMode: DXGI_ALPHA_MODE,
685         surface: *mut *mut IDCompositionSurface,
686     ) -> HRESULT,
687     fn CreateVirtualSurface(
688         initialWidth: UINT,
689         initialHeight: UINT,
690         pixelFormat: DXGI_FORMAT,
691         alphaMode: DXGI_ALPHA_MODE,
692         virtualSurface: *mut *mut IDCompositionVirtualSurface,
693     ) -> HRESULT,
694 }}
695 RIDL!{#[uuid(0xe8de1639, 0x4331, 0x4b26, 0xbc, 0x5f, 0x6a, 0x32, 0x1d, 0x34, 0x7a, 0x85)]
696 interface IDCompositionVisual2(IDCompositionVisual2Vtbl):
697     IDCompositionVisual(IDCompositionVisualVtbl) {
698     fn SetOpacityMode(
699         mode: DCOMPOSITION_OPACITY_MODE,
700     ) -> HRESULT,
701     fn SetBackFaceVisibility(
702         visibility: DCOMPOSITION_BACKFACE_VISIBILITY,
703     ) -> HRESULT,
704 }}
705 RIDL!{#[uuid(0xfed2b808, 0x5eb4, 0x43a0, 0xae, 0xa3, 0x35, 0xf6, 0x52, 0x80, 0xf9, 0x1b)]
706 interface IDCompositionVisualDebug(IDCompositionVisualDebugVtbl):
707     IDCompositionVisual2(IDCompositionVisual2Vtbl) {
708     fn EnableHeatMap(
709         color: *const D2D1_COLOR_F,
710     ) -> HRESULT,
711     fn DisableHeatMap() -> HRESULT,
712     fn EnableRedrawRegions() -> HRESULT,
713     fn DisableRedrawRegions() -> HRESULT,
714 }}
715 RIDL!{#[uuid(0x2775f462, 0xb6c1, 0x4015, 0xb0, 0xbe, 0xb3, 0xe7, 0xd6, 0xa4, 0x97, 0x6d)]
716 interface IDCompositionVisual3(IDCompositionVisual3Vtbl):
717     IDCompositionVisualDebug(IDCompositionVisualDebugVtbl) {
718     fn SetDepthMode(
719         mode: DCOMPOSITION_DEPTH_MODE,
720     ) -> HRESULT,
721     fn SetOffsetZ_2(
722         animation: *const IDCompositionAnimation,
723     ) -> HRESULT,
724     fn SetOffsetZ_1(
725         offsetZ: c_float,
726     ) -> HRESULT,
727     fn SetOpacity_2(
728         animation: *const IDCompositionAnimation,
729     ) -> HRESULT,
730     fn SetOpacity_1(
731         opacity: c_float,
732     ) -> HRESULT,
733     fn SetTransform_2(
734         transform: *const IDCompositionTransform3D,
735     ) -> HRESULT,
736     fn SetTransform_1(
737         matrix: *const D2D_MATRIX_4X4_F,
738     ) -> HRESULT,
739     fn SetVisible(
740         visible: BOOL,
741     ) -> HRESULT,
742 }}
743 RIDL!{#[uuid(0x0987cb06, 0xf916, 0x48bf, 0x8d, 0x35, 0xce, 0x76, 0x41, 0x78, 0x1b, 0xd9)]
744 interface IDCompositionDevice3(IDCompositionDevice3Vtbl):
745     IDCompositionDevice2(IDCompositionDevice2Vtbl) {
746     fn CreateGaussianBlurEffect(
747         gaussianBlurEffect: *mut *mut IDCompositionGaussianBlurEffect,
748     ) -> HRESULT,
749     fn CreateBrightnessEffect(
750         brightnessEffect: *mut *mut IDCompositionBrightnessEffect,
751     ) -> HRESULT,
752     fn CreateColorMatrixEffect(
753         colorMatrixEffect: *mut *mut IDCompositionColorMatrixEffect,
754     ) -> HRESULT,
755     fn CreateShadowEffect(
756         shadowEffect: *mut *mut IDCompositionShadowEffect,
757     ) -> HRESULT,
758     fn CreateHueRotationEffect(
759         hueRotationEffect: *mut *mut IDCompositionHueRotationEffect,
760     ) -> HRESULT,
761     fn CreateSaturationEffect(
762         saturationEffect: *mut *mut IDCompositionSaturationEffect,
763     ) -> HRESULT,
764     fn CreateTurbulenceEffect(
765         turbulenceEffect: *mut *mut IDCompositionTurbulenceEffect,
766     ) -> HRESULT,
767     fn CreateLinearTransferEffect(
768         linearTransferEffect: *mut *mut IDCompositionLinearTransferEffect,
769     ) -> HRESULT,
770     fn CreateTableTransferEffect(
771         tableTransferEffect: *mut *mut IDCompositionTableTransferEffect,
772     ) -> HRESULT,
773     fn CreateCompositeEffect(
774         compositeEffect: *mut *mut IDCompositionCompositeEffect,
775     ) -> HRESULT,
776     fn CreateBlendEffect(
777         blendEffect: *mut *mut IDCompositionBlendEffect,
778     ) -> HRESULT,
779     fn CreateArithmeticCompositeEffect(
780         arithmeticCompositeEffect: *mut *mut IDCompositionArithmeticCompositeEffect,
781     ) -> HRESULT,
782     fn CreateAffineTransform2DEffect(
783         affineTransform2dEffect: *mut *mut IDCompositionAffineTransform2DEffect,
784     ) -> HRESULT,
785 }}
786 RIDL!{#[uuid(0x30c421d5, 0x8cb2, 0x4e9f, 0xb1, 0x33, 0x37, 0xbe, 0x27, 0x0d, 0x4a, 0xc2)]
787 interface IDCompositionFilterEffect(IDCompositionFilterEffectVtbl):
788     IDCompositionEffect(IDCompositionEffectVtbl) {
789     fn SetInput(
790         index: UINT,
791         input: *const IUnknown,
792         flags: UINT,
793     ) -> HRESULT,
794 }}
795 RIDL!{#[uuid(0x45d4d0b7, 0x1bd4, 0x454e, 0x88, 0x94, 0x2b, 0xfa, 0x68, 0x44, 0x30, 0x33)]
796 interface IDCompositionGaussianBlurEffect(IDCompositionGaussianBlurEffectVtbl):
797     IDCompositionFilterEffect(IDCompositionFilterEffectVtbl) {
798     fn SetStandardDeviation_2(
799         animation: *const IDCompositionAnimation,
800     ) -> HRESULT,
801     fn SetStandardDeviation_1(
802         amount: c_float,
803     ) -> HRESULT,
804     fn SetBorderMode(
805         mode: D2D1_BORDER_MODE,
806     ) -> HRESULT,
807 }}
808 RIDL!{#[uuid(0x6027496e, 0xcb3a, 0x49ab, 0x93, 0x4f, 0xd7, 0x98, 0xda, 0x4f, 0x7d, 0xa6)]
809 interface IDCompositionBrightnessEffect(IDCompositionBrightnessEffectVtbl):
810     IDCompositionFilterEffect(IDCompositionFilterEffectVtbl) {
811     fn SetWhitePoint(
812         whitePoint: *const D2D1_VECTOR_2F,
813     ) -> HRESULT,
814     fn SetBlackPoint(
815         blackPoint: *const D2D1_VECTOR_2F,
816     ) -> HRESULT,
817     fn SetWhitePointX_2(
818         animation: *const IDCompositionAnimation,
819     ) -> HRESULT,
820     fn SetWhitePointX_1(
821         whitePointX: c_float,
822     ) -> HRESULT,
823     fn SetWhitePointY_2(
824         animation: *const IDCompositionAnimation,
825     ) -> HRESULT,
826     fn SetWhitePointY_1(
827         whitePointY: c_float,
828     ) -> HRESULT,
829     fn SetBlackPointX_2(
830         animation: *const IDCompositionAnimation,
831     ) -> HRESULT,
832     fn SetBlackPointX_1(
833         blackPointX: c_float,
834     ) -> HRESULT,
835     fn SetBlackPointY_2(
836         animation: *const IDCompositionAnimation,
837     ) -> HRESULT,
838     fn SetBlackPointY_1(
839         blackPointY: c_float,
840     ) -> HRESULT,
841 }}
842 RIDL!{#[uuid(0xc1170a22, 0x3ce2, 0x4966, 0x90, 0xd4, 0x55, 0x40, 0x8b, 0xfc, 0x84, 0xc4)]
843 interface IDCompositionColorMatrixEffect(IDCompositionColorMatrixEffectVtbl):
844     IDCompositionFilterEffect(IDCompositionFilterEffectVtbl) {
845     fn SetMatrix(
846         matrix: *const D2D1_MATRIX_5X4_F,
847     ) -> HRESULT,
848     fn SetMatrixElement_2(
849         row: c_int,
850         column: c_int,
851         animation: *const IDCompositionAnimation,
852     ) -> HRESULT,
853     fn SetMatrixElement_1(
854         row: c_int,
855         column: c_int,
856         value: c_float,
857     ) -> HRESULT,
858     fn SetAlphaMode(
859         mode: D2D1_COLORMATRIX_ALPHA_MODE,
860     ) -> HRESULT,
861     fn SetClampOutput(
862         clamp: BOOL,
863     ) -> HRESULT,
864 }}
865 RIDL!{#[uuid(0x4ad18ac0, 0xcfd2, 0x4c2f, 0xbb, 0x62, 0x96, 0xe5, 0x4f, 0xdb, 0x68, 0x79)]
866 interface IDCompositionShadowEffect(IDCompositionShadowEffectVtbl):
867     IDCompositionFilterEffect(IDCompositionFilterEffectVtbl) {
868     fn SetStandardDeviation_2(
869         animation: *const IDCompositionAnimation,
870     ) -> HRESULT,
871     fn SetStandardDeviation_1(
872         amount: c_float,
873     ) -> HRESULT,
874     fn SetColor(
875         color: *const D2D1_VECTOR_4F,
876     ) -> HRESULT,
877     fn SetRed_2(
878         animation: *const IDCompositionAnimation,
879     ) -> HRESULT,
880     fn SetRed_1(
881         amount: c_float,
882     ) -> HRESULT,
883     fn SetGreen_2(
884         animation: *const IDCompositionAnimation,
885     ) -> HRESULT,
886     fn SetGreen_1(
887         amount: c_float,
888     ) -> HRESULT,
889     fn SetBlue_2(
890         animation: *const IDCompositionAnimation,
891     ) -> HRESULT,
892     fn SetBlue_1(
893         amount: c_float,
894     ) -> HRESULT,
895     fn SetAlpha_2(
896         animation: *const IDCompositionAnimation,
897     ) -> HRESULT,
898     fn SetAlpha_1(
899         amount: c_float,
900     ) -> HRESULT,
901 }}
902 RIDL!{#[uuid(0x6db9f920, 0x0770, 0x4781, 0xb0, 0xc6, 0x38, 0x19, 0x12, 0xf9, 0xd1, 0x67)]
903 interface IDCompositionHueRotationEffect(IDCompositionHueRotationEffectVtbl):
904     IDCompositionFilterEffect(IDCompositionFilterEffectVtbl) {
905     // Changes the angle of rotation
906     fn SetAngle_2(
907         animation: *const IDCompositionAnimation,
908     ) -> HRESULT,
909     fn SetAngle_1(
910         amountDegrees: c_float,
911     ) -> HRESULT,
912 }}
913 RIDL!{#[uuid(0xa08debda, 0x3258, 0x4fa4, 0x9f, 0x16, 0x91, 0x74, 0xd3, 0xfe, 0x93, 0xb1)]
914 interface IDCompositionSaturationEffect(IDCompositionSaturationEffectVtbl):
915     IDCompositionFilterEffect(IDCompositionFilterEffectVtbl) {
916     // Changes the amount of saturation to be applied.
917     fn SetSaturation_2(
918         animation: *const IDCompositionAnimation,
919     ) -> HRESULT,
920     fn SetSaturation_1(
921         ratio: c_float,
922     ) -> HRESULT,
923 }}
924 RIDL!{#[uuid(0xa6a55bda, 0xc09c, 0x49f3, 0x91, 0x93, 0xa4, 0x19, 0x22, 0xc8, 0x97, 0x15)]
925 interface IDCompositionTurbulenceEffect(IDCompositionTurbulenceEffectVtbl):
926     IDCompositionFilterEffect(IDCompositionFilterEffectVtbl) {
927     fn SetOffset(
928         offset: *const D2D1_VECTOR_2F,
929     ) -> HRESULT,
930     fn SetBaseFrequency(
931         frequency: *const D2D1_VECTOR_2F,
932     ) -> HRESULT,
933     fn SetSize(
934         size: *const D2D1_VECTOR_2F,
935     ) -> HRESULT,
936     fn SetNumOctaves(
937         numOctaves: UINT,
938     ) -> HRESULT,
939     fn SetSeed(
940         seed: UINT,
941     ) -> HRESULT,
942     fn SetNoise(
943         noise: D2D1_TURBULENCE_NOISE,
944     ) -> HRESULT,
945     fn SetStitchable(
946         stitchable: BOOL,
947     ) -> HRESULT,
948 }}
949 RIDL!{#[uuid(0x4305ee5b, 0xc4a0, 0x4c88, 0x93, 0x85, 0x67, 0x12, 0x4e, 0x01, 0x76, 0x83)]
950 interface IDCompositionLinearTransferEffect(IDCompositionLinearTransferEffectVtbl):
951     IDCompositionFilterEffect(IDCompositionFilterEffectVtbl) {
952     fn SetRedYIntercept_2(
953         animation: *const IDCompositionAnimation,
954     ) -> HRESULT,
955     fn SetRedYIntercept_1(
956         redYIntercept: c_float,
957     ) -> HRESULT,
958     fn SetRedSlope_2(
959         animation: *const IDCompositionAnimation,
960     ) -> HRESULT,
961     fn SetRedSlope_1(
962         redSlope: c_float,
963     ) -> HRESULT,
964     fn SetRedDisable(
965         redDisable: BOOL,
966     ) -> HRESULT,
967     fn SetGreenYIntercept_2(
968         animation: *const IDCompositionAnimation,
969     ) -> HRESULT,
970     fn SetGreenYIntercept_1(
971         greenYIntercept: c_float,
972     ) -> HRESULT,
973     fn SetGreenSlope_2(
974         animation: *const IDCompositionAnimation,
975     ) -> HRESULT,
976     fn SetGreenSlope_1(
977         greenSlope: c_float,
978     ) -> HRESULT,
979     fn SetGreenDisable(
980         greenDisable: BOOL,
981     ) -> HRESULT,
982     fn SetBlueYIntercept_2(
983         animation: *const IDCompositionAnimation,
984     ) -> HRESULT,
985     fn SetBlueYIntercept_1(
986         blueYIntercept: c_float,
987     ) -> HRESULT,
988     fn SetBlueSlope_2(
989         animation: *const IDCompositionAnimation,
990     ) -> HRESULT,
991     fn SetBlueSlope_1(
992         blueSlope: c_float,
993     ) -> HRESULT,
994     fn SetBlueDisable(
995         blueDisable: BOOL,
996     ) -> HRESULT,
997     fn SetAlphaYIntercept_2(
998         animation: *const IDCompositionAnimation,
999     ) -> HRESULT,
1000     fn SetAlphaYIntercept_1(
1001         alphaYIntercept: c_float,
1002     ) -> HRESULT,
1003     fn SetAlphaSlope_2(
1004         animation: *const IDCompositionAnimation,
1005     ) -> HRESULT,
1006     fn SetAlphaSlope_1(
1007         alphaSlope: c_float,
1008     ) -> HRESULT,
1009     fn SetAlphaDisable(
1010         alphaDisable: BOOL,
1011     ) -> HRESULT,
1012     fn SetClampOutput(
1013         clampOutput: BOOL,
1014     ) -> HRESULT,
1015 }}
1016 RIDL!{#[uuid(0x9b7e82e2, 0x69c5, 0x4eb4, 0xa5, 0xf5, 0xa7, 0x03, 0x3f, 0x51, 0x32, 0xcd)]
1017 interface IDCompositionTableTransferEffect(IDCompositionTableTransferEffectVtbl):
1018     IDCompositionFilterEffect(IDCompositionFilterEffectVtbl) {
1019     fn SetRedTable(
1020         tableValues: *const c_float,
1021         count: UINT,
1022     ) -> HRESULT,
1023     fn SetGreenTable(
1024         tableValues: *const c_float,
1025         count: UINT,
1026     ) -> HRESULT,
1027     fn SetBlueTable(
1028         tableValues: *const c_float,
1029         count: UINT,
1030     ) -> HRESULT,
1031     fn SetAlphaTable(
1032         tableValues: *const c_float,
1033         count: UINT,
1034     ) -> HRESULT,
1035     fn SetRedDisable(
1036         redDisable: BOOL,
1037     ) -> HRESULT,
1038     fn SetGreenDisable(
1039         greenDisable: BOOL,
1040     ) -> HRESULT,
1041     fn SetBlueDisable(
1042         blueDisable: BOOL,
1043     ) -> HRESULT,
1044     fn SetAlphaDisable(
1045         alphaDisable: BOOL,
1046     ) -> HRESULT,
1047     fn SetClampOutput(
1048         clampOutput: BOOL,
1049     ) -> HRESULT,
1050     fn SetRedTableValue_2(
1051         index: UINT,
1052         animation: *const IDCompositionAnimation,
1053     ) -> HRESULT,
1054     fn SetRedTableValue_1(
1055         index: UINT,
1056         value: c_float,
1057     ) -> HRESULT,
1058     fn SetGreenTableValue_2(
1059         index: UINT,
1060         animation: *const IDCompositionAnimation,
1061     ) -> HRESULT,
1062     fn SetGreenTableValue_1(
1063         index: UINT,
1064         value: c_float,
1065     ) -> HRESULT,
1066     fn SetBlueTableValue_2(
1067         index: UINT,
1068         animation: *const IDCompositionAnimation,
1069     ) -> HRESULT,
1070     fn SetBlueTableValue_1(
1071         index: UINT,
1072         value: c_float,
1073     ) -> HRESULT,
1074     fn SetAlphaTableValue_2(
1075         index: UINT,
1076         animation: *const IDCompositionAnimation,
1077     ) -> HRESULT,
1078     fn SetAlphaTableValue_1(
1079         index: UINT,
1080         value: c_float,
1081     ) -> HRESULT,
1082 }}
1083 RIDL!{#[uuid(0x576616c0, 0xa231, 0x494d, 0xa3, 0x8d, 0x00, 0xfd, 0x5e, 0xc4, 0xdb, 0x46)]
1084 interface IDCompositionCompositeEffect(IDCompositionCompositeEffectVtbl):
1085     IDCompositionFilterEffect(IDCompositionFilterEffectVtbl) {
1086     fn SetMode(
1087         mode: D2D1_COMPOSITE_MODE,
1088     ) -> HRESULT,
1089 }}
1090 RIDL!{#[uuid(0x33ecdc0a, 0x578a, 0x4a11, 0x9c, 0x14, 0x0c, 0xb9, 0x05, 0x17, 0xf9, 0xc5)]
1091 interface IDCompositionBlendEffect(IDCompositionBlendEffectVtbl):
1092     IDCompositionFilterEffect(IDCompositionFilterEffectVtbl) {
1093     fn SetMode(
1094         mode: D2D1_BLEND_MODE,
1095     ) -> HRESULT,
1096 }}
1097 RIDL!{#[uuid(0x3b67dfa8, 0xe3dd, 0x4e61, 0xb6, 0x40, 0x46, 0xc2, 0xf3, 0xd7, 0x39, 0xdc)]
1098 interface IDCompositionArithmeticCompositeEffect(IDCompositionArithmeticCompositeEffectVtbl):
1099     IDCompositionFilterEffect(IDCompositionFilterEffectVtbl) {
1100     fn SetCoefficients(
1101         coefficients: *const D2D1_VECTOR_4F,
1102     ) -> HRESULT,
1103     fn SetClampOutput(
1104         clampoutput: BOOL,
1105     ) -> HRESULT,
1106     fn SetCoefficient1_2(
1107         animation: *const IDCompositionAnimation,
1108     ) -> HRESULT,
1109     fn SetCoefficient1_1(
1110         Coeffcient1: c_float,
1111     ) -> HRESULT,
1112     fn SetCoefficient2_2(
1113         animation: *const IDCompositionAnimation,
1114     ) -> HRESULT,
1115     fn SetCoefficient2_1(
1116         Coefficient2: c_float,
1117     ) -> HRESULT,
1118     fn SetCoefficient3_2(
1119         animation: *const IDCompositionAnimation,
1120     ) -> HRESULT,
1121     fn SetCoefficient3_1(
1122         Coefficient3: c_float,
1123     ) -> HRESULT,
1124     fn SetCoefficient4_2(
1125         animation: *const IDCompositionAnimation,
1126     ) -> HRESULT,
1127     fn SetCoefficient4_1(
1128         Coefficient4: c_float,
1129     ) -> HRESULT,
1130 }}
1131 RIDL!{#[uuid(0x0b74b9e8, 0xcdd6, 0x492f, 0xbb, 0xbc, 0x5e, 0xd3, 0x21, 0x57, 0x02, 0x6d)]
1132 interface IDCompositionAffineTransform2DEffect(IDCompositionAffineTransform2DEffectVtbl):
1133     IDCompositionFilterEffect(IDCompositionFilterEffectVtbl) {
1134     fn SetInterpolationMode(
1135         interpolationMode: D2D1_2DAFFINETRANSFORM_INTERPOLATION_MODE,
1136     ) -> HRESULT,
1137     fn SetBorderMode(
1138         borderMode: D2D1_BORDER_MODE,
1139     ) -> HRESULT,
1140     fn SetTransformMatrix(
1141         transformMatrix: *const D2D1_MATRIX_3X2_F,
1142     ) -> HRESULT,
1143     fn SetTransformMatrixElement_2(
1144         row: c_int,
1145         column: c_int,
1146         animation: *const IDCompositionAnimation,
1147     ) -> HRESULT,
1148     fn SetTransformMatrixElement_1(
1149         row: c_int,
1150         column: c_int,
1151         value: c_float,
1152     ) -> HRESULT,
1153     fn SetSharpness_2(
1154         animation: *const IDCompositionAnimation,
1155     ) -> HRESULT,
1156     fn SetSharpness_1(
1157         sharpness: c_float,
1158     ) -> HRESULT,
1159 }}
1160