コード例 #1
0
  /**
   * Gets all x,y coordinates, that have the lowest z-value, therefore making an appropriate measure
   * for a 3D->2D conversion
   *
   * @param verticesBuffer the vertices buffer
   * @return the coordinates
   */
  private List<Vector2f> getCoordinates(FloatBuffer verticesBuffer) {

    // get Coordinates into an array
    float[] vertices = new float[verticesBuffer.capacity()];

    for (int i = 0; i < verticesBuffer.capacity(); i++) {
      vertices[i] = verticesBuffer.get(i);
    }
    // read closest points based on their z-value

    // find smallest z-value
    float z = Float.MAX_VALUE;
    for (int i = 2; i < vertices.length; i += 3) {
      if (vertices[i] < z) {
        z = vertices[i];
      }
    }

    // add all points with a z-value that are equals
    Vector2f vertex;
    List<Vector2f> finalList = new ArrayList<Vector2f>();
    for (int i = 2; i < vertices.length; i += 9) {
      if (vertices[i] == z) {
        vertex = new Vector2f();
        vertex.x = vertices[i - 2];
        vertex.y = vertices[i - 1];
        finalList.add(vertex);
      }
    }

    return finalList;
  }
コード例 #2
0
ファイル: Tank.java プロジェクト: javacslip/battle-tanks
  public void update(long dtime) {
    super.update(dtime);
    if (this.health == 0 && this.dead == false) {
      if (this == Gamestate.getInstance().getPlayer()) {
        this.setController(new NoController());
      }

      SOUNDS.TANK_EXPLODE.play();
      Vector3f bpos = new Vector3f(this.getBase().getPos());
      Gamestate.getInstance().addObject(new ExplosionCluster(bpos, new Vector3f(0, 1.2f, 0), 20));
      this.setController(new NoController());
      this.dead = true;
      this.base.unjoin(this.turret);
      this.parts.remove(this.turret);

    } else {
      lastFired++;
      Vector2f lookdir = turret.getPhys().getDir();
      if (lookdir.y > 25.0f) lookdir.y = 25.0f;
      if (lookdir.y < -25.0f) lookdir.y = -25.0f;

      if (lookdir.x > 55.0f) lookdir.x = 55.0f;
      if (lookdir.x < -55.0f) lookdir.x = -55.0f;

      turret.getPhys().setDir(lookdir);
    }
  }
コード例 #3
0
 public void mouseReleased(MouseEvent event) {
   Vector2f vector = new Vector2f((float) event.getX() - x, (float) event.getY() - y);
   vector.normalize();
   if (Math.abs(event.getX() - x) < 0.0001) {
     camera_pos = new Vector3f(-4.35f, 4.0f, -35.0f);
   } else {
     camera_pos =
         new Vector3f(
             (float) (camera_pos.x + vector.x * 4.0),
             (float) (camera_pos.y + vector.y * 4.0),
             camera_pos.z);
     // camera_pos = calculateCordinates(vector);
   }
   model.transformPoints(camera_pos);
   list = model.project(new OrthographicProjection());
   repaint();
 }
コード例 #4
0
 /** @return Vector2f vector holding the starting location for a Person Node */
 public Vector2f pStartLocation() {
   // Try to place the new node in a location that won't disrupt the system too much (by being too
   // close to another person)
   for (int i = 0; i < 100; i++) {
     Vector2f testStart = this.randomLocation();
     boolean good = true;
     for (code_swarm.PersonNode n : code_swarm.getLivingPeople()) {
       Vector2f delta = new Vector2f();
       delta.sub(n.mPosition, testStart);
       if (delta.lengthSquared() < MIN_DISTANCE_SQR) {
         good = false;
         break;
       }
     }
     if (good) return testStart;
   }
   return randomLocation();
 }
コード例 #5
0
    public Vertex(Vertex start, Vertex end, float interp) {
      Vector3f pos = new Vector3f();
      pos.interpolate(start.positionvf(), end.positionvf(), interp);
      positionvf(pos);

      Vector4f colour = new Vector4f();
      colour.interpolate(start.colourv(), end.colourv(), interp);
      colourv(colour);

      Vector3f normal = new Vector3f();
      normal.interpolate(start.normalv(), end.normalv(), interp);
      normalvf(normal);

      Vector2f tex = new Vector2f();
      tex.interpolate(start.texv(), end.texv(), interp);
      texv(tex);

      Vector2f light = new Vector2f();
      light.interpolate(start.lightv(), end.lightv(), interp);
      lightv(light);
    }
