Package ch.bailu.gtk.graphene

Class Vec4

java.lang.Object
ch.bailu.gtk.type.Type
ch.bailu.gtk.type.Pointer
ch.bailu.gtk.type.Record
ch.bailu.gtk.graphene.Vec4
All Implemented Interfaces:
PointerInterface
public class Vec4 extends Record
A structure capable of holding a vector with four dimensions: x, y, z, and w.

The contents of the #graphene_vec4_t structure are private and should
never be accessed directly.

https://ebassi.github.io/graphene/docs/

  • Field Summary

    Fields inherited from class ch.bailu.gtk.type.Pointer

    NULL

  • Constructor Summary

    Constructors
    Constructor
    Description
    Vec4(PointerContainer pointer)
     

  • Method Summary

    Modifier and Type
    Method
    Description
    void
    add(Vec4 b, Vec4 res)
    Adds each component of the two given vectors.
    static Vec4
    allocVec4()
    Allocates a new #graphene_vec4_t structure.
    void
    divide(Vec4 b, Vec4 res)
    Divides each component of the first operand @a by the corresponding
    component of the second operand @b, and places the results into the
    vector @res.
    float
    dot(Vec4 b)
    Computes the dot product of the two given vectors.
    boolean
    equal(Vec4 v2)
    Checks whether the two given #graphene_vec4_t are equal.
    void
    free()
    Frees the resources allocated by @v
    static ClassHandler
    getClassHandler()
     
    static int
    getInstanceSize()
     
    static long
    getParentTypeID()
     
    static TypeSystem.TypeSize
    getParentTypeSize()
     
    static long
    getTypeID()
     
    static TypeSystem.TypeSize
    getTypeSize()
     
    float
    getW()
    Retrieves the value of the fourth component of the given #graphene_vec4_t.
    float
    getX()
    Retrieves the value of the first component of the given #graphene_vec4_t.
    void
    getXy(Vec2 res)
    Creates a #graphene_vec2_t that contains the first two components
    of the given #graphene_vec4_t.
    void
    getXyz(Vec3 res)
    Creates a #graphene_vec3_t that contains the first three components
    of the given #graphene_vec4_t.
    float
    getY()
    Retrieves the value of the second component of the given #graphene_vec4_t.
    float
    getZ()
    Retrieves the value of the third component of the given #graphene_vec4_t.
    Vec4
    init(float x, float y, float z, float w)
    Initializes a #graphene_vec4_t using the given values.
    Vec4
    initFromVec2(Vec2 src, float z, float w)
    Initializes a #graphene_vec4_t using the components of a
    #graphene_vec2_t and the values of @z and @w.
    Vec4
    initFromVec3(Vec3 src, float w)
    Initializes a #graphene_vec4_t using the components of a
    #graphene_vec3_t and the value of @w.
    Vec4
    initFromVec4(Vec4 src)
    Initializes a #graphene_vec4_t using the components of
    another #graphene_vec4_t.
    void
    interpolate(Vec4 v2, double factor, Vec4 res)
    Linearly interpolates @v1 and @v2 using the given @factor.
    float
    length()
    Computes the length of the given #graphene_vec4_t.
    void
    max(Vec4 b, Vec4 res)
    Compares each component of the two given vectors and creates a
    vector that contains the maximum values.
    void
    min(Vec4 b, Vec4 res)
    Compares each component of the two given vectors and creates a
    vector that contains the minimum values.
    void
    multiply(Vec4 b, Vec4 res)
    Multiplies each component of the two given vectors.
    boolean
    near(Vec4 v2, float epsilon)
    Compares the two given #graphene_vec4_t vectors and checks
    whether their values are within the given @epsilon.
    void
    negate(Vec4 res)
    Negates the given #graphene_vec4_t.
    void
    normalize(Vec4 res)
    Normalizes the given #graphene_vec4_t.
    static Vec4
    one()
    Retrieves a pointer to a #graphene_vec4_t with all its
    components set to 1.
    void
    scale(float factor, Vec4 res)
    Multiplies all components of the given vector with the given scalar @factor.
    void
    subtract(Vec4 b, Vec4 res)
    Subtracts from each component of the first operand @a the
    corresponding component of the second operand @b and places
    each result into the components of @res.
    void
    toFloat(Flt dest)
    Stores the components of the given #graphene_vec4_t into an array
    of floating point values.
    static Vec4
    wAxis()
    Retrieves a pointer to a #graphene_vec4_t with its
    components set to (0, 0, 0, 1).
    static Vec4
    xAxis()
    Retrieves a pointer to a #graphene_vec4_t with its
    components set to (1, 0, 0, 0).
    static Vec4
    yAxis()
    Retrieves a pointer to a #graphene_vec4_t with its
    components set to (0, 1, 0, 0).
    static Vec4
    zAxis()
    Retrieves a pointer to a #graphene_vec4_t with its
    components set to (0, 0, 1, 0).
    static Vec4
    zero()
    Retrieves a pointer to a #graphene_vec4_t with all its
    components set to 0.

    Methods inherited from class ch.bailu.gtk.type.Record

    destroy

    Methods inherited from class ch.bailu.gtk.type.Pointer

    asCPointer, cast, connectSignal, disconnectSignals, disconnectSignals, equals, hashCode, throwIfNull, throwNullPointerException, toString, unregisterCallbacks, unregisterCallbacks

    Methods inherited from class ch.bailu.gtk.type.Type

    asCPointer, asCPointer, asCPointerNotNull, asJnaPointer, asJnaPointer, asPointer, asPointer, cast, cast, throwIfNull

    Methods inherited from class java.lang.Object

    clone, finalize, getClass, notify, notifyAll, wait, wait, wait

    Methods inherited from interface ch.bailu.gtk.type.PointerInterface

    asCPointerNotNull, asJnaPointer, asPointer, isNotNull, isNull

  • Constructor Details

  • Method Details

    • getClassHandler

      public static ClassHandler getClassHandler()

    • allocVec4

      public static Vec4 allocVec4()
      Allocates a new #graphene_vec4_t structure.

      The contents of the returned structure are undefined.

      Use graphene_vec4_init() to initialize the vector.
      Returns:
      the newly allocated #graphene_vec4_t structure. Use graphene_vec4_free() to free the resources allocated by this function.

    • add

      public void add(@Nonnull Vec4 b, @Nonnull Vec4 res)
      Adds each component of the two given vectors.
      Parameters:
      b - a #graphene_vec4_t
      res - return location for the resulting vector

    • divide

      public void divide(@Nonnull Vec4 b, @Nonnull Vec4 res)
      Divides each component of the first operand @a by the corresponding
      component of the second operand @b, and places the results into the
      vector @res.
      Parameters:
      b - a #graphene_vec4_t
      res - return location for the resulting vector

    • dot

      public float dot(@Nonnull Vec4 b)
      Computes the dot product of the two given vectors.
      Parameters:
      b - a #graphene_vec4_t
      Returns:
      the value of the dot product

    • equal

      public boolean equal(@Nonnull Vec4 v2)
      Checks whether the two given #graphene_vec4_t are equal.
      Parameters:
      v2 - a #graphene_vec4_t
      Returns:
      `true` if the two vectors are equal, and false otherwise

    • free

      public void free()
      Frees the resources allocated by @v

    • getW

      public float getW()
      Retrieves the value of the fourth component of the given #graphene_vec4_t.
      Returns:
      the value of the fourth component

    • getX

      public float getX()
      Retrieves the value of the first component of the given #graphene_vec4_t.
      Returns:
      the value of the first component

    • getXy

      public void getXy(@Nonnull Vec2 res)
      Creates a #graphene_vec2_t that contains the first two components
      of the given #graphene_vec4_t.
      Parameters:
      res - return location for a #graphene_vec2_t

    • getXyz

      public void getXyz(@Nonnull Vec3 res)
      Creates a #graphene_vec3_t that contains the first three components
      of the given #graphene_vec4_t.
      Parameters:
      res - return location for a graphene_vec3_t

    • getY

      public float getY()
      Retrieves the value of the second component of the given #graphene_vec4_t.
      Returns:
      the value of the second component

    • getZ

      public float getZ()
      Retrieves the value of the third component of the given #graphene_vec4_t.
      Returns:
      the value of the third component

    • init

      public Vec4 init(float x, float y, float z, float w)
      Initializes a #graphene_vec4_t using the given values.

      This function can be called multiple times.
      Parameters:
      x - the X field of the vector
      y - the Y field of the vector
      z - the Z field of the vector
      w - the W field of the vector
      Returns:
      a pointer to the initialized vector

    • initFromVec2

      public Vec4 initFromVec2(@Nonnull Vec2 src, float z, float w)
      Initializes a #graphene_vec4_t using the components of a
      #graphene_vec2_t and the values of @z and @w.
      Parameters:
      src - a #graphene_vec2_t
      z - the value for the third component of @v
      w - the value for the fourth component of @v
      Returns:
      the initialized vector

    • initFromVec3

      public Vec4 initFromVec3(@Nonnull Vec3 src, float w)
      Initializes a #graphene_vec4_t using the components of a
      #graphene_vec3_t and the value of @w.
      Parameters:
      src - a #graphene_vec3_t
      w - the value for the fourth component of @v
      Returns:
      the initialized vector

    • initFromVec4

      public Vec4 initFromVec4(@Nonnull Vec4 src)
      Initializes a #graphene_vec4_t using the components of
      another #graphene_vec4_t.
      Parameters:
      src - a #graphene_vec4_t
      Returns:
      the initialized vector

    • interpolate

      public void interpolate(@Nonnull Vec4 v2, double factor, @Nonnull Vec4 res)
      Linearly interpolates @v1 and @v2 using the given @factor.
      Parameters:
      v2 - a #graphene_vec4_t
      factor - the interpolation factor
      res - the interpolated vector

    • length

      public float length()
      Computes the length of the given #graphene_vec4_t.
      Returns:
      the length of the vector

    • max

      public void max(@Nonnull Vec4 b, @Nonnull Vec4 res)
      Compares each component of the two given vectors and creates a
      vector that contains the maximum values.
      Parameters:
      b - a #graphene_vec4_t
      res - return location for the result vector

    • min

      public void min(@Nonnull Vec4 b, @Nonnull Vec4 res)
      Compares each component of the two given vectors and creates a
      vector that contains the minimum values.
      Parameters:
      b - a #graphene_vec4_t
      res - return location for the result vector

    • multiply

      public void multiply(@Nonnull Vec4 b, @Nonnull Vec4 res)
      Multiplies each component of the two given vectors.
      Parameters:
      b - a #graphene_vec4_t
      res - return location for the resulting vector

    • near

      public boolean near(@Nonnull Vec4 v2, float epsilon)
      Compares the two given #graphene_vec4_t vectors and checks
      whether their values are within the given @epsilon.
      Parameters:
      v2 - a #graphene_vec4_t
      epsilon - the threshold between the two vectors
      Returns:
      `true` if the two vectors are near each other

    • negate

      public void negate(@Nonnull Vec4 res)
      Negates the given #graphene_vec4_t.
      Parameters:
      res - return location for the result vector

    • normalize

      public void normalize(@Nonnull Vec4 res)
      Normalizes the given #graphene_vec4_t.
      Parameters:
      res - return location for the normalized vector

    • scale

      public void scale(float factor, @Nonnull Vec4 res)
      Multiplies all components of the given vector with the given scalar @factor.
      Parameters:
      factor - the scalar factor
      res - return location for the result vector

    • subtract

      public void subtract(@Nonnull Vec4 b, @Nonnull Vec4 res)
      Subtracts from each component of the first operand @a the
      corresponding component of the second operand @b and places
      each result into the components of @res.
      Parameters:
      b - a #graphene_vec4_t
      res - return location for the resulting vector

    • toFloat

      public void toFloat(@Nonnull Flt dest)
      Stores the components of the given #graphene_vec4_t into an array
      of floating point values.
      Parameters:
      dest - return location for an array of floating point values

    • one

      public static Vec4 one()
      Retrieves a pointer to a #graphene_vec4_t with all its
      components set to 1.
      Returns:
      a constant vector

    • wAxis

      public static Vec4 wAxis()
      Retrieves a pointer to a #graphene_vec4_t with its
      components set to (0, 0, 0, 1).
      Returns:
      a constant vector

    • xAxis

      public static Vec4 xAxis()
      Retrieves a pointer to a #graphene_vec4_t with its
      components set to (1, 0, 0, 0).
      Returns:
      a constant vector

    • yAxis

      public static Vec4 yAxis()
      Retrieves a pointer to a #graphene_vec4_t with its
      components set to (0, 1, 0, 0).
      Returns:
      a constant vector

    • zAxis

      public static Vec4 zAxis()
      Retrieves a pointer to a #graphene_vec4_t with its
      components set to (0, 0, 1, 0).
      Returns:
      a constant vector

    • zero

      public static Vec4 zero()
      Retrieves a pointer to a #graphene_vec4_t with all its
      components set to 0.
      Returns:
      a constant vector

    • 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()