예제 #1
0
  private void boundary(Particle particle) {

    Vector positionInBoundary = particle.getPosition().clone();
    Vector velocityInBoundary = particle.getVelocity().clone();

    /*
    der lantern renderer verändert die übergebenen winkel, somit muss ich hier schauen,
    dass auch die auslenkung wieder ausgleiche.
     */

    if (positionInBoundary.x < -(BOUNDARY * 0.5f)) {
      positionInBoundary.x = -(BOUNDARY * 0.5f);
      velocityInBoundary.x *= -BUMP_DECELERATION; // reverse and damp
    }
    if (positionInBoundary.x > (BOUNDARY * 0.5f)) {
      positionInBoundary.x = (BOUNDARY * 0.5f);
      velocityInBoundary.x *= -BUMP_DECELERATION; // reverse and damp
    }

    if (positionInBoundary.y < -(BOUNDARY * 0.5f)) {
      positionInBoundary.y = -(BOUNDARY * 0.5f);
      velocityInBoundary.y *= -BUMP_DECELERATION; // reverse and damp
    }
    if (positionInBoundary.y > (BOUNDARY * 1.8)) {
      positionInBoundary.y = (BOUNDARY * 1.8f);
      velocityInBoundary.y *= -BUMP_DECELERATION; // reverse and damp
    }

    particle.setPosition(positionInBoundary);
    particle.setVelocity(velocityInBoundary);
  }
예제 #2
0
  /**
   * Adds the given edge to those to be displayed in the viewer. Note that the edge must connect
   * nodes that have already been added to the viewer. This version will use the locations of the
   * two nodes to calculate their distance of separation.
   *
   * @param edge Edge to add to the display.
   * @return True if edge was added successfully. False if edge contains nodes that have not been
   *     added to the viewer.
   */
  public boolean addEdge(E edge) {
    Particle p1 = nodes.get(edge.getNode1());
    if (p1 == null) {
      System.err.println("Warning: Node1 not found when creating edge.");
      return false;
    }
    Particle p2 = nodes.get(edge.getNode2());
    if (p2 == null) {
      System.err.println("Warning: Node2 not found when creating edge.");
      return false;
    }

    // Only add edge if it does not already exist in the collection
    if (!edges.containsKey(edge)) {
      float x1 = p1.position().x();
      float y1 = p1.position().y();
      float x2 = p2.position().x();
      float y2 = p2.position().y();
      // Strength, damping, reset length
      edges.put(
          edge,
          physics.makeSpring(
              p1,
              p2,
              EDGE_STRENGTH,
              DAMPING,
              (float) Math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2))));
    }
    return true;
  }
예제 #3
0
 public void update(float delta) {
   for (Particle particle : particles) {
     if (particle.active) {
       particle.update(delta);
     }
   }
 }
  @Override
  public void draw(SpriteBatch spriteBatch) {
    delta = Math.min(0.06f, Gdx.graphics.getDeltaTime());

    this.setOrigin(0, 0);
    for (int i = particles.size - 1; i >= 0; i--) {
      Particle particle = particles.get(i);
      if (particle.life > 0) {
        updateParticle(particle);
        float dx = this.getWidth() / 2 * particle.scale;
        float dy = this.getHeight() / 2 * particle.scale;
        this.setColor(1, 1, 1, Math.max(particle.life / this.life, 0));
        this.setScale(particle.scale);
        this.setPosition(particle.position.x - dx, particle.position.y - dy);
        if (!(particle.position.y - dy >= -10 && particle.position.y - dy <= 10)
            && !(particle.position.x - dx >= -10 && particle.position.x - dx <= 10)) {
          super.draw(spriteBatch);
        } else {
          particle.life = 0;
        }
      } else {
        particles.removeIndex(i);
        freeParticles.free(particle);
      }
    }
  }
