private static void applyInverse(Vector3f translation, Quaternion rotation, Vector3f scale, Transform inverseBindPose) { Transform t = new Transform(); t.setTranslation(translation); t.setRotation(rotation); if (scale != null) { t.setScale(scale); } t.combineWithParent(inverseBindPose); t.getTranslation(translation); t.getRotation(rotation); if (scale != null) { t.getScale(scale); } }
public void updateWorldTransforms(Transform jmeParentNodeTransform, Transform parentBindPose) { Transform fbxLocalTransform = computeFbxLocalTransform(); jmeLocalNodeTransform.set(fbxLocalTransform); jmeParentNodeTransform = jmeParentNodeTransform.clone(); switch (inheritMode) { case NoParentScale: case ScaleAfterChildRotation: case ScaleBeforeChildRotation: jmeWorldNodeTransform.set(jmeLocalNodeTransform); jmeWorldNodeTransform.combineWithParent(jmeParentNodeTransform); break; jmeWorldNodeTransform.set(jmeLocalNodeTransform); jmeLocalBindPose = new Transform(); jmeLocalBindPose.set(jmeWorldBindPose); jmeLocalBindPose.combineWithParent(parentBindPose.invert()); if (!jmeLocalBindPose.equals(jmeLocalNodeTransform)) { System.out.println("Local Bind: " + jmeLocalBindPose); System.out.println("Local Trans: " + jmeLocalNodeTransform); if (!jmeWorldBindPose.equals(jmeWorldNodeTransform)) { System.out.println("World Bind: " + jmeWorldBindPose); System.out.println("World Trans: " + jmeWorldNodeTransform); jmeLocalBindPose = new Transform(); jmeWorldBindPose = new Transform();
/** * Convert a vector (in) from this spatial's local coordinate space to world * coordinate space. * * @param in * vector to read from * @param store * where to write the result (null to create a new vector, may be * same as in) * @return the result (store) */ public Vector3f localToWorld(final Vector3f in, Vector3f store) { checkDoTransformUpdate(); return worldTransform.transformVector(in, store); }
public Transform getBindInverseTransform() { Transform t = new Transform(); t.setTranslation(bindPos); t.setRotation(bindRot); if (bindScale != null) { t.setScale(bindScale); } return t.invert(); }
/** * Should only be called from updateGeometricState(). * In most cases should not be subclassed. */ protected void updateWorldTransforms() { if (parent == null) { worldTransform.set(localTransform); refreshFlags &= ~RF_TRANSFORM; } else { // check if transform for parent is updated assert ((parent.refreshFlags & RF_TRANSFORM) == 0); worldTransform.set(localTransform); worldTransform.combineWithParent(parent.worldTransform); refreshFlags &= ~RF_TRANSFORM; } }
public Bone getJmeBone() { if (bone == null) { bone = new Bone(name); bone.setBindTransforms(jmeLocalBindPose.getTranslation(), jmeLocalBindPose.getRotation(), jmeLocalBindPose.getScale()); } return bone; } }
if (time < 0 || lastFrame == 0) { if (translations != null) { translations.get(0, transform.getTranslation()); rotations.get(0, transform.getRotation()); scales.get(0, transform.getScale()); transform.setTranslation(interpolated.getTranslation()); transform.setRotation(interpolated.getRotation()); transform.setScale(interpolated.getScale());
/** * Returns the local transform of this bone combined with the given position and rotation * @param position a position * @param rotation a rotation */ public Transform getCombinedTransform(Vector3f position, Quaternion rotation) { if(tmpTransform == null){ tmpTransform = new Transform(); } rotation.mult(localPos, tmpTransform.getTranslation()).addLocal(position); tmpTransform.setRotation(rotation).getRotation().multLocal(localRot); return tmpTransform; }
private static void relocateSpatial(Spatial spatial, Transform originalWorldTransform, Transform newWorldTransform) { Transform localTransform = new Transform(); localTransform.set(originalWorldTransform); localTransform.combineWithParent(newWorldTransform.invert()); spatial.setLocalTransform(localTransform); }
/** * Calculate the correct transform for a collision shape relative to the * ancestor for which the shape was generated. * * @param spat * @param parent * @return a new instance (not null) */ private static Transform getTransform(Spatial spat, Spatial parent) { Transform shapeTransform = new Transform(); Spatial parentNode = spat.getParent() != null ? spat.getParent() : spat; Spatial currentSpatial = spat; //if we have parents combine their transforms while (parentNode != null) { if (parent == currentSpatial) { //real parent -> only apply scale, not transform Transform trans = new Transform(); trans.setScale(currentSpatial.getLocalScale()); shapeTransform.combineWithParent(trans); parentNode = null; } else { shapeTransform.combineWithParent(currentSpatial.getLocalTransform()); parentNode = currentSpatial.getParent(); currentSpatial = parentNode; } } return shapeTransform; }
public static Transform multiply(Transform matrix, Transform transformToApply) { Transform temp = new Transform(); temp.set(matrix); temp.combineWithParent(transformToApply); return temp; }
public void setAreaType(AreaType type){ switch (type){ case Spherical: area = new SphereProbeArea(Vector3f.ZERO, 1.0f); break; case OrientedBox: area = new OrientedBoxProbeArea(new Transform()); area.setCenter(position); break; } }
/** * <code>getLocalTranslation</code> retrieves the local translation of * this node. * * @return the local translation of this node. */ public Vector3f getLocalTranslation() { return localTransform.getTranslation(); }
/** * <code>getLocalRotation</code> retrieves the local rotation of this * node. * * @return the local rotation of this node. */ public Quaternion getLocalRotation() { return localTransform.getRotation(); }
public static com.jme3.math.Transform convert(com.bulletphysics.linearmath.Transform in, com.jme3.math.Transform out) { convert(in.origin, out.getTranslation()); convert(in.basis, out.getRotation()); return out; }
jmeLocalNodeTransform.setTranslation(localTranslation); jmeLocalNodeTransform.setRotation(localRotation); jmeLocalNodeTransform.setScale(localScale);
if (attachParent == null || targetGeometry == null || targetGeometry.getParent() == attachParent && targetGeometry.getLocalTransform().isIdentity()) { attachNode.setLocalRotation(modelRot); attachNode.setLocalScale(modelScale); attachNode.getLocalTransform().combineWithParent(attachNode.getParent().getWorldTransform().invert()); Transform combined = new Transform(modelPos, modelRot, modelScale); combined.combineWithParent(localTransform); loopSpatial = loopSpatial.getParent();
if (geoms != null) { Geometry jGeom = geoms[0]; jGeom.setLocalTranslation(joint.getModelTransform().getTranslation()); Geometry bGeom = geoms[1]; if (bGeom != null) { Vector3f start = bGeom.getUserData("start"); Vector3f[] ends = bGeom.getUserData("end"); start.set(joint.getModelTransform().getTranslation()); if (ends != null) { for (int i = 0; i < joint.getChildren().size(); i++) { ends[i].set(joint.getChildren().get(i).getModelTransform().getTranslation()); updateBoneMesh(bGeomO, start, ends); bGeom.setUserData("start", getWorldTransform().transformVector(start, start)); for (int i = 0; i < ends.length; i++) { getWorldTransform().transformVector(ends[i], ends[i]);
public Transform invert() { Transform t = new Transform(); t.fromTransformMatrix(toTransformMatrix().invertLocal()); return t; }
private void pushScale(Transform transform, DAENode node, MeasuringUnit unit) { TransformedValue<Vector3f> vector = node.getContent(VECTOR); checkTrue(vector.isDefined()); Transform t = newIdentity(); t.setScale(vector.get()); t.combineWithParent(transform); transform.set(t); }