From 504a32e5d29aa103b6a103d57076d74b4131ae96 Mon Sep 17 00:00:00 2001 From: mgood7123 Date: Fri, 1 Jul 2022 17:34:05 +1000 Subject: [PATCH 1/3] add /.idea to git ignore --- .gitignore | 1 + 1 file changed, 1 insertion(+) diff --git a/.gitignore b/.gitignore index c358466167..be8ad6baab 100644 --- a/.gitignore +++ b/.gitignore @@ -299,3 +299,4 @@ Carthage/Build fastlane/report.xml fastlane/screenshots +/.idea From 4eabb6e6694966541826b1e29c7c6e3ea58981b1 Mon Sep 17 00:00:00 2001 From: mgood7123 Date: Thu, 7 Jul 2022 23:22:33 +1000 Subject: [PATCH 2/3] expose more of SKMatrix --- binding/Binding/SKMatrix.cs | 619 +++++++++++++++++++++------ binding/Binding/SkiaApi.generated.cs | 547 +++++++++++++++++++++++ 2 files changed, 1040 insertions(+), 126 deletions(-) diff --git a/binding/Binding/SKMatrix.cs b/binding/Binding/SKMatrix.cs index 6388e814a6..c07d488994 100644 --- a/binding/Binding/SKMatrix.cs +++ b/binding/Binding/SKMatrix.cs @@ -1,4 +1,5 @@ using System; +using System.Runtime.CompilerServices; // inlining using System.ComponentModel; namespace SkiaSharp @@ -11,39 +12,26 @@ public unsafe partial struct SKMatrix public readonly static SKMatrix Identity = new SKMatrix { scaleX = 1, scaleY = 1, persp2 = 1 }; - private class Indices - { - public const int ScaleX = 0; - public const int SkewX = 1; - public const int TransX = 2; - public const int SkewY = 3; - public const int ScaleY = 4; - public const int TransY = 5; - public const int Persp0 = 6; - public const int Persp1 = 7; - public const int Persp2 = 8; - - public const int Count = 9; - } + public SKMatrix() : this(1, 0, 0, 0, 1, 0, 0, 0, 1) {} public SKMatrix (float[] values) { if (values == null) throw new ArgumentNullException (nameof (values)); - if (values.Length != Indices.Count) - throw new ArgumentException ($"The matrix array must have a length of {Indices.Count}.", nameof (values)); + if (values.Length != 9) + throw new ArgumentException ($"The matrix array must have a length of 9.", nameof (values)); - scaleX = values[Indices.ScaleX]; - skewX = values[Indices.SkewX]; - transX = values[Indices.TransX]; + scaleX = values[(int)SKMatrixRowMajorMask.ScaleX]; + skewX = values[(int)SKMatrixRowMajorMask.SkewX]; + transX = values[(int)SKMatrixRowMajorMask.TransX]; - skewY = values[Indices.SkewY]; - scaleY = values[Indices.ScaleY]; - transY = values[Indices.TransY]; + skewY = values[(int)SKMatrixRowMajorMask.SkewY]; + scaleY = values[(int)SKMatrixRowMajorMask.ScaleY]; + transY = values[(int)SKMatrixRowMajorMask.TransY]; - persp0 = values[Indices.Persp0]; - persp1 = values[Indices.Persp1]; - persp2 = values[Indices.Persp2]; + persp0 = values[(int)SKMatrixRowMajorMask.Persp0]; + persp1 = values[(int)SKMatrixRowMajorMask.Persp1]; + persp2 = values[(int)SKMatrixRowMajorMask.Persp2]; } public SKMatrix ( @@ -62,10 +50,58 @@ public SKMatrix ( this.persp2 = persp2; } - public readonly bool IsIdentity => Equals (Identity); + private void setFrom (ref SKMatrix m) + { + scaleX = m.scaleX; + skewX = m.skewX; + transX = m.transX; + skewY = m.skewY; + scaleY = m.scaleY; + transY = m.transY; + persp0 = m.persp0; + persp1 = m.persp1; + persp2 = m.persp2; + } + + public readonly bool IsIdentity { + get { + fixed (SKMatrix* t = &this) { + return SkiaApi.sk_matrix_is_identity (t); + }; + } + } + + public readonly bool IsTranslate { + get { + fixed (SKMatrix* t = &this) { + return SkiaApi.sk_matrix_is_translate (t); + }; + } + } + + public readonly bool IsScaleTranslate { + get { + fixed (SKMatrix* t = &this) { + return SkiaApi.sk_matrix_is_scale_translate (t); + }; + } + } + + public bool IsSimilarity(float tol) { + fixed (SKMatrix* t = &this) { + return SkiaApi.sk_matrix_is_similarity (t, tol); + }; + } // Values + public float Get(SKMatrixRowMajorMask index) + { + fixed (SKMatrix* t = &this) { + return SkiaApi.sk_matrix_get (t, index); + } + } + public float[] Values { readonly get => new float[9] { @@ -76,20 +112,20 @@ public float[] Values { set { if (value == null) throw new ArgumentNullException (nameof (Values)); - if (value.Length != Indices.Count) - throw new ArgumentException ($"The matrix array must have a length of {Indices.Count}.", nameof (Values)); + if (value.Length != 9) + throw new ArgumentException ($"The matrix array must have a length of 9.", nameof (Values)); - scaleX = value[Indices.ScaleX]; - skewX = value[Indices.SkewX]; - transX = value[Indices.TransX]; + scaleX = value[(int)SKMatrixRowMajorMask.ScaleX]; + skewX = value[(int)SKMatrixRowMajorMask.SkewX]; + transX = value[(int)SKMatrixRowMajorMask.TransX]; - skewY = value[Indices.SkewY]; - scaleY = value[Indices.ScaleY]; - transY = value[Indices.TransY]; + skewY = value[(int)SKMatrixRowMajorMask.SkewY]; + scaleY = value[(int)SKMatrixRowMajorMask.ScaleY]; + transY = value[(int)SKMatrixRowMajorMask.TransY]; - persp0 = value[Indices.Persp0]; - persp1 = value[Indices.Persp1]; - persp2 = value[Indices.Persp2]; + persp0 = value[(int)SKMatrixRowMajorMask.Persp0]; + persp1 = value[(int)SKMatrixRowMajorMask.Persp1]; + persp2 = value[(int)SKMatrixRowMajorMask.Persp2]; } } @@ -97,39 +133,62 @@ public readonly void GetValues (float[] values) { if (values == null) throw new ArgumentNullException (nameof (values)); - if (values.Length != Indices.Count) - throw new ArgumentException ($"The matrix array must have a length of {Indices.Count}.", nameof (values)); + if (values.Length != 9) + throw new ArgumentException ($"The matrix array must have a length of 9.", nameof (values)); - values[Indices.ScaleX] = scaleX; - values[Indices.SkewX] = skewX; - values[Indices.TransX] = transX; + values[(int)SKMatrixRowMajorMask.ScaleX] = scaleX; + values[(int)SKMatrixRowMajorMask.SkewX] = skewX; + values[(int)SKMatrixRowMajorMask.TransX] = transX; - values[Indices.SkewY] = skewY; - values[Indices.ScaleY] = scaleY; - values[Indices.TransY] = transY; + values[(int)SKMatrixRowMajorMask.SkewY] = skewY; + values[(int)SKMatrixRowMajorMask.ScaleY] = scaleY; + values[(int)SKMatrixRowMajorMask.TransY] = transY; - values[Indices.Persp0] = persp0; - values[Indices.Persp1] = persp1; - values[Indices.Persp2] = persp2; + values[(int)SKMatrixRowMajorMask.Persp0] = persp0; + values[(int)SKMatrixRowMajorMask.Persp1] = persp1; + values[(int)SKMatrixRowMajorMask.Persp2] = persp2; } // Create* - public static SKMatrix CreateIdentity () => - new SKMatrix { scaleX = 1, scaleY = 1, persp2 = 1 }; + public static SKMatrix NativeCreateScale(float sx, float sy) => SkiaApi.sk_matrix_scale(sx, sy); + + public static SKMatrix NativeCreateTranslate(float dx, float dy) => SkiaApi.sk_matrix_translate(dx, dy); + + public static SKMatrix NativeCreateTranslate(SKPoint point) => SkiaApi.sk_matrix_translate_point(point); + + public static SKMatrix NativeCreateTranslate(SKPointI point) => SkiaApi.sk_matrix_translate_ipoint(point); + + public static SKMatrix NativeCreateRotateDeg(float deg) => SkiaApi.sk_matrix_rotate_deg(deg); + + public static SKMatrix NativeCreateRotateDeg(float deg, SKPoint pivot) => SkiaApi.sk_matrix_rotate_deg_point(deg, pivot); + + public static SKMatrix NativeCreateRotateRad(float rad) => SkiaApi.sk_matrix_rotate_rad(rad); + + public static SKMatrix CreateIdentity () => new SKMatrix { scaleX = 1, scaleY = 1, persp2 = 1 }; + + public static SKMatrix CreateSinCos(float sin, float cos) + { + SKMatrix matrix = Identity; + matrix.SetSinCos(sin, cos); + return matrix; + } + + public static SKMatrix CreateSinCos(float sin, float cos, float pivotx, float pivoty) + { + SKMatrix matrix = Identity; + matrix.SetSinCos(sin, cos, pivotx, pivoty); + return matrix; + } public static SKMatrix CreateTranslation (float x, float y) { if (x == 0 && y == 0) return Identity; - return new SKMatrix { - scaleX = 1, - scaleY = 1, - transX = x, - transY = y, - persp2 = 1, - }; + SKMatrix m = Identity; + m.SetTranslate(x, y); + return m; } public static SKMatrix CreateScale (float x, float y) @@ -137,11 +196,9 @@ public static SKMatrix CreateScale (float x, float y) if (x == 1 && y == 1) return Identity; - return new SKMatrix { - scaleX = x, - scaleY = y, - persp2 = 1, - }; + SKMatrix m = Identity; + m.SetScale(x, y); + return m; } public static SKMatrix CreateScale (float x, float y, float pivotX, float pivotY) @@ -149,16 +206,9 @@ public static SKMatrix CreateScale (float x, float y, float pivotX, float pivotY if (x == 1 && y == 1) return Identity; - var tx = pivotX - x * pivotX; - var ty = pivotY - y * pivotY; - - return new SKMatrix { - scaleX = x, - scaleY = y, - transX = tx, - transY = ty, - persp2 = 1, - }; + SKMatrix m = Identity; + m.SetScale(x, y, pivotX, pivotY); + return m; } public static SKMatrix CreateRotation (float radians) @@ -170,7 +220,7 @@ public static SKMatrix CreateRotation (float radians) var cos = (float)Math.Cos (radians); var matrix = Identity; - SetSinCos (ref matrix, sin, cos); + matrix.SetSinCos(sin, cos); return matrix; } @@ -183,7 +233,7 @@ public static SKMatrix CreateRotation (float radians, float pivotX, float pivotY var cos = (float)Math.Cos (radians); var matrix = Identity; - SetSinCos (ref matrix, sin, cos, pivotX, pivotY); + matrix.SetSinCos(sin, cos, pivotX, pivotY); return matrix; } @@ -222,19 +272,9 @@ public static SKMatrix CreateScaleTranslation (float sx, float sy, float tx, flo if (sx == 0 && sy == 0 && tx == 0 && ty == 0) return Identity; - return new SKMatrix { - scaleX = sx, - skewX = 0, - transX = tx, - - skewY = 0, - scaleY = sy, - transY = ty, - - persp0 = 0, - persp1 = 0, - persp2 = 1, - }; + SKMatrix m = new(); + m.SetScaleTranslate(sx, sy, tx, ty); + return m; } // Make* @@ -286,21 +326,70 @@ public static SKMatrix MakeSkew (float sx, float sy) => // Set* - [EditorBrowsable (EditorBrowsableState.Never)] - [Obsolete ("Use CreateScaleTranslation(float, float, float, float) instead.")] public void SetScaleTranslate (float sx, float sy, float tx, float ty) { - scaleX = sx; - skewX = 0; - transX = tx; + SetAll( + sx, 0, tx, + 0, sy, ty, + 0, 0, 1 + ); + } + + public void SetScale(float sx, float sy, float px, float py) { + if (1 == sx && 1 == sy) { + Reset(); + } else { + SetScaleTranslate(sx, sy, px - sx * px, py - sy * py); + } + } + + public void SetScale(float sx, float sy) { + SetAll(sx, 0, 0, + 0, sy, 0, + 0, 0, 1 + ); + } + + public void SetTranslate(float dx, float dy) { + SetAll(1, 0, dx, + 0, 1, dy, + 0, 0, 1 + ); + } + + internal const float SK_Scalar1 = 1.0f; + internal const float SK_ScalarNearlyZero = (SK_Scalar1 / (1 << 12)); + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static bool SkScalarNearlyZero(float x, float tolerance = SK_ScalarNearlyZero) + { + return Math.Abs(x) <= tolerance; + } - skewY = 0; - scaleY = sy; - transY = ty; + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static float SkScalarSinSnapToZero(float radians) + { + float v = (float)Math.Sin(radians); + return SkScalarNearlyZero(v) ? 0.0f : v; + } - persp0 = 0; - persp1 = 0; - persp2 = 1; + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static float SkScalarCosSnapToZero(float radians) + { + float v = (float)Math.Cos(radians); + return SkScalarNearlyZero(v) ? 0.0f : v; + } + + public void SetRotate(float degrees, float px, float py) + { + float rad = degrees * DegreesToRadians; + SetSinCos(SkScalarSinSnapToZero(rad), SkScalarCosSnapToZero(rad), px, py); + } + + public void SetRotate(float degrees) + { + float rad = degrees * DegreesToRadians; + SetSinCos(SkScalarSinSnapToZero(rad), SkScalarCosSnapToZero(rad)); } // Rotate @@ -311,16 +400,17 @@ public static void Rotate (ref SKMatrix matrix, float radians, float pivotx, flo { var sin = (float)Math.Sin (radians); var cos = (float)Math.Cos (radians); - SetSinCos (ref matrix, sin, cos, pivotx, pivoty); + matrix.SetSinCos(sin, cos, pivotx, pivoty); } [EditorBrowsable (EditorBrowsableState.Never)] [Obsolete ("Use CreateRotationDegrees(float, float, float) instead.")] public static void RotateDegrees (ref SKMatrix matrix, float degrees, float pivotx, float pivoty) { - var sin = (float)Math.Sin (degrees * DegreesToRadians); - var cos = (float)Math.Cos (degrees * DegreesToRadians); - SetSinCos (ref matrix, sin, cos, pivotx, pivoty); + float rad = degrees * DegreesToRadians; + var sin = (float)Math.Sin (rad); + var cos = (float)Math.Cos (rad); + matrix.SetSinCos(sin, cos, pivotx, pivoty); } [EditorBrowsable (EditorBrowsableState.Never)] @@ -329,16 +419,17 @@ public static void Rotate (ref SKMatrix matrix, float radians) { var sin = (float)Math.Sin (radians); var cos = (float)Math.Cos (radians); - SetSinCos (ref matrix, sin, cos); + matrix.SetSinCos(sin, cos); } [EditorBrowsable (EditorBrowsableState.Never)] [Obsolete ("Use CreateRotationDegrees(float) instead.")] public static void RotateDegrees (ref SKMatrix matrix, float degrees) { - var sin = (float)Math.Sin (degrees * DegreesToRadians); - var cos = (float)Math.Cos (degrees * DegreesToRadians); - SetSinCos (ref matrix, sin, cos); + float rad = degrees * DegreesToRadians; + var sin = (float)Math.Sin (rad); + var cos = (float)Math.Cos (rad); + matrix.SetSinCos(sin, cos); } // Invert @@ -444,6 +535,78 @@ public static void PostConcat (ref SKMatrix target, ref SKMatrix matrix) } } + // *Scale + public void PreScale(float sx, float sy) + { + SKMatrix o; + fixed (SKMatrix* t = &this) + { + SkiaApi.sk_matrix_pre_scale(&o, t, sx, sy); + }; + setFrom(ref o); + } + + public void PreScale(float sx, float sy, float px, float py) + { + SKMatrix o; + fixed (SKMatrix* t = &this) + { + SkiaApi.sk_matrix_pre_scale_with_pivot(&o, t, sx, sy, px, py); + }; + setFrom(ref o); + } + + public void PostScale(float sx, float sy) + { + SKMatrix o; + fixed (SKMatrix* t = &this) + { + SkiaApi.sk_matrix_post_scale(&o, t, sx, sy); + }; + setFrom(ref o); + } + + public void PostScale(float sx, float sy, float px, float py) + { + SKMatrix o; + fixed (SKMatrix* t = &this) + { + SkiaApi.sk_matrix_post_scale_with_pivot(&o, t, sx, sy, px, py); + }; + setFrom(ref o); + } + + + public void PreTranslate(float dx, float dy) + { + SKMatrix o; + fixed (SKMatrix* t = &this) + { + SkiaApi.sk_matrix_post_translate(&o, t, dx, dy); + }; + setFrom(ref o); + } + + public void PostTranslate(float dx, float dy) + { + SKMatrix o; + fixed (SKMatrix* t = &this) + { + SkiaApi.sk_matrix_post_translate(&o, t, dx, dy); + }; + setFrom(ref o); + } + + public bool SetRectToRect(SKRect source, SKRect dest, SKMatrixScaleToFit scaleToFit) + { + SKMatrix o; + fixed (SKMatrix* m = &this) + { + return SkiaApi.sk_matrix_set_rect_to_rect(m, &o, &dest, &source, scaleToFit); + } + setFrom(ref o); + } + // MapRect public readonly SKRect MapRect (SKRect source) @@ -557,32 +720,24 @@ public readonly float MapRadius (float radius) // private - private static void SetSinCos (ref SKMatrix matrix, float sin, float cos) + public void SetSinCos (float sin, float cos) { - matrix.scaleX = cos; - matrix.skewX = -sin; - matrix.transX = 0; - matrix.skewY = sin; - matrix.scaleY = cos; - matrix.transY = 0; - matrix.persp0 = 0; - matrix.persp1 = 0; - matrix.persp2 = 1; + SetAll( + cos, -sin, 0, + sin, cos, 0, + 0, 0, 1 + ); } - private static void SetSinCos (ref SKMatrix matrix, float sin, float cos, float pivotx, float pivoty) + public void SetSinCos (float sin, float cos, float pivotx, float pivoty) { float oneMinusCos = 1 - cos; - matrix.scaleX = cos; - matrix.skewX = -sin; - matrix.transX = Dot (sin, pivoty, oneMinusCos, pivotx); - matrix.skewY = sin; - matrix.scaleY = cos; - matrix.transY = Dot (-sin, pivotx, oneMinusCos, pivoty); - matrix.persp0 = 0; - matrix.persp1 = 0; - matrix.persp2 = 1; + SetAll( + cos, -sin, Dot(sin, pivoty, oneMinusCos, pivotx), + sin, cos, Dot(-sin, pivotx, oneMinusCos, pivoty), + 0, 0, 1 + ); } private static float Dot (float a, float b, float c, float d) => @@ -590,5 +745,217 @@ private static float Dot (float a, float b, float c, float d) => private static float Cross (float a, float b, float c, float d) => a * b - c * d; + + // additional + public void SetAll ( + float scaleX, float skewX, float transX, + float skewY, float scaleY, float transY, + float pers0, float pers1, float pers2 + ) + { + ScaleX = scaleX; + SkewX = skewX; + TransX = transX; + + ScaleY = scaleY; + SkewY = skewY; + TransY = transY; + + Persp0 = pers0; + Persp1 = pers1; + Persp2 = pers2; + } + + public SKMatrixTypeMask Type { + get { + fixed (SKMatrix* t = &this) { + return SkiaApi.sk_matrix_get_type (t); + }; + } + } + + public bool RectStaysRect { + get { + fixed (SKMatrix* t = &this) { + return SkiaApi.sk_matrix_rect_stays_rect (t); + }; + } + } + + public bool PreservesAxisAlignment { + get { + fixed (SKMatrix* t = &this) { + return SkiaApi.sk_matrix_preserves_axis_alignment (t); + }; + } + } + + public bool HasPerspective { + get { + fixed (SKMatrix* t = &this) { + return SkiaApi.sk_matrix_has_perspective (t); + }; + } + } + + public bool PreservesRightAngles(float tol) { + fixed (SKMatrix* t = &this) { + return SkiaApi.sk_matrix_preserves_right_angles (t, tol); + }; + } + + public void Set9 (float[] buffer) + { + if (buffer == null) + throw new ArgumentNullException (nameof (buffer)); + if (buffer.Length != 9) + throw new ArgumentException ($"The matrix array must have a length of 9.", nameof (buffer)); + + SKMatrix o; + fixed (float* buf = buffer) + fixed (SKMatrix* t = &this) { + SkiaApi.sk_matrix_set9 (t, buf, &o); + }; + setFrom (ref o); + } + + public void Get9 (float[] buffer) + { + if (buffer == null) + throw new ArgumentNullException (nameof (buffer)); + if (buffer.Length != 9) + throw new ArgumentException ($"The matrix array must have a length of 9.", nameof (buffer)); + + fixed (float* buf = buffer) + fixed (SKMatrix* t = &this) { + SkiaApi.sk_matrix_get9 (t, buf); + }; + } + + public void Reset () + { + SKMatrix o; + fixed (SKMatrix* t = &this) { + SkiaApi.sk_matrix_reset (t, &o); + }; + setFrom (ref o); + } + + public void SetIdentity () + { + SKMatrix o; + fixed (SKMatrix* t = &this) { + SkiaApi.sk_matrix_set_identity (t, &o); + }; + setFrom (ref o); + } + + public static void SetIdentityAffine(float[] affine) + { + if (affine == null) + throw new ArgumentNullException (nameof (affine)); + if (affine.Length != 6) + throw new ArgumentException ($"The matrix array must have a length of 6.", nameof (affine)); + + affine[(int)SKMatrixAffineColomnMajorMask.AScaleX] = 1; + affine[(int)SKMatrixAffineColomnMajorMask.ASkewY] = 0; + affine[(int)SKMatrixAffineColomnMajorMask.ASkewX] = 0; + affine[(int)SKMatrixAffineColomnMajorMask.AScaleY] = 1; + affine[(int)SKMatrixAffineColomnMajorMask.ATransX] = 0; + affine[(int)SKMatrixAffineColomnMajorMask.ATransY] = 0; + } + + public bool AsAffine(float[] affine) { + if (HasPerspective) { + return false; + } + if (affine != null) { + if (affine.Length != 6) + throw new ArgumentException ($"The matrix array must have a length of 6.", nameof (affine)); + affine[(int)SKMatrixAffineColomnMajorMask.AScaleX] = ScaleX; + affine[(int)SKMatrixAffineColomnMajorMask.ASkewY] = SkewY; + affine[(int)SKMatrixAffineColomnMajorMask.ASkewX] = SkewX; + affine[(int)SKMatrixAffineColomnMajorMask.AScaleY] = ScaleY; + affine[(int)SKMatrixAffineColomnMajorMask.ATransX] = TransX; + affine[(int)SKMatrixAffineColomnMajorMask.ATransY] = TransY; + } + return true; + } + + public void SetAffine(float[] buffer) { + if (buffer == null) + throw new ArgumentNullException (nameof (buffer)); + if (buffer.Length != 6) + throw new ArgumentException ($"The matrix array must have a length of 6.", nameof (buffer)); + + ScaleX = buffer[(int)SKMatrixAffineColomnMajorMask.AScaleX]; + SkewX = buffer[(int)SKMatrixAffineColomnMajorMask.ASkewX]; + TransX = buffer[(int)SKMatrixAffineColomnMajorMask.ATransX]; + SkewY = buffer[(int)SKMatrixAffineColomnMajorMask.ASkewY]; + ScaleY = buffer[(int)SKMatrixAffineColomnMajorMask.AScaleY]; + TransY = buffer[(int)SKMatrixAffineColomnMajorMask.ATransY]; + Persp0 = 0; + Persp1 = 0; + Persp2 = 1; + } + + public void NormalizePerspective() + { + SKMatrix o; + fixed (SKMatrix* t = &this) { + SkiaApi.sk_matrix_normalize_perspective (t, &o); + }; + setFrom (ref o); + } + + public void MapHomogeneousPoints (SKPoint3[] dst, SKPoint3[] src) + { + MapHomogeneousPoints (dst, src, src.Length); + } + + public void MapHomogeneousPoints(SKPoint3[] dst, SKPoint3[] src, int count) + { + if (dst == null) + throw new ArgumentNullException (nameof (dst)); + if (src == null) + throw new ArgumentNullException (nameof (src)); + if (dst.Length != src.Length) + throw new ArgumentException ("Buffers must be the same size."); + + fixed (SKMatrix* t = &this) + fixed (SKPoint3* s = src) + fixed (SKPoint3* d = dst) { + SkiaApi.sk_matrix_map_homogeneous_points3 (t, d, s, count); + } + } + + public void MapHomogeneousPoints (SKPoint3[] dst, SKPoint[] src) + { + MapHomogeneousPoints (dst, src, src.Length); + } + + public void MapHomogeneousPoints (SKPoint3[] dst, SKPoint[] src, int count) + { + if (dst == null) + throw new ArgumentNullException (nameof (dst)); + if (src == null) + throw new ArgumentNullException (nameof (src)); + if (dst.Length != src.Length) + throw new ArgumentException ("Buffers must be the same size."); + + fixed (SKMatrix* t = &this) + fixed (SKPoint* s = src) + fixed (SKPoint3* d = dst) { + SkiaApi.sk_matrix_map_homogeneous_points (t, d, s, count); + } + } + + public bool IsFinite { + get { + fixed (SKMatrix* t = &this) { + return SkiaApi.sk_matrix_is_finite (t); + }; + } + } } } diff --git a/binding/Binding/SkiaApi.generated.cs b/binding/Binding/SkiaApi.generated.cs index 8a70b54134..8da4008546 100644 --- a/binding/Binding/SkiaApi.generated.cs +++ b/binding/Binding/SkiaApi.generated.cs @@ -6284,6 +6284,172 @@ internal static void sk_matrix_concat (SKMatrix* result, SKMatrix* first, SKMatr (sk_matrix_concat_delegate ??= GetSymbol ("sk_matrix_concat")).Invoke (result, first, second); #endif + // float sk_matrix_get(sk_matrix_t* matrix, sk_matrix_row_major_mask_t mask) + #if !USE_DELEGATES + [DllImport (SKIA, CallingConvention = CallingConvention.Cdecl)] + internal static extern Single sk_matrix_get (SKMatrix* matrix, SKMatrixRowMajorMask mask); + #else + private partial class Delegates { + [UnmanagedFunctionPointer (CallingConvention.Cdecl)] + internal delegate Single sk_matrix_get (SKMatrix* matrix, SKMatrixRowMajorMask mask); + } + private static Delegates.sk_matrix_get sk_matrix_get_delegate; + internal static Single sk_matrix_get (SKMatrix* matrix, SKMatrixRowMajorMask mask) => + (sk_matrix_get_delegate ??= GetSymbol ("sk_matrix_get")).Invoke (matrix, mask); + #endif + + // sk_matrix_type_mask_t sk_matrix_get_type(sk_matrix_t* matrix) + #if !USE_DELEGATES + [DllImport (SKIA, CallingConvention = CallingConvention.Cdecl)] + internal static extern SKMatrixTypeMask sk_matrix_get_type (SKMatrix* matrix); + #else + private partial class Delegates { + [UnmanagedFunctionPointer (CallingConvention.Cdecl)] + internal delegate SKMatrixTypeMask sk_matrix_get_type (SKMatrix* matrix); + } + private static Delegates.sk_matrix_get_type sk_matrix_get_type_delegate; + internal static SKMatrixTypeMask sk_matrix_get_type (SKMatrix* matrix) => + (sk_matrix_get_type_delegate ??= GetSymbol ("sk_matrix_get_type")).Invoke (matrix); + #endif + + // void sk_matrix_get9(sk_matrix_t* matrix, float* buffer) + #if !USE_DELEGATES + [DllImport (SKIA, CallingConvention = CallingConvention.Cdecl)] + internal static extern void sk_matrix_get9 (SKMatrix* matrix, Single* buffer); + #else + private partial class Delegates { + [UnmanagedFunctionPointer (CallingConvention.Cdecl)] + internal delegate void sk_matrix_get9 (SKMatrix* matrix, Single* buffer); + } + private static Delegates.sk_matrix_get9 sk_matrix_get9_delegate; + internal static void sk_matrix_get9 (SKMatrix* matrix, Single* buffer) => + (sk_matrix_get9_delegate ??= GetSymbol ("sk_matrix_get9")).Invoke (matrix, buffer); + #endif + + // bool sk_matrix_has_perspective(sk_matrix_t* matrix) + #if !USE_DELEGATES + [DllImport (SKIA, CallingConvention = CallingConvention.Cdecl)] + [return: MarshalAs (UnmanagedType.I1)] + internal static extern bool sk_matrix_has_perspective (SKMatrix* matrix); + #else + private partial class Delegates { + [UnmanagedFunctionPointer (CallingConvention.Cdecl)] + [return: MarshalAs (UnmanagedType.I1)] + internal delegate bool sk_matrix_has_perspective (SKMatrix* matrix); + } + private static Delegates.sk_matrix_has_perspective sk_matrix_has_perspective_delegate; + internal static bool sk_matrix_has_perspective (SKMatrix* matrix) => + (sk_matrix_has_perspective_delegate ??= GetSymbol ("sk_matrix_has_perspective")).Invoke (matrix); + #endif + + // bool sk_matrix_is_finite(sk_matrix_t* matrix) + #if !USE_DELEGATES + [DllImport (SKIA, CallingConvention = CallingConvention.Cdecl)] + [return: MarshalAs (UnmanagedType.I1)] + internal static extern bool sk_matrix_is_finite (SKMatrix* matrix); + #else + private partial class Delegates { + [UnmanagedFunctionPointer (CallingConvention.Cdecl)] + [return: MarshalAs (UnmanagedType.I1)] + internal delegate bool sk_matrix_is_finite (SKMatrix* matrix); + } + private static Delegates.sk_matrix_is_finite sk_matrix_is_finite_delegate; + internal static bool sk_matrix_is_finite (SKMatrix* matrix) => + (sk_matrix_is_finite_delegate ??= GetSymbol ("sk_matrix_is_finite")).Invoke (matrix); + #endif + + // bool sk_matrix_is_identity(sk_matrix_t* matrix) + #if !USE_DELEGATES + [DllImport (SKIA, CallingConvention = CallingConvention.Cdecl)] + [return: MarshalAs (UnmanagedType.I1)] + internal static extern bool sk_matrix_is_identity (SKMatrix* matrix); + #else + private partial class Delegates { + [UnmanagedFunctionPointer (CallingConvention.Cdecl)] + [return: MarshalAs (UnmanagedType.I1)] + internal delegate bool sk_matrix_is_identity (SKMatrix* matrix); + } + private static Delegates.sk_matrix_is_identity sk_matrix_is_identity_delegate; + internal static bool sk_matrix_is_identity (SKMatrix* matrix) => + (sk_matrix_is_identity_delegate ??= GetSymbol ("sk_matrix_is_identity")).Invoke (matrix); + #endif + + // bool sk_matrix_is_scale_translate(sk_matrix_t* matrix) + #if !USE_DELEGATES + [DllImport (SKIA, CallingConvention = CallingConvention.Cdecl)] + [return: MarshalAs (UnmanagedType.I1)] + internal static extern bool sk_matrix_is_scale_translate (SKMatrix* matrix); + #else + private partial class Delegates { + [UnmanagedFunctionPointer (CallingConvention.Cdecl)] + [return: MarshalAs (UnmanagedType.I1)] + internal delegate bool sk_matrix_is_scale_translate (SKMatrix* matrix); + } + private static Delegates.sk_matrix_is_scale_translate sk_matrix_is_scale_translate_delegate; + internal static bool sk_matrix_is_scale_translate (SKMatrix* matrix) => + (sk_matrix_is_scale_translate_delegate ??= GetSymbol ("sk_matrix_is_scale_translate")).Invoke (matrix); + #endif + + // bool sk_matrix_is_similarity(sk_matrix_t* matrix, float tol) + #if !USE_DELEGATES + [DllImport (SKIA, CallingConvention = CallingConvention.Cdecl)] + [return: MarshalAs (UnmanagedType.I1)] + internal static extern bool sk_matrix_is_similarity (SKMatrix* matrix, Single tol); + #else + private partial class Delegates { + [UnmanagedFunctionPointer (CallingConvention.Cdecl)] + [return: MarshalAs (UnmanagedType.I1)] + internal delegate bool sk_matrix_is_similarity (SKMatrix* matrix, Single tol); + } + private static Delegates.sk_matrix_is_similarity sk_matrix_is_similarity_delegate; + internal static bool sk_matrix_is_similarity (SKMatrix* matrix, Single tol) => + (sk_matrix_is_similarity_delegate ??= GetSymbol ("sk_matrix_is_similarity")).Invoke (matrix, tol); + #endif + + // bool sk_matrix_is_translate(sk_matrix_t* matrix) + #if !USE_DELEGATES + [DllImport (SKIA, CallingConvention = CallingConvention.Cdecl)] + [return: MarshalAs (UnmanagedType.I1)] + internal static extern bool sk_matrix_is_translate (SKMatrix* matrix); + #else + private partial class Delegates { + [UnmanagedFunctionPointer (CallingConvention.Cdecl)] + [return: MarshalAs (UnmanagedType.I1)] + internal delegate bool sk_matrix_is_translate (SKMatrix* matrix); + } + private static Delegates.sk_matrix_is_translate sk_matrix_is_translate_delegate; + internal static bool sk_matrix_is_translate (SKMatrix* matrix) => + (sk_matrix_is_translate_delegate ??= GetSymbol ("sk_matrix_is_translate")).Invoke (matrix); + #endif + + // void sk_matrix_map_homogeneous_points(sk_matrix_t* matrix, sk_point3_t* dst, sk_point_t* src, int count) + #if !USE_DELEGATES + [DllImport (SKIA, CallingConvention = CallingConvention.Cdecl)] + internal static extern void sk_matrix_map_homogeneous_points (SKMatrix* matrix, SKPoint3* dst, SKPoint* src, Int32 count); + #else + private partial class Delegates { + [UnmanagedFunctionPointer (CallingConvention.Cdecl)] + internal delegate void sk_matrix_map_homogeneous_points (SKMatrix* matrix, SKPoint3* dst, SKPoint* src, Int32 count); + } + private static Delegates.sk_matrix_map_homogeneous_points sk_matrix_map_homogeneous_points_delegate; + internal static void sk_matrix_map_homogeneous_points (SKMatrix* matrix, SKPoint3* dst, SKPoint* src, Int32 count) => + (sk_matrix_map_homogeneous_points_delegate ??= GetSymbol ("sk_matrix_map_homogeneous_points")).Invoke (matrix, dst, src, count); + #endif + + // void sk_matrix_map_homogeneous_points3(sk_matrix_t* matrix, sk_point3_t* dst, sk_point3_t* src, int count) + #if !USE_DELEGATES + [DllImport (SKIA, CallingConvention = CallingConvention.Cdecl)] + internal static extern void sk_matrix_map_homogeneous_points3 (SKMatrix* matrix, SKPoint3* dst, SKPoint3* src, Int32 count); + #else + private partial class Delegates { + [UnmanagedFunctionPointer (CallingConvention.Cdecl)] + internal delegate void sk_matrix_map_homogeneous_points3 (SKMatrix* matrix, SKPoint3* dst, SKPoint3* src, Int32 count); + } + private static Delegates.sk_matrix_map_homogeneous_points3 sk_matrix_map_homogeneous_points3_delegate; + internal static void sk_matrix_map_homogeneous_points3 (SKMatrix* matrix, SKPoint3* dst, SKPoint3* src, Int32 count) => + (sk_matrix_map_homogeneous_points3_delegate ??= GetSymbol ("sk_matrix_map_homogeneous_points3")).Invoke (matrix, dst, src, count); + #endif + // void sk_matrix_map_points(sk_matrix_t* matrix, sk_point_t* dst, sk_point_t* src, int count) #if !USE_DELEGATES [DllImport (SKIA, CallingConvention = CallingConvention.Cdecl)] @@ -6368,6 +6534,20 @@ internal static void sk_matrix_map_xy (SKMatrix* matrix, Single x, Single y, SKP (sk_matrix_map_xy_delegate ??= GetSymbol ("sk_matrix_map_xy")).Invoke (matrix, x, y, result); #endif + // void sk_matrix_normalize_perspective(sk_matrix_t* matrix, sk_matrix_t* result) + #if !USE_DELEGATES + [DllImport (SKIA, CallingConvention = CallingConvention.Cdecl)] + internal static extern void sk_matrix_normalize_perspective (SKMatrix* matrix, SKMatrix* result); + #else + private partial class Delegates { + [UnmanagedFunctionPointer (CallingConvention.Cdecl)] + internal delegate void sk_matrix_normalize_perspective (SKMatrix* matrix, SKMatrix* result); + } + private static Delegates.sk_matrix_normalize_perspective sk_matrix_normalize_perspective_delegate; + internal static void sk_matrix_normalize_perspective (SKMatrix* matrix, SKMatrix* result) => + (sk_matrix_normalize_perspective_delegate ??= GetSymbol ("sk_matrix_normalize_perspective")).Invoke (matrix, result); + #endif + // void sk_matrix_post_concat(sk_matrix_t* result, sk_matrix_t* matrix) #if !USE_DELEGATES [DllImport (SKIA, CallingConvention = CallingConvention.Cdecl)] @@ -6382,6 +6562,48 @@ internal static void sk_matrix_post_concat (SKMatrix* result, SKMatrix* matrix) (sk_matrix_post_concat_delegate ??= GetSymbol ("sk_matrix_post_concat")).Invoke (result, matrix); #endif + // void sk_matrix_post_scale(sk_matrix_t* result, sk_matrix_t* matrix, float sx, float sy) + #if !USE_DELEGATES + [DllImport (SKIA, CallingConvention = CallingConvention.Cdecl)] + internal static extern void sk_matrix_post_scale (SKMatrix* result, SKMatrix* matrix, Single sx, Single sy); + #else + private partial class Delegates { + [UnmanagedFunctionPointer (CallingConvention.Cdecl)] + internal delegate void sk_matrix_post_scale (SKMatrix* result, SKMatrix* matrix, Single sx, Single sy); + } + private static Delegates.sk_matrix_post_scale sk_matrix_post_scale_delegate; + internal static void sk_matrix_post_scale (SKMatrix* result, SKMatrix* matrix, Single sx, Single sy) => + (sk_matrix_post_scale_delegate ??= GetSymbol ("sk_matrix_post_scale")).Invoke (result, matrix, sx, sy); + #endif + + // void sk_matrix_post_scale_with_pivot(sk_matrix_t* result, sk_matrix_t* matrix, float sx, float sy, float px, float py) + #if !USE_DELEGATES + [DllImport (SKIA, CallingConvention = CallingConvention.Cdecl)] + internal static extern void sk_matrix_post_scale_with_pivot (SKMatrix* result, SKMatrix* matrix, Single sx, Single sy, Single px, Single py); + #else + private partial class Delegates { + [UnmanagedFunctionPointer (CallingConvention.Cdecl)] + internal delegate void sk_matrix_post_scale_with_pivot (SKMatrix* result, SKMatrix* matrix, Single sx, Single sy, Single px, Single py); + } + private static Delegates.sk_matrix_post_scale_with_pivot sk_matrix_post_scale_with_pivot_delegate; + internal static void sk_matrix_post_scale_with_pivot (SKMatrix* result, SKMatrix* matrix, Single sx, Single sy, Single px, Single py) => + (sk_matrix_post_scale_with_pivot_delegate ??= GetSymbol ("sk_matrix_post_scale_with_pivot")).Invoke (result, matrix, sx, sy, px, py); + #endif + + // void sk_matrix_post_translate(sk_matrix_t* result, sk_matrix_t* matrix, float dx, float dy) + #if !USE_DELEGATES + [DllImport (SKIA, CallingConvention = CallingConvention.Cdecl)] + internal static extern void sk_matrix_post_translate (SKMatrix* result, SKMatrix* matrix, Single dx, Single dy); + #else + private partial class Delegates { + [UnmanagedFunctionPointer (CallingConvention.Cdecl)] + internal delegate void sk_matrix_post_translate (SKMatrix* result, SKMatrix* matrix, Single dx, Single dy); + } + private static Delegates.sk_matrix_post_translate sk_matrix_post_translate_delegate; + internal static void sk_matrix_post_translate (SKMatrix* result, SKMatrix* matrix, Single dx, Single dy) => + (sk_matrix_post_translate_delegate ??= GetSymbol ("sk_matrix_post_translate")).Invoke (result, matrix, dx, dy); + #endif + // void sk_matrix_pre_concat(sk_matrix_t* result, sk_matrix_t* matrix) #if !USE_DELEGATES [DllImport (SKIA, CallingConvention = CallingConvention.Cdecl)] @@ -6396,6 +6618,266 @@ internal static void sk_matrix_pre_concat (SKMatrix* result, SKMatrix* matrix) = (sk_matrix_pre_concat_delegate ??= GetSymbol ("sk_matrix_pre_concat")).Invoke (result, matrix); #endif + // void sk_matrix_pre_scale(sk_matrix_t* result, sk_matrix_t* matrix, float sx, float sy) + #if !USE_DELEGATES + [DllImport (SKIA, CallingConvention = CallingConvention.Cdecl)] + internal static extern void sk_matrix_pre_scale (SKMatrix* result, SKMatrix* matrix, Single sx, Single sy); + #else + private partial class Delegates { + [UnmanagedFunctionPointer (CallingConvention.Cdecl)] + internal delegate void sk_matrix_pre_scale (SKMatrix* result, SKMatrix* matrix, Single sx, Single sy); + } + private static Delegates.sk_matrix_pre_scale sk_matrix_pre_scale_delegate; + internal static void sk_matrix_pre_scale (SKMatrix* result, SKMatrix* matrix, Single sx, Single sy) => + (sk_matrix_pre_scale_delegate ??= GetSymbol ("sk_matrix_pre_scale")).Invoke (result, matrix, sx, sy); + #endif + + // void sk_matrix_pre_scale_with_pivot(sk_matrix_t* result, sk_matrix_t* matrix, float sx, float sy, float px, float py) + #if !USE_DELEGATES + [DllImport (SKIA, CallingConvention = CallingConvention.Cdecl)] + internal static extern void sk_matrix_pre_scale_with_pivot (SKMatrix* result, SKMatrix* matrix, Single sx, Single sy, Single px, Single py); + #else + private partial class Delegates { + [UnmanagedFunctionPointer (CallingConvention.Cdecl)] + internal delegate void sk_matrix_pre_scale_with_pivot (SKMatrix* result, SKMatrix* matrix, Single sx, Single sy, Single px, Single py); + } + private static Delegates.sk_matrix_pre_scale_with_pivot sk_matrix_pre_scale_with_pivot_delegate; + internal static void sk_matrix_pre_scale_with_pivot (SKMatrix* result, SKMatrix* matrix, Single sx, Single sy, Single px, Single py) => + (sk_matrix_pre_scale_with_pivot_delegate ??= GetSymbol ("sk_matrix_pre_scale_with_pivot")).Invoke (result, matrix, sx, sy, px, py); + #endif + + // void sk_matrix_pre_translate(sk_matrix_t* result, sk_matrix_t* matrix, float dx, float dy) + #if !USE_DELEGATES + [DllImport (SKIA, CallingConvention = CallingConvention.Cdecl)] + internal static extern void sk_matrix_pre_translate (SKMatrix* result, SKMatrix* matrix, Single dx, Single dy); + #else + private partial class Delegates { + [UnmanagedFunctionPointer (CallingConvention.Cdecl)] + internal delegate void sk_matrix_pre_translate (SKMatrix* result, SKMatrix* matrix, Single dx, Single dy); + } + private static Delegates.sk_matrix_pre_translate sk_matrix_pre_translate_delegate; + internal static void sk_matrix_pre_translate (SKMatrix* result, SKMatrix* matrix, Single dx, Single dy) => + (sk_matrix_pre_translate_delegate ??= GetSymbol ("sk_matrix_pre_translate")).Invoke (result, matrix, dx, dy); + #endif + + // bool sk_matrix_preserves_axis_alignment(sk_matrix_t* matrix) + #if !USE_DELEGATES + [DllImport (SKIA, CallingConvention = CallingConvention.Cdecl)] + [return: MarshalAs (UnmanagedType.I1)] + internal static extern bool sk_matrix_preserves_axis_alignment (SKMatrix* matrix); + #else + private partial class Delegates { + [UnmanagedFunctionPointer (CallingConvention.Cdecl)] + [return: MarshalAs (UnmanagedType.I1)] + internal delegate bool sk_matrix_preserves_axis_alignment (SKMatrix* matrix); + } + private static Delegates.sk_matrix_preserves_axis_alignment sk_matrix_preserves_axis_alignment_delegate; + internal static bool sk_matrix_preserves_axis_alignment (SKMatrix* matrix) => + (sk_matrix_preserves_axis_alignment_delegate ??= GetSymbol ("sk_matrix_preserves_axis_alignment")).Invoke (matrix); + #endif + + // bool sk_matrix_preserves_right_angles(sk_matrix_t* matrix, float tol) + #if !USE_DELEGATES + [DllImport (SKIA, CallingConvention = CallingConvention.Cdecl)] + [return: MarshalAs (UnmanagedType.I1)] + internal static extern bool sk_matrix_preserves_right_angles (SKMatrix* matrix, Single tol); + #else + private partial class Delegates { + [UnmanagedFunctionPointer (CallingConvention.Cdecl)] + [return: MarshalAs (UnmanagedType.I1)] + internal delegate bool sk_matrix_preserves_right_angles (SKMatrix* matrix, Single tol); + } + private static Delegates.sk_matrix_preserves_right_angles sk_matrix_preserves_right_angles_delegate; + internal static bool sk_matrix_preserves_right_angles (SKMatrix* matrix, Single tol) => + (sk_matrix_preserves_right_angles_delegate ??= GetSymbol ("sk_matrix_preserves_right_angles")).Invoke (matrix, tol); + #endif + + // float sk_matrix_rc(sk_matrix_t* matrix, int r, int c) + #if !USE_DELEGATES + [DllImport (SKIA, CallingConvention = CallingConvention.Cdecl)] + internal static extern Single sk_matrix_rc (SKMatrix* matrix, Int32 r, Int32 c); + #else + private partial class Delegates { + [UnmanagedFunctionPointer (CallingConvention.Cdecl)] + internal delegate Single sk_matrix_rc (SKMatrix* matrix, Int32 r, Int32 c); + } + private static Delegates.sk_matrix_rc sk_matrix_rc_delegate; + internal static Single sk_matrix_rc (SKMatrix* matrix, Int32 r, Int32 c) => + (sk_matrix_rc_delegate ??= GetSymbol ("sk_matrix_rc")).Invoke (matrix, r, c); + #endif + + // bool sk_matrix_rect_stays_rect(sk_matrix_t* matrix) + #if !USE_DELEGATES + [DllImport (SKIA, CallingConvention = CallingConvention.Cdecl)] + [return: MarshalAs (UnmanagedType.I1)] + internal static extern bool sk_matrix_rect_stays_rect (SKMatrix* matrix); + #else + private partial class Delegates { + [UnmanagedFunctionPointer (CallingConvention.Cdecl)] + [return: MarshalAs (UnmanagedType.I1)] + internal delegate bool sk_matrix_rect_stays_rect (SKMatrix* matrix); + } + private static Delegates.sk_matrix_rect_stays_rect sk_matrix_rect_stays_rect_delegate; + internal static bool sk_matrix_rect_stays_rect (SKMatrix* matrix) => + (sk_matrix_rect_stays_rect_delegate ??= GetSymbol ("sk_matrix_rect_stays_rect")).Invoke (matrix); + #endif + + // void sk_matrix_reset(sk_matrix_t* matrix, sk_matrix_t* result) + #if !USE_DELEGATES + [DllImport (SKIA, CallingConvention = CallingConvention.Cdecl)] + internal static extern void sk_matrix_reset (SKMatrix* matrix, SKMatrix* result); + #else + private partial class Delegates { + [UnmanagedFunctionPointer (CallingConvention.Cdecl)] + internal delegate void sk_matrix_reset (SKMatrix* matrix, SKMatrix* result); + } + private static Delegates.sk_matrix_reset sk_matrix_reset_delegate; + internal static void sk_matrix_reset (SKMatrix* matrix, SKMatrix* result) => + (sk_matrix_reset_delegate ??= GetSymbol ("sk_matrix_reset")).Invoke (matrix, result); + #endif + + // sk_matrix_t sk_matrix_rotate_deg(float deg) + #if !USE_DELEGATES + [DllImport (SKIA, CallingConvention = CallingConvention.Cdecl)] + internal static extern SKMatrix sk_matrix_rotate_deg (Single deg); + #else + private partial class Delegates { + [UnmanagedFunctionPointer (CallingConvention.Cdecl)] + internal delegate SKMatrix sk_matrix_rotate_deg (Single deg); + } + private static Delegates.sk_matrix_rotate_deg sk_matrix_rotate_deg_delegate; + internal static SKMatrix sk_matrix_rotate_deg (Single deg) => + (sk_matrix_rotate_deg_delegate ??= GetSymbol ("sk_matrix_rotate_deg")).Invoke (deg); + #endif + + // sk_matrix_t sk_matrix_rotate_deg_point(float deg, sk_point_t t) + #if !USE_DELEGATES + [DllImport (SKIA, CallingConvention = CallingConvention.Cdecl)] + internal static extern SKMatrix sk_matrix_rotate_deg_point (Single deg, SKPoint t); + #else + private partial class Delegates { + [UnmanagedFunctionPointer (CallingConvention.Cdecl)] + internal delegate SKMatrix sk_matrix_rotate_deg_point (Single deg, SKPoint t); + } + private static Delegates.sk_matrix_rotate_deg_point sk_matrix_rotate_deg_point_delegate; + internal static SKMatrix sk_matrix_rotate_deg_point (Single deg, SKPoint t) => + (sk_matrix_rotate_deg_point_delegate ??= GetSymbol ("sk_matrix_rotate_deg_point")).Invoke (deg, t); + #endif + + // sk_matrix_t sk_matrix_rotate_rad(float rad) + #if !USE_DELEGATES + [DllImport (SKIA, CallingConvention = CallingConvention.Cdecl)] + internal static extern SKMatrix sk_matrix_rotate_rad (Single rad); + #else + private partial class Delegates { + [UnmanagedFunctionPointer (CallingConvention.Cdecl)] + internal delegate SKMatrix sk_matrix_rotate_rad (Single rad); + } + private static Delegates.sk_matrix_rotate_rad sk_matrix_rotate_rad_delegate; + internal static SKMatrix sk_matrix_rotate_rad (Single rad) => + (sk_matrix_rotate_rad_delegate ??= GetSymbol ("sk_matrix_rotate_rad")).Invoke (rad); + #endif + + // sk_matrix_t sk_matrix_scale(float sx, float sy) + #if !USE_DELEGATES + [DllImport (SKIA, CallingConvention = CallingConvention.Cdecl)] + internal static extern SKMatrix sk_matrix_scale (Single sx, Single sy); + #else + private partial class Delegates { + [UnmanagedFunctionPointer (CallingConvention.Cdecl)] + internal delegate SKMatrix sk_matrix_scale (Single sx, Single sy); + } + private static Delegates.sk_matrix_scale sk_matrix_scale_delegate; + internal static SKMatrix sk_matrix_scale (Single sx, Single sy) => + (sk_matrix_scale_delegate ??= GetSymbol ("sk_matrix_scale")).Invoke (sx, sy); + #endif + + // void sk_matrix_set_identity(sk_matrix_t* matrix, sk_matrix_t* result) + #if !USE_DELEGATES + [DllImport (SKIA, CallingConvention = CallingConvention.Cdecl)] + internal static extern void sk_matrix_set_identity (SKMatrix* matrix, SKMatrix* result); + #else + private partial class Delegates { + [UnmanagedFunctionPointer (CallingConvention.Cdecl)] + internal delegate void sk_matrix_set_identity (SKMatrix* matrix, SKMatrix* result); + } + private static Delegates.sk_matrix_set_identity sk_matrix_set_identity_delegate; + internal static void sk_matrix_set_identity (SKMatrix* matrix, SKMatrix* result) => + (sk_matrix_set_identity_delegate ??= GetSymbol ("sk_matrix_set_identity")).Invoke (matrix, result); + #endif + + // bool sk_matrix_set_rect_to_rect(sk_matrix_t* matrix, sk_matrix_t* result, sk_rect_t* dest, sk_rect_t* source, sk_matrix_scale_to_fit_t stf) + #if !USE_DELEGATES + [DllImport (SKIA, CallingConvention = CallingConvention.Cdecl)] + [return: MarshalAs (UnmanagedType.I1)] + internal static extern bool sk_matrix_set_rect_to_rect (SKMatrix* matrix, SKMatrix* result, SKRect* dest, SKRect* source, SKMatrixScaleToFit stf); + #else + private partial class Delegates { + [UnmanagedFunctionPointer (CallingConvention.Cdecl)] + [return: MarshalAs (UnmanagedType.I1)] + internal delegate bool sk_matrix_set_rect_to_rect (SKMatrix* matrix, SKMatrix* result, SKRect* dest, SKRect* source, SKMatrixScaleToFit stf); + } + private static Delegates.sk_matrix_set_rect_to_rect sk_matrix_set_rect_to_rect_delegate; + internal static bool sk_matrix_set_rect_to_rect (SKMatrix* matrix, SKMatrix* result, SKRect* dest, SKRect* source, SKMatrixScaleToFit stf) => + (sk_matrix_set_rect_to_rect_delegate ??= GetSymbol ("sk_matrix_set_rect_to_rect")).Invoke (matrix, result, dest, source, stf); + #endif + + // void sk_matrix_set9(sk_matrix_t* matrix, float* buffer, sk_matrix_t* result) + #if !USE_DELEGATES + [DllImport (SKIA, CallingConvention = CallingConvention.Cdecl)] + internal static extern void sk_matrix_set9 (SKMatrix* matrix, Single* buffer, SKMatrix* result); + #else + private partial class Delegates { + [UnmanagedFunctionPointer (CallingConvention.Cdecl)] + internal delegate void sk_matrix_set9 (SKMatrix* matrix, Single* buffer, SKMatrix* result); + } + private static Delegates.sk_matrix_set9 sk_matrix_set9_delegate; + internal static void sk_matrix_set9 (SKMatrix* matrix, Single* buffer, SKMatrix* result) => + (sk_matrix_set9_delegate ??= GetSymbol ("sk_matrix_set9")).Invoke (matrix, buffer, result); + #endif + + // sk_matrix_t sk_matrix_translate(float dx, float dy) + #if !USE_DELEGATES + [DllImport (SKIA, CallingConvention = CallingConvention.Cdecl)] + internal static extern SKMatrix sk_matrix_translate (Single dx, Single dy); + #else + private partial class Delegates { + [UnmanagedFunctionPointer (CallingConvention.Cdecl)] + internal delegate SKMatrix sk_matrix_translate (Single dx, Single dy); + } + private static Delegates.sk_matrix_translate sk_matrix_translate_delegate; + internal static SKMatrix sk_matrix_translate (Single dx, Single dy) => + (sk_matrix_translate_delegate ??= GetSymbol ("sk_matrix_translate")).Invoke (dx, dy); + #endif + + // sk_matrix_t sk_matrix_translate_ipoint(sk_ipoint_t t) + #if !USE_DELEGATES + [DllImport (SKIA, CallingConvention = CallingConvention.Cdecl)] + internal static extern SKMatrix sk_matrix_translate_ipoint (SKPointI t); + #else + private partial class Delegates { + [UnmanagedFunctionPointer (CallingConvention.Cdecl)] + internal delegate SKMatrix sk_matrix_translate_ipoint (SKPointI t); + } + private static Delegates.sk_matrix_translate_ipoint sk_matrix_translate_ipoint_delegate; + internal static SKMatrix sk_matrix_translate_ipoint (SKPointI t) => + (sk_matrix_translate_ipoint_delegate ??= GetSymbol ("sk_matrix_translate_ipoint")).Invoke (t); + #endif + + // sk_matrix_t sk_matrix_translate_point(sk_point_t t) + #if !USE_DELEGATES + [DllImport (SKIA, CallingConvention = CallingConvention.Cdecl)] + internal static extern SKMatrix sk_matrix_translate_point (SKPoint t); + #else + private partial class Delegates { + [UnmanagedFunctionPointer (CallingConvention.Cdecl)] + internal delegate SKMatrix sk_matrix_translate_point (SKPoint t); + } + private static Delegates.sk_matrix_translate_point sk_matrix_translate_point_delegate; + internal static SKMatrix sk_matrix_translate_point (SKPoint t) => + (sk_matrix_translate_point_delegate ??= GetSymbol ("sk_matrix_translate_point")).Invoke (t); + #endif + // bool sk_matrix_try_invert(sk_matrix_t* matrix, sk_matrix_t* result) #if !USE_DELEGATES [DllImport (SKIA, CallingConvention = CallingConvention.Cdecl)] @@ -16018,6 +16500,71 @@ public enum SKMaskFormat { Sdf = 5, } + // sk_matrix_affine_colomn_major_mask_t + public enum SKMatrixAffineColomnMajorMask { + // AScaleX = 0 + AScaleX = 0, + // ASkewY = 1 + ASkewY = 1, + // ASkewX = 2 + ASkewX = 2, + // AScaleY = 3 + AScaleY = 3, + // ATransX = 4 + ATransX = 4, + // ATransY = 5 + ATransY = 5, + } + + // sk_matrix_row_major_mask_t + public enum SKMatrixRowMajorMask { + // ScaleX = 0 + ScaleX = 0, + // SkewX = 1 + SkewX = 1, + // TransX = 2 + TransX = 2, + // SkewY = 3 + SkewY = 3, + // ScaleY = 4 + ScaleY = 4, + // TransY = 5 + TransY = 5, + // Persp0 = 6 + Persp0 = 6, + // Persp1 = 7 + Persp1 = 7, + // Persp2 = 8 + Persp2 = 8, + } + + // sk_matrix_scale_to_fit_t + public enum SKMatrixScaleToFit { + // Fill = 0 + Fill = 0, + // Start = 1 + Start = 1, + // Center = 2 + Center = 2, + // End = 3 + End = 3, + } + + // sk_matrix_type_mask_t + [Flags] + public enum SKMatrixTypeMask { + // IDENTITY_SK_MATRIX_TYPE_MASK = 0 + Identity = 0, + // TRANSLATE_SK_MATRIX_TYPE_MASK = 0x01 + Translate = 1, + // SCALE_SK_MATRIX_TYPE_MASK = 0x02 + Scale = 2, + // AFFINE_SK_MATRIX_TYPE_MASK = 0x04 + Affine = 4, + // PERSPECTIVE_SK_MATRIX_TYPE_MASK = 0x08 + Perspective = 8, + } + // sk_matrix44_type_mask_t [Flags] public enum SKMatrix44TypeMask { From 3d01e6e61e2ddc02d6c6c7b82d190aedce23cbc2 Mon Sep 17 00:00:00 2001 From: mgood7123 Date: Fri, 8 Jul 2022 13:08:23 +1000 Subject: [PATCH 3/3] add json changes --- binding/libSkiaSharp.json | 3 +++ 1 file changed, 3 insertions(+) diff --git a/binding/libSkiaSharp.json b/binding/libSkiaSharp.json index cf4cc50988..32d66c54d8 100644 --- a/binding/libSkiaSharp.json +++ b/binding/libSkiaSharp.json @@ -304,6 +304,9 @@ "sk_mask_t": { "properties": false }, + "sk_matrix_type_mask_t": { + "flags": true + }, "sk_matrix44_type_mask_t": { "flags": true },