Java Interpolation类代码示例

import com.badlogic.gdx.math.Interpolation; //导入依赖的package包/类
private void tryToTransition(float delta) {
    if(focus) {
        elapsed += delta;
        float progress = Math.min(1f, elapsed / lifetime);

        gameCamera.position.x = Interpolation.circleOut.apply(startX, targetX, progress);
        gameCamera.update();

        starCamera.position.x = Interpolation.circleOut.apply(startStarX, targetStarX, progress);
        starCamera.update();

        if(progress == 1) {
            focus = false;
        }
    }
}
 

import com.badlogic.gdx.math.Interpolation; //导入依赖的package包/类
public void showConfig(Tile tile){
    configTile = tile;

    table.clear();
    tile.block().buildTable(tile, table);
    table.pack();
    table.setTransform(true);
    table.actions(Actions.scaleTo(0f, 1f), Actions.visible(true),
            Actions.scaleTo(1f, 1f, 0.07f, Interpolation.pow3Out));

    table.update(()->{
        table.setOrigin(Align.center);
        Vector2 pos = Graphics.screen(tile.worldx() + tile.block().getPlaceOffset().x, tile.worldy() + tile.block().getPlaceOffset().y);
        table.setPosition(pos.x, pos.y, Align.center);
        if(configTile == null || configTile.block() == Blocks.air){
            hideConfig();
        }
    });
}
 

import com.badlogic.gdx.math.Interpolation; //导入依赖的package包/类
public void addLogo() {

        // approximate percentage of screen size with logo. Use rounded numbers to keep the logo crisp.

        float zoom = Anims.scaleToScreenRounded(0.8f, FeatureScreenAssetSystem.LOGO_WIDTH);

        Anims.createCenteredAt(
                FeatureScreenAssetSystem.LOGO_WIDTH,
                FeatureScreenAssetSystem.LOGO_HEIGHT,
                "logo",
                zoom)
                .tint(COLOR_LOGO_FADED)
                .script(
                        scaleBetween(zoom * 2, zoom, 2f, Interpolation.bounceOut),
                        tween(new Tint(COLOR_LOGO_FADED), new Tint(COLOR_LOGO_FULL), 2f, Interpolation.fade)
                );

    }
 

import com.badlogic.gdx.math.Interpolation; //导入依赖的package包/类
@Override
protected void process(E e) {
    if ( Gdx.input.isKeyJustPressed(Input.Keys.F9) ) lockCamera = !lockCamera;

    if ( lockCamera) return;
    if (e.wallSensorOnFloor() || e.wallSensorOnPlatform()) {
        float newTargetY = myAnimRenderSystem.roundToPixels(e.posY());
        if (targetY != newTargetY) {
            sourceY = (int) cameraSystem.camera.position.y;
            targetY = (int) newTargetY;
            cooldown = 0f;
        }
    }
    if (cooldown <= 1F) {
        cooldown += world.delta*2f;
        if (cooldown > 1f) cooldown = 1f;
        cameraSystem.camera.position.y = myAnimRenderSystem.roundToPixels(Interpolation.pow2Out.apply(sourceY,targetY, cooldown));        }
    cameraSystem.camera.position.x = myAnimRenderSystem.roundToPixels(e.posX());
    cameraSystem.camera.update();

    float maxDistance = (Gdx.graphics.getHeight() / G.CAMERA_ZOOM) * 0.5F * 0.6f;
    if (  e.posY() < cameraSystem.camera.position.y - maxDistance) {
        cameraSystem.camera.position.y = e.posY() + maxDistance;
        cameraSystem.camera.update();
    }
}
 

import com.badlogic.gdx.math.Interpolation; //导入依赖的package包/类
public void draw(SpriteBatch batch) {
    // If we beat a new record, the cup color will linear interpolate to the high score color
    cupColor.lerp(isNewRecord() ? Klooni.theme.highScore : Klooni.theme.currentScore, 0.05f);
    batch.setColor(cupColor);
    batch.draw(cupTexture, cupArea.x, cupArea.y, cupArea.width, cupArea.height);

    int roundShown = MathUtils.round(shownScore);
    if (roundShown != currentScore) {
        shownScore = Interpolation.linear.apply(shownScore, currentScore, 0.1f);
        currentScoreLabel.setText(Integer.toString(MathUtils.round(shownScore)));
    }

    currentScoreLabel.setColor(Klooni.theme.currentScore);
    currentScoreLabel.draw(batch, 1f);

    highScoreLabel.setColor(Klooni.theme.highScore);
    highScoreLabel.draw(batch, 1f);
}
 

