Пример #1
0
 void setDirectionVector(ServerElement element, Float x, Float y, Float z) {
   RigidBody rb = elementToRigidBody.get(element);
   rb.getOrientation(oriantation);
   rot.set(oriantation);
   directionVector.set(x, y, z);
   rot.transform(directionVector);
 }
Пример #2
0
  void updateServerElements() {
    for (RigidBody rb : rigidBodies) {
      ServerElement element = rigidBodyToServerElement.get(rb);
      if (rb != null && rb.getMotionState() != null) {
        rb.getMotionState().getWorldTransform(tmpTrans);
        element.setTransform(tmpTrans);
      }
      if (!rb.isActive()) {
        rb.activate();
      }
      // log.debug(" "+element.getPosition());
    }

    for (Integer id : serverGameArea.getGameState().getDynamicElements().keySet()) {
      ServerElement elem = serverGameArea.getGameState().getDynamicElements().get(id);
      elem.getCollidees().clear();
    }

    Integer nbManifold = dynamicsWorld.getDispatcher().getNumManifolds();
    for (Integer i = 0; i < nbManifold; i++) {
      PersistentManifold pm = dynamicsWorld.getDispatcher().getManifoldByIndexInternal(i);
      RigidBody rb0 = (RigidBody) pm.getBody0();
      RigidBody rb1 = (RigidBody) pm.getBody1();

      ServerElement elem0 = rigidBodyToServerElement.get(rb0);
      ServerElement elem1 = rigidBodyToServerElement.get(rb1);

      if ((elem0 instanceof ServerBullet) || (elem1 instanceof ServerBullet)) {
        log.info("coll " + elem0 + " " + elem1);
      }

      elem0.addCollidee(elem1);
      elem1.addCollidee(elem0);
    }
  }
Пример #3
0
  public void transform(Matrix4f mat, boolean updateLocal) {
    activate();

    Transform t = new Transform();
    t.set(mat);

    Vector3f v = new Vector3f();
    for (int i = 0; i < 3; ++i) {
      t.basis.getColumn(i, v);
      v.normalize();
      t.basis.setColumn(i, v);
    }

    body.setWorldTransform(t);

    // required for static objects:
    body.getMotionState().setWorldTransform(t);
    if (body.isInWorld() && body.isStaticOrKinematicObject()) {
      scene.world.updateSingleAabb(body);
      for (GameObject g : touchingObjects) g.activate();
    }
    //

    updateChildTransforms();

    if (parent != null && updateLocal) {
      updateLocalTransform();
    }
  }
Пример #4
0
 public void mass(float mass) {
   if (mass == 0) {
     throw new RuntimeException("no zero value allowed: use 'dynamics(false)' instead");
   }
   Vector3f inertia = new Vector3f();
   body.getCollisionShape().calculateLocalInertia(mass, inertia);
   body.setMassProps(mass, inertia);
 }
Пример #5
0
 public void setElementRotation(ServerElement element, Float rot) {
   // log.debug("rot");
   RigidBody rb = elementToRigidBody.get(element);
   synchronized (turnVector) {
     turnVector.set(0f, rot, 0f);
     rb.applyTorque(turnVector);
     // rb.setAngularVelocity(turnVector);
   }
 }
Пример #6
0
 public void dynamics(boolean restore) {
   if (currBodyType.equals("DYNAMIC") || currBodyType.equals("RIGID_BODY")) {
     if (restore) {
       bodyType(currBodyType);
     } else { // suspend
       body.setCollisionFlags(body.getCollisionFlags() | CollisionFlags.KINEMATIC_OBJECT);
     }
   }
 }
Пример #7
0
  public void ghostNoChildren(boolean ghost) {
    int flags = body.getCollisionFlags();
    int noContact = CollisionFlags.NO_CONTACT_RESPONSE;

    if (ghost) flags |= noContact;
    else flags &= ~noContact;

    body.setCollisionFlags(flags);
  }
