@Override
  public Vector3 get3DPoint(
      final double gridX, final double gridY, final double height, final Vector3 store) {
    final Vector3 rVal = store != null ? store : new Vector3();

    return rVal.set(gridX, gridY, height);
  }
  @Override
  public void run() {
    while (true) {

      synchronized (lastestPosition) {
        currentPosition.set(lastestPosition);
      }

      // obtain the coordiante in geographic crs
      final ReadOnlyVector3 corrected = container.correctLocation(currentPosition);

      for (Double key : sensitives.keySet()) {
        final Object[] combination = sensitives.get(key);
        final Vector3 vect = (Vector3) combination[0];
        final List<LocationSensitiveGraphic> graphics =
            (List<LocationSensitiveGraphic>) combination[1];

        if (vect.distance(currentPosition) > key) {
          vect.set(currentPosition);
          for (LocationSensitiveGraphic gra : graphics) {
            gra.update(corrected);
          }
        }
      }

      try {
        // we dont need to consume much cpu
        sleep(100);
      } catch (InterruptedException ex) {
        Logging.getLogger(LocationSensitiveUpdater.class).log(Level.WARNING, null, ex);
      }
    }
  }
Example #3
0
  /**
   * update position (using current position and velocity), color (interpolating between start and
   * end color), size (interpolating between start and end size), spin (using parent's spin speed)
   * and current age of particle. If this particle's age is greater than its lifespan, it is set to
   * status DEAD.
   *
   * <p>Note that this only changes the parameters of the Particle, not the geometry the particle is
   * associated with.
   *
   * @param secondsPassed number of seconds passed since last update.
   * @return true if this particle is not ALIVE (in other words, if it is ready to be reused.)
   */
  public boolean updateAndCheck(final double secondsPassed) {
    if (status != Status.Alive) {
      return true;
    }
    currentAge += secondsPassed * 1000; // add ms time to age
    if (currentAge > lifeSpan) {
      killParticle();
      return true;
    }

    final Vector3 temp = Vector3.fetchTempInstance();
    _position.addLocal(_velocity.multiply(secondsPassed * 1000f, temp));
    Vector3.releaseTempInstance(temp);

    // get interpolated values from appearance ramp:
    parent.getRamp().getValuesAtAge(currentAge, lifeSpan, currColor, values, parent);

    // interpolate colors
    final int verts = ParticleSystem.getVertsForParticleType(type);
    for (int x = 0; x < verts; x++) {
      BufferUtils.setInBuffer(
          currColor, parent.getParticleGeometry().getMeshData().getColorBuffer(), startIndex + x);
    }

    // check for tex animation
    final int newTexIndex = parent.getTexAnimation().getTexIndexAtAge(currentAge, lifeSpan, parent);
    // Update tex coords if applicable
    if (currentTexIndex != newTexIndex) {
      // Only supported in Quad type for now.
      if (ParticleType.Quad.equals(parent.getParticleType())) {
        // determine side
        final float side = (float) Math.sqrt(parent.getTexQuantity());
        int index = newTexIndex;
        if (index >= parent.getTexQuantity()) {
          index %= parent.getTexQuantity();
        }
        // figure row / col
        final float row = side - (int) (index / side) - 1;
        final float col = index % side;
        // set texcoords
        final float sU = col / side, eU = (col + 1) / side;
        final float sV = row / side, eV = (row + 1) / side;
        final FloatBuffer texs =
            parent.getParticleGeometry().getMeshData().getTextureCoords(0).getBuffer();
        texs.position(startIndex * 2);
        texs.put(eU).put(sV);
        texs.put(eU).put(eV);
        texs.put(sU).put(eV);
        texs.put(sU).put(sV);
        texs.clear();
      }
      currentTexIndex = newTexIndex;
    }

    return false;
  }
Example #4
0
  @Override
  public boolean intersectsSphere(final BoundingSphere bs) {
    if (!Vector3.isValid(_center) || !Vector3.isValid(bs._center)) {
      return false;
    }

    final Vector3 diff = _compVect1.set(getCenter()).subtractLocal(bs.getCenter());
    final double rsum = getRadius() + bs.getRadius();
    return (diff.dot(diff) <= rsum * rsum);
  }
