// Method to update location
 public void update() {
   // Update velocity
   vel.add(acc);
   // Limit speed
   vel.limit(maxspeed);
   loc.add(vel);
   // Reset accelertion to 0 each cycle
   acc.mult(0);
 }
Пример #2
0
 @Override
 public void mouseWheelMoved(MouseWheelEvent e) {
   if (camDist > 1.0) {
     camDist += (0.5f * camDist) * zoomFactor * e.getWheelRotation();
     PVector newMouse = getNewMouse();
     //			PVector toAdd = new PVector(newMouse.x - p.width*0.5f,newMouse.y - p.height*0.5f);
     PVector toAdd = new PVector(newMouse.x, newMouse.y);
     toAdd.sub(new PVector(camCenter.x, camCenter.y));
     toAdd.mult(-0.05f * e.getWheelRotation());
     camPos.add(toAdd);
     //			camPos.mult(0.5f);
     camCenter.add(toAdd);
     //			camCenter.mult(0.5f);
   } else camDist = 1.01f;
 }
Пример #3
0
  void setParent(ControllerGroup<?> theParent) {
    if (_myParent != null && _myParent != this) {
      _myParent.remove(this);
    }

    _myParent = theParent;

    if (_myParent != this) {
      _myParent.add(this);
    }
    absolutePosition = new PVector(position.x, position.y);

    absolutePosition.add(_myParent.absolutePosition);

    positionBuffer = new PVector(position.x, position.y);

    _myControlWindow = _myParent.getWindow();

    for (int i = 0; i < controllers.size(); i++) {
      if (controllers.get(i) instanceof Controller<?>) {
        ((Controller<?>) controllers.get(i))._myControlWindow = _myControlWindow;
      } else {
        ((ControllerGroup<?>) controllers.get(i))._myControlWindow = _myControlWindow;
      }
    }
    if (_myControlWindow != null) {
      setMouseOver(false);
    }
  }
Пример #4
0
 public void displayByArea(DisplayArea area) {
   changeMode();
   position.add(direction);
   if (position.z > 300 || position.z < -300) { // ograniczenie poruszania się obszaru wyświetlania
     direction.mult(-1);
   }
   area.moveCenterTo(position);
   pApplet.stroke(255, 0, 0);
   pApplet.pushMatrix();
   for (int j = 0; j < model.getSegmentCount(); j++) {
     Segment segment = model.getSegment(j);
     Face[] faces = segment.getFaces();
     pApplet.beginShape(PConstants.QUADS);
     for (Face face : faces) {
       if (area.isColliding(face.getCenter())) {
         PVector[] v = face.getVertices();
         PVector[] n = face.getNormals();
         for (int k = 0; k < v.length; k++) {
           pApplet.normal(n[k].x, n[k].y, n[k].z);
           pApplet.vertex(v[k].x, v[k].y, v[k].z);
         }
       }
     }
     pApplet.endShape();
   }
   pApplet.popMatrix();
 }
Пример #5
0
 // tällä funktiolla on huono nimi ja toteutuskin o ruma.
 // tämä on se juttu mikä tekee työt endpoints()ille.
 // jos tilepisteen reunalla toinen tile vain yhdessä suunnassa,
 // niin piste on yksinään. tähän tarttis jonkun kuvan selostamaan.
 PVector head(int x, int y, int z) {
   PVector pp = new PVector(x, y, z);
   PVector[] dirs = {
     new PVector(-1, 0, 0),
     new PVector(1, 0, 0),
     new PVector(0, -1, 0),
     new PVector(0, 1, 0),
     new PVector(0, 0, -1),
     new PVector(0, 0, 1),
   };
   int blkfound = -1;
   for (int i = 0; i < dirs.length; i++) {
     PVector p = dirs[i];
     PVector next = PVector.add(pp, p);
     if (next.x >= 0
         && next.x < size
         && next.y >= 0
         && next.y < size
         && next.z >= 0
         && next.z < size) {
       if (map[at(next)] != 0) {
         if (blkfound != -1) return null;
         blkfound = i;
       }
     }
   }
   if (blkfound != -1) return PVector.sub(pp, dirs[blkfound]);
   return null;
 }
