Exemple #1
0
 public void get(
     final IVerhaltenEntity[] theNeighbors, final Engine theEngine, final Vector3f theDirection) {
   theDirection.set(0, 0, 0);
   if (theNeighbors.length != 0) {
     for (int i = 0; i < theNeighbors.length; i++) {
       theDirection.add(theNeighbors[i].position());
     }
     theDirection.scale(1.0f / (float) theNeighbors.length);
     _mySeek.setPoint(theDirection);
     _mySeek.get(theEngine, theDirection);
   }
 }
  public void pre_step() {
    Vector3f ab = mathematik.Util.sub(mParticleA.position(), mParticleB.position());
    Vector3f cb = mathematik.Util.sub(mParticleC.position(), mParticleB.position());
    final float mCurrentAngle = ab.angle(cb);

    if (mCurrentAngle < mMinAngle) {
      final int TINY_FACTOR_MODELL = 0;
      final int TRIG_MODELL = 1;
      final int MAX_DISTANCE_MODELL = 2;

      final int mModell = TRIG_MODELL;

      switch (mModell) {
        case TINY_FACTOR_MODELL:
          {
            final float TINY_FACTOR = 1.1f;
            final float mDistance =
                mParticleA.position().distance(mParticleC.position()) * TINY_FACTOR;
            restlength(mDistance);
          }
          break;
        case TRIG_MODELL:
          {
            // a = sqrt ( b*b + c*c - 2bc*cosA )
            final float b = ab.length();
            final float c = cb.length();
            final float mDistance =
                (float) Math.sqrt(b * b + c * c - 2 * b * c * (float) Math.cos(mMinAngle));
            restlength(mDistance);
          }
          break;
        case MAX_DISTANCE_MODELL:
          {
            final float mDistance =
                mParticleA.position().distance(mParticleB.position())
                    + mParticleC.position().distance(mParticleB.position());
            restlength(mDistance);
          }
          break;
      }
      active(true);
    }
  }
Exemple #3
0
  public <E extends IVerhaltenEntity> void get(
      final Vector<E> theNeighbors,
      final int theNumberOfEntities,
      final Engine theEngine,
      final Vector3f theDirection) {

    final int myNumberOfEntities;
    if (theNumberOfEntities < theNeighbors.size()) {
      myNumberOfEntities = theNumberOfEntities;
    } else {
      myNumberOfEntities = theNeighbors.size();
    }

    theDirection.set(0, 0, 0);
    if (!theNeighbors.isEmpty()) {
      for (int i = 0; i < myNumberOfEntities; i++) {
        theDirection.add(theNeighbors.get(i).position());
      }
      theDirection.scale(1.0f / (float) myNumberOfEntities);
      _mySeek.setPoint(theDirection);
      _mySeek.get(theEngine, theDirection);
    }
  }
    public void loop() {
      for (int i = 0; i < particles.length; i++) {
        /* check if particle is active.
         * if so, animate the particle, if not, reset the particle
         * to a random start position */
        if (particles[i].isActive) {
          Vector3f myDirection = new Vector3f(event().mouseX, event().mouseY, 0);
          myDirection.sub(particles[i].position);
          final float myDistance = myDirection.length();
          myDirection.scale(particles[i].speed / myDistance);
          particles[i].position.add(myDirection);

          particles[i].color.a = 1 - myDistance / (-1.5f * SPAWN_DEPTH);

          if (myDistance < 1) {
            particles[i].isActive = false;
          }
        } else {
          particles[i].isActive = true;
          particles[i].position.set(
              _myRandom.getFloat(-640, 640), _myRandom.getFloat(-480, 480), SPAWN_DEPTH);
          particles[i].color.a = 0;
        }

        /* map position to backup array */
        positionbackuparray[i * 3 + 0] = particles[i].position.x;
        positionbackuparray[i * 3 + 1] = particles[i].position.y;
        positionbackuparray[i * 3 + 2] = particles[i].position.z;

        /* map color4f to backup array */
        colorbackuparray[i * 4 + 0] = particles[i].color.r;
        colorbackuparray[i * 4 + 1] = particles[i].color.g;
        colorbackuparray[i * 4 + 2] = particles[i].color.b;
        colorbackuparray[i * 4 + 3] = particles[i].color.a;
      }
    }
