184 lines
7.1 KiB
Text
184 lines
7.1 KiB
Text
// Copyright 2009-2021 Intel Corporation
|
|
// SPDX-License-Identifier: Apache-2.0
|
|
|
|
#pragma once
|
|
|
|
#include "../common.isph"
|
|
|
|
// ------------------------------------------------------------------
|
|
// Constants
|
|
// ------------------------------------------------------------------
|
|
|
|
#define inf (1e100f)
|
|
#define pos_inf (1e100f)
|
|
#define neg_inf (-1e100f)
|
|
|
|
#define M_PI 3.14159265358979323846f
|
|
#define pi 3.14159265358979323846f
|
|
#define two_pi 6.283185307179586232f
|
|
#define four_pi 12.566370614359172464f
|
|
|
|
#define one_over_pi 0.31830988618379069122f
|
|
#define one_over_two_pi 0.15915494309189534561f
|
|
#define one_over_four_pi 0.079577471545947672804f
|
|
#define one_over_two_pi_sqr 0.050660591821168885722f
|
|
|
|
/*! c-style reciprocal. required since ispc 1.7 due to type changes in this version */
|
|
inline float rcpf(const float f) { return rcp(f); }
|
|
/*! c-style reciprocal. required since ispc 1.7 due to type changes in this version */
|
|
inline uniform float rcpf(const uniform float f) { return rcp(f); }
|
|
|
|
/*! c-style square root. */
|
|
inline float sqrtf(const float f) { return sqrt(f); }
|
|
/*! c-style square root */
|
|
inline uniform float sqrtf(const uniform float f) { return sqrt(f); }
|
|
|
|
/*! c-style reciprocal square root. */
|
|
inline float rsqrtf(const float f) { return rsqrt(f); }
|
|
/*! c-style reciprocal square root */
|
|
inline uniform float rsqrtf(const uniform float f) { return rsqrt(f); }
|
|
|
|
/*! square. */
|
|
inline float sqr(const float f) { return f*f; }
|
|
/*! square. */
|
|
inline uniform float sqr(const uniform float f) { return f*f; }
|
|
/*! c-style square. */
|
|
inline float sqrf(const float f) { return f*f; }
|
|
/*! c-style square */
|
|
inline uniform float sqrf(const uniform float f) { return f*f; }
|
|
|
|
/*! c-style pow function. */
|
|
inline float powf(const float a, const float b) { return pow(a,b); }
|
|
/*! c-style pow function */
|
|
inline uniform float powf(const uniform float a, const uniform float b) { return pow(a,b); }
|
|
|
|
|
|
/*! c-style cos. */
|
|
inline float cosf(const float f) { return cos(f); }
|
|
/*! c-style cos */
|
|
inline uniform float cosf(const uniform float f) { return cos(f); }
|
|
|
|
/*! c-style sin. */
|
|
inline float sinf(const float f) { return sin(f); }
|
|
/*! c-style sin */
|
|
inline uniform float sinf(const uniform float f) { return sin(f); }
|
|
|
|
/*! c-style exp. */
|
|
inline float expf(const float f) { return exp(f); }
|
|
/*! c-style exp */
|
|
inline uniform float expf(const uniform float f) { return exp(f); }
|
|
|
|
/*! c-style log. */
|
|
inline float logf(const float f) { return log(f); }
|
|
/*! c-style log */
|
|
inline uniform float logf(const uniform float f) { return log(f); }
|
|
|
|
/*! c-style abs. */
|
|
inline float absf(const float f) { return abs(f); }
|
|
/*! c-style abs */
|
|
inline uniform float absf(const uniform float f) { return abs(f); }
|
|
|
|
|
|
// inline float clamp(const float f) { return max(min(1.f,f),0.f); }
|
|
|
|
inline uniform float rcp_safe(uniform float f) { return rcpf((abs(f) < 1e-8f) ? 1e-8f : f); }
|
|
inline varying float rcp_safe(varying float f) { return rcpf((abs(f) < 1e-8f) ? 1e-8f : f); }
|
|
|
|
inline uniform float sqrt_safe(uniform float f) { return sqrt(max(f, 0.0f)); }
|
|
inline varying float sqrt_safe(varying float f) { return sqrt(max(f, 0.0f)); }
|
|
|
|
inline uniform float clamp (const uniform float v) { return max(0.0f,min(v,1.0f)); }
|
|
inline varying float clamp (const varying float v) { return max(0.0f,min(v,1.0f)); }
|
|
|
|
inline uniform float clamp (const uniform float v, const uniform float lower, const uniform float upper) { return max(lower,min(v,upper)); }
|
|
inline varying float clamp (const varying float v, const varying float lower, const varying float upper) { return max(lower,min(v,upper)); }
|
|
|
|
inline uniform int clamp (const uniform int v, const uniform int lower, const uniform int upper) { return max(lower,min(v,upper)); }
|
|
inline varying int clamp (const varying int v, const varying int lower, const varying int upper) { return max(lower,min(v,upper)); }
|
|
|
|
inline uniform float frac(const uniform float x) { return x - floor(x); }
|
|
inline varying float frac(const varying float x) { return x - floor(x); }
|
|
|
|
inline uniform float deg2rad (const uniform float x) { return x * 1.74532925199432957692e-2f; }
|
|
inline varying float deg2rad (const varying float x) { return x * 1.74532925199432957692e-2f; }
|
|
|
|
inline uniform float rad2deg (const uniform float x) { return x * 5.72957795130823208768e1f; }
|
|
inline varying float rad2deg (const varying float x) { return x * 5.72957795130823208768e1f; }
|
|
|
|
inline float cos2sin(const float f) { return sqrt(max(0.f, 1.f - sqr(f))); }
|
|
inline float sin2cos(const float f) { return cos2sin(f); }
|
|
|
|
inline uniform float nextafter(const uniform float a, const uniform float b)
|
|
{
|
|
//! Match the behavior of the C99 math.h function.
|
|
if (a == b) return(b);
|
|
|
|
//! We will compute the smallest representable floating increment or decrement around 'a'.
|
|
uniform float delta = (b > a) ? 1.0f : -1.0f;
|
|
|
|
//! Iteratively compute the positive or negative increment.
|
|
while (a + 0.5f * delta != a) delta *= 0.5f;
|
|
|
|
//! Return the smallest number greater than 'a' or the largest number smaller than 'a'.
|
|
return(a + delta);
|
|
}
|
|
|
|
#define __define_lerp(TYPE) \
|
|
inline TYPE lerp(float factor, TYPE a, TYPE b) \
|
|
{ \
|
|
return (1-factor)* a + factor * b; \
|
|
} \
|
|
inline uniform TYPE lerp(uniform float factor, uniform TYPE a, uniform TYPE b) \
|
|
{ \
|
|
return (1-factor)* a + factor * b; \
|
|
}
|
|
|
|
|
|
__define_lerp(int8)
|
|
__define_lerp(int32)
|
|
__define_lerp(float)
|
|
__define_lerp(uint8)
|
|
__define_lerp(uint32)
|
|
|
|
#undef __define_lerp
|
|
|
|
// ------------------------------------------------------------------
|
|
// min4/max4, for all types
|
|
// ------------------------------------------------------------------
|
|
#define __define_op4T(MM,TYPE) \
|
|
inline uniform TYPE MM##4(uniform TYPE a, uniform TYPE b, \
|
|
uniform TYPE c, uniform TYPE d) \
|
|
{ \
|
|
return MM(a, MM(b, MM(c, d))); \
|
|
} \
|
|
inline varying TYPE MM##4(varying TYPE a, varying TYPE b, \
|
|
varying TYPE c, varying TYPE d) \
|
|
{ \
|
|
return MM(a, MM(b, MM(c, d))); \
|
|
}
|
|
|
|
#define __define_op4(MM) \
|
|
__define_op4T(MM,int8) \
|
|
__define_op4T(MM,int32) \
|
|
__define_op4T(MM,uint8) \
|
|
__define_op4T(MM,uint32) \
|
|
__define_op4T(MM,float) \
|
|
__define_op4T(MM,double)
|
|
|
|
__define_op4(min)
|
|
__define_op4(max)
|
|
|
|
#undef __define_op4T
|
|
#undef __define_op4
|
|
|
|
#define SIMILAR_EPSILON .00001f
|
|
inline float similar(float a, float b)
|
|
{
|
|
return absf(a - b) <= SIMILAR_EPSILON;
|
|
}
|
|
|
|
inline uniform float similar(uniform float a, uniform float b)
|
|
{
|
|
return absf(a - b) <= SIMILAR_EPSILON;
|
|
}
|
|
#undef SIMILAR_EPSILON
|