Пример #6
0
 /** {@inheritDoc} */
 public T updateAbsolutePosition() {
   absolutePosition.set(position);
   absolutePosition.add(_myParent.getAbsolutePosition());
   for (int i = 0; i < controllers.size(); i++) {
     controllers.get(i).updateAbsolutePosition();
   }
   return me;
 }
    public void avoid(ArrayList obstacles) {

      // Make a vector that will be the position of the object
      // relative to the Boid rotated in the direction of boid's velocity
      PVector closestRotated = new PVector(sight + 1, sight + 1);
      float closestDistance = 99999;
      Obstacle avoid = null;

      // Let's look at each obstacle
      for (int i = 0; i < obstacles.size(); i++) {
        Obstacle o = (Obstacle) obstacles.get(i);

        float d = PVector.dist(loc, o.loc);
        PVector dir = vel.get();
        dir.normalize();
        PVector diff = PVector.sub(o.loc, loc);

        // Now we use the dot product to rotate the vector that points from boid to obstacle
        // Velocity is the new x-axis
        PVector rotated = new PVector(diff.dot(dir), diff.dot(getNormal(dir)));

        // Is the obstacle in our path?
        if (PApplet.abs(rotated.y) < (o.radius + r)) {
          // Is it the closest obstacle?
          if ((rotated.x > 0) && (rotated.x < closestRotated.x)) {
            closestRotated = rotated;
            avoid = o;
          }
        }
      }

      // Can we actually see the closest one?
      if (PApplet.abs(closestRotated.x) < sight) {

        // The desired vector should point away from the obstacle
        // The closer to the obstacle, the more it should steer
        PVector desired =
            new PVector(closestRotated.x, -closestRotated.y * sight / closestRotated.x);
        desired.normalize();
        desired.mult(closestDistance);
        desired.limit(maxspeed);
        // Rotate back to the regular coordinate system
        rotateVector(desired, vel.heading2D());

        // Draw some debugging stuff
        if (debug) {
          stroke(0);
          line(loc.x, loc.y, loc.x + desired.x * 10, loc.y + desired.y * 10);
          avoid.highlight(true);
        }

        // Apply Reynolds steering rules
        desired.sub(vel);
        desired.limit(maxforce);
        acc.add(desired);
      }
    }
Пример #8
0
  private PVector getLatticePos(String nodeName, String slotName) {

    PVector nodeLoc = lattice.getLocation(nodeName);
    Lattice<Void> slotLat = lattice.getContents(nodeName);

    if (slotLat == null) {
      log.warn("No slot lattice for node " + nodeName);
      return new PVector(0, 0, 0);
    }

    // Node position within the lattice, natural coordinates
    float nodeOffset = nodeSize + 2 * nodePadding;
    PVector nodePos = nodeLoc.get();
    nodePos.mult(nodeOffset);
    nodePos.add(nodePadding, nodePadding, nodePadding);

    PVector slotLoc = slotLat.getLocation(slotName);
    if (slotLoc == null) {
      log.warn("No slot location for slot " + slotName + " in node " + nodeName);
      return nodePos.get();
    }

    // TODO: cache these calculations

    // Slot position within the node, natural coordinates
    float slotOffset = jobSize + 2 * jobPadding;
    PVector slotPos = slotLoc.get();
    slotPos.mult(slotOffset);
    slotPos.add(jobPadding, jobPadding, jobPadding);

    // Combine node and slot position, natural coordinates
    PVector pos = slotPos.get();
    pos.add(nodePos);

    // Convert into central coordinate system
    float latticeWidth = lattice.size * nodeOffset;
    float t = latticeWidth / 2;
    pos.sub(t, t, t);

    return pos;
  }
    public void update(float db) {
      // we can use the db value here to change the speed of the particles
      loc.add(vel.mult(vel, map(db, -100, 100, .05f, 5)));
      if (loc.x < 0 || loc.x > width) {
        vel.x *= -1;
      }
      if (loc.y < 0 || loc.y > height) {
        vel.y *= -1;
      }

      radius = constrain(db, 2, 100);
    }
