de.lessvoid.math.Vec2 Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of coregl-utils Show documentation
simple utility methods to make life with OpenGL core profile simpler
The newest version!
/*
 * Copyright (c) 2002-2008 LWJGL Project
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 * * Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 *
 * * Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 *
 * * Neither the name of 'LWJGL' nor the names of
 *   its contributors may be used to endorse or promote products derived
 *   from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
package de.lessvoid.math;

import java.io.Serializable;
import java.nio.FloatBuffer;

/**
 *
 * Holds a 2-tuple vector.
 *
 * @author cix_foo 
 * @author void256 - removed the interfaces this class implements and remove the
 *         base class to make that a simple and plain self-contained class
 */

public class Vec2 implements Serializable {

  private static final long serialVersionUID = 1L;

  public float x, y;

  /**
   * Constructor for Vec2.
   */
  public Vec2() {
    x = 0.f;
    y = 0.f;
  }

  /**
   * Constructor
   */
  public Vec2(final Vec2 src) {
    set(src);
  }

  /**
   * Constructor
   */
  public Vec2(final float x, final float y) {
    set(x, y);
  }

  /*
   * (non-Javadoc)
   * 
   * @see org.lwjgl.util.vector.WritableVector2f#set(float, float)
   */
  public void set(final float x, final float y) {
    this.x = x;
    this.y = y;
  }

  /**
   * Load from another Vector4f
   * 
   * @param src
   *          The source vector
   * @return this
   */
  public Vec2 set(final Vec2 src) {
    x = src.getX();
    y = src.getY();
    return this;
  }

  /**
   * @return the length squared of the vector
   */
  public float lengthSquared() {
    return x * x + y * y;
  }

  public float length() {
    return (float) Math.sqrt(lengthSquared());
  }

  /**
   * Translate a vector
   * 
   * @param x
   *          The translation in x
   * @param y
   *          the translation in y
   * @return this
   */
  public Vec2 translate(final float x, final float y) {
    this.x += x;
    this.y += y;
    return this;
  }

  /**
   * Add a vector to another vector and place the result in a destination
   * vector.
   * 
   * @param left
   *          The LHS vector
   * @param right
   *          The RHS vector
   * @param dest
   *          The destination vector, or null if a new vector is to be created
   * @return the sum of left and right in dest
   */
  public static Vec2 add(final Vec2 left, final Vec2 right, final Vec2 dest) {
    if (dest == null) return new Vec2(left.x + right.x, left.y + right.y);
    else {
      dest.set(left.x + right.x, left.y + right.y);
      return dest;
    }
  }

  /**
   * Subtract a vector from another vector and place the result in a destination
   * vector.
   * 
   * @param left
   *          The LHS vector
   * @param right
   *          The RHS vector
   * @param dest
   *          The destination vector, or null if a new vector is to be created
   * @return left minus right in dest
   */
  public static Vec2 sub(final Vec2 left, final Vec2 right, final Vec2 dest) {
    if (dest == null) return new Vec2(left.x - right.x, left.y - right.y);
    else {
      dest.set(left.x - right.x, left.y - right.y);
      return dest;
    }
  }

  /**
   * Negate a vector
   * 
   * @return this
   */
  public Vec2 negate() {
    x = -x;
    y = -y;
    return this;
  }

  /**
   * Normalise this vector and place the result in another vector.
   * 
   * @param dest
   *          The destination vector, or null if a new vector is to be created
   * @return the normalised vector
   */
  public Vec2 normalise(Vec2 dest) {
    final float l = length();

    if (dest == null) dest = new Vec2(x / l, y / l);
    else dest.set(x / l, y / l);

    return dest;
  }

  /**
   * The dot product of two vectors is calculated as v1.x * v2.x + v1.y * v2.y
   * 
   * @param left
   *          The LHS vector
   * @param right
   *          The RHS vector
   * @return left dot right
   */
  public static float dot(final Vec2 left, final Vec2 right) {
    return left.x * right.x + left.y * right.y;
  }

  /**
   * Calculate the angle between two vectors, in radians
   * 
   * @param a
   *          A vector
   * @param b
   *          The other vector
   * @return the angle between the two vectors, in radians
   */
  public static float angle(final Vec2 a, final Vec2 b) {
    float dls = dot(a, b) / (a.length() * b.length());
    if (dls < -1f) dls = -1f;
    else if (dls > 1.0f) dls = 1.0f;
    return (float) Math.acos(dls);
  }

  /*
   * (non-Javadoc)
   * 
   * @see org.lwjgl.vector.Vector#load(FloatBuffer)
   */
  public Vec2 load(final FloatBuffer buf) {
    x = buf.get();
    y = buf.get();
    return this;
  }

  /*
   * (non-Javadoc)
   * 
   * @see org.lwjgl.vector.Vector#scale(float)
   */
  public Vec2 scale(final float scale) {
    x *= scale;
    y *= scale;
    return this;
  }

  /*
   * (non-Javadoc)
   * 
   * @see org.lwjgl.vector.Vector#store(FloatBuffer)
   */
  public Vec2 store(final FloatBuffer buf) {
    buf.put(x);
    buf.put(y);
    return this;
  }

  @Override
  public String toString() {
    return "Vec2: " + x + " " + y;
  }

  /**
   * @return x
   */
  public final float getX() {
    return x;
  }

  /**
   * @return y
   */
  public final float getY() {
    return y;
  }

  /**
   * Set X
   * 
   * @param x
   */
  public final void setX(final float x) {
    this.x = x;
  }

  /**
   * Set Y
   * 
   * @param y
   */
  public final void setY(final float y) {
    this.y = y;
  }

}