예제 #5
0
 /*loops through particles and calls the MCC algorith for each*/
 void CollideParticles() {
   Iterator iterator = particles.iterator();
   while (iterator.hasNext()) {
     Particle part = (Particle) iterator.next();
     part.collideMCC(dt);
   }
 }
예제 #6
0
  private void integrate(float time) {
    for (int i = 0; i < modifers.size(); i++) {
      modifers.get(i).update();
    }

    RigidBody obj;
    for (int i = 0; i < physObjs.size(); i++) {
      obj = physObjs.get(i);
      if (!obj.isGhost) {
        obj.f = obj.f.add(g.mul(obj.mass));
      }
      obj.dcm.set(obj.v.mul(time));
      obj.cm.set(obj.cm.add(obj.dcm));
      obj.v.set(obj.v.add(obj.f.mul(time).div(obj.mass)));

      if (obj.isRotated) {
        obj.angVel += obj.torque * time / obj.inertia;
        obj.theta += obj.angVel * time;
        obj.angVel += obj.torque * time / obj.inertia;
        obj.torque = obj.angVel * time * -obj.angDamp * obj.inertia;
      }
      obj.f.set(obj.v.mul(time * -obj.damp * obj.mass));
    }

    Particle part;
    for (int p = 0; p < particles.size(); p++) {
      part = particles.get(p);
      if (!part.isGhost) {
        part.f = part.f.add(g.mul(part.mass));
      }
      part.cm.set(part.cm.add(part.v.mul(time)));
    }
  }
예제 #7
0
 /** Remove all living particles and restart emitting. */
 public void reset() {
   mIsActive = true;
   mElapsed = 0;
   for (mParticleIdx = 0; mParticleIdx < mParticleCount; ++mParticleIdx) {
     Particle p = mParticles[mParticleIdx];
     p.timeToLive = 0;
   }
 }
예제 #8
0
  public double getAccelerationX(Particle p) {

    if ((p.getRecY() >= this.y) && (p.getRecY() <= (this.y + this.height)) && this.haveDone) {
      p.setRecX(2 * p.getX() - p.getRecX());
      this.haveDone = false;
    }
    return 0;
  }
예제 #9
0
 /**
  * Gets the delta from dead reckoning and moves the distribution in this direction
  *
  * @param x delta x
  * @param y delta y
  */
 public void updateAction(double x, double y) {
   // propagate position through motion model
   for (Particle particle : particleList) {
     final double val = nextGaussian() * sigmaAction * scale;
     particle.setXY(particle.getX() + x + val, particle.getY() + y + val);
   }
   showParticles();
 }
 private void applyForces(final double dt) {
   for (final Object object : this.particles.keySet()) {
     final Particle particle = this.particles.get(object);
     final Vector oldSpeed = particle.getSpeed();
     final Vector newSpeed = oldSpeed.add(this.forces.get(object).scale(dt / particle.getMass()));
     particle.setSpeed(newSpeed);
   }
 }
 public void addParticle(Vector2 position, Vector2 velocity, float life, float scale) {
   if (particles.size > maxParticle) return;
   if (Gdx.graphics.getFramesPerSecond() < 25 && !(this instanceof ExplosionParticleEmitter))
     return;
   Particle particle = freeParticles.obtain();
   particle.setup(position, velocity, life, scale);
   particles.add(particle);
 }
예제 #12
0
 /**
  * Returns the minimum number of occurances that this ContentModelGroup must appear
  *
  * @return the minimum number of occurances that this ContentModelGroup must appear A negative (n
  *     < 0) value indicates that the value is unspecified.
  */
 public int getMinOccurs() {
   if (_contentModel.getParticleCount() > 0) {
     Particle particle = _contentModel.getParticle(0);
     if (particle instanceof ContentModelGroup) {
       return particle.getMinOccurs();
     }
   }
   return _contentModel.getMinOccurs();
 } // -- getMinOccurs
