Package rope.vector

Class vec3

All Implemented Interfaces:
R_Constants

public class vec3 extends vec
  • Constructor Details

    • vec3

      public vec3()
    • vec3

      public vec3(float v)
    • vec3

      public vec3(float x, float y, float z)
    • vec3

      public vec3(vec v)
    • vec3

      public vec3(ivec v)
    • vec3

      public vec3(float[] source)
    • vec3

      public vec3(int[] source)
  • Method Details

    • set

      public vec3 set(float x, float y, float z)
      set component main method
      Parameters:
      x -
      y -
      z -
      Returns:
    • set

      public vec3 set(float v)
    • set

      public vec3 set(vec v)
    • set

      public vec3 set(ivec v)
    • set

      public vec3 set(float[] source)
    • set

      public vec3 set(int[] source)
    • set_to

      public vec3 set_to(int index, float arg)
    • inv

      public vec3 inv()
      Returns:
      inverse all argument
    • x

      public vec3 x(float x)
    • add_x

      public vec3 add_x(float x)
    • sub_x

      public vec3 sub_x(float x)
    • mult_x

      public vec3 mult_x(float x)
    • div_x

      public vec3 div_x(float x)
    • y

      public vec3 y(float y)
    • add_y

      public vec3 add_y(float y)
    • sub_y

      public vec3 sub_y(float y)
    • mult_y

      public vec3 mult_y(float y)
    • div_y

      public vec3 div_y(float y)
    • z

      public vec3 z(float z)
    • add_z

      public vec3 add_z(float z)
    • sub_z

      public vec3 sub_z(float z)
    • mult_z

      public vec3 mult_z(float z)
    • div_z

      public vec3 div_z(float z)
    • red

      public vec3 red(float x)
    • gre

      public vec3 gre(float y)
    • blu

      public vec3 blu(float z)
    • hue

      public vec3 hue(float x)
    • sat

      public vec3 sat(float y)
    • bri

      public vec3 bri(float z)
    • s

      public vec3 s(float x)
    • t

      public vec3 t(float y)
    • p

      public vec3 p(float z)
    • mult

      public vec3 mult(float mx, float my, float mz)
      mult
      Parameters:
      mx -
      my -
      mz -
      Returns:
    • mult

      public vec3 mult(float m)
    • mult

      public vec3 mult(vec v)
    • mult

      public vec3 mult(ivec v)
    • div

      public vec3 div(float dx, float dy, float dz)
      div
      Parameters:
      dx -
      dy -
      dz -
      Returns:
    • div

      public vec3 div(float d)
    • div

      public vec3 div(vec v)
    • div

      public vec3 div(ivec v)
    • add

      public vec3 add(float ax, float ay, float az)
      add main method
      Parameters:
      ax -
      ay -
      az -
      Returns:
    • add

      public vec3 add(float a)
    • add

      public vec3 add(vec v)
    • add

      public vec3 add(ivec v)
    • sub

      public vec3 sub(float sx, float sy, float sz)
      sub main method
      Parameters:
      sx -
      sy -
      sz -
      Returns:
    • sub

      public vec3 sub(float s)
    • sub

      public vec3 sub(vec v)
    • sub

      public vec3 sub(ivec v)
    • dot

      public float dot(float x, float y, float z)
      Parameters:
      x -
      y -
      z -
      Returns:
      the doc product between the vec and the target
    • dot

      public float dot(vec3 v)
    • pow

      public vec3 pow(float pow)
      each component of the vec is power push
      Parameters:
      pow -
      Returns:
      vec3
    • pow

      public vec3 pow(float pow_x, float pow_y, float pow_z)
      each component of the vec is power push
      Parameters:
      pow_x -
      pow_y -
      pow_z -
      Returns:
    • cross

      public vec3 cross(vec3 v, vec3 target)
      Parameters:
      v -
      target -
      Returns:
      vec3
    • cross

      public vec3 cross(vec3 v)
      Parameters:
      v -
      Returns:
      vec3
    • cross

      public vec3 cross(float x, float y, float z)
      Parameters:
      x -
      y -
      z -
      Returns:
      vec3
    • normalize

      public vec3 normalize(vec3 target)
      Parameters:
      target -
      Returns:
    • normalize

      public vec3 normalize()
    • map

      public vec3 map(float minIn, float maxIn, float minOut, float maxOut)
    • map

      public vec3 map(vec3 minIn, vec3 maxIn, vec3 minOut, vec3 maxOut)
    • limit

      public vec3 limit(float max)
      limit
      Parameters:
      max -
      Returns:
    • constrain

      public vec3 constrain(float min, float max)
    • constrain

      public vec3 constrain(float max)
    • constrain

      public vec3 constrain(vec3 max)
    • constrain

      public vec3 constrain(vec3 min, vec3 max)
      Constrains a value to not exceed a maximum and minimum value.
      Parameters:
      min -
      max -
      Returns:
    • jitter

      public vec3 jitter(int range_x, int range_y, int range_z)
      jitter
      Parameters:
      range_x -
      range_y -
      range_z -
      Returns:
    • jitter

      public vec3 jitter(int range)
    • jitter

      public vec3 jitter(vec3 range)
    • rand

      public vec3 rand(float max)
      random
      Parameters:
      max - float
      Returns:
      random value from 0 to float max for each argument
    • rand

      public vec3 rand(float min, float max)
      random
      Parameters:
      min - float
      max - float
      Returns:
      random value from float min to float max for each argument
    • rand

      public vec3 rand(vec3 min, vec3 max)
      random
      Parameters:
      min -
      max -
      Returns:
      random value from vec min to vec max for each argument
    • wave

      public vec3 wave(int timeline, float s)
      Parameters:
      timeline -
      s -
      Returns:
      vec3 cosinus of each argument
    • wave

      public vec3 wave(int timeline, float sx, float sy, float sz)
      Parameters:
      timeline -
      sx -
      sy -
      sz -
      Returns:
      vec3 cosinus of each argument
    • cos_wave

      public vec3 cos_wave(int timeline, float s)
      WAVE COSINUS
      Parameters:
      timeline - int
      s - float speed for all vec arg
      Returns:
      vec3 cosinus of each argument
    • cos_wave

      public vec3 cos_wave(int timeline, float sx, float sy, float sz)
      Parameters:
      timeline -
      sx - float speed for all vec arg x
      sy - float speed for all vec arg y
      sz - float speed for all vec arg z
      Returns:
      vec3 cosinus of each argument
    • sin_wave

      public vec3 sin_wave(int timeline, float s)
      WAVE SINUS
      Parameters:
      timeline - int
      s - float speed for all vec arg
      Returns:
      vec3 sinus of the value
    • sin_wave

      public vec3 sin_wave(int timeline, float sx, float sy, float sz)
      Parameters:
      timeline -
      sx - float speed for all vec arg x
      sy - float speed for all vec arg y
      sz - float speed for all vec arg z
      Returns:
    • mod

      public vec3 mod(float mod_x, float mod_y, float mod_z)
      Parameters:
      mod_x -
      mod_y -
      mod_z -
      Returns:
      return the modulo of each element in the same order
    • mod

      public vec3 mod(float mod)
    • mod

      public vec3 mod(vec3 mod)
    • sum

      public float sum()
      sum of all components
      Returns:
      float
    • average

      public float average()
      average of all components
      Returns:
      float
    • dist

      public float dist(vec target)
      * return distance between vector
      Parameters:
      target -
      Returns:
    • dir

      public vec3 dir()
      return normal cartesian angle coord
      Returns:
      vec3
    • dir

      public vec3 dir(float a_x, float a_y, float a_z)
      return normal cartesian angle coord
      Parameters:
      a_x -
      a_y -
      a_z -
      Returns:
      vec3
    • dir

      public vec3 dir(vec3 origin)
      return normal cartesian angle coord
      Parameters:
      origin -
      Returns:
    • tan

      public vec3 tan(float float_to_make_plane_ref_x, float float_to_make_plane_ref_y, float float_to_make_plane_ref_z)
    • tan

      public vec3 tan(vec3 vector_to_make_plane_ref)
      Parameters:
      vector_to_make_plane_ref -
      Returns:
    • magSq

      public float magSq()
      Returns:
    • mag

      public float mag(vec3 v_target)
      Parameters:
      v_target -
      Returns:
    • mag

      public float mag()
    • equals

      public boolean equals(vec3 target)
      return true if the vector this is equals to vector target
      Parameters:
      target -
      Returns:
    • equals

      public boolean equals(float target)
      return true if the vector this is equals to float target
      Parameters:
      target -
      Returns:
    • equals

      public boolean equals(float t_x, float t_y, float t_z)
      return true if the vector this is equals to float arguments
      Parameters:
      t_x -
      t_y -
      t_z -
      Returns:
    • compare

      public boolean compare(vec3 target, vec3 area)
      return true if the vector this and vector target are in the same vector area
      Parameters:
      target -
      area -
      Returns:
    • copy

      public vec3 copy()
      Returns:
    • toString

      public String toString()
      Overrides:
      toString in class Object