예제 #1
0
 /**
  * Removes all physics controls and joints in the given spatial from the physics space (e.g.
  * before saving to disk) - recursive if node
  *
  * @param spatial the rootnode containing the physics objects
  */
 public void removeAll(Spatial spatial) {
   if (spatial.getControl(RigidBodyControl.class) != null) {
     RigidBodyControl physicsNode = spatial.getControl(RigidBodyControl.class);
     // remove joints with physicsNode as BodyA
     List<PhysicsJoint> joints = physicsNode.getJoints();
     for (Iterator<PhysicsJoint> it1 = joints.iterator(); it1.hasNext(); ) {
       PhysicsJoint physicsJoint = it1.next();
       if (physicsNode.equals(physicsJoint.getBodyA())) {
         removeJoint(physicsJoint);
         // remove(physicsJoint.getBodyB());
       }
     }
     remove(physicsNode);
   } else if (spatial.getControl(PhysicsControl.class) != null) {
     remove(spatial);
   }
   // recursion
   if (spatial instanceof Node) {
     List<Spatial> children = ((Node) spatial).getChildren();
     for (Iterator<Spatial> it = children.iterator(); it.hasNext(); ) {
       Spatial spat = it.next();
       removeAll(spat);
     }
   }
 }
예제 #2
0
파일: Main.java 프로젝트: Wigglez/GSP362
  @Override
  public void simpleUpdate(float tpf) {
    Juggernaut.Update(tpf);
    // Vector3f camLeft = cam.getLeft().clone().multLocal(0.4f);
    //        walkDirection.set( 0, 0, 0);
    //        if(left)    { walkDirection.addLocal(Vector3f.UNIT_X.negate().multLocal(0.4f));}
    //        if(right)   { walkDirection.addLocal(Vector3f.UNIT_X.clone().multLocal(0.4f));}
    //        player.setWalkDirection(walkDirection);
    //        if( walkDirection != Vector3f.ZERO){
    //            player.setViewDirection(walkDirection.negate());
    //        }
    //
    //        playerDebug.setLocalTranslation(player.getPhysicsLocation());
    elevator1.setLocalTranslation(304 + 20 * FastMath.cos(timer.getTimeInSeconds()), 20, 0);
    elvtr1.setPhysicsLocation(elevator1.getLocalTranslation());

    //        elevator2.setLocalTranslation( 192, 208 + 35*FastMath.cos(timer.getTimeInSeconds()),
    // 0);
    //        elvtr2.setPhysicsLocation(elevator2.getLocalTranslation());
    elvtr2.setLinearVelocity(new Vector3f(0, 25 * FastMath.cos(timer.getTimeInSeconds()), 0));
    elvtr2.setPhysicsRotation(Matrix3f.IDENTITY);
    System.out.print(landscape.getCollideWithGroups() + "\n");

    for (int i = 0; i < views.length; i++) {
      if (views[i].testForPlayer(Juggernaut)) {
        currentView = views[i];
      }
    }

    cam.setLocation(currentView.CamPosition());
    cam.lookAt(currentView.CamLookAt(), Vector3f.UNIT_Y);
  }
예제 #3
0
 /**
  * Moves the camera to (0, y, 0)
  *
  * @param y
  */
 public void reset() {
   centralNodeControl.setEnabled(false);
   centralNode.setLocalTranslation(0, 0, 0);
   centralNodeControl.setEnabled(true);
   // Re-enabling the control resets the gravity,
   // so we have to set it back to zero.
   centralNodeControl.setGravity(Vector3f.ZERO);
 }
 @Override
 public void update(float tpf) {
   Quaternion rot = new Quaternion().fromAngleAxis(FastMath.QUARTER_PI * tpf, Vector3f.UNIT_Y);
   if (control != null) {
     Quaternion angle = control.getPhysicsRotation();
     Quaternion rotation = rot.mult(angle).normalizeLocal();
     control.setPhysicsRotation(rotation);
     car_con[index].setPhysicsRotation(rotation);
   }
 }