예제 #13
0
 private void removeDeadParticles() {
   for (Particle p : particles) {
     if (p.killed()) {
       particlesRemove.add(p);
     }
   }
   for (Particle pr : particlesRemove) particles.remove(pr);
   particlesRemove.clear();
 }
예제 #14
0
  public double getAccelerationY(Particle p) {

    if ((p.getRecX() >= this.x) && (p.getRecX() <= (this.x + this.length)) && this.haveDone) {
      p.setRecY(2 * p.getY() - p.getRecY());
      this.haveDone = false;
    }

    return 0;
  }
예제 #15
0
  /**
   * @see
   *     org.newdawn.slick.particles.ParticleEmitter#updateParticle(org.newdawn.slick.particles.Particle,
   *     int)
   */
  @SuppressWarnings("null")
  @Override
  public void updateParticle(Particle particle, int delta) {
    particleCount++;

    // adjust the particles if required
    particle.x += adjustx;
    particle.y += adjusty;

    particle.adjustVelocity(
        windFactor.getValue(0) * 0.00005f * delta, gravityFactor.getValue(0) * 0.00005f * delta);

    float offset = particle.getLife() / particle.getOriginalLife();
    float inv = 1 - offset;
    float colOffset = 0;
    float colInv = 1;

    Color startColor = null;
    Color endColor = null;
    for (int i = 0; i < colors.size() - 1; i++) {
      ColorRecord rec1 = colors.get(i);
      ColorRecord rec2 = colors.get(i + 1);

      if ((inv >= rec1.pos) && (inv <= rec2.pos)) {
        startColor = rec1.col;
        endColor = rec2.col;

        float step = rec2.pos - rec1.pos;
        colOffset = inv - rec1.pos;
        colOffset /= step;
        colOffset = 1 - colOffset;
        colInv = 1 - colOffset;
      }
    }

    if (startColor != null) {
      float r = (startColor.r * colOffset) + (endColor.r * colInv);
      float g = (startColor.g * colOffset) + (endColor.g * colInv);
      float b = (startColor.b * colOffset) + (endColor.b * colInv);

      float a;
      if (alpha.isActive()) a = alpha.getValue(inv) / 255.0f;
      else
        a = ((startAlpha.getValue(0) / 255.0f) * offset) + ((endAlpha.getValue(0) / 255.0f) * inv);
      particle.setColor(r, g, b, a);
    }

    if (size.isActive()) {
      float s = size.getValue(inv);
      particle.setSize(s);
    } else particle.adjustSize(delta * growthFactor.getValue(0) * 0.001f);

    if (velocity.isActive()) particle.setSpeed(velocity.getValue(inv));

    if (scaleY.isActive()) particle.setScaleY(scaleY.getValue(inv));
  }
  private void updateParticle(Particle particle) {
    delta = Math.min(0.06f, Gdx.graphics.getDeltaTime());

    if (particle.life > 0) {
      particle.life -= delta;
      particle.position.add(particle.velocity.x * delta * 10, particle.velocity.y * delta * 10);
      particle.velocity.mul((float) Math.pow(damping, delta));
      particle.scale += this.delta_scale * delta / 5f;
    }
  }
 private void slowdownSpeeds(final double dt) {
   for (final Object object : this.particles.keySet()) {
     final Particle particle = this.particles.get(object);
     final Vector oldSpeed = particle.getSpeed();
     final double oldSpeedValue = oldSpeed.getLength();
     final double newSpeedValue = this.slowdownFunction.evaluate(oldSpeedValue, dt);
     final Vector newSpeed = oldSpeed.setLength(newSpeedValue);
     particle.setSpeed(newSpeed);
   }
 }
예제 #18
0
 public void func_73774_a() {
   for (int i = 0; i < field_73776_a.size(); i++) {
     Particle particle = (Particle) field_73776_a.get(i);
     particle.func_78062_a();
     particle.func_78063_a(this);
     if (particle.field_78078_h) {
       field_73776_a.remove(i--);
     }
   }
 }
