Exemple #1
0
  /**
   * Returns a random unit Quaternion.
   *
   * <p>You can create a randomly directed unit vector using:
   *
   * <p>{@code PVector randomDir = new PVector(1.0f, 0.0f, 0.0f);} <br>
   * {@code randomDir = Quaternion.multiply(Quaternion.randomQuaternion(), randomDir);}
   */
  public static final Quaternion randomQuaternion() {
    float seed = (float) Math.random();
    float r1 = PApplet.sqrt(1.0f - seed);
    float r2 = PApplet.sqrt(seed);
    float t1 = 2.0f * PI * (float) Math.random();
    float t2 = 2.0f * PI * (float) Math.random();

    return new Quaternion(
        PApplet.sin(t1) * r1, PApplet.cos(t1) * r1, PApplet.sin(t2) * r2, PApplet.cos(t2) * r2);
  }
  public void computeMidPoint() {
    PVector p1 = points.get(0);
    PVector p2 = points.get(points.size() - 1);

    int steps = (int) (25 * .5f * t);
    int i = (int) (steps * .5f);
    float s = (float) i / steps;
    float x = PApplet.lerp(p1.x, p2.x, s);
    float y =
        (is3D)
            ? PApplet.lerp(p1.y, p2.y, s)
            : PApplet.lerp(p1.y, p2.y, s) - h * PApplet.sin(s * PApplet.PI);
    float z = (is3D) ? h * PApplet.sin(s * PApplet.PI) : 0;

    midPoint = new PVector(x, y, z);
  }
 // A function to rotate a vector
 public void rotateVector(PVector v, float theta) {
   float m = v.mag();
   float a = v.heading2D();
   a += theta;
   v.x = m * PApplet.cos(a);
   v.y = m * PApplet.sin(a);
 }
  /**
   * Convenience method to calculate <code>res</code> vertices along a circle of <code>R</code>
   * radius
   *
   * @param R Radius of circle
   * @param res Number of points to calculate
   * @return
   */
  public static UVertexList getCircle(float R, int res) {
    UVertexList vl = new UVertexList();
    float D = TWO_PI / (float) (res - 1);
    for (int i = 0; i < res; i++)
      vl.add(PApplet.cos(D * (float) i) * R, PApplet.sin(D * (float) i) * R, 0);

    return vl;
  }
Exemple #5
0
  /**
   * Returns the exponential of the Quaternion.
   *
   * @see #log()
   */
  public final Quaternion exp() {
    float theta = PApplet.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);

    if (theta < 1E-6f) return new Quaternion(this.x, this.y, this.z, PApplet.cos(theta));
    else {
      float coef = PApplet.sin(theta) / theta;
      return new Quaternion(this.x * coef, this.y * coef, this.z * coef, PApplet.cos(theta));
    }
  }
Exemple #6
0
 void randomWalk(Mimo m) {
   Simulation1.app.noiseSeed(Simulation1.app.millis());
   float speed = Simulation1.app.noise(Simulation1.app.frameCount * 0.1f) * maxSpeed;
   if (Simulation1.app.random(1) < 0.99) {
     return;
   }
   float a =
       PApplet.map(
           Simulation1.app.random(1), 0, 1, directionChangeRange.x, directionChangeRange.y);
   m.vel = new PVector(PApplet.cos(a), PApplet.sin(a));
   m.vel.mult(speed);
 }
  private void calculateCoordinates() {

    float x = 0;
    float y = 0;
    float z = 0;

    coordinates = new PVector[latDetail + 1][longDetail + 1];

    for (int a = 0 + (int) (latDetail * bottomCrop); a <= latDetail - (latDetail * topCrop); a++) {

      for (int b = 0 + (int) (longDetail * leftCrop);
          b <= longDetail - (longDetail * rightCrop);
          b++) {

        System.out.println("A:" + a + " " + "B:" + b);

        x =
            radius
                * PApplet.cos((PConstants.TWO_PI / longDetail) * b)
                * PApplet.sin((PConstants.PI / latDetail) * a);

        y =
            radius
                * PApplet.sin((PConstants.TWO_PI / longDetail) * b)
                * PApplet.sin((PConstants.PI / latDetail) * a);

        z = radius * PApplet.cos((PConstants.PI / latDetail) * a);

        // guardo las coordenadas
        // de sur a norte
        // y de este a oeste.

        //

        coordinates[a][b] = new PVector(x, y, z);
      }
    }
  }
Exemple #8
0
  /**
   * Returns the slerp interpolation of quaternions {@code a} and {@code b}, at time {@code t}.
   *
   * <p>{@code t} should range in {@code [0,1]}. Result is a when {@code t=0 } and {@code b} when
   * {@code t=1}.
   *
   * <p>When {@code allowFlip} is true (default) the slerp interpolation will always use the
   * "shortest path" between the quaternions' orientations, by "flipping" the source Quaternion if
   * needed (see {@link #negate()}).
   *
   * @param a the first Quaternion
   * @param b the second Quaternion
   * @param t the t interpolation parameter
   * @param allowFlip tells whether or not the interpolation allows axis flip
   */
  public static final Quaternion slerp(Quaternion a, Quaternion b, float t, boolean allowFlip) {
    // Warning: this method should not normalize the Quaternion
    float cosAngle = Quaternion.dotProduct(a, b);

    float c1, c2;
    // Linear interpolation for close orientations
    if ((1.0 - PApplet.abs(cosAngle)) < 0.01) {
      c1 = 1.0f - t;
      c2 = t;
    } else {
      // Spherical interpolation
      float angle = PApplet.acos(PApplet.abs(cosAngle));
      float sinAngle = PApplet.sin(angle);
      c1 = PApplet.sin(angle * (1.0f - t)) / sinAngle;
      c2 = PApplet.sin(angle * t) / sinAngle;
    }

    // Use the shortest path
    if (allowFlip && (cosAngle < 0.0)) c1 = -c1;

    return new Quaternion(
        c1 * a.x + c2 * b.x, c1 * a.y + c2 * b.y, c1 * a.z + c2 * b.z, c1 * a.w + c2 * b.w, false);
  }