Exemple #5
0
 public Vector3f getV3fLoc() {
   Vector3f v = new Vector3f();
   v.set(loc.x, loc.y, loc.z);
   return v;
 }
  static Vector3f getCenter(final Vector<Vector3f> theVertices, final Triangle theTriangle) {
    final Vector3f myCenter = new Vector3f();
    final Vector3f v0 = theVertices.get(theTriangle.p[0]);
    final Vector3f v1 = theVertices.get(theTriangle.p[1]);
    final Vector3f v2 = theVertices.get(theTriangle.p[2]);
    final Vector3f myNormal = new Vector3f(0, 0, 1);

    final Vector3f pA = mathematik.Util.sub(v2, v0);
    pA.scale(0.5f);
    Vector3f pAc = new Vector3f();
    pAc.cross(pA, myNormal);
    pAc.add(v0);
    pAc.add(pA);
    pA.add(v0);

    final Vector3f pB = mathematik.Util.sub(v2, v1);
    pB.scale(0.5f);
    Vector3f pBc = new Vector3f(pB);
    pBc.cross(pB, myNormal);
    pBc.add(v1);
    pBc.add(pB);
    pB.add(v1);

    mathematik.Intersection.lineLineIntersect(pA, pAc, pB, pBc, myCenter, new Vector3f(), null);
    return myCenter;
  }
  private static boolean getCircumCircle(
      float xp,
      float yp,
      float x1,
      float y1,
      float x2,
      float y2,
      float x3,
      float y3,
      Vector3f circle) {
    /*
     * Return TRUE if a point (xp,yp) is inside the circumcircle made up
     * of the points (x1, y1), (x2, y2), (x3, y3)
     * The circumcircle centre is returned in (xc, yc) and the radius r
     * NOTE: A point on the edge is inside the circumcircle
     */

    float m1, m2, mx1, mx2, my1, my2;
    float dx, dy, rsqr, drsqr;
    float xc, yc, r;

    /* Check for coincident points */
    if (Math.abs(y1 - y2) < mathematik.Mathematik.EPSILON
        && Math.abs(y2 - y3) < mathematik.Mathematik.EPSILON) {
      if (VERBOSE) {
        System.out.println("### points are coincident.");
      }
      return false;
    }

    if (Math.abs(y2 - y1) < mathematik.Mathematik.EPSILON) {
      m2 = -(x3 - x2) / (y3 - y2);
      mx2 = (x2 + x3) / 2.0f;
      my2 = (y2 + y3) / 2.0f;
      xc = (x2 + x1) / 2.0f;
      yc = m2 * (xc - mx2) + my2;
    } else if (Math.abs(y3 - y2) < mathematik.Mathematik.EPSILON) {
      m1 = -(x2 - x1) / (y2 - y1);
      mx1 = (x1 + x2) / 2.0f;
      my1 = (y1 + y2) / 2.0f;
      xc = (x3 + x2) / 2.0f;
      yc = m1 * (xc - mx1) + my1;
    } else {
      m1 = -(x2 - x1) / (y2 - y1);
      m2 = -(x3 - x2) / (y3 - y2);
      mx1 = (x1 + x2) / 2.0f;
      mx2 = (x2 + x3) / 2.0f;
      my1 = (y1 + y2) / 2.0f;
      my2 = (y2 + y3) / 2.0f;
      xc = (m1 * mx1 - m2 * mx2 + my2 - my1) / (m1 - m2);
      yc = m1 * (xc - mx1) + my1;
    }

    dx = x2 - xc;
    dy = y2 - yc;
    rsqr = dx * dx + dy * dy;
    r = (float) Math.sqrt(rsqr);

    dx = xp - xc;
    dy = yp - yc;
    drsqr = dx * dx + dy * dy;

    circle.x = xc;
    circle.y = yc;
    circle.z = r;

    return (drsqr <= rsqr ? true : false);
  }