Пример #10
0
  public Box(float width, float height, float depth /* , DrawMode drawMode */) {

    outlineFrontFace = new ArrayList<PVector>();
    outlineBackFace = new ArrayList<PVector>();
    pointCloud = new ArrayList<YPoint>();

    // Names for vars are Top||Bottom Left||Right || Back||Font
    PVector tlf = new PVector();
    PVector trf = new PVector();

    PVector blf = new PVector();
    PVector brf = new PVector();

    PVector blb = new PVector();
    PVector brb = new PVector();

    PVector tlb = new PVector();
    PVector trb = new PVector();

    tlf.add(width / 2, -height / 2, depth / 2);
    trf.add(-width / 2, -height / 2, depth / 2);

    blf.add(width / 2, height / 2, depth / 2);
    brf.add(-width / 2, height / 2, depth / 2);

    blb.add(width / 2, height / 2, -depth / 2);
    brb.add(-width / 2, height / 2, -depth / 2);

    tlb.add(width / 2, -height / 2, -depth / 2);
    trb.add(-width / 2, -height / 2, -depth / 2);

    // this.drawMode = drawMode;

    outlineFrontFace.add(POV.project(tlf));
    outlineFrontFace.add(POV.project(trf));
    outlineFrontFace.add(POV.project(brf));
    outlineFrontFace.add(POV.project(blf));

    outlineBackFace.add(POV.project(tlb));
    outlineBackFace.add(POV.project(trb));
    outlineBackFace.add(POV.project(brb));
    outlineBackFace.add(POV.project(blb));

    addFaceToPointCloud(outlineFrontFace);
    addFaceToPointCloud(outlineBackFace);
    joinFaces();
  }
 // Function to update location
 public void update() {
   // As long as we aren't dragging the pendulum, let it swing!
   if (!dragging) {
     float G = 0.4f; // Arbitrary universal gravitational constant
     theta_acc =
         (-1 * G / r)
             * sin(
                 theta); // Calculate acceleration (see:
                         // http://www.myphysicslab.com/pendulum1.html)
     theta_vel += theta_acc; // Increment velocity
     theta_vel *= damping; // Arbitrary damping
     theta += theta_vel; // Increment theta
   }
   loc.set(r * sin(theta), r * cos(theta), 0); // Polar to cartesian conversion
   loc.add(origin); // Make sure the location is relative to the pendulum's origin
 }
  public void draw() {
    /*---Update---*/
    world.update();
    worm.update();
    for (int i = 0; i < extraNum; i++) {
      extraWorms[i].update();
    }

    /*---Draw--*/
    // Lights
    lights();
    /*
    ambientLight(128f, 128f, 128f);
    directionalLight(128f, 128f, 128f, 0f, 0f, -1f);
    lightFalloff(1f, 0f, 0f);
    lightSpecular(0f, 0f, 0f);
    */

    // Camera
    perspective(fov, aspect, near, far);
    // Calculate camera position
    if (PVector.dist(worm.getPosition(), eye) > eyeDist) {
      eye = PVector.sub(eye, worm.getPosition());
      eye.normalize();
      eye.mult(eyeDist);
      eye.add(worm.getPosition());
    }
    camera(
        eye.x,
        eye.y,
        eye.z, // eyeX, eyeY, eyeZ (camera position)
        worm.getPosition().x,
        worm.getPosition().y,
        worm.getPosition().z, // centerX, centerY, centerZ (look at)
        0f,
        1f,
        0f); // upX, upY, upZ

    // Action
    world.draw();
    worm.draw();
    for (int i = 0; i < extraNum; i++) {
      extraWorms[i].draw();
    }
    // Drama!
  }
Пример #13
0
 private static void findAwayVector(
     ArrayList<ProximityStructure> mCloseNeighbors, final PVector pForce) {
   /* find away vector */
   if (!mCloseNeighbors.isEmpty()) {
     pForce.set(0, 0, 0);
     /**
      * @todo the vectors could be weighted according to distance: 1.0 - distance ( for example )
      */
     for (ProximityStructure p : mCloseNeighbors) {
       pForce.add(p.distanceVec);
     }
     pForce.mult(1.0f / mCloseNeighbors.size());
     pForce.normalize();
     if (isNaN(pForce)) {
       pForce.set(0, 0, 0);
     }
   } else {
     pForce.set(0, 0, 0);
   }
 }