Пример #8
0
 public void setServerElementStraf(ServerElement element, Float straf) {
   // log.debug("accel");
   synchronized (directionVector) {
     setRightDirectionVector(element);
     directionVector.scale(straf);
     RigidBody rb = elementToRigidBody.get(element);
     rb.applyCentralForce(directionVector);
     // rb.setLinearVelocity(directionVector);
   }
 }
  @Override
  public Element persist(Document doc, Element widgetNode, Widget widget) {
    CylinderWidget cylinder = (CylinderWidget) widget;
    RigidBody cylinderBody = cylinder.getRigidBody();

    widgetNode.appendChild(
        persistParam(
            doc, "location", v3fToString(cylinderBody.getCenterOfMassPosition(new Vector3f()))));
    widgetNode.appendChild(
        persistParam(
            doc,
            "orientation",
            v3fToString(
                RenderableBase.toAngles(
                    cylinderBody.getWorldTransform(new Transform()).getRotation(new Quat4f())))));
    widgetNode.appendChild(
        persistParam(
            doc, "linearVeloctiy", v3fToString(cylinderBody.getLinearVelocity(new Vector3f()))));
    widgetNode.appendChild(
        persistParam(
            doc, "angularVelocity", v3fToString(cylinderBody.getAngularVelocity(new Vector3f()))));
    widgetNode.appendChild(persistParam(doc, "radius", "" + cylinder.getRadius()));
    widgetNode.appendChild(persistParam(doc, "height", "" + cylinder.getHeight()));
    widgetNode.appendChild(persistParam(doc, "mass", "" + (1f / cylinderBody.getInvMass())));
    widgetNode.appendChild(persistParam(doc, "restitution", "" + cylinderBody.getRestitution()));
    widgetNode.appendChild(persistParam(doc, "friction", "" + cylinderBody.getFriction()));

    return widgetNode;
  }
Пример #10
0
 public Vector3f velocityLocal() {
   Vector3f v = new Vector3f();
   body.getLinearVelocity(v);
   Matrix3f invOri = orientation();
   invOri.invert();
   return invOri.mult(v);
 }
 public void update(float deltaTime) {
   rigidBody.getMotionState().getWorldTransform(trans);
   this.getPosition().set(trans.origin.x, trans.origin.y, trans.origin.z);
   //		Quat4f rotate = trans.getRotation(new Quat4f());
   //		float[] rotation = new float[] { 0, 0, 0, 0 };
   //		rotation = GPTransLation.translateQuatToAXYZ(rotate);
   //		this.setRotation(rotation);
 }
 /**
  * @param restitution反弹系数
  * @param friction摩擦力系数
  * @param mass
  */
 public void init(float restitution, float friction, float mass) {
   this.restitution = restitution;
   this.friction = friction;
   this.mass = mass;
   intertia = new javax.vecmath.Vector3f();
   RigidBodyConstructionInfo info;
   if (mass == 0) {
     info = new RigidBodyConstructionInfo(this.mass, state, shape);
   } else {
     shape.calculateLocalInertia(mass, intertia);
     info = new RigidBodyConstructionInfo(this.mass, state, shape, intertia);
   }
   rigidBody = new RigidBody(info);
   rigidBody.setFriction(friction);
   rigidBody.setRestitution(restitution);
   world.addRigidBody(rigidBody);
 }
Пример #13
0
  public void setServerElementForce(ServerElement element) {
    // log.debug("accel");
    synchronized (directionVector) {
      RigidBody rb = elementToRigidBody.get(element);
      Vector3f velocity = new Vector3f();
      rb.getLinearVelocity(velocity);
      velocity.scale(-1f);
      rb.applyCentralForce(velocity);

      Vector3f angularVelocity = new Vector3f();
      rb.getAngularVelocity(angularVelocity);
      angularVelocity.scale(-0.5f);
      rb.applyTorque(angularVelocity);
      // rb.setLinearVelocity(directionVector);

    }
  }
Пример #14
0
  public void parent(GameObject p, boolean compound) {
    CompoundShape compShapeOld = null;

    if (parent != null) {
      parent.children.remove(this);

      if (compound) {
        compShapeOld = parent.compoundShape();
        if (compShapeOld != null) {
          scene.world.removeRigidBody(parent.body);
          compShapeOld.removeChildShape(body.getCollisionShape());
          scene.world.addRigidBody(parent.body);
        }
      }

    } else if (p == null) {
      return;
    }

    parent = p;

    if (parent != null) {

      parent.children.add(this);

      updateLocalTransform();
      updateLocalScale();

      if (compound) {
        CompoundShape compShape = parent.compoundShape();
        if (compShape != null) {
          scene.world.removeRigidBody(body);
          compShape.addChildShape(new Transform(localTransform), body.getCollisionShape());
        }
      } else {
        dynamics(false);
      }

    } else if (currBodyType.equals("STATIC") || currBodyType.equals("SENSOR")) {
      if (compound && compShapeOld != null) scene.world.addRigidBody(body);

    } else {
      dynamics(true);
    }
  }