예제 #5
0
  /**
   * Create a prop without adding it to the scene.
   *
   * @param propType which kind of prop to add (not null)
   * @param relativeSize the prop's size relative to standard (&gt;0)
   * @return a new node to represent the prop, or null if the model is invalid
   */
  private Node create(String propType, float relativeSize) {
    assert propType != null;
    assert relativeSize > 0f : relativeSize;

    Node propNode = loadModel(propType);
    Node modelNode = (Node) propNode.getChild(0);
    List<Spatial> parts = modelNode.getChildren();
    /*
     * Texture each part of the prop and specify its hardness.
     */
    for (Spatial part : parts) {
      String partName = part.getName();
      if (!(part instanceof Geometry)) {
        logger.log(Level.SEVERE, "Prop part {0} is not a geometry.", MyString.quote(partName));
        return null;
      }
      String materialName = material(partName);
      SpatialProperties.setHardness(part, materialName);
      Material material = Assets.loadBlockMaterial(materialName);
      part.setMaterial(material);
    }
    /*
     * Set the scale factor.
     */
    float scaleFactor = scene.getScaleFactor();
    float modelScale = relativeSize / scaleFactor;
    propNode.setLocalScale(modelScale);
    assert getRelativeSize(propNode) == relativeSize : relativeSize;
    /*
     * Set other properties.
     */
    propNode.setShadowMode(RenderQueue.ShadowMode.CastAndReceive);
    /*
     * Give the prop a physics control.
     */
    CollisionShape shape = createShape(propType, relativeSize, parts);
    float mass = calculateMass(propType, relativeSize);
    RigidBodyControl rigidBodyControl = new RigidBodyControl(shape, mass);
    propNode.addControl(rigidBodyControl);
    /*
     * Configure the physics control.
     */
    rigidBodyControl.setFriction(friction);
    scene.getWorld().getPhysics().addObject(rigidBodyControl);
    /*
     * Give the prop a PickedControl.
     */
    SpatialProperties.setPickType(propNode, pickType);
    PickedControl pickedControl = new PickedControl();
    propNode.addControl(pickedControl);

    return propNode;
  }