Example #5
0
  public void reconstruct(final Vector3 top, final Vector3 bottom, final double radius) {
    // our temp vars
    final Vector3 localTranslation = Vector3.fetchTempInstance();
    final Vector3 capsuleUp = Vector3.fetchTempInstance();

    // first make the capsule the right shape
    height = top.distance(bottom);
    this.radius = radius;
    setGeometryData();

    // now orient it in space.
    localTranslation.set(_localTransform.getTranslation());
    top.add(bottom, localTranslation).multiplyLocal(.5);

    // rotation that takes us from 0,1,0 to the unit vector described by top/center.
    top.subtract(localTranslation, capsuleUp).normalizeLocal();
    final Matrix3 rotation = Matrix3.fetchTempInstance();
    rotation.fromStartEndLocal(Vector3.UNIT_Y, capsuleUp);
    _localTransform.setRotation(rotation);

    Vector3.releaseTempInstance(localTranslation);
    Vector3.releaseTempInstance(capsuleUp);
    Matrix3.releaseTempInstance(rotation);

    updateWorldTransform(false);
  }
Example #6
0
  /**
   * Cause this particle to reset it's color, age and size per the parent's settings. status is set
   * to Status.Available. Location, velocity and lifespan are set as given. Actual geometry data is
   * not affected by this call, only particle params.
   *
   * @param velocity new initial particle velocity
   * @param position new initial particle position
   * @param lifeSpan new particle lifespan in ms
   */
  public void init(
      final ReadOnlyVector3 velocity, final ReadOnlyVector3 position, final double lifeSpan) {
    this.lifeSpan = lifeSpan;
    _velocity.set(velocity);
    _position.set(position);

    currColor.set(parent.getStartColor());
    currentAge = 0;
    status = Status.Available;
    values[VAL_CURRENT_SIZE] = parent.getStartSize();
  }
Example #7
0
  public void killParticle() {
    setStatus(Status.Dead);

    final Vector3 tempVec3 = Vector3.fetchTempInstance();
    final FloatBuffer vertexBuffer = parent.getParticleGeometry().getMeshData().getVertexBuffer();
    BufferUtils.populateFromBuffer(tempVec3, vertexBuffer, startIndex);
    final int verts = ParticleSystem.getVertsForParticleType(type);
    for (int x = 1; x < verts; x++) {
      BufferUtils.setInBuffer(tempVec3, vertexBuffer, startIndex + x);
    }
    Vector3.releaseTempInstance(tempVec3);
  }
Example #8
0
 public void read(final InputCapsule capsule) throws IOException {
   startIndex = capsule.readInt("startIndex", 0);
   _position.set((Vector3) capsule.readSavable("position", new Vector3(Vector3.ZERO)));
   status = capsule.readEnum("status", Status.class, Status.Available);
   lifeSpan = capsule.readDouble("lifeSpan", 0);
   currentAge = capsule.readInt("currentAge", 0);
   parent = (ParticleSystem) capsule.readSavable("parent", null);
   _velocity.set((Vector3) capsule.readSavable("velocity", new Vector3()));
   type =
       capsule.readEnum(
           "type", ParticleSystem.ParticleType.class, ParticleSystem.ParticleType.Quad);
 }
Example #9
0
  @Override
  public boolean intersectsBoundingBox(final BoundingBox bb) {
    if (!Vector3.isValid(_center) || !Vector3.isValid(bb._center)) {
      return false;
    }

    if (Math.abs(bb._center.getX() - getCenter().getX()) < getRadius() + bb.getXExtent()
        && Math.abs(bb._center.getY() - getCenter().getY()) < getRadius() + bb.getYExtent()
        && Math.abs(bb._center.getZ() - getCenter().getZ()) < getRadius() + bb.getZExtent()) {
      return true;
    }

    return false;
  }
Example #10
0
File: Grid.java Project: nasa/DERT
 protected RasterText createRowText(
     String name, double val, double x, double y, ReadOnlyColorRGBA color) {
   if (actualCoords) {
     val += origin.getYf();
   }
   return (createText(name, val, x, y, color));
 }