Пример #15
0
  private void updateRigidBodys() {
    for (RigidBody rb : rigidBodies) {
      ServerElement element = rigidBodyToServerElement.get(rb);
      if (rb != null && rb.getMotionState() != null) {
        if (element.isUpdatedByUser()) {

          /*rb.getMotionState().getWorldTransform(tmpTrans);
          tmpTrans.origin.x=element.getTransform().origin.x;
          tmpTrans.origin.y=element.getTransform().origin.y;
          tmpTrans.origin.z=element.getTransform().origin.z;
          */
          rb.getMotionState().setWorldTransform(element.getTransform());
          rb.setMotionState(rb.getMotionState());
          element.resetUpdatedByUser();
        }
      }
    }
  }
Пример #16
0
  public void scale(float x, float y, float z, boolean updateLocal) {
    activate();
    // Set unit scale
    Matrix4 t = modelInstance.transform;
    Matrix4 mat_scale = new Matrix4();
    Vector3 s = new Vector3();
    t.getScale(s);
    mat_scale.scl(1 / s.x, 1 / s.y, 1 / s.z);
    t.mul(mat_scale);

    // Set target scale
    mat_scale.idt();
    mat_scale.scl(x, y, z);
    t.mul(mat_scale);

    // Relevant bullet body update
    CollisionShape cs = body.getCollisionShape();
    cs.setLocalScaling(new Vector3f(x, y, z));
    if (body.isInWorld() && body.isStaticOrKinematicObject()) scene.world.updateSingleAabb(body);

    // Child propagation
    Vector3f ps = scale();
    Matrix4f pt = transform();
    Matrix4f ct = new Matrix4f();
    Matrix4f ms = new Matrix4f();
    ms.setIdentity();
    ms.m00 = ps.x;
    ms.m11 = ps.y;
    ms.m22 = ps.z;
    pt.mul(ms);

    for (GameObject c : children) {
      c.scale(scale().mul(c.localScale), false);
      ct.mul(pt, c.localTransform);
      c.transform(ct, false);
    }

    if (parent != null && updateLocal) {
      updateLocalScale();
    }
  }
Пример #17
0
  RigidBody createBody(
      float mass,
      Vector3f position,
      CollisionShape shape,
      Float initialVelocity,
      Matrix3f orientation) {

    // Create Dynamic Objects
    Transform startTransform = new Transform();
    startTransform.setIdentity();
    // rigidbody is dynamic if and only if mass is non zero,
    // otherwise static
    boolean isDynamic = (mass != 0f);
    Vector3f localInertia = new Vector3f(0, 0, 0);
    if (isDynamic) {
      shape.calculateLocalInertia(mass, localInertia);
    }
    if (orientation != null) {
      startTransform.set(orientation);
    }
    startTransform.origin.set(position);
    // using motionstate is recommended, it provides
    // interpolation capabilities, and only synchronizes
    // 'active' objects
    DefaultMotionState myMotionState = new DefaultMotionState(startTransform);
    RigidBodyConstructionInfo rbInfo =
        new RigidBodyConstructionInfo(mass, myMotionState, shape, localInertia);

    RigidBody rb = new RigidBody(rbInfo);
    rb.setFriction(0.4f);
    // rb.setDamping(0.7f, 0.7f);
    if (initialVelocity != 0f && orientation != null) {
      synchronized (initialVelocityVector) {
        initialVelocityVector.set(0f, 0f, initialVelocity);
        orientation.transform(initialVelocityVector);
        rb.setLinearVelocity(initialVelocityVector);
      }
    }
    return rb;
  }
Пример #18
0
  public boolean insideFrustum() {
    Vector3f min = new Vector3f();
    Vector3f max = new Vector3f();
    body.getAabb(min, max);
    Vector3f dimHalved = max.minus(min).mul(0.5f);
    Vector3f center;

    if (origin.length() == 0
        || json.get("physics").get("bounds_type").asString().equals("CONVEX_HULL"))
      center = min.plus(dimHalved);
    else center = min.plus(dimHalved).plus(orientation().mult(origin).mul(scale()));

    return scene.cam.frustum.boundsInFrustum(
        center.x, center.y, center.z, dimHalved.x, dimHalved.y, dimHalved.z);
  }