Пример #14
0
  /**
   * Will calculate the normals for any 2D mesh. <br>
   * This is a heavy mathematical process so should be overridden in child classes if there is a
   * suitable alternative method.
   */
  protected void calcNormals() {
    PVector c, np, nt;
    int ns, ew;
    for (ns = 0; ns < nsSteps; ns++) {
      for (ew = 0; ew < ewSteps /* - 1*/; ew++) {
        c = coord[ew][ns];
        if (ns == nsSteps - 1) {
          np = PVector.sub(c, coord[ew][ns - 1]);
          np.add(c);
        } else np = coord[ew][ns + 1];

        if (ew == ewSteps - 1) nt = coord[1][ns];
        else nt = coord[ew + 1][ns];

        norm[ew][ns] = PVector.cross(PVector.sub(nt, c, null), PVector.sub(np, c, null), null);

        norm[ew][ns].normalize();
      }
    }
  }
Пример #15
0
  /** Triangulate the glyph, but first save the original outline. */
  public void triangulate() {
    // Save the outline and calculate normals
    outline = new Vector<PlanarEdge>();
    for (PlanarEdge e : subdivision.getEdges()) {
      if (e.isRealEdge()) {
        outline.add(e);
      }
    }
    // Calculate outline normals
    outline_normals = new PVector[outline.size()];
    for (PlanarEdge e : outline) {
      TriangulationVertex vert = (TriangulationVertex) e.getDestination();
      // Normal 1
      PVector normal1 = vert.getOutGoingEdge().getDestination().getPoint().get();
      normal1.sub(vert.getPoint());
      normal1.normalize();
      // Vector3 normal1 = new
      // Vector3(vert.getOutGoingEdge().getDestination().getPoint()).subtractLocal(vert.getPoint());
      normal1.z = -normal1.x;
      normal1.x = normal1.y;
      normal1.y = normal1.z;
      normal1.z = 0;
      // Normal 2
      PVector normal2 = vert.getPoint().get();
      normal2.sub(vert.getInGoingEdge().getOrigin().getPoint());
      normal2.normalize();
      // Vector3 normal2 = new
      // Vector3(vert.getPoint()).subtractLocal(vert.getInGoingEdge().getOrigin().getPoint());
      normal2.z = -normal2.x;
      normal2.x = normal2.y;
      normal2.y = normal2.z;
      normal2.z = 0;
      normal1.add(normal2);
      normal1.normalize();

      outline_normals[vert.getIndex()] = normal1;
    }

    // Calculate the triangulation of the surface.
    surface = subdivision.triangulate();
  }
Пример #16
0
  public void setup() {

    mFont = createFont("ArialRoundedMTBold-36", 48);
    size(1440, 900, OPENGL);
    background(0);
    frameRate(120);
    //  model   = new OBJModel(this, "alyson_laugh.obj", "absolute", TRIANGLES);
    model = new OBJModel(this, "alyson_scared.obj", "absolute", TRIANGLES);
    //  model   = new OBJModel(this, "alyson_crying.obj", "absolute", TRIANGLES);

    smooth();
    colorMode(HSB);
    strokeWeight(4);

    model.scale(800);
    model.translateToCenter();

    detailValue = 3;
    scaleValue = 10;
    vertices = new ArrayList();
    ps = new ParticleSystem(this, scaleValue);

    PVector averagePosition = new PVector(0, 0, 0);

    for (int i = 0; i < model.getVertexCount(); i += detailValue) {
      PVector destinationPoint = model.getVertex(i);

      vertices.add(destinationPoint);

      averagePosition.add(destinationPoint);
    }

    averagePosition.div(vertices.size());

    for (int i = 0; i < vertices.size(); i++) {
      PVector destination = (PVector) vertices.get(i);
      Particle p = new Particle(this, averagePosition, destination);
      ps.addParticle(p);
    }
  }