Example #11
0
  @Override
  public IntersectionRecord intersectsWhere(final ReadOnlyRay3 ray) {

    final Vector3 diff = ray.getOrigin().subtract(getCenter(), _compVect1);
    final double a = diff.dot(diff) - (getRadius() * getRadius());
    double a1, discr, root;
    if (a <= 0.0) {
      // inside sphere
      a1 = ray.getDirection().dot(diff);
      discr = (a1 * a1) - a;
      root = Math.sqrt(discr);
      final double[] distances = new double[] {root - a1};
      final Vector3[] points =
          new Vector3[] {
            ray.getDirection().multiply(distances[0], new Vector3()).addLocal(ray.getOrigin())
          };
      return new IntersectionRecord(distances, points);
    }

    a1 = ray.getDirection().dot(diff);
    if (a1 >= 0.0) {
      // No intersection
      return null;
    }

    discr = a1 * a1 - a;
    if (discr < 0.0) {
      return null;
    } else if (discr >= MathUtils.ZERO_TOLERANCE) {
      root = Math.sqrt(discr);
      final double[] distances = new double[] {-a1 - root, -a1 + root};
      final Vector3[] points =
          new Vector3[] {
            ray.getDirection().multiply(distances[0], new Vector3()).addLocal(ray.getOrigin()),
            ray.getDirection().multiply(distances[1], new Vector3()).addLocal(ray.getOrigin())
          };
      final IntersectionRecord record = new IntersectionRecord(distances, points);
      return record;
    }

    final double[] distances = new double[] {-a1};
    final Vector3[] points =
        new Vector3[] {
          ray.getDirection().multiply(distances[0], new Vector3()).addLocal(ray.getOrigin())
        };
    return new IntersectionRecord(distances, points);
  }
Example #12
0
  /**
   * Merges this sphere with the given OBB.
   *
   * @param volume The OBB to merge.
   * @return This sphere, after merging.
   */
  private BoundingSphere mergeLocalOBB(final OrientedBoundingBox volume) {
    // check for infinite bounds to prevent NaN values... is so, return infinite bounds with center
    // at origin
    if (Double.isInfinite(getRadius()) || Vector3.isInfinite(volume.getExtent())) {
      setCenter(Vector3.ZERO);
      setRadius(Double.POSITIVE_INFINITY);
      return this;
    }

    // compute edge points from the obb
    if (!volume.correctCorners) {
      volume.computeCorners();
    }

    final FloatBuffer mergeBuf = BufferUtils.createFloatBufferOnHeap(8 * 3);

    for (int i = 0; i < 8; i++) {
      mergeBuf.put((float) volume._vectorStore[i].getX());
      mergeBuf.put((float) volume._vectorStore[i].getY());
      mergeBuf.put((float) volume._vectorStore[i].getZ());
    }

    // remember old radius and center
    final double oldRadius = getRadius();
    final double oldCenterX = _center.getX();
    final double oldCenterY = _center.getY();
    final double oldCenterZ = _center.getZ();

    // compute new radius and center from obb points
    computeFromPoints(mergeBuf);

    final double newCenterX = _center.getX();
    final double newCenterY = _center.getY();
    final double newCenterZ = _center.getZ();
    final double newRadius = getRadius();

    // restore old center and radius
    _center.set(oldCenterX, oldCenterY, oldCenterZ);
    setRadius(oldRadius);

    // merge obb points result
    merge(newRadius, _compVect4.set(newCenterX, newCenterY, newCenterZ), this);

    return this;
  }