import com.badlogic.gdx.math.Interpolation; //导入依赖的package包/类
private void hide() {
    shown = false;
    hiding = true;
    Gdx.input.setInputProcessor(lastInputProcessor);

    addAction(Actions.sequence(
            Actions.moveTo(0, Gdx.graphics.getHeight(), 0.5f, Interpolation.swingIn),
            new RunnableAction() {
                @Override
                public void run() {
                    hiding = false;
                }
            }
    ));
    scorer.resume();
}
 

import com.badlogic.gdx.math.Interpolation; //导入依赖的package包/类
@Override
public void draw(Batch batch) {
    age += Gdx.graphics.getDeltaTime();

    final float progress = age * INV_LIFETIME;
    final float currentSize = Interpolation.pow2In.apply(size, 0, progress);
    final float currentRotation = Interpolation.sine.apply(0, TOTAL_ROTATION, progress);

    final Matrix4 original = batch.getTransformMatrix().cpy();
    final Matrix4 rotated = batch.getTransformMatrix();

    final float disp =
            + 0.5f * (size - currentSize) // the smaller, the more we need to "push" to center
            + currentSize * 0.5f; // center the cell for rotation

    rotated.translate(pos.x + disp, pos.y + disp, 0);
    rotated.rotate(0, 0, 1, currentRotation);
    rotated.translate(currentSize * -0.5f, currentSize * -0.5f, 0); // revert centering for rotation

    batch.setTransformMatrix(rotated);
    Cell.draw(color, batch, 0, 0, currentSize);
    batch.setTransformMatrix(original);
}
 

import com.badlogic.gdx.math.Interpolation; //导入依赖的package包/类
@Override
public void draw(Batch batch) {
    vanishElapsed += Gdx.graphics.getDeltaTime();

    // Update the size as we fade away
    final float progress = vanishElapsed * INV_LIFETIME;
    vanishSize = Interpolation.fade.apply(size, 0, progress);

    // Fade away depending on the time
    vanishColor.set(vanishColor.r, vanishColor.g, vanishColor.b, 1.0f - progress);

    // Ghostly fade upwards, by doing a lerp from our current position to the wavy one
    pos.x = MathUtils.lerp(
            pos.x,
            originalX + MathUtils.sin(randomOffset + vanishElapsed * 3f) * driftMagnitude,
            0.3f
    );
    pos.y += UP_SPEED * Gdx.graphics.getDeltaTime();

    Cell.draw(vanishColor, batch, pos.x, pos.y, vanishSize);
}
 

import com.badlogic.gdx.math.Interpolation; //导入依赖的package包/类
@Override
public void draw(Batch batch) {
    vanishElapsed += Gdx.graphics.getDeltaTime();

    // vanishElapsed might be < 0 (delay), so clamp to 0
    float progress = Math.min(1f,
            Math.max(vanishElapsed, 0f) / vanishLifetime);

    // If one were to plot the elasticIn function, they would see that the slope increases
    // a lot towards the end- a linear interpolation between the last size + the desired
    // size at 20% seems to look a lot better.
    vanishSize = MathUtils.lerp(
            vanishSize,
            Interpolation.elasticIn.apply(cell.size, 0, progress),
            0.2f
    );

    float centerOffset = cell.size * 0.5f - vanishSize * 0.5f;
    Cell.draw(vanishColor, batch, cell.pos.x + centerOffset, cell.pos.y + centerOffset, vanishSize);
}
 

import com.badlogic.gdx.math.Interpolation; //导入依赖的package包/类
@Override
protected void onApply (Glyph glyph, int localIndex) {
	// Calculate progress
	float progressModifier = (1f / intensity) * DEFAULT_INTENSITY;
	float normalFrequency = (1f / frequency) * DEFAULT_FREQUENCY;
	float progressOffset = localIndex / normalFrequency;
	float progress = calculateProgress(progressModifier, progressOffset);

	// Calculate offset
	float y = getLineHeight() * distance * Interpolation.sine.apply(-1, 1, progress) * DEFAULT_DISTANCE;

	// Calculate fadeout
	float fadeout = calculateFadeout();
	y *= fadeout;

	// Apply changes
	glyph.yoffset += y;
}
 