コード例 #6
0
  public double calcDensity(int x, int y, int z) {
    double height = calcBaseTerrain(x, z);
    double ocean = calcOceanTerrain(x, z);
    double river = calcRiverTerrain(x, z);

    float temp = biomeProvider.getTemperatureAt(x, z);
    float humidity = biomeProvider.getHumidityAt(x, z);

    Vector2f distanceToMountainBiome = new Vector2f(temp - 0.25f, humidity - 0.35f);

    double mIntens = TeraMath.clamp(1.0 - distanceToMountainBiome.length() * 3.0);
    double densityMountains = calcMountainDensity(x, y, z) * mIntens;
    double densityHills = calcHillDensity(x, y, z) * (1.0 - mIntens);

    int plateauArea = (int) (Chunk.SIZE_Y * 0.10);
    double flatten = TeraMath.clamp(((Chunk.SIZE_Y - 16) - y) / plateauArea);

    return -y
        + (((32.0 + height * 32.0) * TeraMath.clamp(river + 0.25) * TeraMath.clamp(ocean + 0.25))
                + densityMountains * 1024.0
                + densityHills * 128.0)
            * flatten;
  }
コード例 #7
0
 // Vector arithmetic
 // A: current position
 // B: target position
 // d: distance to travel along the line from A to B
 //     A_moved = A + |B - A| * d where |  | represents 'norm'
 public void updateLocation() {
   Vector2f currentLoc = new Vector2f((float) getX2(), (float) getY2());
   Vector2f update = new Vector2f(target.x, target.y);
   update.sub(currentLoc); // B - A
   update.normalize(); // |B - A|
   update.scale(travelDistance); // |B - A| x dist
   currentLoc.add(update); // A + |B - A| x d
   setLine(x1, y1, currentLoc.x, currentLoc.y);
 }
コード例 #8
0
  /**
   * Method that allows Physics Engine to modify Speed / Position during the relax phase.
   *
   * @param pNode the node to which the force apply @Note Standard physics is "Position Variation =
   *     Speed x Duration" with a convention of "Duration=1" between to frames
   */
  public void onRelax(code_swarm.PersonNode pNode) {
    Vector2f delta = new Vector2f();

    // A gentle force to attract pNodes to the center
    // NOTE: this should be done prior to attraction/repulsion forces, otherwise
    // tends to generate a grid-like pattern
    Vector2f midpoint = new Vector2f(code_swarm.width / 2, code_swarm.height / 2);
    delta = new Vector2f();
    delta.sub(midpoint, pNode.mPosition);

    delta.scale(1 / delta.length() * 0.003f);
    pNode.mPosition.add(delta);

    // All person nodes attract each other, but only to a certain point, then they repel with gentle
    // force
    for (code_swarm.PersonNode n : code_swarm.getLivingPeople()) {
      if (pNode != n) {
        delta.sub(pNode.mPosition, n.mPosition);
        if (delta.lengthSquared() < MIN_DISTANCE_SQR) {
          // This calculation gives a 'stiff spring' affect
          float toMove = ((float) Math.sqrt(MIN_DISTANCE_SQR) - delta.length()) / 10.0f;

          // This calculation gives a much nicer flow
          // float toMove = 0.03f;
          delta.scale((1 / delta.length()) * toMove);

          n.mPosition.sub(delta);
          pNode.mPosition.add(delta);
        } else {
          float toMove = -0.003f;
          delta.scale((1 / delta.length()) * toMove);

          n.mPosition.sub(delta);
          pNode.mPosition.add(delta);
        }
      }
    }

    // place the edited files around the person
    Iterator<code_swarm.FileNode> editedFiles = pNode.editing.iterator();
    int index = 0;
    int radius = 45;
    final int node_size = 4;
    final int salt = pNode.hashCode(); // used to randomize orientation of circle of nodes
    int num_nodes_in_ring = (int) ((2 * radius * Math.PI) / node_size);
    while (editedFiles.hasNext()) {
      // if we've placed all the nodes in this ring...
      if (index == num_nodes_in_ring) {
        // start on a new ring
        radius += node_size;
        num_nodes_in_ring = (int) ((2 * radius * Math.PI) / node_size);
        index = 0;
      }
      index++;

      code_swarm.FileNode file = editedFiles.next();
      // leave a hole for the null files
      if (file == null) continue;

      final int place_around_ring = index * num_nodes_in_ring + salt;
      int x = (int) (radius * Math.sin(place_around_ring));
      int y = (int) (radius * Math.cos(place_around_ring));

      delta = new Vector2f();
      delta.sub(file.mPosition, new Vector2f(pNode.mPosition.x + x, pNode.mPosition.y + y));
      float distance = delta.length();
      delta.scale(1 / delta.length() * -0.01f * distance);
      file.mPosition.add(delta);
    }
  }