Example #13
0
  /**
   * Calculates the distance from a spatial to the camera. Distance is a squared distance.
   *
   * @param spat Spatial to check distance.
   * @return Distance from Spatial to current context's camera.
   */
  protected double distanceToCam(final Spatial spat) {
    if (spat._queueDistance != Double.NEGATIVE_INFINITY) {
      return spat._queueDistance;
    }

    final Camera cam = Camera.getCurrentCamera();

    if (spat.getWorldBound() != null && Vector3.isValid(spat.getWorldBound().getCenter())) {
      spat._queueDistance = spat.getWorldBound().distanceToEdge(cam.getLocation());
    } else {
      final ReadOnlyVector3 spatPosition = spat.getWorldTranslation();
      if (!Vector3.isValid(spatPosition)) {
        spat._queueDistance = Double.POSITIVE_INFINITY;
      } else {
        spat._queueDistance = cam.getLocation().distance(spatPosition);
      }
    }

    return spat._queueDistance;
  }
Example #14
0
 @Override
 public void read(final Ardor3DImporter e) throws IOException {
   super.read(e);
   final InputCapsule cap = e.getCapsule(this);
   _swarmRangeSQ = cap.readDouble("swarmRangeSQ", DEFAULT_SWARM_RANGE_SQ);
   _deviance = cap.readDouble("deviance", DEFAULT_DEVIANCE);
   _turnSpeed = cap.readDouble("turnSpeed", DEFAULT_TURN_SPEED);
   _speedBump = cap.readDouble("speedBump", DEFAULT_SPEED_BUMP);
   _maxSpeed = cap.readDouble("maxSpeed", DEFAULT_MAX_SPEED);
   _swarmOffset.set((Vector3) cap.readSavable("swarmOffset", new Vector3()));
 }
Example #15
0
  @Override
  public void startWalk(final Ray3 walkRay) {
    // store ray
    _walkRay.set(walkRay);

    // simplify access to direction
    final ReadOnlyVector3 direction = _walkRay.getDirection();

    // Move start point to grid space
    final Vector3 start = _walkRay.getOrigin().subtract(_gridOrigin, null);

    _gridLocation[0] = (int) MathUtils.floor(start.getX() / _gridSpacing.getX());
    _gridLocation[1] = (int) MathUtils.floor(start.getY() / _gridSpacing.getY());

    final double invDirX = 1.0 / direction.getX();
    final double invDirY = 1.0 / direction.getY();

    // Check which direction on the X world axis we are moving.
    if (direction.getX() > BresenhamZUpGridTracer.TOLERANCE) {
      _distToNextXIntersection =
          ((_gridLocation[0] + 1) * _gridSpacing.getX() - start.getX()) * invDirX;
      _distBetweenXIntersections = _gridSpacing.getX() * invDirX;
      _stepXDirection = 1;
    } else if (direction.getX() < -BresenhamZUpGridTracer.TOLERANCE) {
      _distToNextXIntersection =
          (start.getX() - _gridLocation[0] * _gridSpacing.getX()) * -direction.getX();
      _distBetweenXIntersections = -_gridSpacing.getX() * invDirX;
      _stepXDirection = -1;
    } else {
      _distToNextXIntersection = Double.MAX_VALUE;
      _distBetweenXIntersections = Double.MAX_VALUE;
      _stepXDirection = 0;
    }

    // Check which direction on the Y world axis we are moving.
    if (direction.getY() > BresenhamZUpGridTracer.TOLERANCE) {
      _distToNextYIntersection =
          ((_gridLocation[1] + 1) * _gridSpacing.getY() - start.getY()) * invDirY;
      _distBetweenYIntersections = _gridSpacing.getY() * invDirY;
      _stepYDirection = 1;
    } else if (direction.getY() < -BresenhamZUpGridTracer.TOLERANCE) {
      _distToNextYIntersection =
          (start.getY() - _gridLocation[1] * _gridSpacing.getY()) * -direction.getY();
      _distBetweenYIntersections = -_gridSpacing.getY() * invDirY;
      _stepYDirection = -1;
    } else {
      _distToNextYIntersection = Double.MAX_VALUE;
      _distBetweenYIntersections = Double.MAX_VALUE;
      _stepYDirection = 0;
    }

    // Reset some variables
    _rayLocation.set(start);
    _totalTravel = 0.0;
    _stepDirection = Direction.None;
  }
