Java MathUtils.clamp方法代码示例

import com.badlogic.gdx.math.MathUtils; //导入方法依赖的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.MathUtils; //导入方法依赖的package包/类
@Override
protected void processSystem() {


    float halfScreenWidth = (Gdx.graphics.getWidth() / G.CAMERA_ZOOM) * 0.5f;
    float halfScreenHeight = (Gdx.graphics.getHeight() / G.CAMERA_ZOOM) * 0.5f;

    float minCameraX = halfScreenWidth;
    float maxCameraX = mapSystem.width * G.CELL_SIZE - halfScreenWidth;
    float minCameraY = halfScreenHeight;
    float maxCameraY = mapSystem.height * G.CELL_SIZE - halfScreenHeight;

    if (minCameraX > maxCameraX) {
        maxCameraX = minCameraX;
    }
    if (minCameraY > maxCameraY) maxCameraY = minCameraY;

    cameraSystem.camera.position.x = MathUtils.clamp(cameraSystem.camera.position.x, minCameraX, maxCameraX);
    cameraSystem.camera.position.y = MathUtils.clamp(cameraSystem.camera.position.y, minCameraY, maxCameraY);
    cameraSystem.camera.update();
}
 

import com.badlogic.gdx.math.MathUtils; //导入方法依赖的package包/类
private void smoothMask(Planet planet) {
    for (int y = 1; y < (SIMULATION_HEIGHT / GRADIENT_SCALE) - 1; y++) {
        if (G.INTERLACING_SIMULATION && y % 2 == lace) {
            for (int x = 1; x < (SIMULATION_WIDTH / GRADIENT_SCALE) - 1; x++) {
                planet.tempMask[y][x].temperature = planet.mask[y][x].temperature;
                for (int i = 0; i < 8; i++) {
                    planet.tempMask[y][x].temperature =
                            Math.max(
                                    (planet.mask[y + PlanetCell.directions[i][1]][x + PlanetCell.directions[i][0]].temperature) * TEMPERATURE_LOSS,
                                    planet.tempMask[y][x].temperature
                            );
                }
            }
        }
    }
    for (int y = 1; y < (SIMULATION_HEIGHT / GRADIENT_SCALE) - 1; y++) {
        for (int x = 1; x < (SIMULATION_WIDTH / GRADIENT_SCALE) - 1; x++) {
            planet.mask[y][x].temperature = MathUtils.clamp(planet.tempMask[y][x].temperature, -100f, StatusMask.MAX_TEMPERATURE) * 0.95f;
        }
    }
}
 

import com.badlogic.gdx.math.MathUtils; //导入方法依赖的package包/类
@Override
public void render() {
    if (Gdx.input.justTouched() && Gdx.input.getY() < 100) {
        if (Gdx.input.getX() < 100) {
            xOffsetTarget = Math.max(xOffsetTarget - 0.2f, 0);
        } else if (Gdx.input.getX() > (Gdx.graphics.getWidth() - 100)) {
            xOffsetTarget = Math.min(xOffsetTarget + 0.2f, 1);
        }
        MathUtils.clamp(xOffsetTarget, 0, 1);
    }
    xOffset += (xOffsetTarget - xOffset) * 2 * Gdx.graphics.getDeltaTime();

    handleFakeTouch();

    liveWallpaper.render();
    liveWallpaper.render(xOffsetFake, 0.5f, xOffsetFake, xOffsetFake);
}
 

import com.badlogic.gdx.math.MathUtils; //导入方法依赖的package包/类
protected void updateMotionX(float deltaTime) {
    if (velocity.x != 0) {
        //应用摩擦力
        if (velocity.x > 0) {
            velocity.x = Math.max(velocity.x - friction.x * deltaTime, 0);
        } else {
            velocity.x = Math.max(velocity.x + friction.x * deltaTime, 0);
        }
    }

    //应用加速度
    velocity.x += acceleration.x * deltaTime;
    //确保速度没超过最大值
    velocity.x = MathUtils.clamp(velocity.x, -terminalVelocity.x, terminalVelocity.x);
}
 

import com.badlogic.gdx.math.MathUtils; //导入方法依赖的package包/类
/** Returns the interpolated percentage for the specified key frame and linear percentage. */
public float getCurvePercent (int frameIndex, float percent) {
	percent = MathUtils.clamp(percent, 0, 1);
	float[] curves = this.curves;
	int i = frameIndex * BEZIER_SIZE;
	float type = curves[i];
	if (type == LINEAR) return percent;
	if (type == STEPPED) return 0;
	i++;
	float x = 0;
	for (int start = i, n = i + BEZIER_SIZE - 1; i < n; i += 2) {
		x = curves[i];
		if (x >= percent) {
			float prevX, prevY;
			if (i == start) {
				prevX = 0;
				prevY = 0;
			} else {
				prevX = curves[i - 2];
				prevY = curves[i - 1];
			}
			return prevY + (curves[i + 1] - prevY) * (percent - prevX) / (x - prevX);
		}
	}
	float y = curves[i - 1];
	return y + (1 - y) * (percent - x) / (1 - x); // Last point is 1,1.
}
 