예제 #6
0
 public void onAction(String name, boolean keyPressed, float tpf) {
   if (name.equals("shoot") && !keyPressed) {
     Geometry bulletg = new Geometry("bullet", bullet);
     bulletg.setMaterial(mat2);
     bulletg.setShadowMode(ShadowMode.CastAndReceive);
     bulletg.setLocalTranslation(getCam().getLocation());
     RigidBodyControl bulletNode = new BombControl(assetManager, bulletCollisionShape, 1);
     //                RigidBodyControl bulletNode = new
     // RigidBodyControl(bulletCollisionShape, 1);
     bulletNode.setLinearVelocity(getCam().getDirection().mult(25));
     bulletg.addControl(bulletNode);
     rootNode.attachChild(bulletg);
     getPhysicsSpace().add(bulletNode);
   }
 }
  public void setPosition(String objectID, Vector3f position) {
    // get "visual" or "physical" spatial
    // search in all sub-nodes of root node (scene node, trigger node, ...)
    Spatial object = Util.findNode(sim.getRootNode(), objectID);
    RigidBodyControl control = null;

    try {
      control = (RigidBodyControl) object.getControl(0);
    } catch (IndexOutOfBoundsException e2) {
      System.err.println("Could not manipulate physics of '" + objectID + "'!");
    }

    if (control != null) control.setPhysicsLocation(position);
    else object.setLocalTranslation(position);
  }
  public void showCar() {
    for (int i = 0; i < 4; i++) {
      cars[i] = factory.getCar(car_names[i], assetManager);
      car_con[i] = cars[i].getControl(VehicleControl.class);
    }
    Camera camera = cam.clone();

    camera.setViewPort(.25f, .9f, .1f, .75f);
    carView = this.app.getRenderManager().createPostView("carview", camera);

    space.add(car_con[index]);
    dl = new DirectionalLight();
    localRootNode.addLight(dl);
    ai = new AmbientLight();
    localRootNode.addLight(ai);
    car_con[index].setPhysicsLocation(new Vector3f(0, 1, 0));
    localRootNode.attachChild(cars[index]);
    floor = assetManager.loadModel("Models/garage/garage.mesh.j3o");
    control = new RigidBodyControl(0);
    floor.addControl(control);
    control.setPhysicsLocation(Vector3f.ZERO);
    space.add(control);
    localRootNode.attachChild(floor);

    camera.setLocation(car_con[index].getPhysicsLocation().add(new Vector3f(3, 1f, 0)));
    camera.lookAt(car_con[index].getPhysicsLocation().add(new Vector3f(0, -1, 0)), Vector3f.UNIT_Y);
    dl.setDirection(camera.getDirection());

    carView.attachScene(localRootNode);
  }
  public void setRotation(String objectID, float[] rotation) {
    // get "visual" or "physical" spatial
    // search in all sub-nodes of root node (scene node, trigger node, ...)
    Spatial object = Util.findNode(sim.getRootNode(), objectID);
    RigidBodyControl control = null;

    try {
      control = (RigidBodyControl) object.getControl(0);
    } catch (IndexOutOfBoundsException e2) {
      System.err.println("Could not manipulate physics of '" + objectID + "'!");
    }

    if (control != null) {
      Quaternion rot = new Quaternion().fromAngles(degToRad(rotation));
      control.setPhysicsRotation(rot);
    } else {
      Quaternion rot = new Quaternion().fromAngles(degToRad(rotation));
      object.setLocalRotation(rot);
    }
  }
예제 #10
0
  private void resetWallPhysics(PhysicsSpace space) {
    List<Spatial> children = ((Node) getTerrainNode().getChild("Walls")).getChildren();
    for (Spatial wallNode : children) {
      Spatial wall = ((Node) wallNode).getChild("Wall");
      wall.scale(6f);

      space.removeAll(wallNode);

      CollisionShape meshShape = CollisionShapeFactory.createMeshShape(wall);

      wall.scale(1f / 6f);
      RigidBodyControl wallPhysics = new RigidBodyControl(meshShape, 0);
      wallPhysics.setCollideWithGroups(CollisionGroups.NONE);

      wallPhysics.setFriction(0.5f);
      wall.addControl(wallPhysics);
      wall.getControl(RigidBodyControl.class).setCollisionGroup(CollisionGroups.WALLS);

      space.addAll(wall);
    }
  }
예제 #11
0
  public void loadLevel() {

    // create ground
    Vector3f pos = new Vector3f(0f, -1.5f, 0f);
    float size = 10f;
    Geometry ground = new Geometry("ground", new Box(Vector3f.ZERO, size, 1.0f, size));

    // create node
    Node groundNode = new Node();
    groundNode.attachChild(ground);

    // setup physics
    RigidBodyControl grbc = new RigidBodyControl(0f);
    ground.addControl(grbc);
    getPhysicsSpace().add(grbc);
    grbc.setPhysicsLocation(pos);

    // create boxes
    Vector3f[] positions =
        new Vector3f[] {
          new Vector3f(2f, 0f, 2f),
          new Vector3f(2f, 0f, -2f),
          new Vector3f(-2f, 0f, -2f),
          new Vector3f(-2f, 0f, 2f)
        };
    for (int i = 0; i < 4; i++) {
      Box box = new Box(1f, 1f, 1f);
      Geometry geometry = new Geometry("geometry", box);
      Node node = new Node("box");
      node.attachChild(geometry);

      RigidBodyControl rbc = new RigidBodyControl(0f);
      geometry.addControl(rbc);
      getPhysicsSpace().add(rbc);

      rbc.setPhysicsLocation(positions[i]);
    }
  }