Example #16
0
 private Vector3 findFarthestIntersection(
     final List<? extends ReadOnlyVector3> wallUpperPoints,
     final ReadOnlyVector3 center,
     final Vector3 p) {
   double farthestDistance = 0;
   Vector3 farthestIntersection = null;
   final int n = wallUpperPoints.size();
   for (int i = 0; i < n; i++) {
     final Vector3 intersect =
         Util.intersectLineSegments(
             center, p, wallUpperPoints.get(i), wallUpperPoints.get((i + 1) % n));
     if (intersect != null) {
       final double d = intersect.distanceSquared(center);
       if (d > farthestDistance) {
         farthestDistance = d;
         farthestIntersection = intersect;
       }
     }
   }
   return farthestIntersection;
 }
Example #17
0
  /**
   * <code>averagePoints</code> selects the sphere center to be the average of the points and the
   * sphere radius to be the smallest value to enclose all points.
   *
   * @param points the list of points to contain.
   */
  public void averagePoints(final Vector3[] points) {
    _center.set(points[0]);

    for (int i = 1; i < points.length; i++) {
      _center.addLocal(points[i]);
    }

    final double quantity = 1.0 / points.length;
    _center.multiplyLocal(quantity);

    double maxRadiusSqr = 0;
    for (int i = 0; i < points.length; i++) {
      final Vector3 diff = points[i].subtract(_center, _compVect1);
      final double radiusSqr = diff.lengthSquared();
      if (radiusSqr > maxRadiusSqr) {
        maxRadiusSqr = radiusSqr;
      }
    }

    setRadius(Math.sqrt(maxRadiusSqr) + radiusEpsilon - 1f);
  }
Example #18
0
  @Override
  public boolean intersects(final ReadOnlyRay3 ray) {
    if (!Vector3.isValid(_center)) {
      return false;
    }

    final Vector3 diff = ray.getOrigin().subtract(getCenter(), _compVect1);
    final double radiusSquared = getRadius() * getRadius();
    final double a = diff.dot(diff) - radiusSquared;
    if (a <= 0.0) {
      // in sphere
      return true;
    }

    // outside sphere
    final Vector3 dir = _compVect2.set(ray.getDirection());
    final double b = dir.dot(diff);
    if (b >= 0.0) {
      return false;
    }
    return b * b >= a;
  }
Example #19
0
  @Override
  public void computeFromPrimitives(
      final MeshData data, final int section, final int[] indices, final int start, final int end) {
    if (end - start <= 0) {
      return;
    }

    final int vertsPerPrimitive = data.getIndexMode(section).getVertexCount();
    final Vector3[] vertList = new Vector3[(end - start) * vertsPerPrimitive];
    Vector3[] store = new Vector3[vertsPerPrimitive];

    int count = 0;
    for (int i = start; i < end; i++) {
      store = data.getPrimitiveVertices(indices[i], section, store);
      for (int j = 0; j < vertsPerPrimitive; j++) {
        vertList[count++] = Vector3.fetchTempInstance().set(store[0]);
      }
    }

    averagePoints(vertList);
    for (int i = 0; i < vertList.length; i++) {
      Vector3.releaseTempInstance(vertList[i]);
    }
  }
Example #20
0
  /**
   * <code>merge</code> combines this sphere with a second bounding sphere. This new sphere contains
   * both bounding spheres and is returned.
   *
   * @param volume the sphere to combine with this sphere.
   * @return a new sphere
   */
  @Override
  public BoundingVolume merge(final BoundingVolume volume) {
    if (volume == null) {
      return this;
    }

    switch (volume.getType()) {
      case Sphere:
        {
          final BoundingSphere sphere = (BoundingSphere) volume;
          final double temp_radius = sphere.getRadius();
          final ReadOnlyVector3 tempCenter = sphere.getCenter();
          final BoundingSphere rVal = new BoundingSphere();
          return merge(temp_radius, tempCenter, rVal);
        }

      case AABB:
        {
          final BoundingBox box = (BoundingBox) volume;
          final Vector3 radVect = new Vector3(box.getXExtent(), box.getYExtent(), box.getZExtent());
          final Vector3 tempCenter = box._center;
          final BoundingSphere rVal = new BoundingSphere();
          return merge(radVect.length(), tempCenter, rVal);
        }

      case OBB:
        {
          final OrientedBoundingBox box = (OrientedBoundingBox) volume;
          final BoundingSphere rVal = (BoundingSphere) this.clone(null);
          return rVal.mergeLocalOBB(box);
        }

      default:
        return null;
    }
  }
