/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
/*
Functions:
CGLM_INLINE int glm_sign(int val);
CGLM_INLINE float glm_signf(float val);
CGLM_INLINE float glm_rad(float deg);
CGLM_INLINE float glm_deg(float rad);
CGLM_INLINE void glm_make_rad(float *deg);
CGLM_INLINE void glm_make_deg(float *rad);
CGLM_INLINE float glm_pow2(float x);
CGLM_INLINE float glm_min(float a, float b);
CGLM_INLINE float glm_max(float a, float b);
CGLM_INLINE float glm_clamp(float val, float minVal, float maxVal);
CGLM_INLINE float glm_clamp_zo(float val, float minVal, float maxVal);
CGLM_INLINE float glm_lerp(float from, float to, float t);
CGLM_INLINE float glm_lerpc(float from, float to, float t);
CGLM_INLINE float glm_step(float edge, float x);
CGLM_INLINE float glm_smooth(float t);
CGLM_INLINE float glm_smoothstep(float edge0, float edge1, float x);
CGLM_INLINE float glm_smoothinterp(float from, float to, float t);
CGLM_INLINE float glm_smoothinterpc(float from, float to, float t);
CGLM_INLINE bool glm_eq(float a, float b);
CGLM_INLINE float glm_percent(float from, float to, float current);
CGLM_INLINE float glm_percentc(float from, float to, float current);
*/
#ifndef cglm_util_h
#define cglm_util_h
#include "common.h"
#define GLM_MIN(X, Y) (((X) < (Y)) ? (X) : (Y))
#define GLM_MAX(X, Y) (((X) > (Y)) ? (X) : (Y))
/*!
* @brief get sign of 32 bit integer as +1, -1, 0
*
* Important: It returns 0 for zero input
*
* @param val integer value
*/
CGLM_INLINE
int
glm_sign(int val) {
return ((val >> 31) - (-val >> 31));
}
/*!
* @brief get sign of 32 bit float as +1, -1, 0
*
* Important: It returns 0 for zero/NaN input
*
* @param val float value
*/
CGLM_INLINE
float
glm_signf(float val) {
return (float)((val > 0.0f) - (val < 0.0f));
}
/*!
* @brief convert degree to radians
*
* @param[in] deg angle in degrees
*/
CGLM_INLINE
float
glm_rad(float deg) {
return deg * GLM_PIf / 180.0f;
}
/*!
* @brief convert radians to degree
*
* @param[in] rad angle in radians
*/
CGLM_INLINE
float
glm_deg(float rad) {
return rad * 180.0f / GLM_PIf;
}
/*!
* @brief convert existing degree to radians. this will override degrees value
*
* @param[in, out] deg pointer to angle in degrees
*/
CGLM_INLINE
void
glm_make_rad(float *deg) {
*deg = *deg * GLM_PIf / 180.0f;
}
/*!
* @brief convert existing radians to degree. this will override radians value
*
* @param[in, out] rad pointer to angle in radians
*/
CGLM_INLINE
void
glm_make_deg(float *rad) {
*rad = *rad * 180.0f / GLM_PIf;
}
/*!
* @brief multiplies given parameter with itself = x * x or powf(x, 2)
*
* @param[in] x x
*/
CGLM_INLINE
float
glm_pow2(float x) {
return x * x;
}
/*!
* @brief find minimum of given two values
*
* @param[in] a number 1
* @param[in] b number 2
*/
CGLM_INLINE
float
glm_min(float a, float b) {
if (a < b)
return a;
return b;
}
/*!
* @brief find maximum of given two values
*
* @param[in] a number 1
* @param[in] b number 2
*/
CGLM_INLINE
float
glm_max(float a, float b) {
if (a > b)
return a;
return b;
}
/*!
* @brief find minimum of given two values
*
* @param[in] a number 1
* @param[in] b number 2
*
* @return smallest of the two values
*/
CGLM_INLINE
int
glm_imin(int a, int b) {
if (a < b)
return a;
return b;
}
/*!
* @brief find maximum of given two values
*
* @param[in] a number 1
* @param[in] b number 2
*
* @return largest of the two values
*/
CGLM_INLINE
int
glm_imax(int a, int b) {
if (a > b)
return a;
return b;
}
/*!
* @brief clamp a number between min and max
*
* @param[in] val value to clamp
* @param[in] minVal minimum value
* @param[in] maxVal maximum value
*/
CGLM_INLINE
float
glm_clamp(float val, float minVal, float maxVal) {
return glm_min(glm_max(val, minVal), maxVal);
}
/*!
* @brief clamp a number to zero and one
*
* @param[in] val value to clamp
*/
CGLM_INLINE
float
glm_clamp_zo(float val) {
return glm_clamp(val, 0.0f, 1.0f);
}
/*!
* @brief linear interpolation between two numbers
*
* formula: from + t * (to - from)
*
* @param[in] from from value
* @param[in] to to value
* @param[in] t interpolant (amount)
*/
CGLM_INLINE
float
glm_lerp(float from, float to, float t) {
return from + t * (to - from);
}
/*!
* @brief clamped linear interpolation between two numbers
*
* formula: from + t * (to - from)
*
* @param[in] from from value
* @param[in] to to value
* @param[in] t interpolant (amount) clamped between 0 and 1
*/
CGLM_INLINE
float
glm_lerpc(float from, float to, float t) {
return glm_lerp(from, to, glm_clamp_zo(t));
}
/*!
* @brief threshold function
*
* @param[in] edge threshold
* @param[in] x value to test against threshold
* @return returns 0.0 if x < edge, else 1.0
*/
CGLM_INLINE
float
glm_step(float edge, float x) {
/* branching - no type conversion */
return (x < edge) ? 0.0f : 1.0f;
/*
* An alternative implementation without branching
* but with type conversion could be:
* return !(x < edge);
*/
}
/*!
* @brief smooth Hermite interpolation
*
* formula: t^2 * (3-2t)
*
* @param[in] t interpolant (amount)
*/
CGLM_INLINE
float
glm_smooth(float t) {
return t * t * (3.0f - 2.0f * t);
}
/*!
* @brief threshold function with a smooth transition (according to OpenCL specs)
*
* formula: t^2 * (3-2t)
*
* @param[in] edge0 low threshold
* @param[in] edge1 high threshold
* @param[in] x interpolant (amount)
*/
CGLM_INLINE
float
glm_smoothstep(float edge0, float edge1, float x) {
float t;
t = glm_clamp_zo((x - edge0) / (edge1 - edge0));
return glm_smooth(t);
}
/*!
* @brief smoothstep interpolation between two numbers
*
* formula: from + smoothstep(t) * (to - from)
*
* @param[in] from from value
* @param[in] to to value
* @param[in] t interpolant (amount)
*/
CGLM_INLINE
float
glm_smoothinterp(float from, float to, float t) {
return from + glm_smooth(t) * (to - from);
}
/*!
* @brief clamped smoothstep interpolation between two numbers
*
* formula: from + smoothstep(t) * (to - from)
*
* @param[in] from from value
* @param[in] to to value
* @param[in] t interpolant (amount) clamped between 0 and 1
*/
CGLM_INLINE
float
glm_smoothinterpc(float from, float to, float t) {
return glm_smoothinterp(from, to, glm_clamp_zo(t));
}
/*!
* @brief check if two float equal with using EPSILON
*
* @param[in] a a
* @param[in] b b
*/
CGLM_INLINE
bool
glm_eq(float a, float b) {
return fabsf(a - b) <= GLM_FLT_EPSILON;
}
/*!
* @brief percentage of current value between start and end value
*
* maybe fraction could be alternative name.
*
* @param[in] from from value
* @param[in] to to value
* @param[in] current current value
*/
CGLM_INLINE
float
glm_percent(float from, float to, float current) {
float t;
if ((t = to - from) == 0.0f)
return 1.0f;
return (current - from) / t;
}
/*!
* @brief clamped percentage of current value between start and end value
*
* @param[in] from from value
* @param[in] to to value
* @param[in] current current value
*/
CGLM_INLINE
float
glm_percentc(float from, float to, float current) {
return glm_clamp_zo(glm_percent(from, to, current));
}
/*!
* @brief swap two float values
*
* @param[in] a float value 1 (pointer)
* @param[in] b float value 2 (pointer)
*/
CGLM_INLINE
void
glm_swapf(float * __restrict a, float * __restrict b) {
float t;
t = *a;
*a = *b;
*b = t;
}
#endif /* cglm_util_h */