예제 #19
0
 public static void main(String[] args) {
   List<Frob> list = new ArrayList<Frob>();
   Map<Frob, Fnorkle> map = new HashMap<Frob, Fnorkle>();
   Quark<Fnorkle> quark = new Quark<Fnorkle>();
   Particle<Long, Double> p = new Particle<Long, Double>();
   System.out.println(Arrays.toString(list.getClass().getTypeParameters()));
   System.out.println(Arrays.toString(map.getClass().getTypeParameters()));
   System.out.println(Arrays.toString(quark.getClass().getTypeParameters()));
   System.out.println(Arrays.toString(p.getClass().getTypeParameters()));
 }
예제 #20
0
 @Test
 public void testSimpleBarycenter() {
   Particle p1 = new Particle(1.0, vector(1, 1, 1));
   Particle p2 = new Particle(1.0, vector(0, 0, 0));
   Vector3D center = Particle.geometricCenter(particles(p1, p2));
   Vector3D barycenter = Particle.barycenter(particles(p1, p2));
   Vector3D expected = vector(0.5, 0.5, 0.5);
   assertEquals(expected, center);
   assertEquals(expected, barycenter);
 }
예제 #21
0
  public String toString() {
    String result = "UnitCell [T= " + elapsedTime + " ] : ";
    for (Particle p : particles) {

      result += '\n';
      result += '\t';
      result += p.toString();
    }
    return result;
  }
예제 #22
0
 public void update() {
   for (int i = 0; i < particles.size(); i++) {
     Particle particle = (Particle) particles.get(i);
     particle.preUpdate();
     particle.update(this);
     if (particle.isDead) {
       particles.remove(i--);
     }
   }
 }
예제 #23
0
  public Particle getNewParticle(ParticleEmitter emitter, float life) {
    ParticlePool pool = particlesByEmitter.get(emitter);
    ArrayList<Particle> available = pool.available;
    if (available.size() > 0) {
      Particle p = available.remove(available.size() - 1);
      p.init(emitter, life);
      p.setImage(sprite);

      return p;
    }
    return dummy;
  }
예제 #24
0
  /*loops over particles and moves them*/
  void MoveParticles() {
    Iterator iterator = particles.iterator();
    while (iterator.hasNext()) {
      Particle part = (Particle) iterator.next();

      part.accelerate(dt);
      part.move(dt);

      /*make sure the particle is still in domain*/
      if (!InDomain(part)) iterator.remove();
    }
  }
예제 #25
0
  public boolean collidesWith(Particle p) {
    float deltaX = this.getX() - p.getX();
    float deltaY = this.getY() - p.getY();
    float minDist = this.getR() + p.getR();
    float distance = deltaX * deltaX + deltaY * deltaY;

    if (distance <= (minDist * minDist)) {
      return true;
    }

    return false;
  }
예제 #26
0
 /*
  * The magnetic potential of an atom is always zero, because magnetic force does not do any work. But for a dipole
  * moment, it is not zero.
  *
  * FIXME: I didn't find a closed-form solution for an electric dipole's magnetic potential.
  */
 double getPotential(Particle p, float time) {
   if (bounds != null && !bounds.contains(p.getRx(), p.getRy())) return 0;
   double poten = 0.0;
   if (p instanceof GayBerneParticle) {
     GayBerneParticle gb = (GayBerneParticle) p;
     if (Math.abs(gb.dipoleMoment) > 0) {
       double temp = Math.sin(gb.theta) * gb.vx - Math.cos(gb.theta) * gb.vy;
       if (o == OUTWARD) temp = -temp;
       poten = gb.dipoleMoment * b * temp;
     }
   }
   return poten;
 }
예제 #27
0
  private Particle createRandomizedParticle() {
    Particle rc = new Particle();

    float[] pos = rc.getPosition();
    pos[0] = (float) Math.random() * boxWidth;
    pos[1] = (float) Math.random() * boxHeight;

    float[] vel = rc.getVelocity();
    vel[0] = (float) Math.random() * 150 - 75;
    vel[1] = (float) Math.random() * 150 - 75;

    return rc;
  }
