Package ch.bailu.gtk.gsk

Klasse Transform

java.lang.Object
ch.bailu.gtk.type.Type
ch.bailu.gtk.type.Pointer
ch.bailu.gtk.type.Record
ch.bailu.gtk.gsk.Transform
Alle implementierten Schnittstellen:
PointerInterface
public class Transform extends Record
Describes a 3D transform.

Unlike `graphene_matrix_t`, `GskTransform` retains the steps in how
a transform was constructed, and allows inspecting them. It is modeled
after the way CSS describes transforms.

`GskTransform` objects are immutable and cannot be changed after creation.
This means code can safely expose them as properties of objects without
having to worry about others changing them.

https://docs.gtk.org/gsk4/struct.Transform.html

  • Konstruktordetails

    • Transform

      public Transform(PointerContainer pointer)

    • Transform

      public Transform()
      Creates a new identity transform.

      This function is meant to be used by language
      bindings. For C code, this is equivalent to using `NULL`.

  • Methodendetails

    • getClassHandler

      public static ClassHandler getClassHandler()

    • equal

      public boolean equal(@Nullable Transform second)
      Checks two transforms for equality.
      Parameter:
      second - the second transform
      Gibt zurück:
      true if the two transforms perform the same operation

    • getCategory

      public int getCategory()
      Returns the category this transform belongs to.
      Gibt zurück:
      The category of the transform

    • invert

      public Transform invert()
      Inverts the given transform.

      If @self is not invertible, `NULL` is returned.
      Note that inverting `NULL` also returns `NULL`, which is
      the correct inverse of `NULL`. If you need to differentiate
      between those cases, you should check @self is not `NULL`
      before calling this function.

      This function consumes @self. Use [method@Gsk.Transform.ref] first
      if you want to keep it around.
      Gibt zurück:
      The inverted transform

    • matrix

      public Transform matrix(@Nonnull Matrix matrix)
      Multiplies @next with the given @matrix.

      This function consumes @next. Use [method@Gsk.Transform.ref] first
      if you want to keep it around.
      Parameter:
      matrix - the matrix to multiply @next with
      Gibt zurück:
      The new transform

    • perspective

      public Transform perspective(float depth)
      Applies a perspective projection transform.

      This transform scales points in X and Y based on their Z value,
      scaling points with positive Z values away from the origin, and
      those with negative Z values towards the origin. Points
      on the z=0 plane are unchanged.

      This function consumes @next. Use [method@Gsk.Transform.ref] first
      if you want to keep it around.
      Parameter:
      depth - distance of the z=0 plane. Lower values give a more flattened pyramid and therefore a more pronounced perspective effect.
      Gibt zurück:
      The new transform

    • print

      public void print(@Nonnull GString string)
      Converts the transform into a human-readable representation.

      The result of this function can later be parsed with
      [func@Gsk.Transform.parse].
      Parameter:
      string - The string to print into

    • ref

      public Transform ref()
      Acquires a reference on the given transform.
      Gibt zurück:
      the transform with an additional reference

    • rotate

      public Transform rotate(float angle)
      Rotates @next by an angle around the Z axis.

      The rotation happens around the origin point of (0, 0).

      This function consumes @next. Use [method@Gsk.Transform.ref] first
      if you want to keep it around.
      Parameter:
      angle - the rotation angle, in degrees (clockwise)
      Gibt zurück:
      The new transform

    • rotate3d

      public Transform rotate3d(float angle, @Nonnull Vec3 axis)
      Rotates @next @angle degrees around @axis.

      For a rotation in 2D space, use [method@Gsk.Transform.rotate]

      This function consumes @next. Use [method@Gsk.Transform.ref] first
      if you want to keep it around.
      Parameter:
      angle - the rotation angle, in degrees (clockwise)
      axis - The rotation axis
      Gibt zurück:
      The new transform

    • scale

      public Transform scale(float factor_x, float factor_y)
      Scales @next in 2-dimensional space by the given factors.

      Use [method@Gsk.Transform.scale_3d] to scale in all 3 dimensions.

      This function consumes @next. Use [method@Gsk.Transform.ref] first
      if you want to keep it around.
      Parameter:
      factor_x - scaling factor on the X axis
      factor_y - scaling factor on the Y axis
      Gibt zurück:
      The new transform

    • scale3d

      public Transform scale3d(float factor_x, float factor_y, float factor_z)
      Scales @next by the given factors.

      This function consumes @next. Use [method@Gsk.Transform.ref] first
      if you want to keep it around.
      Parameter:
      factor_x - scaling factor on the X axis
      factor_y - scaling factor on the Y axis
      factor_z - scaling factor on the Z axis
      Gibt zurück:
      The new transform

    • skew

      public Transform skew(float skew_x, float skew_y)
      Applies a skew transform.

      This function consumes @next. Use [method@Gsk.Transform.ref] first
      if you want to keep it around.
      Parameter:
      skew_x - skew factor, in degrees, on the X axis
      skew_y - skew factor, in degrees, on the Y axis
      Gibt zurück:
      The new transform

    • to2d

      public void to2d(@Nonnull Flt out_xx, @Nonnull Flt out_yx, @Nonnull Flt out_xy, @Nonnull Flt out_yy, @Nonnull Flt out_dx, @Nonnull Flt out_dy)
      Converts a transform to a 2D transformation matrix.

      @self must be a 2D transformation. If you are not
      sure, use

      gsk_transform_get_category() >= GSK_TRANSFORM_CATEGORY_2D

      to check.

      The returned values are a subset of the full 4x4 matrix that
      is computed by [method@Gsk.Transform.to_matrix] and have the
      following layout:

      ```
      | xx yx | | a b 0 |
      | xy yy | = | c d 0 |
      | dx dy | | tx ty 1 |
      ```

      This function can be used to convert between a `GskTransform`
      and a matrix type from other 2D drawing libraries, in particular
      Cairo.
      Parameter:
      out_xx - return location for the xx member
      out_yx - return location for the yx member
      out_xy - return location for the xy member
      out_yy - return location for the yy member
      out_dx - return location for the x0 member
      out_dy - return location for the y0 member

    • to2dComponents

      public void to2dComponents(@Nonnull Flt out_skew_x, @Nonnull Flt out_skew_y, @Nonnull Flt out_scale_x, @Nonnull Flt out_scale_y, @Nonnull Flt out_angle, @Nonnull Flt out_dx, @Nonnull Flt out_dy)
      Converts a transform to 2D transformation factors.

      To recreate an equivalent transform from the factors returned
      by this function, use

      gsk_transform_skew (
      gsk_transform_scale (
      gsk_transform_rotate (
      gsk_transform_translate (NULL, &GRAPHENE_POINT_T (dx, dy)),
      angle),
      scale_x, scale_y),
      skew_x, skew_y)

      @self must be a 2D transformation. If you are not sure, use

      gsk_transform_get_category() >= GSK_TRANSFORM_CATEGORY_2D

      to check.
      Parameter:
      out_skew_x - return location for the skew factor in the x direction
      out_skew_y - return location for the skew factor in the y direction
      out_scale_x - return location for the scale factor in the x direction
      out_scale_y - return location for the scale factor in the y direction
      out_angle - return location for the rotation angle
      out_dx - return location for the translation in the x direction
      out_dy - return location for the translation in the y direction

    • toAffine

      public void toAffine(@Nonnull Flt out_scale_x, @Nonnull Flt out_scale_y, @Nonnull Flt out_dx, @Nonnull Flt out_dy)
      Converts a transform to 2D affine transformation factors.

      To recreate an equivalent transform from the factors returned
      by this function, use

      gsk_transform_scale (
      gsk_transform_translate (
      NULL,
      &GRAPHENE_POINT_T (dx, dy)),
      sx, sy)

      @self must be a 2D affine transformation. If you are not
      sure, use

      gsk_transform_get_category() >= GSK_TRANSFORM_CATEGORY_2D_AFFINE

      to check.
      Parameter:
      out_scale_x - return location for the scale factor in the x direction
      out_scale_y - return location for the scale factor in the y direction
      out_dx - return location for the translation in the x direction
      out_dy - return location for the translation in the y direction

    • toMatrix

      public void toMatrix(@Nonnull Matrix out_matrix)
      Computes the 4x4 matrix for the transform.

      The previous value of @out_matrix will be ignored.
      Parameter:
      out_matrix - return location for the matrix

    • toStr

      public Str toStr()
      Converts the transform into a human-readable string.

      The resulting string can be parsed with [func@Gsk.Transform.parse].

      This is a wrapper around [method@Gsk.Transform.print].
      Gibt zurück:
      A new string for @self

    • toTranslate

      public void toTranslate(@Nonnull Flt out_dx, @Nonnull Flt out_dy)
      Converts a transform to a translation operation.

      @self must be a 2D transformation. If you are not
      sure, use

      gsk_transform_get_category() >= GSK_TRANSFORM_CATEGORY_2D_TRANSLATE

      to check.
      Parameter:
      out_dx - return location for the translation in the x direction
      out_dy - return location for the translation in the y direction

    • transform

      public Transform transform(@Nullable Transform other)
      Applies all the operations from @other to @next.

      This function consumes @next. Use [method@Gsk.Transform.ref] first
      if you want to keep it around.
      Parameter:
      other - transform to apply
      Gibt zurück:
      The new transform

    • transformBounds

      public void transformBounds(@Nonnull Rect rect, @Nonnull Rect out_rect)
      Transforms a rectangle using the given transform.

      The result is the bounding box containing the coplanar quad.
      Parameter:
      rect - the rectangle to transform
      out_rect - return location for the bounds of the transformed rectangle

    • transformPoint

      public void transformPoint(@Nonnull Point point, @Nonnull Point out_point)
      Transforms a point using the given transform.
      Parameter:
      point - the point to transform
      out_point - return location for the transformed point

    • translate

      public Transform translate(@Nonnull Point point)
      Translates @next in 2-dimensional space by @point.

      This function consumes @next. Use [method@Gsk.Transform.ref] first
      if you want to keep it around.
      Parameter:
      point - the point to translate the transform by
      Gibt zurück:
      The new transform

    • translate3d

      public Transform translate3d(@Nonnull Point3D point)
      Translates @next by @point.

      This function consumes @next. Use [method@Gsk.Transform.ref] first
      if you want to keep it around.
      Parameter:
      point - the point to translate the transform by
      Gibt zurück:
      The new transform

    • unref

      public void unref()
      Releases a reference on the given transform.

      If the reference was the last, the resources associated to the @self are
      freed.

    • getTypeID

      public static long getTypeID()

    • getParentTypeID

      public static long getParentTypeID()

    • getTypeSize

      public static TypeSystem.TypeSize getTypeSize()

    • getParentTypeSize

      public static TypeSystem.TypeSize getParentTypeSize()

    • getInstanceSize

      public static int getInstanceSize()