 |
|
|
|
Files | |
| file | interval.h |
| file | limits.h |
| Defines useful mathematical limits. | |
| file | math.h |
| Assorted mathematical utility functions. | |
| file | multiInterval.h |
Classes | |
| class | GfInterval |
| A basic mathematical interval class. More... | |
| class | GfMultiInterval |
| GfMultiInterval represents a subset of the real number line as an ordered set of non-intersecting GfIntervals. More... | |
Macros | |
| #define | GF_MIN_VECTOR_LENGTH 1e-10 |
| This constant is used to determine whether the length of a vector is too small to handle accurately. | |
Functions | |
| bool | GfIsClose (double a, double b, double epsilon) |
Returns true if a and b are with epsilon of each other. | |
| double | GfRadiansToDegrees (double radians) |
| Converts an angle in radians to degrees. | |
| double | GfDegreesToRadians (double degrees) |
| Converts an angle in degrees to radians. | |
| GF_API double | GfSmoothStep (double min, double max, double val, double slope0=0.0, double slope1=0.0) |
| Smooth step function using a cubic hermite blend. | |
| GF_API double | GfSmoothRamp (double tmin, double tmax, double t, double w0, double w1) |
| Smooth Step with independently controllable shoulders. | |
| template<class T > | |
| double | GfSqr (const T &x) |
Returns the inner product of x with itself: specifically, x*x. | |
| template<typename T > | |
| T | GfSgn (T v) |
Return the signum of v (i.e. | |
| double | GfSqrt (double f) |
Return sqrt(f). | |
| float | GfSqrt (float f) |
Return sqrt(f). | |
| double | GfExp (double f) |
Return exp(f). | |
| float | GfExp (float f) |
Return exp(f). | |
| double | GfLog (double f) |
Return log(f). | |
| float | GfLog (float f) |
Return log(f). | |
| double | GfFloor (double f) |
Return floor(f). | |
| float | GfFloor (float f) |
Return floor(f). | |
| double | GfCeil (double f) |
Return ceil(f). | |
| float | GfCeil (float f) |
Return ceil(f). | |
| double | GfAbs (double f) |
Return abs(f). | |
| float | GfAbs (float f) |
Return abs(f). | |
| double | GfRound (double f) |
Return round(f). | |
| float | GfRound (float f) |
Return round(f). | |
| double | GfPow (double f, double p) |
Return pow(f, p). | |
| float | GfPow (float f, float p) |
Return pow(f, p). | |
| double | GfSin (double v) |
Return sin(v). | |
| float | GfSin (float v) |
Return sin(v). | |
| double | GfCos (double v) |
Return cos(v). | |
| float | GfCos (float v) |
Return cos(v). | |
| void | GfSinCos (double v, double *s, double *c) |
Return sin(v) in s and cos(v) in c. | |
| void | GfSinCos (float v, float *s, float *c) |
Return sin(v) in s and cos(v) in c. | |
| double | GfClamp (double value, double min, double max) |
Return the resulting of clamping value to lie between min and max. | |
| float | GfClamp (float value, float min, float max) |
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
| GF_API double | GfMod (double a, double b) |
| The mod function with "correct" behaviour for negative numbers. | |
| template<class T > | |
| T | GfLerp (double alpha, const T &a, const T &b) |
| Linear interpolation function. | |
| template<class T > | |
| T | GfMin (T a1, T a2) |
Returns the smallest of the given values. | |
| template<class T > | |
| T | GfMax (T a1, T a2) |
Returns the largest of the given values. | |
| template<typename Left , typename Right , std::enable_if_t< GfIsArithmetic< Left >::value &&GfIsArithmetic< Right >::value, int > = 0> | |
| decltype(std::declval< Left >() *std::declval< Right >()) | GfDot (Left left, Right right) |
| Returns the dot (inner) product of two vectors. | |
| template<typename Left , typename Right , std::enable_if_t< GfIsArithmetic< Left >::value &&GfIsArithmetic< Right >::value, int > = 0> | |
| decltype(std::declval< Left >() *std::declval< Right >()) | GfCompMult (Left left, Right right) |
| Returns component-wise multiplication of vectors. | |
| template<typename Left , typename Right , std::enable_if_t< GfIsArithmetic< Left >::value &&GfIsArithmetic< Right >::value, int > = 0> | |
| decltype(std::declval< Left >()/std::declval< Right >()) | GfCompDiv (Left left, Right right) |
| Returns component-wise quotient of vectors. | |
| #define GF_MIN_VECTOR_LENGTH 1e-10 |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
| GF_API double GfMod | ( | double | a, |
| double | b ) |
The mod function with "correct" behaviour for negative numbers.
If a = n b for some integer n, zero is returned. Otherwise, for positive a, the value returned is fmod(a,b), and for negative a, the value returned is fmod(a,b)+b.
|
inline |
|
inline |
|
inline |
|
inline |
| GF_API double GfSmoothRamp | ( | double | tmin, |
| double | tmax, | ||
| double | t, | ||
| double | w0, | ||
| double | w1 ) |
Smooth Step with independently controllable shoulders.
Based on an idea and different implementation by Rob Cook. See his notes attached at the end.
I (whorfin) extended this to have independently controllable shoulders at either end, and to specify shoulders directly in the domain of the curve. Rob's derivation frankly confused me, so I proceeded slightly differently. This derivation has more degrees of freedom but is the same order, so some tricks must be done.
Summary: This function is similar to "smoothstep" except that instead of using a Hermite curve, the interpolation is done with a linear ramp with smooth shoulders (i.e., C1 = continuous first derivatives).
Conceptually, it's a line with variable C1 zero-slope junctures.
Additionally, w0 + w1 <= 1. Otherwise, the curves will take up more space than is available, and "that would be bad". A value of 0 for w0 and w1 gives a pure linear ramp. A reasonable value for a symmetric smooth ramp is .2 for w0 and w1. this means that the middle 60% of the ramp is linear, and the left 20% and right 20% are the transition into and out of the linear ramp.
The ramp looks like this:
smooth ********** <-result = 1
***|
** |
* | |
linear * | |
* | |
* | |
smooth ** | tmax = end of ramp
*** | |
result=0 -> ******* | tmax - w1*(tmax-tmin) = end of linear region
| |
| tmin + w0*(tmax-tmin) = start of linear region
|
tmin = start of ramp
Derivation:
We're going to splice parabolas onto both ends for the "0 slope smooth" connectors. So we therefore constrain the parabolic sections to have a given width and given slope (the slope of the connecting line segment) at the "w" edge.
We'll first derive the equations for the parabolic splicing segment, expressed at the origin (but generalizable by flipping).
Given:
f(t) = a t� + b t + c
f(0) = 0
f'(0) = 0
f(w) = y At the "w" edge of the shoulder, value is y
f'(w) = s ...what is the slope there? s...
-->
c = 0
b = 0
a = � s/w
y = � w s
-->
g(t,w,s) = � s t� / w # Our parabolic segment
Now, in our desired composite curve, the slope is the same at both endpoints (since they're connected by a line). This slope is (1-y0-y1)/(1-w0-w1) [from simple geometry].
More formally, let's express the constraints Given:
So now we're done; we splice these two together and connect with a line.
The domain and range of this function is [0,1]
f(t, w0, w1) =
g(t, w0, s(w0,w1)) t<w0
1-g(1-t, w1, s(w0,w1)) t>1-w1
s(w0,w1) t - y(w0, s(w0,w1)) w0 <= t <= 1-w1
Expanding and collecting terms gives us the result expressed in the code below. We also generalize to tmin/tmax form, in keeping with smoothstep. This simply involves reranging to [0,1] on input.
| tmin | where the ramp starts |
| tmax | where the ramp ends (must be > tmin) |
| t | location to evaluate in this call |
| w0 | size of the first smooth section as a fraction of the size of the ramp (tmax-tmin). This value must be in the range 0-1. |
| w1 | size of the second smooth section as a fraction of the size of the ramp (tmax-tmin). This value must be in the range 0-1. |
| GF_API double GfSmoothStep | ( | double | min, |
| double | max, | ||
| double | val, | ||
| double | slope0 = 0.0, | ||
| double | slope1 = 0.0 ) |
Smooth step function using a cubic hermite blend.
Returns 0 if val <= min, and 1 if val >= max. As val varies between min and max, the return value smoothly varies from 0 to 1 using a cubic hermite blend, with given slopes at the min and max points. The slopes are in the space that min and max are in.
|
inline |
1.12.0