コード例 #9
0
ファイル: Geometry.java プロジェクト: mjs513/cs4620-1
  /*
   * Takes in a 3D location and spits out its texture coordinate. This version
   * simply returns 1/2 the x and y coordinate, offset by 0.5 This will ensure
   * that all texture coordinates are valid, based on assumption about the
   * incoming 3D location. This is valid because we know this method will only
   * be called from our spheretri methods.
   */
  private static void xyTex(Vector3f v, Vector2f tex) {

    tex.x = v.x / 2 + 0.5f;
    tex.y = v.y / 2 + 0.5f;
  }
コード例 #10
0
  /**
   * Set the layout of the child elements here. Will be executed if the display or a parent window
   * was resized.
   */
  public void layout() {

    // reset to the position and size to the original position
    position.set(positionOriginal);
    size.set(sizeOriginal);

    /*
       Position
    */

    position.x = calcHorizontalAlign(horizontalAlign);
    position.y = calcVerticalAlign(verticalAlign);

    // recalculate position x relative to parent if unit is percentage
    if (unitPositionX == EUnitType.PERCENTAGE
        && positionType == EPositionType.RELATIVE
        && parent != null) {
      getPosition().x += parent.getSize().x * positionOriginal.x / 100f;
    } else if (unitPositionX == EUnitType.PERCENTAGE && positionType == EPositionType.ABSOLUTE) {
      // recalculate position x absolute to display if unit is percentage
      getPosition().x += Display.getWidth() * positionOriginal.x / 100f;
    } else {
      getPosition().x += positionOriginal.x;
    }

    // recalculate position x relative to parent if unit is percentage
    if (unitPositionY == EUnitType.PERCENTAGE
        && positionType == EPositionType.RELATIVE
        && parent != null) {
      getPosition().y += parent.getSize().y * positionOriginal.y / 100f;
    } else if (unitPositionY == EUnitType.PERCENTAGE && positionType == EPositionType.ABSOLUTE) {
      // recalculate position x absolute to display if unit is percentage
      getPosition().y += Display.getHeight() * positionOriginal.y / 100f;
    } else {
      getPosition().y += positionOriginal.y;
    }

    /*
       Size
    */

    // recalculate width relative to parent if unit is percentage
    if (unitSizeX == EUnitType.PERCENTAGE
        && positionType == EPositionType.RELATIVE
        && parent != null) {
      getSize().x = parent.getSize().x * size.x / 100f;
    } else if (unitSizeX == EUnitType.PERCENTAGE && positionType == EPositionType.ABSOLUTE) {
      // recalculate width absolute to display if unit is percentage
      getSize().x = Display.getWidth() * size.x / 100f;
    }

    // recalculate height relative to parent if unit is percentage
    if (unitSizeY == EUnitType.PERCENTAGE
        && positionType == EPositionType.RELATIVE
        && parent != null) {
      getSize().y = parent.getSize().y * size.y / 100f;
    } else if (unitSizeY == EUnitType.PERCENTAGE && positionType == EPositionType.ABSOLUTE) {
      // recalculate height absolute to display if unit is percentage
      getSize().y = Display.getHeight() * size.y / 100f;
    }
  }