Exemple #9
0
  // Project each corner of the object onto the "ground"
  void project(PVector[] _points) {

    for (int p = 0; p < _points.length; p++) {

      // Find the angle of the corner being project relative to the sun
      PVector projection = _points[p].get();
      projection.sub(Stage.source);
      float angle = projection.heading2D();

      // Calculate the distance of projection
      // Based on height of the point from the "ground" as defined by the
      // alt
      float _alt = PApplet.abs(_points[p].y - Stage.alt);
      float yOffset = _alt * PApplet.sin(angle);
      float radius = yOffset / PApplet.sin(angle);

      shadow[p] = _points[p].get();
      shadow[p].add(new PVector(radius * PApplet.cos(angle), radius * PApplet.sin(angle)));

      // println("Source: " + source + "\t" + "Point: " + p + "\t" +
      // "Angle: " + degrees(angle) + "\t" + "Offset: " + offset);
    }
  }
Exemple #10
0
 /**
  * Sets the Quaternion as a rotation of {@link #axis() axis} and {@link #angle() angle} (in
  * radians).
  *
  * <p>The {@code axis} does not need to be normalized. A null {@code axis} will result in an
  * identity Quaternion.
  *
  * @param axis the PVector representing the axis
  * @param angle the angle in radians
  */
 public void fromAxisAngle(PVector axis, float angle) {
   float norm = axis.mag();
   if (norm < 1E-8f) {
     // Null rotation
     this.x = 0.0f;
     this.y = 0.0f;
     this.z = 0.0f;
     this.w = 1.0f;
   } else {
     float sin_half_angle = PApplet.sin(angle / 2.0f);
     this.x = sin_half_angle * axis.x / norm;
     this.y = sin_half_angle * axis.y / norm;
     this.z = sin_half_angle * axis.z / norm;
     this.w = PApplet.cos(angle / 2.0f);
   }
 }
Exemple #11
0
  public void computePoints() {
    // PVector p1 = map.worldPoint(ll1.x, ll1.y);
    // PVector p2 = map.worldPoint(ll2.x, ll2.y);
    PVector p1 = new PVector(0, 300);
    PVector p2 = new PVector(800, 300);
    int steps = 50;

    this.removeAll();

    for (int i = 0; i <= steps; i++) {
      float s = (float) i / steps;
      float x = PApplet.lerp(p1.x, p2.x, s);
      float y = PApplet.lerp(p1.y, p2.y, s) - h * PApplet.sin(s * PApplet.PI);
      float z = 0;

      add(new PVector(x, y, z));
    }
  }
Exemple #12
0
  private void update(Mimo m) {
    if (m.ancestor
        && (m.pos.x <= 0
            || m.pos.x >= Simulation1.screenWidth
            || m.pos.y <= 0
            || m.pos.y >= Simulation1.screenHeight)) {
      // orient the ancestor towards the center
      float a =
          PApplet.atan2(
              Simulation1.screenHeight / 2 - m.pos.y, Simulation1.screenWidth / 2 - m.pos.x);
      m.vel = new PVector(PApplet.cos(a), PApplet.sin(a));
      float speed = Simulation1.app.noise(Simulation1.app.frameCount * 0.1f) * maxSpeed;
      m.vel.mult(speed);

    } else {
      randomWalk(m);
    }
    m.pos.add(m.vel);
  }
Exemple #13
0
 public void moveNormals() {
   changeMode();
   pApplet.pushMatrix();
   for (int j = 0; j < model.getSegmentCount(); j++) {
     Segment segment = model.getSegment(j);
     Face[] faces = segment.getFaces();
     pApplet.beginShape(PConstants.QUADS);
     for (int i = 0; i < faces.length; i++) {
       PVector[] vertices = faces[i].getVertices();
       PVector normal = faces[i].getNormal();
       float nor = PApplet.abs(PApplet.sin(PApplet.radians((pApplet.frameCount + i))) * 100);
       for (PVector vertex : vertices) {
         pApplet.vertex(
             vertex.x + (normal.x * nor),
             vertex.y + (normal.y * nor),
             vertex.z + (normal.z * nor));
       }
     }
     pApplet.endShape();
   }
   pApplet.popMatrix();
 }
Exemple #14
0
 /**
  * Rotate the vector by an angle (only 2D vectors), magnitude remains the same
  *
  * @param theta the angle of rotation
  */
 public void rotate(float theta) {
   float xTemp = x;
   // Might need to check for rounding errors like with angleBetween function?
   x = x * PApplet.cos(theta) - y * PApplet.sin(theta);
   y = xTemp * PApplet.sin(theta) + y * PApplet.cos(theta);
 }