Пример #17
0
  /** Initializes the preview applet layout according to the graph's dimension. */
  private void initAppletLayout() {
    //            graphSheet.setMargin(MARGIN);
    if (model != null && model.getDimensions() != null && model.getTopLeftPosition() != null) {

      // initializes zoom
      Dimension dimensions = model.getDimensions();
      Point topLeftPostition = model.getTopLeftPosition();
      PVector box = new PVector((float) dimensions.getWidth(), (float) dimensions.getHeight());
      float ratioWidth = width / box.x;
      float ratioHeight = height / box.y;
      scaling = ratioWidth < ratioHeight ? ratioWidth : ratioHeight;

      // initializes move
      PVector semiBox = PVector.div(box, 2);
      PVector topLeftVector = new PVector((float) topLeftPostition.x, (float) topLeftPostition.y);
      PVector center = new PVector(width / 2f, height / 2f);
      PVector scaledCenter = PVector.add(topLeftVector, semiBox);
      trans.set(center);
      trans.sub(scaledCenter);
      lastMove.set(trans);
    }
  }
Пример #18
0
    public void checkThirtyDegreeRule(
        ArrayList<Cam> cameras, ArrayList<Character> characters, int selectedIdx) {
      if (cameras == null || cameras.isEmpty()) {
        println("No cameras in the scene!");
      }

      if (characters.size() != 2) {
        println("Only two characters supported for now");
        // TODO (sanjeet): Hack! Fix this once more characters are allowed
      }

      Cam selectedCamera = cameras.get(selectedIdx);

      // TODO The characters.get results in a runtime error because there aren't currently any
      // characters allocated in the input file.
      Character ch1 = characters.get(0);
      Character ch2 = characters.get(1);

      // Obtaining (x,y,z) for characters and selected camera
      PVector ch1Location = ch1.getTranslation();
      PVector ch2Location = ch2.getTranslation();
      PVector selectedCameraLocation = selectedCamera.getTranslation();

      PVector cameraPoint = new PVector();
      cameraPoint.add(selectedCameraLocation);
      for (int i = 0; i < 100; i++) {
        cameraPoint.add(selectedCamera.getZAxis());
      }
      PVector intersection =
          getTwoLinesIntersection(
              new PVector(ch1Location.x, ch1Location.z),
              new PVector(ch2Location.x, ch2Location.z),
              new PVector(selectedCameraLocation.x, selectedCameraLocation.z),
              new PVector(cameraPoint.x, cameraPoint.z));

      PVector diff = PVector.sub(selectedCameraLocation, intersection);
      diff.normalize();
      FloatBuffer fb = selectedCamera.modelViewMatrix;
      float[] mat = fb.array();
      float[] fbMatrix = new float[mat.length];
      for (int i = 0; i < fbMatrix.length; i++) {
        fbMatrix[i] = mat[i];
      }
      fbMatrix[0] = -diff.x;
      fbMatrix[1] = diff.y;
      fbMatrix[2] = -diff.z;
      fbMatrix[9] = diff.x;
      fbMatrix[10] = diff.y;
      fbMatrix[11] = diff.z;
      fbMatrix[13] = intersection.x;
      fbMatrix[14] = intersection.y;
      fbMatrix[15] = intersection.z;
      PMatrix3D matrix = new PMatrix3D();
      matrix.set(fbMatrix);
      matrix.transpose();
      pushMatrix();
      applyMatrix(matrix);
      rotateY(radians(30));
      line(0, 0, 0, 0, 0, 1000);
      rotateY(radians(-2 * 30));
      line(0, 0, 0, 0, 0, 1000);
      popMatrix();

      for (int i = 0; i < cameras.size(); i++) {
        if (i == selectedIdx) {
          continue;
        }

        if (!cameras.get(i).isInView(ch1Location) && !cameras.get(i).isInView(ch2Location)) {
          continue;
        }
        PVector currCamLocation = cameras.get(i).getTranslation();
        PVector vect1 = PVector.sub(currCamLocation, intersection);
        PVector vect2 = PVector.sub(selectedCameraLocation, intersection);
        float dotP = vect1.dot(vect2) / (vect1.mag() * vect2.mag());
        if (acos(dotP) <= PI / 6) {
          cameras.get(i).setColor(255, 0, 0);
        } else {
          cameras.get(i).setColor(0, 0, 255);
        }
      }
    }
 public void update() {
   velocity.add(acceleration);
   location.add(velocity);
   acceleration.mult(0);
   lifespan -= 8.0;
 }
Пример #20
0
 public void setAcceleration(PVector acceleration) {
   this.acceleration = acceleration;
   velocity.add(acceleration);
   position.add(velocity);
 }