예제 #12
0
 /**
  * This method creates one individual physical cannon ball. By defaul, the ball is accelerated and
  * flies from the camera position in the camera direction.
  */
 public void makeCannonBall() {
   /** Create a cannon ball geometry and attach to scene graph. */
   Geometry ball_geo = new Geometry("cannon ball", sphere);
   ball_geo.setMaterial(stone_mat);
   rootNode.attachChild(ball_geo);
   /** Position the cannon ball and activate shadows */
   ball_geo.setLocalTranslation(cam.getLocation());
   ball_geo.setShadowMode(ShadowMode.CastAndReceive);
   /** Make the ball physcial with a mass > 0.0f */
   ball_phy = new RigidBodyControl(1f);
   /** Add physical ball to physics space. */
   ball_geo.addControl(ball_phy);
   bulletAppState.getPhysicsSpace().add(ball_phy);
   /** Accelerate the physcial ball to shoot it. */
   ball_phy.setLinearVelocity(cam.getDirection().mult(25));
 }
예제 #13
0
  public static Spatial AddModel(Vector3f position, String name) {
    s_Model = Main.s_AssetManager.loadModel("Models/tree.obj");

    s_Model.setLocalTranslation(position);
    s_Model.scale(0.8f);
    s_Model.setName(name);

    s_Model.setShadowMode(ShadowMode.CastAndReceive);

    CollisionShape collision = new CapsuleCollisionShape(0.5f, 1f);
    physicsControl = new RigidBodyControl(collision, 0);
    physicsControl.setKinematic(true);
    s_Model.addControl(physicsControl);
    Main.bulletAppState.getPhysicsSpace().add(s_Model);
    // Main.s_TreeNode.attachChild(s_Model);

    return s_Model;
  }
예제 #14
0
 @Override
 protected void controlUpdate(float tpf) {
   RigidBodyControl diceControl = spatial.getControl(RigidBodyControl.class);
   if (number != 0) {
     diceControl.setEnabled(true);
     int numberValue = 0;
     synchronized (spatial) {
       numberValue = number;
     }
     switch (numberValue) {
       case 1:
         diceControl.setPhysicsRotation(
             new Quaternion().fromAngleAxis(FastMath.HALF_PI, new Vector3f(1, 0, 0)));
         break;
       case 2:
         diceControl.setPhysicsRotation(
             new Quaternion().fromAngleAxis(-FastMath.HALF_PI, new Vector3f(0, 1, 0)));
         break;
       case 3:
         diceControl.setPhysicsRotation(
             new Quaternion().fromAngleAxis(FastMath.ZERO_TOLERANCE, new Vector3f(1, 0, 0)));
         break;
       case 4:
         diceControl.setPhysicsRotation(
             new Quaternion().fromAngleAxis(FastMath.PI, new Vector3f(1, 0, 0)));
         break;
       case 5:
         diceControl.setPhysicsRotation(
             new Quaternion().fromAngleAxis(FastMath.HALF_PI, new Vector3f(0, 1, 0)));
         break;
       case 6:
         diceControl.setPhysicsRotation(
             new Quaternion().fromAngleAxis(-FastMath.HALF_PI, new Vector3f(1, 0, 0)));
         break;
     }
     diceControl.setLinearVelocity(new Vector3f(0, 0, 0));
     diceControl.setAngularVelocity(new Vector3f(0, 0, 0));
     diceControl.setPhysicsLocation(putLocation);
     spatial.getControl(AbstractRollControl.class).setEnabled(false);
     Geometry d6 = ((Geometry) spatial);
     d6.getMaterial().setColor("Diffuse", ColorRGBA.White);
     number = 0;
   } else {
     diceControl.setEnabled(false);
     this.setEnabled(false);
   }
 }
예제 #15
0
 /** Sets the speed at which the camera should move forward */
 public void setSpeed(float speed) {
   centralNodeControl.setLinearVelocity(new Vector3f(0, speed, 0));
 }