Пример #19
0
  public void addDynamicServerElement(ServerElement elem, Float initialVelocity) {
    RigidBody rb =
        createBody(
            elem.getMass(),
            elem.getPosition(),
            getCollisionShape(elem.getSize()),
            initialVelocity,
            elem.getOriantation());
    dynamicsWorld.addRigidBody(rb);

    rigidBodyToServerElement.put(rb, elem);
    elementToRigidBody.put(elem, rb);
    rigidBodies.add(rb);
    // dynamicServerElements.put(elem.getId(),elem);
    if (elem instanceof ServerPlayer) {
      ServerPlayer p = (ServerPlayer) elem;
      players.add(p);
      rb.setAngularFactor(0.3f);
    }

    if (elem instanceof ServerBullet) {
      rb.setGravity(new Vector3f(0, -0.2f, 0));
    }
  }
Пример #20
0
 public void bodyType(String s) {
   int flags = body.getCollisionFlags();
   if (body.isInWorld()) scene.world.removeRigidBody(body);
   if (s.equals("NO_COLLISION")) {
     for (GameObject g : touchingObjects) g.activate();
     flags &= ~CollisionFlags.KINEMATIC_OBJECT;
   } else {
     if (s.equals("STATIC")) {
       flags |= CollisionFlags.KINEMATIC_OBJECT;
     } else if (s.equals("SENSOR")) {
       flags |= CollisionFlags.KINEMATIC_OBJECT;
       flags |= CollisionFlags.NO_CONTACT_RESPONSE;
     } else {
       // NO_COLLISION -> DYNAMIC or RIGID_BODY hack
       if (currBodyType.equals("NO_COLLISION")) {
         body.clearForces();
         body.setLinearVelocity(new Vector3f());
       }
       // kinematic initialization hack
       if (mass() == Float.POSITIVE_INFINITY) {
         mass(1); // Blender default
         flags &= ~CollisionFlags.KINEMATIC_OBJECT;
         body.setCollisionFlags(flags);
       }
       flags &= ~CollisionFlags.KINEMATIC_OBJECT;
       if (s.equals("DYNAMIC")) {
         body.setAngularVelocity(new Vector3f());
         body.setAngularFactor(0);
       } else if (s.equals("RIGID_BODY")) {
         body.setAngularFactor(1);
       } else {
         throw new RuntimeException(s + " is no valid bodyType name.");
       }
     }
     scene.world.addRigidBody(body);
     activate();
   }
   body.setCollisionFlags(flags);
   currBodyType = s;
 }
Пример #21
0
  public Matrix4f transform() {
    Transform t = new Transform();
    body.getWorldTransform(t);

    Vector3f v = new Vector3f();
    for (int i = 0; i < 3; ++i) {
      t.basis.getColumn(i, v);
      v.normalize();
      t.basis.setColumn(i, v);
    }

    Matrix4f m = new Matrix4f();
    t.getMatrix(m);

    return m;
  }
Пример #22
0
  public void drawSelf(float angle, float x, float y, float z) {
    // 制定使用某套shader程序
    MatrixState.pushMatrix();
    MySurfaceView.init = false;
    Transform trans = body.getMotionState().getWorldTransform(new Transform());
    MatrixState.translate(trans.origin.x, trans.origin.y, trans.origin.z);
    Quat4f ro = trans.getRotation(new Quat4f());
    if (ro.x != 0 || ro.y != 0 || ro.z != 0) {
      float[] fa = SYSUtil.fromSYStoAXYZ(ro);
      if (isNumber(fa[0] + "") && isNumber(fa[1] + "") && isNumber(fa[2] + "")) {

        MatrixState.rotate(fa[0], fa[1], fa[2], fa[3]);
      }
    }

    GLES20.glUseProgram(mProgram);
    MatrixState.rotate(angle, x, y, z);
    // 将最终变换矩阵传入shader程序
    GLES20.glUniformMatrix4fv(muMVPMatrixHandle, 1, false, MatrixState.getFinalMatrix(), 0);
    // 将位置、旋转变换矩阵传入着色器程序
    GLES20.glUniformMatrix4fv(muMMatrixHandle, 1, false, MatrixState.currMatrix, 0);
    // 将光源位置传入着色器程序
    GLES20.glUniform3fv(maLightLocationHandle, 1, MatrixState.lightPositionFBRed);
    // 将摄像机位置传入着色器程序
    GLES20.glUniform3fv(maCameraHandle, 1, MatrixState.cameraFB);

    // 为画笔指定顶点位置数据
    GLES20.glVertexAttribPointer(maPositionHandle, 3, GLES20.GL_FLOAT, false, 3 * 4, mVertexBuffer);
    // 为画笔指定顶点法向量数据
    GLES20.glVertexAttribPointer(maNormalHandle, 4, GLES20.GL_FLOAT, false, 3 * 4, mNormalBuffer);
    // 允许顶点位置数据数组
    GLES20.glEnableVertexAttribArray(maPositionHandle);
    GLES20.glEnableVertexAttribArray(maNormalHandle);

    // 绘制三角形
    GLES20.glDrawArrays(GLES20.GL_TRIANGLES, 0, vCount);
    MatrixState.popMatrix();
  }
