Files
Angelica/src/main/java/net/coderbot/iris/parsing/SmoothFloat.java
T
Darren Eberly bed724ba59 Support for custom uniforms (#902)
* wip backport of custom uniforms

* Functioning custom uniforms maybe?

* Workon separating dynamic/non-dynamic uniforms and making variables available to custom uniforms (currently the JVM dies horribly)

* wip

* It no longer crashes horrifically

* star imports
2025-03-18 10:04:31 -07:00

122 lines
3.6 KiB
Java
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
package net.coderbot.iris.parsing;
import net.coderbot.iris.uniforms.SystemTimeUniforms;
/**
* An implementation of basic exponential smoothing that converts a sequence of unsmoothed values into a sequence of
* smoothed values.
*
* @see <a href="https://en.wikipedia.org/wiki/Exponential_smoothing#Basic_(simple)_exponential_smoothing_(Holt_linear)">
* Wikipedia: Basic (simple) exponential smoothing (Holt linear)</a>
*/
public class SmoothFloat {
/**
* Natural logarithm of 2, ie. {@code ln(2)}
*/
private static final double LN_OF_2 = Math.log(2.0);
/**
* An accumulator for smoothed values.
*/
private float accumulator;
/**
* Tracks whether an initial value has already been generated, because otherwise there will be nothing to smooth
* with.
*/
private boolean hasInitialValue;
private float cachedHalfLifeUp;
private float cachedDecayUp;
private float cachedHalfLifeDown;
private float cachedDecayDown;
/**
* Computes an exponential decay factor based on the given decay constant and time value
*
* @param k the decay constant, derived from the half life
* @param t the time that has passed since the decay started
*/
private static float exponentialDecayFactor(float k, float t) {
// https://en.wikipedia.org/wiki/Exponential_decay
// e^(-kt)
return (float) Math.exp(-k * t);
}
/**
* Computes a linearly interpolated value between v0 and v1
*
* @param v0 the starting value (t = 0)
* @param v1 the ending value (t = 1)
* @param t the time/progress value - should be in the range of 0.0 to 1.0
*/
private static float lerp(float v0, float v1, float t) {
// https://en.wikipedia.org/wiki/Linear_interpolation
return (1 - t) * v0 + t * v1;
}
/**
* Takes one value from the unsmoothed value sequence, and smooths it into our accumulator
*/
public float updateAndGet(float value, float halfLifeUp, float halfLifeDown) {
if (halfLifeUp != cachedHalfLifeUp) {
cachedHalfLifeUp = halfLifeUp;
if (halfLifeUp == 0.0f) {
cachedDecayUp = 0;
} else {
cachedDecayUp = computeDecay(halfLifeUp * 0.1F);
}
}
if (halfLifeDown != cachedHalfLifeDown) {
cachedHalfLifeDown = halfLifeDown;
if (halfLifeDown == 0.0f) {
cachedDecayDown = 0;
} else {
cachedDecayDown = computeDecay(halfLifeDown * 0.1F);
}
}
if (!hasInitialValue) {
// There is no smoothing on the first value.
// This is not an optimal approach to choosing the initial value:
// https://en.wikipedia.org/wiki/Exponential_smoothing#Choosing_the_initial_smoothed_value
//
// However, it works well enough for now.
accumulator = value;
hasInitialValue = true;
return accumulator;
}
// Implements the basic variant of exponential smoothing
// https://en.wikipedia.org/wiki/Exponential_smoothing#Basic_(simple)_exponential_smoothing_(Holt_linear)
// 𝚫t
float lastFrameTime = SystemTimeUniforms.TIMER.getLastFrameTime();
float decay = value > this.accumulator ? cachedDecayUp : cachedDecayDown;
if (decay == 0.0f) {
accumulator = value;
return accumulator;
}
// Compute the smoothing factor based on our
// α = 1 - e^(-𝚫t/τ) = 1 - e^(-k𝚫t)
float smoothingFactor = 1.0f - exponentialDecayFactor(decay, lastFrameTime);
// sₜ = αxₜ + (1 - α)sₜ₋₁
accumulator = lerp(accumulator, value, smoothingFactor);
return accumulator;
}
private float computeDecay(float halfLife) {
// Compute the decay constant from the half life
// https://en.wikipedia.org/wiki/Exponential_decay#Measuring_rates_of_decay
// https://en.wikipedia.org/wiki/Exponential_smoothing#Time_constant
// k = 1 / τ
return (float) (1.0f / (halfLife / LN_OF_2));
}
}