예제 #28
0
  /**
   * Updates the particle view. This should be called on each draw cycle in order to update the
   * positions of all nodes and edges in the viewer. If you need to update the positions of
   * particles without drawing it (e.g. to speed up movement, call updateParticles() instead.
   */
  public void draw() {
    parent.pushStyle();
    parent.pushMatrix();
    zoomer.transform();
    updateCentroid();
    centroid.tick();

    parent.translate(width / 2, height / 2);
    parent.scale(centroid.getZ());
    parent.translate(-centroid.getX(), -centroid.getY());

    if (!isPaused) {
      updateParticles();
    }

    // Ensure that any selected element is positioned at the mouse location.
    if (selectedNode != null) {
      Particle p = nodes.get(selectedNode);
      p.makeFixed();
      float mX = (zoomer.getMouseCoord().x - (width / 2)) / centroid.getZ() + centroid.getX();
      float mY = (zoomer.getMouseCoord().y - (height / 2)) / centroid.getZ() + centroid.getY();
      p.position().set(mX, mY, 0);
    }

    // Draw edges if we have positive stroke weight.
    if (parent.g.strokeWeight > 0) {
      parent.stroke(0, 180);
      parent.noFill();

      for (Map.Entry<E, Spring> row : edges.entrySet()) {
        E edge = row.getKey();
        Spring spring = row.getValue();
        Vector3D p1 = spring.getOneEnd().position();
        Vector3D p2 = spring.getTheOtherEnd().position();
        edge.draw(parent, p1.x(), p1.y(), p2.x(), p2.y());
      }
    }

    // Draw nodes.
    parent.noStroke();
    parent.fill(120, 50, 50, 180);

    for (Map.Entry<N, Particle> row : nodes.entrySet()) {
      N node = row.getKey();
      Vector3D p = row.getValue().position();
      node.draw(parent, p.x(), p.y());
    }

    parent.popMatrix();
    parent.popStyle();
  }
예제 #29
0
  /**
   * Get a new particle from the system. This should be used by emitters to request particles
   *
   * @param emitter The emitter requesting the particle
   * @param life The time the new particle should live for
   * @return A particle from the system
   */
  public Particle getNewParticle(ParticleEmitter emitter, float life) {
    ParticlePool pool = (ParticlePool) particlesByEmitter.get(emitter);
    ArrayList available = pool.available;
    if (available.size() > 0) {
      Particle p = (Particle) available.remove(available.size() - 1);
      p.init(emitter, life);
      p.setImage(sprite);

      return p;
    }

    Log.warn("Ran out of particles (increase the limit)!");
    return dummy;
  }
예제 #30
0
  public static Simulation initSpring(int count, double radius) {
    Settings stt = new Settings();

    stt.setTimeStep(1);
    stt.setSpeedOfLight(3);
    stt.setSimulationWidth(100);
    stt.setSimulationHeight(100);

    stt.addForce(new ConstantForce());
    stt.addForce(new SpringForce());

    stt.setNumOfParticles(count);
    stt.setParticleRadius(radius);
    stt.setParticleMaxSpeed(stt.getSpeedOfLight());

    stt.setBoundary(GeneralBoundaryType.Periodic);
    stt.setParticleSolver(new EulerRichardson());

    for (int k = 0; k < count; k++) {
      Particle par = new Particle();
      par.setX(stt.getSimulationWidth() * Math.random());
      par.setY(stt.getSimulationHeight() * Math.random());
      par.setRadius(15);
      par.setVx(10 * Math.random());
      par.setVy(0);
      par.setMass(1);
      par.setCharge(.001);
      stt.addParticle(par);
    }

    Simulation simulation = new Simulation(stt);
    return simulation;
  }