Example #21
0
 @Override
 public void setPreviewPoint(final int x, final int y) {
   final EditState editState = new EditState();
   if (editPointIndex == -1) {
     pickContainer(x, y, Wall.class);
     recalculateEditPoints = true;
   } else if (editPointIndex == 0) {
     final ReadOnlyVector3 base = getCenter();
     final Vector3 p = Util.closestPoint(base, Vector3.UNIT_Z, x, y);
     if (p != null) {
       snapToGrid(p, getAbsPoint(editPointIndex), getGridSize());
       height = Math.max(0, p.getZ() - base.getZ());
     }
   } else if (editPointIndex == 1 || editPointIndex == 2) {
     final Vector3 hipDirection =
         container.getAbsPoint(2).subtractLocal(container.getAbsPoint(0)).normalizeLocal();
     final Vector3 p = Util.closestPoint(getAbsPoint(0), hipDirection, x, y);
     if (p != null) {
       // snapToGrid(p, getAbsPoint(editPointIndex), getGridSize(), false);
       if (insideWallsPolygon(p)) points.get(editPointIndex).set(toRelative(p));
     }
   }
   postEdit(editState);
 }
Example #22
0
  @Override
  public void applyFilter(final InteractManager manager) {
    final SpatialState state = manager.getSpatialState();
    final ReadOnlyVector3 scale = state.getTransform().getScale();
    final double x = MathUtils.clamp(scale.getX(), _minScale.getX(), _maxScale.getX());
    final double y = MathUtils.clamp(scale.getY(), _minScale.getY(), _maxScale.getY());
    final double z = MathUtils.clamp(scale.getZ(), _minScale.getZ(), _maxScale.getZ());

    state.getTransform().setScale(x, y, z);
  }
Example #23
0
File: Grid.java Project: nasa/DERT
 @Override
 public void setInMotion(boolean inMotion, ReadOnlyVector3 pickPosition) {
   super.setInMotion(inMotion, pickPosition);
   if (inMotion) {
     pickPosition.subtract(getWorldTranslation(), offset);
   } else {
     if (actualCoords) {
       origin = new Vector3(getWorldTranslation());
       buildText();
       updateGeometricState(0, true);
       updateWorldTransform(true);
       updateWorldBound(true);
     }
     offset.set(Vector3.ZERO);
   }
 }
Example #24
0
  private BoundingVolume merge(
      final double otherRadius, final ReadOnlyVector3 otherCenter, final BoundingSphere store) {
    // check for infinite bounds... is so, return infinite bounds with center at origin
    if (Double.isInfinite(otherRadius) || Double.isInfinite(getRadius())) {
      store.setCenter(Vector3.ZERO);
      store.setRadius(Double.POSITIVE_INFINITY);
      return store;
    }

    final Vector3 diff = otherCenter.subtract(_center, _compVect1);
    final double lengthSquared = diff.lengthSquared();
    final double radiusDiff = otherRadius - getRadius();
    final double radiusDiffSqr = radiusDiff * radiusDiff;

    // if one sphere wholly contains the other
    if (radiusDiffSqr >= lengthSquared) {
      // if we contain the other
      if (radiusDiff <= 0.0) {
        store.setCenter(_center);
        store.setRadius(_radius);
        return store;
      }
      // else the other contains us
      else {
        store.setCenter(otherCenter);
        store.setRadius(otherRadius);
        return store;
      }
    }

    // distance between sphere centers
    final double length = Math.sqrt(lengthSquared);

    // init a center var using our center
    final Vector3 rCenter = _compVect2;
    rCenter.set(_center);

    // if our centers are at least a tiny amount apart from each other...
    if (length > MathUtils.EPSILON) {
      // place us between the two centers, weighted by radii
      final double coeff = (length + radiusDiff) / (2.0 * length);
      rCenter.addLocal(diff.multiplyLocal(coeff));
    }

    // set center on our resulting bounds
    store.setCenter(rCenter);

    // Set radius
    store.setRadius(0.5 * (length + getRadius() + otherRadius));
    return store;
  }