import com.badlogic.gdx.math.Interpolation; //导入依赖的package包/类
@Override
protected void onApply (Glyph glyph, int localIndex) {
	// Calculate progress
	float progressModifier = (1f / intensity) * DEFAULT_INTENSITY;
	float normalFrequency = (1f / frequency) * DEFAULT_FREQUENCY;
	float progressOffset = localIndex / normalFrequency;
	float progress = calculateProgress(progressModifier, -progressOffset, false);

	// Calculate offset
	float interpolation = 0;
	float split = 0.2f;
	if (progress < split) {
		interpolation = Interpolation.pow2Out.apply(0, 1, progress / split);
	} else {
		interpolation = Interpolation.bounceOut.apply(1, 0, (progress - split) / (1f - split));
	}
	float y = getLineHeight() * distance * interpolation * DEFAULT_DISTANCE;

	// Calculate fadeout
	float fadeout = calculateFadeout();
	y *= fadeout;

	// Apply changes
	glyph.yoffset += y;
}
 

import com.badlogic.gdx.math.Interpolation; //导入依赖的package包/类
public void render(float deltaTime){
    if (elapsed >= fadeTime)
        return;

    if (delay > 0){
        delay -= deltaTime;
    }

    GL20 gl = Gdx.gl20;
    gl.glEnable(GL20.GL_BLEND);
    gl.glBlendFunc(GL20.GL_SRC_ALPHA, GL20.GL_ONE_MINUS_SRC_ALPHA);

    color.a = delay > 0 ? 1f : 1f - Interpolation.fade.apply( elapsed / fadeTime);

    if (shader==null)
        createShader();
    shader.begin();
    shader.setUniformf(u_color, color);
    mesh.render(shader, GL20.GL_TRIANGLE_FAN);

    shader.end();

    if (delay <= 0)
        elapsed += deltaTime;
}
 

import com.badlogic.gdx.math.Interpolation; //导入依赖的package包/类
public void setUpSkinImages() {
    skinImage = new Image(skins.get(position).getTextureRegion());
    skinImageRotation = new Image(skins.get(position).getTextureRegion());

    skinImage.setSize(3f, 3f);
    skinImage.setOrigin(skinImage.getWidth() / 2, skinImage.getHeight() / 2);
    skinImage.setPosition(Constants.WIDTH / 3 - skinImage.getWidth() / 2, Constants.HEIGHT / 2);

    skinImageRotation.setSize(3f, 3f);
    skinImageRotation.setOrigin(skinImageRotation.getWidth() / 2, skinImageRotation.getHeight() / 2);
    skinImageRotation.setPosition(Constants.WIDTH * 2 / 3 - skinImageRotation.getWidth() / 2, Constants.HEIGHT / 2);

    SequenceAction rotateAction = new SequenceAction();
    rotateAction.addAction(Actions.rotateBy(360, 0.5f, Interpolation.linear));
    RepeatAction infiniteLoop = new RepeatAction();
    infiniteLoop.setCount(RepeatAction.FOREVER);
    infiniteLoop.setAction(rotateAction);

    skinImageRotation.addAction(infiniteLoop);
    stage.addActor(skinImageRotation);
    stage.addActor(skinImage);
}
 

import com.badlogic.gdx.math.Interpolation; //导入依赖的package包/类
private void trustEffect() {

        // work towards full thrust.
        if (active) {
            timer += world.delta * 0.25f;
            timer = MathUtils.clamp(timer, 0f, 1f);
            speedFactor = Interpolation.exp5.apply(timer * 0.6f);
            if (playSoundState == 0) {
                playSoundState = 1;
            }
        } else {
            timer -= world.delta * 0.25f;
            timer = MathUtils.clamp(timer, 0f, 1f);
            speedFactor = Interpolation.exp5.apply(timer * 0.6f);
            if (playSoundState == 1) {
                playSoundState = 0;
            }
        }

    }
 

import com.badlogic.gdx.math.Interpolation; //导入依赖的package包/类
@Override
protected void processSystem() {
    if (cooldown > 0 && !G.DEBUG_SKIP_INTRO) {
        if ( cooldown < 2f ) {
            starEffectSystem.active=false;
        }
        starEffectSystem.active = true;
        cooldown -= world.delta;
        if (cooldown < 0) cooldown = 0;
        camera.position.y = Interpolation.pow2In.apply(y, y + G.SCREEN_HEIGHT / 2, MathUtils.clamp(cooldown / VISIBLE_FOCUS_COOLDOWN,0f,1f));
        camera.update();
    } else  {
        if ( !introDone ) {
            introDone=true;
            gameScreenAssetSystem.playMusicInGame();
        }
        starEffectSystem.active = false;
    }
    super.processSystem();
}