Package ch.bailu.gtk.graphene

Class Vec3

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

The contents of the #graphene_vec3_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
    Vec3(PointerContainer pointer)
     

  • Method Summary

    Modifier and Type
    Method
    Description
    void
    add(Vec3 b, Vec3 res)
    Adds each component of the two given vectors.
    static Vec3
    allocVec3()
    Allocates a new #graphene_vec3_t structure.
    void
    cross(Vec3 b, Vec3 res)
    Computes the cross product of the two given vectors.
    void
    divide(Vec3 b, Vec3 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(Vec3 b)
    Computes the dot product of the two given vectors.
    boolean
    equal(Vec3 v2)
    Checks whether the two given #graphene_vec3_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
    getX()
    Retrieves the first component of the given vector @v.
    void
    getXy(Vec2 res)
    Creates a #graphene_vec2_t that contains the first and second
    components of the given #graphene_vec3_t.
    void
    getXy0(Vec3 res)
    Creates a #graphene_vec3_t that contains the first two components of
    the given #graphene_vec3_t, and the third component set to 0.
    void
    getXyz0(Vec4 res)
    Converts a #graphene_vec3_t in a #graphene_vec4_t using 0.0
    as the value for the fourth component of the resulting vector.
    void
    getXyz1(Vec4 res)
    Converts a #graphene_vec3_t in a #graphene_vec4_t using 1.0
    as the value for the fourth component of the resulting vector.
    void
    getXyzw(float w, Vec4 res)
    Converts a #graphene_vec3_t in a #graphene_vec4_t using @w as
    the value of the fourth component of the resulting vector.
    float
    getY()
    Retrieves the second component of the given vector @v.
    float
    getZ()
    Retrieves the third component of the given vector @v.
    Vec3
    init(float x, float y, float z)
    Initializes a #graphene_vec3_t using the given values.
    Vec3
    initFromVec3(Vec3 src)
    Initializes a #graphene_vec3_t with the values of another
    #graphene_vec3_t.
    void
    interpolate(Vec3 v2, double factor, Vec3 res)
    Linearly interpolates @v1 and @v2 using the given @factor.
    float
    length()
    Retrieves the length of the given vector @v.
    void
    max(Vec3 b, Vec3 res)
    Compares each component of the two given vectors and creates a
    vector that contains the maximum values.
    void
    min(Vec3 b, Vec3 res)
    Compares each component of the two given vectors and creates a
    vector that contains the minimum values.
    void
    multiply(Vec3 b, Vec3 res)
    Multiplies each component of the two given vectors.
    boolean
    near(Vec3 v2, float epsilon)
    Compares the two given #graphene_vec3_t vectors and checks
    whether their values are within the given @epsilon.
    void
    negate(Vec3 res)
    Negates the given #graphene_vec3_t.
    void
    normalize(Vec3 res)
    Normalizes the given #graphene_vec3_t.
    static Vec3
    one()
    Provides a constant pointer to a vector with three components,
    all sets to 1.
    void
    scale(float factor, Vec3 res)
    Multiplies all components of the given vector with the given scalar @factor.
    void
    subtract(Vec3 b, Vec3 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)
    Copies the components of a #graphene_vec3_t into the given array.
    static Vec3
    xAxis()
    Provides a constant pointer to a vector with three components
    with values set to (1, 0, 0).
    static Vec3
    yAxis()
    Provides a constant pointer to a vector with three components
    with values set to (0, 1, 0).
    static Vec3
    zAxis()
    Provides a constant pointer to a vector with three components
    with values set to (0, 0, 1).
    static Vec3
    zero()
    Provides a constant pointer to a vector with three components,
    all sets 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()

    • allocVec3

      public static Vec3 allocVec3()
      Allocates a new #graphene_vec3_t structure.

      The contents of the returned structure are undefined.

      Use graphene_vec3_init() to initialize the vector.
      Returns:
      the newly allocated #graphene_vec3_t structure. Use graphene_vec3_free() to free the resources allocated by this function.

    • add

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

    • cross

      public void cross(@Nonnull Vec3 b, @Nonnull Vec3 res)
      Computes the cross product of the two given vectors.
      Parameters:
      b - a #graphene_vec3_t
      res - return location for the resulting vector

    • divide

      public void divide(@Nonnull Vec3 b, @Nonnull Vec3 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_vec3_t
      res - return location for the resulting vector

    • dot

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

    • equal

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

    • free

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

    • getX

      public float getX()
      Retrieves the first component of the given vector @v.
      Returns:
      the value of the first component of the vector

    • getXy

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

    • getXy0

      public void getXy0(@Nonnull Vec3 res)
      Creates a #graphene_vec3_t that contains the first two components of
      the given #graphene_vec3_t, and the third component set to 0.
      Parameters:
      res - return location for a #graphene_vec3_t

    • getXyz0

      public void getXyz0(@Nonnull Vec4 res)
      Converts a #graphene_vec3_t in a #graphene_vec4_t using 0.0
      as the value for the fourth component of the resulting vector.
      Parameters:
      res - return location for the vector

    • getXyz1

      public void getXyz1(@Nonnull Vec4 res)
      Converts a #graphene_vec3_t in a #graphene_vec4_t using 1.0
      as the value for the fourth component of the resulting vector.
      Parameters:
      res - return location for the vector

    • getXyzw

      public void getXyzw(float w, @Nonnull Vec4 res)
      Converts a #graphene_vec3_t in a #graphene_vec4_t using @w as
      the value of the fourth component of the resulting vector.
      Parameters:
      w - the value of the W component
      res - return location for the vector

    • getY

      public float getY()
      Retrieves the second component of the given vector @v.
      Returns:
      the value of the second component of the vector

    • getZ

      public float getZ()
      Retrieves the third component of the given vector @v.
      Returns:
      the value of the third component of the vector

    • init

      public Vec3 init(float x, float y, float z)
      Initializes a #graphene_vec3_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
      Returns:
      a pointer to the initialized vector

    • initFromVec3

      public Vec3 initFromVec3(@Nonnull Vec3 src)
      Initializes a #graphene_vec3_t with the values of another
      #graphene_vec3_t.
      Parameters:
      src - a #graphene_vec3_t
      Returns:
      the initialized vector

    • interpolate

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

    • length

      public float length()
      Retrieves the length of the given vector @v.
      Returns:
      the value of the length of the vector

    • max

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

    • min

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

    • multiply

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

    • near

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

    • negate

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

    • normalize

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

    • scale

      public void scale(float factor, @Nonnull Vec3 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 Vec3 b, @Nonnull Vec3 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_vec3_t
      res - return location for the resulting vector

    • toFloat

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

    • one

      public static Vec3 one()
      Provides a constant pointer to a vector with three components,
      all sets to 1.
      Returns:
      a constant vector

    • xAxis

      public static Vec3 xAxis()
      Provides a constant pointer to a vector with three components
      with values set to (1, 0, 0).
      Returns:
      a constant vector

    • yAxis

      public static Vec3 yAxis()
      Provides a constant pointer to a vector with three components
      with values set to (0, 1, 0).
      Returns:
      a constant vector

    • zAxis

      public static Vec3 zAxis()
      Provides a constant pointer to a vector with three components
      with values set to (0, 0, 1).
      Returns:
      a constant vector

    • zero

      public static Vec3 zero()
      Provides a constant pointer to a vector with three components,
      all sets 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()