Java Vector3f.setZ方法代码示例

import com.jme3.math.Vector3f; //导入方法依赖的package包/类
private boolean applyVelocitySeparately(Vector3f velocity, float tpf){
    float x = velocity.getX();
    float y = velocity.getY();
    float z = velocity.getZ();
    boolean hit = false;

    velocity.set(0, 0, 0);

    velocity.setX(x);
    if(applyVelocity(velocity, tpf)) hit = true;
    velocity.setX(0);

    velocity.setY(y);
    if(applyVelocity(velocity, tpf)) hit = true;
    velocity.setY(0);

    velocity.setZ(z);
    if(applyVelocity(velocity, tpf)) hit = true;
    velocity.setZ(0);

    velocity.set(x, y, z);

    return hit;
}
 

import com.jme3.math.Vector3f; //导入方法依赖的package包/类
/**
 * The process of creating a new sky.
 */
@FXThread
private void createSkyInBackground() {

    final AssetManager assetManager = EDITOR.getAssetManager();

    final NodeTree<?> nodeTree = getNodeTree();
    final ChangeConsumer changeConsumer = notNull(nodeTree.getChangeConsumer());

    final FloatTextField normalScaleXSpinner = getNormalScaleXField();
    final FloatTextField normalScaleYSpinner = getNormalScaleYField();
    final FloatTextField normalScaleZSpinner = getNormalScaleZField();

    final Vector3f scale = new Vector3f();
    scale.setX(normalScaleXSpinner.getValue());
    scale.setY(normalScaleYSpinner.getValue());
    scale.setZ(normalScaleZSpinner.getValue());

    final ComboBox<SkyType> skyTypeComboBox = getSkyTypeComboBox();
    final SingleSelectionModel<SkyType> selectionModel = skyTypeComboBox.getSelectionModel();
    final SkyType selectedItem = selectionModel.getSelectedItem();

    if (selectedItem == SkyType.SINGLE_TEXTURE) {
        createSingleTexture(assetManager, changeConsumer, scale);
    } else if (selectedItem == SkyType.MULTIPLE_TEXTURE) {
        createMultipleTexture(assetManager, changeConsumer, scale);
    }
}
 

import com.jme3.math.Vector3f; //导入方法依赖的package包/类
@Override
public void update() {
    //update the character state based on the needed components
    //first collect some necessary information
    PhysicsCharacter character = get(PhysicsCharacter.class);
    Vector2f move = get(PhysicsCharacterMovement.class).getDirection();
    set(new PhysicsCharacterMovementForce(new Vector3f(
            move.x*character.getMass()*character.getAcceleration(), 0,
            move.y*character.getMass()*character.getAcceleration())));
    float capsuleHeight = character.getHeight()-2*character.getRadius()-character.getStepHeight();
    float bodyHeight = capsuleHeight+2*character.getRadius();
    float jumpSpeed = FastMath.sqrt(2*9.81f*character.getJumpHeight());
    boolean jumping = get(PhysicsCharacterState.class).isJumping();
    boolean ducking = get(PhysicsCharacterState.class).isDucking();
    set(new PhysicsCharacterState(false, false)); //TODO remove
    int jumpCount = get(PhysicsCharacterJumpCount.class).getCount();
    boolean onGround = false;
    Vector3f velocity = get(LinearVelocity.class).getVelocity();
    PhysicsPosition pos = get(PhysicsPosition.class);

    //the most important part is the ray system which keeps the capsule floating
    //in the air over the ground
    List<PhysicsRayTestResult> rayTestResultList = bulletSystem.getPhysicsSpace()
            .rayTest(pos.getLocation(), pos.getLocation().add(0,-50,0));
    if(rayTestResultList.size() > 0){
        float len = 60;
        for (PhysicsRayTestResult physicsRayTestResult : rayTestResultList) {
            if(physicsRayTestResult.getHitFraction()*50 < len){
                len = physicsRayTestResult.getHitFraction()*50;
            }
        }
        //if the character is near the ground or below it push it to the min step height.
        if(len <= character.getStepHeight() + bodyHeight/2){
            float diff = character.getStepHeight() + bodyHeight/2-len;
            set(new WarpPosition(pos.getLocation().add(0, diff,  0), pos.getRotation()));
            if(velocity.y < 0) {
                set(new WarpVelocity(velocity.clone().setY(0), Vector3f.ZERO));
            }
            onGround = true;
            set(new PhysicsCharacterJumpCount(0));
            jumpCount = 0;
        }
    }

    Vector3f impulse = new Vector3f();
    //apply jump
    if(jumping && (onGround || jumpCount < character.getMaxJumpNumber())){
        set(new PhysicsCharacterJumpCount(jumpCount+1));
        impulse.addLocal(new Vector3f(0, character.getMass()*jumpSpeed, 0));
    }
    //slow the character down if no movement is applied
    if(onGround){
        Vector3f slowDownImpulse = new Vector3f();
        if(FastMath.approximateEquals(move.x, 0)){
            slowDownImpulse.setX(-velocity.x*character.getMass()*0.05f);
        }
        if(FastMath.approximateEquals(move.y, 0)){
            slowDownImpulse.setZ(-velocity.z*character.getMass()*0.05f);
        }
        impulse.addLocal(slowDownImpulse);
    }
    //TODO use combined impulse
    set(new Impulse(impulse, new Vector3f()));
}
 