import com.badlogic.gdx.math.MathUtils; //导入方法依赖的package包/类
@Override
protected void process(E e) {
    if (e.explosivePrimed()) {
        int cx = (int) (e.posX() + e.boundsCx());
        int cy = (int) (e.posY() + e.boundsCy());
        drawingSystem.draw(planetCreationSystem.planetEntity,
                cx, cy,
                e.explosiveYield(),
                PlanetCell.CellType.FIRE);
        e.deleteFromWorld();

        for (E wanderer : allEntitiesMatching(Aspect.all(Wander.class, Pos.class, Physics.class))) {

            v2.set(wanderer.posX(), wanderer.posY()).sub(cx, cy);

            float len = Math.abs(v2.len());
            if (len < 100) {
                float strength = MathUtils.clamp(0, 220 - len, 100);
                v2.nor().scl(strength);

                v3.set(wanderer.posX(), wanderer.posY()).sub(G.PLANET_CENTER_X, G.PLANET_CENTER_Y).nor().scl(strength / 2);

                v2.add(v3);

                wanderer.physicsVx(v2.x);
                wanderer.physicsVy(v2.y);
            }
        }
    }
}
 

import com.badlogic.gdx.math.MathUtils; //导入方法依赖的package包/类
@Override
public void readJson(JsonValue json) {
	this.f = json.asFloat();
	if (hasRange)
		MathUtils.clamp(f, rangeStart, rangeEnd);
	onChange();
}
 

import com.badlogic.gdx.math.MathUtils; //导入方法依赖的package包/类
/** Calculates the fadeout of this effect, if any. Only considers the second half of the duration. */
protected float calculateFadeout () {
	if (Float.isInfinite(duration)) return 1;

	// Calculate raw progress
	float progress = MathUtils.clamp(totalTime / duration, 0, 1);

	// If progress is before the split point, return a full factor
	if (progress < FADEOUT_SPLIT) return 1;

	// Otherwise calculate from the split point
	return Interpolation.smooth.apply(1, 0, (progress - FADEOUT_SPLIT) / (1f - FADEOUT_SPLIT));
}
 

import com.badlogic.gdx.math.MathUtils; //导入方法依赖的package包/类
@Override
protected void onApply (Glyph glyph, int localIndex) {
	// Make sure we can hold enough entries for the current index
	if (localIndex >= lastOffsets.size / 2) {
		lastOffsets.setSize(lastOffsets.size + 16);
	}

	// Get last offsets
	float lastX = lastOffsets.get(localIndex * 2);
	float lastY = lastOffsets.get(localIndex * 2 + 1);

	// Calculate new offsets
	float x = getLineHeight() * distance * MathUtils.random(-1, 1) * DEFAULT_DISTANCE;
	float y = getLineHeight() * distance * MathUtils.random(-1, 1) * DEFAULT_DISTANCE;

	// Apply intensity
	float normalIntensity = MathUtils.clamp(intensity * DEFAULT_INTENSITY, 0, 1);
	x = Interpolation.linear.apply(lastX, x, normalIntensity);
	y = Interpolation.linear.apply(lastY, y, normalIntensity);

	// Apply fadeout
	float fadeout = calculateFadeout();
	x *= fadeout;
	y *= fadeout;
	x = Math.round(x);
	y = Math.round(y);

	// Store offsets for the next tick
	lastOffsets.set(localIndex * 2, x);
	lastOffsets.set(localIndex * 2 + 1, y);

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

import com.badlogic.gdx.math.MathUtils; //导入方法依赖的package包/类
/**
* Change node opacity.
* @param opacity A float opacity value. [0, 1]
*/
public void setOpacity(float opacity) {
 _displayColor.a = _opacity = MathUtils.clamp(opacity, 0, 1);
 updateCascadeOpacity();
}
 

import com.badlogic.gdx.math.MathUtils; //导入方法依赖的package包/类
private void updateVelocities() {
    velocity.x = MathUtils.clamp(velocity.x + acceleration.x, -1, 1f);
    velocity.y = MathUtils.clamp(velocity.y + acceleration.y, -1f, 3f);
    acceleration.x *= 0f; /* make player left and right movement very responsive. */
}
 

import com.badlogic.gdx.math.MathUtils; //导入方法依赖的package包/类
public void setXSpeed(float x_speed) {
	this.x_speed = MathUtils.clamp(x_speed, .01f, 100f);
}
 

import com.badlogic.gdx.math.MathUtils; //导入方法依赖的package包/类
private void applyGravity() {
    acceleration.y = MathUtils.clamp(acceleration.y - 0.25f, -0.25f, 10);
}
 

import com.badlogic.gdx.math.MathUtils; //导入方法依赖的package包/类
public void Update(float y, Vector3 vectorUp, Vector3 position, float elapsedTime)
{
 this.up.set(vectorUp);
    boolean needResetTie = false;
    time += elapsedTime;
    if (y != lastY)
    {
        interpolatedSpeed = MathUtils.clamp(chaseSpeed * elapsedTime, 0.0f, 1.0f);
        y = Utils.Lerp(lastY, y, interpolatedSpeed);
    }
    else
    {
        needResetTie = true;
    }
   
    if (lastPosition != position)
    {
        interpolatedSpeed = MathUtils.clamp(chaseSpeed * elapsedTime, 0.0f, 1.0f);
        this.position.set(Utils.Lerp(lastPosition, position, interpolatedSpeed));
    }
    else
    {
        needResetTie = true;
    }
    if (needResetTie)
    {
        time = 0f;
    }
    
    Matrix4 rotationMatrix = new Matrix4();
    rotationMatrix.setToRotation(0, 1, 0, y);
    Vector3 transformedheadOffset = Utils.Transform(AvatarHeadOffset, rotationMatrix);
    Vector3 transformedReference = Utils.Transform(TargetOffset, rotationMatrix);

    Vector3 cameraPosition = Utils.addVector(this.position, transformedheadOffset);
    Vector3 cameraTarget = Utils.addVector(this.position , transformedReference);
    
    vectorUp  = Utils.Transform(vectorUp, rotationMatrix);

    lastY = y;
    lastPosition = this.position;
    
    view.setToLookAt(cameraPosition, cameraTarget, vectorUp);
}