예제 #16
0
 /** Gets the speed at which the camera is moving forward */
 public float getSpeed() {
   return centralNodeControl.getLinearVelocity().y;
 }
예제 #17
0
파일: Main.java 프로젝트: Wigglez/GSP362
  @Override
  public void simpleInitApp() {

    //        setUpKeys();
    flyCam.setEnabled(false);

    bulletAppState = new BulletAppState();
    stateManager.attach(bulletAppState);
    bulletAppState.getPhysicsSpace().enableDebug(assetManager);

    Juggernaut = new Character(this, bulletAppState);

    setUpCameraBoxes();
    // Load in the level
    // Material m = assetManager.loadMaterial("Models/levelLayout - Update.mtl");
    Spatial map = assetManager.loadModel("Models/levelLayout - Update_cameraPos.obj");
    rootNode.attachChild(map);

    Material mark_mat = new Material(assetManager, "Common/MatDefs/Misc/Unshaded.j3md");
    //       mark_mat.setColor("Color", ColorRGBA.White);
    //       mark.setMaterial(mark_mat);
    //        mark.setLocalTranslation(1f,1f,1f);
    //        rootNode.attachChild(mark);

    CollisionShape sceneShape = CollisionShapeFactory.createMeshShape(map);
    landscape = new RigidBodyControl(sceneShape, 0);
    map.addControl(landscape);
    landscape.setCollisionGroup(1);
    landscape.removeCollideWithGroup(2);

    //        //Load Ninja as filler for character model
    //        ninja = assetManager.loadModel("Models/Ninja/Ninja.mesh.xml");
    //        //ninja.rotate(0, -1.5f, 0);
    //        ninja.scale(0.02f, 0.02f, 0.02f);
    //        ninja.setLocalTranslation(new Vector3f(341, 300, 0));
    //        //ninja.setMaterial(mark_mat);
    //        rootNode.attachChild(ninja);
    //        CapsuleCollisionShape capsuleShape = new CapsuleCollisionShape(1f, 2f);
    //        player = new CharacterControl(capsuleShape, .05f);
    //        player.setJumpSpeed(50);
    //        player.setFallSpeed(50);
    //        player.setGravity(120);
    //        player.setPhysicsLocation(new Vector3f(1f,8f,1f));
    //        player.setViewDirection(new Vector3f(-1.0f, 0, 0));
    //        player.setCollideWithGroups(2);
    //
    //
    //
    //        playerDebug = player.createDebugShape(assetManager);
    //        ninja.addControl(player);
    //        rootNode.attachChild(playerDebug);
    //
    //        bulletAppState.getPhysicsSpace().add(player);
    bulletAppState.getPhysicsSpace().add(landscape);

    // Elevator 1
    elevator1 = new Geometry("Elevator1", new Box(4, 1, 5));
    elevator1.setLocalTranslation(304, 20, 0);
    elevator1.setMaterial(mark_mat);
    elvtr1 = new RigidBodyControl(10);

    elevator1.addControl(elvtr1);
    elvtr1.setFriction(1000.0f);
    elvtr1.setKinematic(true);
    bulletAppState.getPhysicsSpace().add(elvtr1);
    rootNode.attachChild(elevator1);

    // Elevator 2
    elevator2 = new Geometry("Elevator2", new Box(4, 1, 5));
    elevator2.setLocalTranslation(192, 208, 0);
    elevator2.setMaterial(mark_mat);
    elvtr2 = new RigidBodyControl(1000000000);

    elevator2.addControl(elvtr2);
    elvtr2.setAngularDamping(100000.0f);
    elvtr2.setFriction(1000.0f);
    //        elvtr2.setKinematic(true);
    bulletAppState.getPhysicsSpace().add(elvtr2);
    rootNode.attachChild(elevator2);

    // Add lights to see the models
    DirectionalLight sun = new DirectionalLight();
    sun.setDirection(new Vector3f(-0.1f, -0.7f, -1.0f));
    rootNode.addLight(sun);

    AmbientLight al = new AmbientLight();
    al.setColor(ColorRGBA.White);
    rootNode.addLight(al);

    //        cam.setLocation(new Vector3f(player.getPhysicsLocation().x,
    // player.getPhysicsLocation().y + 5, player.getPhysicsLocation().z +40 ));
    //        cam.lookAt(player.getPhysicsLocation(), Vector3f.UNIT_Y);
    cam.setLocation(new Vector3f(0, 5, 40));
    cam.lookAt(new Vector3f(0, 5, 0), Vector3f.UNIT_Y);
  }
