From 94ffb629769196690bc30065dfd515e94e6ce295 Mon Sep 17 00:00:00 2001 From: Patrick Walton Date: Fri, 5 Dec 2014 04:04:43 -0800 Subject: [PATCH] Add bindings to the filter node pipeline, and upgrade Skia --- Cargo.toml | 1 + src/azure-c.cpp | 66 +++++++++++++++++++++- src/azure-c.h | 22 +++++++- src/azure.rs | 35 ++++++++++++ src/azure_hl.rs | 143 +++++++++++++++++++++++++++++++++++++++++++++++- 5 files changed, 263 insertions(+), 4 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index c8951f3..2682ec7 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -17,6 +17,7 @@ git = "https://github.com/servo/rust-layers" [dependencies.skia-sys] git = "https://github.com/servo/skia" +branch = "upstream-2014-06-16" [dependencies.xlib] diff --git a/src/azure-c.cpp b/src/azure-c.cpp index d4bd8a1..8e8207d 100644 --- a/src/azure-c.cpp +++ b/src/azure-c.cpp @@ -4,7 +4,9 @@ #include "azure-c.h" #include "2D.h" +#include "Filters.h" #include "ScaledFontSkia.h" +#include "Types.h" #include #include @@ -414,6 +416,20 @@ AzDrawTargetDrawSurface(AzDrawTargetRef aDrawTarget, gfxDrawTarget->DrawSurface(gfxSourceSurface, *gfxDest, *gfxSource, *gfxDrawSurfaceOptions, *gfxDrawOptions); } +extern "C" void +AzDrawTargetDrawFilter(AzDrawTargetRef aDrawTarget, + AzFilterNodeRef aFilter, + const AzRect *aSourceRect, + const AzPoint *aDestPoint, + const AzDrawOptions *aOptions) { + gfx::DrawTarget *gfxDrawTarget = static_cast(aDrawTarget); + gfx::FilterNode *gfxFilterNode = static_cast(aFilter); + const gfx::Rect *gfxSourceRect = reinterpret_cast(aSourceRect); + const gfx::Point *gfxDestPoint = reinterpret_cast(aDestPoint); + const gfx::DrawOptions *gfxDrawOptions = reinterpret_cast(aOptions); + gfxDrawTarget->DrawFilter(gfxFilterNode, *gfxSourceRect, *gfxDestPoint, *gfxDrawOptions); +} + extern "C" void AzDrawTargetDrawSurfaceWithShadow(AzDrawTargetRef aDrawTarget, AzSourceSurfaceRef aSurface, @@ -680,13 +696,59 @@ AzCreateLinearGradientPattern(const AzPoint *aBegin, return gfxLinearGradientPattern; } -void AzReleasePattern(AzPatternRef aPattern) { +extern "C" void +AzReleasePattern(AzPatternRef aPattern) { gfx::Pattern *gfxPattern = reinterpret_cast(aPattern); delete gfxPattern; } -void AzReleaseGradientStops(AzGradientStopsRef aStops) { +extern "C" void +AzReleaseGradientStops(AzGradientStopsRef aStops) { gfx::GradientStops *gfxStops = reinterpret_cast(aStops); gfxStops->Release(); } +extern "C" AzFilterNodeRef +AzDrawTargetCreateFilter(AzDrawTargetRef aDrawTarget, AzFilterType aType) { + gfx::DrawTarget *gfxDrawTarget = static_cast(aDrawTarget); + gfx::FilterType gfxFilterType = static_cast(aType); + return gfxDrawTarget->CreateFilter(gfxFilterType).drop(); +} + +extern "C" void +AzReleaseFilterNode(AzFilterNodeRef aFilter) { + gfx::FilterNode *gfxFilterNode = reinterpret_cast(aFilter); + gfxFilterNode->Release(); +} + +extern "C" void +AzFilterNodeSetSourceSurfaceInput(AzFilterNodeRef aFilter, + uint32_t aIndex, + AzSourceSurfaceRef aSurface) { + gfx::FilterNode *gfxFilterNode = reinterpret_cast(aFilter); + gfx::SourceSurface *gfxSourceSurface = reinterpret_cast(aSurface); + gfxFilterNode->SetInput(aIndex, gfxSourceSurface); +} + +extern "C" void +AzFilterNodeSetFilterNodeInput(AzFilterNodeRef aFilter, + uint32_t aIndex, + AzFilterNodeRef aInputFilter) { + gfx::FilterNode *gfxFilterNode = reinterpret_cast(aFilter); + gfx::FilterNode *gfxInputFilterNode = reinterpret_cast(aInputFilter); + gfxFilterNode->SetInput(aIndex, gfxInputFilterNode); +} + +extern "C" void +AzFilterNodeSetFloatAttribute(AzFilterNodeRef aFilter, uint32_t aIndex, AzFloat aValue) { + gfx::FilterNode *gfxFilterNode = reinterpret_cast(aFilter); + gfxFilterNode->SetAttribute(aIndex, aValue); +} + +extern "C" void +AzFilterNodeSetColorAttribute(AzFilterNodeRef aFilter, uint32_t aIndex, const AzColor *aValue) { + gfx::FilterNode *gfxFilterNode = reinterpret_cast(aFilter); + const gfx::Color *gfxColor = reinterpret_cast(aValue); + gfxFilterNode->SetAttribute(aIndex, aValue); +} + diff --git a/src/azure-c.h b/src/azure-c.h index f546eda..6e52646 100644 --- a/src/azure-c.h +++ b/src/azure-c.h @@ -6,7 +6,6 @@ #define MOZILLA_GFX_AZURE_C_H_ #include "GrContext.h" - #include "SkNativeSharedGLContext.h" #include @@ -40,6 +39,7 @@ typedef void* AzGLContextMetadataRef; typedef void* AzPathBuilderRef; typedef void* AzPathRef; typedef void* AzLinearGradientPatternRef; +typedef void* AzFilterNodeRef; /* Types.h */ @@ -402,6 +402,11 @@ void AzDrawTargetDrawSurface(AzDrawTargetRef aDrawTarget, AzRect *aSource, AzDrawSurfaceOptionsRef aSurfOptions, AzDrawOptions *aOptions); +void AzDrawTargetDrawFilter(AzDrawTargetRef aDrawTarget, + AzFilterNodeRef aFilter, + const AzRect *aSourceRect, + const AzPoint *aDestPoint, + const AzDrawOptions *aOptions); void AzDrawTargetDrawSurfaceWithShadow(AzDrawTargetRef aDrawTarget, AzSourceSurfaceRef aSurface, const AzPoint* aPoint, @@ -426,6 +431,7 @@ AzGradientStopsRef AzDrawTargetCreateGradientStops(AzDrawTargetRef aDrawTarget, void AzDrawTargetPushClip(AzDrawTargetRef aDrawTarget, AzPathRef aPath); void AzDrawTargetPushClipRect(AzDrawTargetRef aDrawTarget, const AzRect *aRect); void AzDrawTargetPopClip(AzDrawTargetRef aDrawTarget); +AzFilterNodeRef AzDrawTargetCreateFilter(AzDrawTargetRef aDrawTarget, AzFilterType aType); void AzReleaseSourceSurface(AzSourceSurfaceRef aSurface); AzIntSize AzSourceSurfaceGetSize(AzSourceSurfaceRef aSurface); @@ -454,6 +460,20 @@ void AzReleasePattern(AzPatternRef aPattern); void AzReleaseGradientStops(AzGradientStopsRef aStops); +/* Filters.h */ + +void AzReleaseFilterNode(AzFilterNodeRef aFilter); +void AzFilterNodeSetSourceSurfaceInput(AzFilterNodeRef aFilter, + uint32_t aIndex, + AzSourceSurfaceRef aSurface); +void AzFilterNodeSetFilterNodeInput(AzFilterNodeRef aFilter, + uint32_t aIndex, + AzFilterNodeRef aInputFilter); +void AzFilterNodeSetFloatAttribute(AzFilterNodeRef aFilter, uint32_t aIndex, AzFloat aValue); +void AzFilterNodeSetColorAttribute(AzFilterNodeRef aFilter, + uint32_t aIndex, + const AzColor *aValue); + /* Factory.h */ void AzReleaseScaledFont(AzScaledFontRef aFont); diff --git a/src/azure.rs b/src/azure.rs index c0497c7..3afc1c7 100644 --- a/src/azure.rs +++ b/src/azure.rs @@ -193,6 +193,18 @@ pub static AZ_eSideRight: u32 = 1_u32; pub static AZ_eSideBottom: u32 = 2_u32; pub static AZ_eSideLeft: u32 = 3_u32; +pub type enum_AzFloodFilterAtts = u32; +pub static AZ_ATT_FLOOD_COLOR: u32 = 0; + +pub type enum_AzFloodFilterInputs = u32; +pub static AZ_IN_FLOOD_IN: u32 = 0; + +pub type enum_AzGaussianBlurAtts = u32; +pub static AZ_ATT_GAUSSIAN_BLUR_STD_DEVIATION: u32 = 0; + +pub type enum_AzGaussianBlurInputs = u32; +pub static AZ_IN_GAUSSIAN_BLUR_IN: u32 = 0; + #[repr(C)] #[deriving(Clone)] pub struct struct__AzColor { @@ -370,6 +382,8 @@ pub type AzPathRef = *mut c_void; pub type AzPathBuilderRef = *mut c_void; +pub type AzFilterNodeRef = *mut c_void; + pub type AzExtendMode = i32; #[link(name = "azure")] @@ -439,6 +453,12 @@ pub fn AzDrawTargetFillGlyphs(aDrawTarget: AzDrawTargetRef, aFont: AzScaledFontR pub fn AzDrawTargetDrawSurface(aDrawTarget: AzDrawTargetRef, aSurface: AzSourceSurfaceRef, aDest: *mut AzRect, aSource: *mut AzRect, aSurfOptions: AzDrawSurfaceOptionsRef, aOptions: *mut AzDrawOptions); +pub fn AzDrawTargetDrawFilter(aDrawTarget: AzDrawTargetRef, + aFilter: AzFilterNodeRef, + aSourceRect: *const AzRect, + aDestPoint: *const AzPoint, + aOptions: *const AzDrawOptions); + pub fn AzDrawTargetDrawSurfaceWithShadow(aDrawTarget: AzDrawTargetRef, aSurface: AzSourceSurfaceRef, aDest: *const AzPoint, @@ -468,6 +488,9 @@ pub fn AzDrawTargetCreateGradientStops(aDrawTarget: AzDrawTargetRef, aExtendMode: AzExtendMode) -> AzGradientStopsRef; +pub fn AzDrawTargetCreateFilter(aDrawTarget: AzDrawTargetRef, aFilterType: AzFilterType) + -> AzFilterNodeRef; + pub fn AzCreateLinearGradientPattern(aBegin: *const AzPoint, aEnd: *const AzPoint, aStops: AzGradientStopsRef, @@ -521,4 +544,16 @@ pub fn AzReleasePath(aPath: AzPathRef); pub fn AzReleaseGradientStops(aFont: AzScaledFontRef); +pub fn AzReleaseFilterNode(aFilter: AzFilterNodeRef); +pub fn AzFilterNodeSetSourceSurfaceInput(aFilter: AzFilterNodeRef, + aIndex: u32, + aSurface: AzSourceSurfaceRef); +pub fn AzFilterNodeSetFilterNodeInput(aFilter: AzFilterNodeRef, + aIndex: u32, + aInputFilter: AzFilterNodeRef); +pub fn AzFilterNodeSetFloatAttribute(aFilter: AzFilterNodeRef, aIndex: u32, aValue: AzFloat); +pub fn AzFilterNodeSetColorAttribute(aFilter: AzFilterNodeRef, + aIndex: u32, + aValue: *const AzColor); + } diff --git a/src/azure_hl.rs b/src/azure_hl.rs index cbd4305..fd4d2aa 100644 --- a/src/azure_hl.rs +++ b/src/azure_hl.rs @@ -4,7 +4,9 @@ //! High-level bindings to Azure. -use azure::{AZ_CAP_BUTT, AZ_JOIN_MITER_OR_BEVEL}; +use azure::{AZ_CAP_BUTT, AZ_JOIN_MITER_OR_BEVEL, AZ_FILTER_TYPE_FLOOD}; +use azure::{AZ_FILTER_TYPE_GAUSSIAN_BLUR, AZ_IN_FLOOD_IN, AZ_IN_GAUSSIAN_BLUR_IN}; +use azure::{AZ_ATT_FLOOD_COLOR, AZ_ATT_GAUSSIAN_BLUR_STD_DEVIATION}; use azure::{AzPoint, AzRect, AzFloat, AzIntSize, AzColor, AzColorPatternRef, AzGradientStopsRef}; use azure::{AzStrokeOptions, AzDrawOptions, AzSurfaceFormat, AzFilter, AzDrawSurfaceOptions}; use azure::{AzBackendType, AzDrawTargetRef, AzSourceSurfaceRef, AzDataSourceSurfaceRef}; @@ -36,6 +38,9 @@ use azure::{AzGLNativeContextRef, AzLinearGradientPatternRef, AzMatrix, AzPatter use azure::{AzCreateLinearGradientPattern, AzDrawTargetPushClipRect}; use azure::{AzDrawTargetDrawSurfaceWithShadow, AzDrawTargetCreateShadowDrawTarget}; use azure::{AzDrawTargetCreateSimilarDrawTarget, AzDrawTargetGetTransform}; +use azure::{AzFilterNodeSetSourceSurfaceInput, AzReleaseFilterNode, AzDrawTargetCreateFilter}; +use azure::{AzFilterNodeSetColorAttribute, AzFilterNodeSetFloatAttribute}; +use azure::{AzFilterNodeSetFilterNodeInput, AzDrawTargetDrawFilter, AzFilterNodeRef, AzFilterType}; use sync::Arc; use geom::matrix2d::Matrix2D; @@ -576,6 +581,20 @@ impl DrawTarget { } } + pub fn draw_filter(&self, + filter: FilterNode, + source_rect: &Rect, + dest_point: &Point2D, + options: DrawOptions) { + unsafe { + AzDrawTargetDrawFilter(self.azure_draw_target, + filter.azure_filter_node, + mem::transmute::<_,*const AzRect>(source_rect), + mem::transmute::<_,*const AzPoint>(dest_point), + &options.as_azure_draw_options()) + } + } + pub fn draw_surface_with_shadow(&self, surface: SourceSurface, dest: &Point2D, @@ -696,6 +715,15 @@ impl DrawTarget { } } + pub fn create_filter(&self, filter_type: FilterType) -> FilterNode { + unsafe { + FilterNode { + azure_filter_node: AzDrawTargetCreateFilter(self.azure_draw_target, + filter_type.as_azure_filter_type()), + } + } + } + pub fn push_clip(&self, path: &Path) { unsafe { AzDrawTargetPushClip(self.azure_draw_target,path.azure_path); @@ -982,3 +1010,116 @@ pub fn current_gl_context() -> AzGLContext { AzSkiaGetCurrentGLContext() } } + +pub struct FilterNode { + pub azure_filter_node: AzFilterNodeRef, +} + +impl Drop for FilterNode { + fn drop(&mut self) { + unsafe { + AzReleaseFilterNode(self.azure_filter_node); + } + } +} + +impl FilterNode { + pub fn set_input(&self, index: FIndex, input: &FInput) + where FIndex: FilterInputIndex, FInput: FilterInput { + input.set(self, index.azure_index()) + } + pub fn set_attribute(&self, attribute: A) where A: FilterAttribute { + attribute.set(self) + } +} + +pub struct FloodFilterInput; + +pub struct GaussianBlurInput; + +pub trait FilterInputIndex { + fn azure_index(&self) -> u32; +} + +impl FilterInputIndex for FloodFilterInput { + fn azure_index(&self) -> u32 { + AZ_IN_FLOOD_IN + } +} + +impl FilterInputIndex for GaussianBlurInput { + fn azure_index(&self) -> u32 { + AZ_IN_GAUSSIAN_BLUR_IN + } +} + +pub trait FilterAttribute { + fn set(&self, filter_node: &FilterNode); +} + +pub enum FloodAttribute { + ColorFloodAttribute(Color), +} + +pub enum GaussianBlurAttribute { + StdDeviationGaussianBlurAttribute(AzFloat), +} + +impl FilterAttribute for FloodAttribute { + fn set(&self, filter_node: &FilterNode) { + let ColorFloodAttribute(value) = *self; + unsafe { + AzFilterNodeSetColorAttribute(filter_node.azure_filter_node, + AZ_ATT_FLOOD_COLOR, + &value.as_azure_color()) + } + } +} + +impl FilterAttribute for GaussianBlurAttribute { + fn set(&self, filter_node: &FilterNode) { + let StdDeviationGaussianBlurAttribute(value) = *self; + unsafe { + AzFilterNodeSetFloatAttribute(filter_node.azure_filter_node, + AZ_ATT_GAUSSIAN_BLUR_STD_DEVIATION, + value) + } + } +} + +pub enum FilterType { + FloodFilterType, + GaussianBlurFilterType, +} + +impl FilterType { + pub fn as_azure_filter_type(self) -> AzFilterType { + match self { + FloodFilterType => AZ_FILTER_TYPE_FLOOD, + GaussianBlurFilterType => AZ_FILTER_TYPE_GAUSSIAN_BLUR, + } + } +} + +pub trait FilterInput { + fn set(&self, filter: &FilterNode, index: u32); +} + +impl FilterInput for SourceSurface { + fn set(&self, filter: &FilterNode, index: u32) { + unsafe { + AzFilterNodeSetSourceSurfaceInput(filter.azure_filter_node, + index, + self.azure_source_surface) + } + } +} + +impl FilterInput for FilterNode { + fn set(&self, filter: &FilterNode, index: u32) { + unsafe { + AzFilterNodeSetFilterNodeInput(filter.azure_filter_node, index, self.azure_filter_node) + } + } +} +