Пример #23
0
  public void addObjectsToCollisionDomain() {
    Iterator<Entry<MTComponent, ArrayList<MTTriangleMesh>>> groupIter =
        collisionGroups.entrySet().iterator();

    int collidesWith = 0;
    while (groupIter.hasNext()) {
      collidesWith = ~groupId;

      Entry<MTComponent, ArrayList<MTTriangleMesh>> element = groupIter.next();

      // CollisionShape shape = createMeshShapeFromMTMeshTriangle(element.getValue());
      Iterator<MTTriangleMesh> iter = element.getValue().iterator();

      while (iter.hasNext()) {
        MTComponent comp = iter.next();
        CollisionShape shape = createMeshShapeFromMTMeshTriangle((MTTriangleMesh) comp);

        /*	Transform startTransform = new Transform();
        startTransform.setIdentity();

        Vector3f vec = new Vector3f();
        Vector3D translate = currentMesh.getCenterPointRelativeToParent();
        vec.x = translate.x;
        vec.y = translate.y;
        vec.z = translate.z;

        startTransform.origin.set(vec);*/

        Transform startTransform = new Transform();
        startTransform.setIdentity();
        Matrix mat = element.getKey().getGlobalMatrix();

        Vector3f vec = new Vector3f(0.0f, 0.0f, 0.0f);
        vec.x = mat.m03;
        vec.y = mat.m13;
        vec.z = mat.m23;

        // startTransform.transform(vec);
        // Matrix4f mat = CollisionManager.convertMT4JMatrixToMatrix4f(mesh.get);

        // startTransform.set(mat);
        // startTransform.origin.set(vec);
        // mat4f.m03 = mat4f.m03 + vec.x;
        // mat4f.m13 = mat4f.m13 + vec.y;
        // mat4f.m23 = mat4f.m23 + vec.z;
        // mat4f.setTranslation(vec);

        startTransform.origin.set(vec);

        Vector3f scale = new Vector3f(); // get scale value of global matrix

        Vector3D xVec = new Vector3D(mat.m00, mat.m01, mat.m02);
        Vector3D yVec = new Vector3D(mat.m10, mat.m11, mat.m12);
        Vector3D zVec = new Vector3D(mat.m20, mat.m21, mat.m22);

        scale.x = xVec.length();
        scale.y = yVec.length();
        scale.z = zVec.length();

        float[] scaleVals = new float[3];
        scale.get(scaleVals);

        for (int i = 0; i < 3; i++) // get rotation value by extracting scalation
        {

          try {
            float[] colvals = mat.getRow(i);

            for (int j = 0; j < 3; j++) {
              colvals[j] = colvals[j] / scaleVals[i];
            }
            startTransform.basis.setRow(i, colvals);
          } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
          }
        }

        // startTransform.set(mat4f);

        float mass = 5f; // fake mass value only needed correctly if used with dynamic engine
        shape.setLocalScaling(scale);
        GImpactMeshShape sh = (GImpactMeshShape) shape;
        sh.updateBound();

        RigidBody body = localCreateRigidBody(mass, startTransform, shape);

        // get Center Of Mass of Triangle Mesh and write it to MTTriangleMesh
        Vector3f vecCOM = new Vector3f();
        body.getCenterOfMassPosition(vecCOM);
        Vector3D vecComMT4J = new Vector3D(vecCOM.x, vecCOM.y, vecCOM.z);
        // mesh.setCenterOfMass(vecComMT4J);
        // mesh.setMass(100.0f);
        // add Object to Collision World

        collisionWorld.addCollisionObject(body, groupId, (short) collidesWith);

        colObjectToComponent.put(body, comp);

        addCollisionObjectToGroup(
            comp.getParent(), body); // save association between collision objects and groups
      }
      groupId = (short) (groupId << 1); // shift groupId so every group has a unique bit value
    }
    SimulatePreDrawAction calcDynamics =
        new SimulatePreDrawAction(collisionWorld, this, scene.getCanvas());
    calcDynamics.setCurrentTimeStep(1.f / 1000000000000.0f);
    scene.registerPreDrawAction(calcDynamics);
  }