import com.jme3.math.Vector3f; //导入方法依赖的package包/类
@Override
public void processTransform() {

    final EditorTransformSupport editorControl = getEditorControl();

    final LocalObjects local = LocalObjects.get();
    final Camera camera = editorControl.getCamera();
    final InputManager inputManager = EDITOR.getInputManager();
    final Transform transform = notNull(editorControl.getTransformCenter());

    // cursor position and selected position vectors
    final Vector2f cursorPos = inputManager.getCursorPosition();
    final Vector3f transformOnScreen = camera.getScreenCoordinates(transform.getTranslation(), local.nextVector());
    final Vector2f selectedCoords = local.nextVector(transformOnScreen.getX(), transformOnScreen.getY());

    // set new deltaVector if it's not set (scale tool stores position of a cursor)
    if (Float.isNaN(editorControl.getTransformDeltaX())) {
        editorControl.setTransformDeltaX(cursorPos.getX());
        editorControl.setTransformDeltaY(cursorPos.getY());
    }

    final Node parentNode = getParentNode();
    final Node childNode = getChildNode();

    // Picked vector
    final Spatial toTransform = notNull(editorControl.getToTransform());
    final TransformationMode transformationMode = editorControl.getTransformationMode();
    transformationMode.prepareToScale(parentNode, childNode, transform, camera);

    // scale according to distance
    final Vector3f deltaVector = local.nextVector(editorControl.getTransformDeltaX(), editorControl.getTransformDeltaY(), 0F);
    final Vector2f delta2d = local.nextVector(deltaVector.getX(), deltaVector.getY());
    final Vector3f baseScale = local.nextVector(transform.getScale()); // default scale
    final Vector3f pickedVector = local.nextVector(transformationMode.getScaleAxis(transform, editorControl.getPickedAxis(), camera));
    pickedVector.setX(abs(pickedVector.getX()));
    pickedVector.setY(abs(pickedVector.getY()));
    pickedVector.setZ(abs(pickedVector.getZ()));

    if (Config.DEV_TRANSFORMS_DEBUG) {
        System.out.println("Base scale " + baseScale + ", pickedVector " + pickedVector);
    }

    // scale object
    float disCursor = cursorPos.distance(selectedCoords);
    float disDelta = delta2d.distance(selectedCoords);
    float scaleValue = (float) (cursorPos.distance(delta2d) * 0.01f * Math.sqrt(baseScale.length()));

    if (disCursor > disDelta) {
        baseScale.addLocal(pickedVector.mult(scaleValue, local.nextVector()));
    } else {
        scaleValue = Math.min(scaleValue, 0.999f); // remove negateve values
        baseScale.subtractLocal(pickedVector.mult(scaleValue, local.nextVector()));
    }

    parentNode.setLocalScale(baseScale);

    if (Config.DEV_TRANSFORMS_DEBUG) {
        System.out.println("New scale " + baseScale + ", result world " + childNode.getWorldScale());
    }

    parentNode.setLocalScale(baseScale);
    toTransform.setLocalScale(childNode.getWorldScale());

    editorControl.notifyTransformed(toTransform);
}