예제 #18
0
  /**
   * Initialises and sets up the camera. This should be called as soon as possible
   *
   * @param root The node to attach the camera to
   * @param physics The physics of the physics engine
   * @param cam The camera that we are going to position here
   */
  public void loadCamera(Node root, PhysicsSpace physics, Camera cam) {
    // Create a node that is at the origin
    centralNode = new Node(nodeName);
    // Create a physics control, that we can move the node with
    centralNodeControl = new RigidBodyControl(1);
    // Add the control
    centralNode.addControl(centralNodeControl);

    // Set up camera
    CameraNode camNode = new CameraNode("cam", cam);
    // The node moves the camera, instead of the camera moving the node
    camNode.setControlDir(CameraControl.ControlDirection.SpatialToCamera);
    // Move it back and up a bit
    camNode.setLocalTranslation(new Vector3f(0, -10, 20));
    // camNode.setLocalTranslation(new Vector3f(0, -10, 50));
    // Look at the origin
    camNode.lookAt(centralNode.getLocalTranslation(), Vector3f.UNIT_Z);

    // Attach the camera to the node at the origin, so that the camera
    // follows the node
    centralNode.attachChild(camNode);

    // Plane that stays at the top of the screen to stop the ball rolling
    // out of sight
    Plane upperPlane = new Plane(Vector3f.UNIT_Y.negate(), -11f);
    RigidBodyControl upperCollision = new RigidBodyControl(new PlaneCollisionShape(upperPlane), 1f);
    Node upperPlaneNode = new Node("uplane");
    upperPlaneNode.addControl(upperCollision);
    // And another plane for bottom of the screen
    Plane lowerPlane = new Plane(Vector3f.UNIT_Y, -19f);

    RigidBodyControl lowerCollision = new RigidBodyControl(new PlaneCollisionShape(lowerPlane), 1f);
    Node lowerPlaneNode = new Node("lplane");
    lowerPlaneNode.addControl(lowerCollision);
    // Put the planes into their own group so that boxes do not collide with them
    upperCollision.setCollisionGroup(PhysicsCollisionObject.COLLISION_GROUP_02);
    lowerCollision.setCollisionGroup(PhysicsCollisionObject.COLLISION_GROUP_02);
    // Makes the planes un-affected by forces
    upperCollision.setKinematic(true);
    lowerCollision.setKinematic(true);

    // Attach the planes to the central point that the camera looks at
    // That way we can move them both by moving the central point.
    centralNode.attachChild(upperPlaneNode);
    centralNode.attachChild(lowerPlaneNode);

    // Add some lighting
    PointLight light = new PointLight();
    light.setColor(ColorRGBA.White);
    // light.setRadius(30);
    LightControl lightControl = new LightControl(light);
    // Needs to be added to the camera, as a point in space
    camNode.addControl(lightControl);
    // And added to the root, to have an effect on everything
    root.addLight(light);

    // Finally, add the centre point to the root node
    root.attachChild(centralNode);

    // And add the planes and the centre point to the physics space
    physics.add(upperPlaneNode);
    physics.add(lowerPlaneNode);
    physics.add(centralNode);

    centralNodeControl.setGravity(Vector3f.ZERO); // No gravity
    centralNodeControl.setLinearVelocity(Vector3f.UNIT_Y); // Moves forward
  }