Example #25
0
  @Override
  public void apply(final double dt, final Particle particle, final int index) {
    if (_wanderRadius == 0 && _wanderDistance == 0 && _wanderJitter == 0) {
      return;
    }

    final Vector3 wanderTarget = _wanderTargets.get(index);

    wanderTarget.addLocal(calcNewJitter(), calcNewJitter(), calcNewJitter());
    wanderTarget.normalizeLocal();
    wanderTarget.multiplyLocal(_wanderRadius);

    _workVect.set(particle.getVelocity()).normalizeLocal().multiplyLocal(_wanderDistance);
    _workVect.addLocal(wanderTarget).normalizeLocal();
    _workVect.multiplyLocal(particle.getVelocity().length());
    particle.getVelocity().set(_workVect);
  }
Example #26
0
 @Override
 public void apply(final double dt, final Particle particle, final int index) {
   final Vector3 pVelocity = particle.getVelocity();
   // determine if the particle is in the inner or outer zone
   final double pDist = particle.getPosition().distanceSquared(_swarmPoint);
   final Vector3 workVect = Vector3.fetchTempInstance();
   final Vector3 workVect2 = Vector3.fetchTempInstance();
   final Matrix3 workMat = Matrix3.fetchTempInstance();
   workVect.set(_swarmPoint).subtractLocal(particle.getPosition()).normalizeLocal();
   workVect2.set(pVelocity).normalizeLocal();
   if (pDist > _swarmRangeSQ) {
     // IN THE OUTER ZONE...
     // Determine if the angle between particle velocity and a vector to
     // the swarmPoint is less than the accepted deviance
     final double angle = workVect.smallestAngleBetween(workVect2);
     if (angle < _deviance) {
       // if it is, increase the speed speedBump over time
       if (pVelocity.lengthSquared() < maxSpeedSQ) {
         final double change = _speedBump * dt;
         workVect2.multiplyLocal(change); // where workVector2 = pVelocity.normalizeLocal()
         pVelocity.addLocal(workVect2);
       }
     } else {
       final Vector3 axis = workVect2.crossLocal(workVect);
       // if it is not, shift the velocity to bring it back in line
       if ((Double.doubleToLongBits(pVelocity.lengthSquared()) & 0x1d) != 0) {
         workMat.fromAngleAxis(_turnSpeed * dt, axis);
       } else {
         workMat.fromAngleAxis(-_turnSpeed * dt, axis);
       }
       workMat.applyPost(pVelocity, pVelocity);
     }
   } else {
     final Vector3 axis = workVect2.crossLocal(workVect);
     // IN THE INNER ZONE...
     // Alter the heading based on how fast we are going
     if ((index & 0x1f) != 0) {
       workMat.fromAngleAxis(_turnSpeed * dt, axis);
     } else {
       workMat.fromAngleAxis(-_turnSpeed * dt, axis);
     }
     workMat.applyPost(pVelocity, pVelocity);
   }
   Vector3.releaseTempInstance(workVect);
   Vector3.releaseTempInstance(workVect2);
   Matrix3.releaseTempInstance(workMat);
 }
Example #27
0
 @Override
 public void prepare(final ParticleSystem system) {
   super.prepare(system);
   _swarmPoint.set(system.getOriginCenter()).addLocal(_swarmOffset);
 }
Example #28
0
 public SwarmInfluence(final ReadOnlyVector3 offset, final double swarmRange) {
   super();
   _swarmRangeSQ = swarmRange * swarmRange;
   _swarmOffset.set(offset);
 }
Example #29
0
 public void setSwarmOffset(final ReadOnlyVector3 offset) {
   _swarmPoint.set(offset);
 }
Example #30
0
 public BoundingVolume(final Vector3 center) {
   _center.set(center);
 }