Пример #24
0
 public void deactivate() {
   body.forceActivationState(2);
 }
Пример #25
0
 public boolean ghost() {
   int noContact = body.getCollisionFlags() & CollisionFlags.NO_CONTACT_RESPONSE;
   return noContact != 0 ? true : false;
 }
Пример #26
0
 public void activate() {
   if (dynamics()) body.activate();
 }
Пример #27
0
 public Vector3f scale() {
   Vector3f s = new Vector3f();
   CollisionShape cs = body.getCollisionShape();
   cs.getLocalScaling(s);
   return s;
 }
Пример #28
0
  public void replaceModel(String modelName, boolean updateVisual, boolean updatePhysics) {
    if (modelName.equals(modelInstance.model.meshParts.get(0).id)) return;

    Model model = null;
    JsonValue mOrigin = null;
    JsonValue mDimNoScale = null;
    for (Scene sce : Bdx.scenes) {
      if (sce.models.containsKey(modelName)) {
        model = sce.models.get(modelName);
        mOrigin = sce.json.get("origins").get(modelName);
        mDimNoScale = sce.json.get("dimensions").get(modelName);
        break;
      }
    }
    if (model == null) {
      throw new RuntimeException("No model found with name: '" + modelName + "'");
    }
    origin = mOrigin == null ? new Vector3f() : new Vector3f(mOrigin.asFloatArray());
    dimensionsNoScale =
        mDimNoScale == null ? new Vector3f(1, 1, 1) : new Vector3f(mDimNoScale.asFloatArray());
    Matrix4 trans = modelInstance.transform;

    if (updateVisual) {
      ModelInstance mi = new ModelInstance(model);
      mi.transform.set(trans);
      modelInstance = mi;
    }

    if (updatePhysics) {
      GameObject compParent =
          parent != null && parent.body.getCollisionShape().isCompound() ? parent : null;
      boolean isCompChild =
          compParent != null
              && !(currBodyType.equals("NO_COLLISION") || currBodyType.equals("SENSOR"));
      if (isCompChild) {
        parent(null);
      }

      Matrix4f transform = transform();
      Vector3f scale = scale();
      String boundsType = json.get("physics").get("bounds_type").asString();
      float margin = json.get("physics").get("margin").asFloat();
      boolean compound = json.get("physics").get("compound").asBoolean();
      body.setCollisionShape(Bullet.makeShape(model.meshes.first(), boundsType, margin, compound));

      if (boundsType.equals("CONVEX_HULL")) {
        Transform startTransform = new Transform();
        body.getMotionState().getWorldTransform(startTransform);
        Matrix4f originMatrix = new Matrix4f();
        originMatrix.set(origin);
        Transform centerOfMassTransform = new Transform();
        centerOfMassTransform.set(originMatrix);
        centerOfMassTransform.mul(startTransform);
        body.setCenterOfMassTransform(centerOfMassTransform);
      }

      transform(transform);
      scale(scale);

      if (body.isInWorld()) {
        scene.world.updateSingleAabb(body);
      } else { // update Aabb hack for when not in world
        scene.world.addRigidBody(body);
        scene.world.updateSingleAabb(body);
        scene.world.removeRigidBody(body);
      }

      if (isCompChild) {
        parent(compParent);
      }
    }
  }
Пример #29
0
 public float mass() {
   return 1 / body.getInvMass();
 }
Пример #30
0
 public boolean dynamics() {
   return body.isInWorld() && !body.isKinematicObject();
 }