773 lines
25 KiB
C++
773 lines
25 KiB
C++
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
#include "DSP/SphericalHarmonicCalculator.h"
|
|
|
|
namespace Audio
|
|
{
|
|
namespace SphericalHarmonicsPrivate
|
|
{
|
|
// Common constants used in basis functions.
|
|
constexpr float SQRT_3 = 1.73205080757f;
|
|
constexpr float SQRT_3_DIV_2 = 1.224744871391589f;
|
|
constexpr float SQRT_5 = 2.2360679775f;
|
|
constexpr float SQRT_6 = 2.44948974278f;
|
|
constexpr float SQRT_7 = 2.64575131106f;
|
|
constexpr float SQRT_10 = 3.16227766017f;
|
|
constexpr float SQRT_15 = 3.87298334621f;
|
|
constexpr float SQRT_15_DIV_2 = SQRT_15 / 2.0f;
|
|
constexpr float SQRT_21_DIV_2 = 3.24037034920f;
|
|
constexpr float SQRT_35_DIV_2 = 4.18330013267f;
|
|
constexpr float SQRT_105 = 10.24695076596f;
|
|
constexpr float SQRT_35 = 5.9160797831f;
|
|
constexpr float SQRT_70 = 8.3666002653f;
|
|
constexpr float SQRT_5_DIV_4 = 1.1180339887f;
|
|
constexpr float SQRT_70_DIV_4 = 2.0916500663f;
|
|
constexpr float SQRT_105_DIV_4 = 2.5311320584f;
|
|
constexpr float SQRT_5_DIV_16 = 0.5590169944f;
|
|
constexpr float SQRT_70_DIV_8 = 1.0458250331f;
|
|
constexpr float SQRT_35_DIV_8 = 0.7395099729f;
|
|
constexpr float SQRT_14 = 3.74165738677f;
|
|
constexpr float SQRT_13 = 3.60555127546f;
|
|
constexpr float SQRT_91 = 9.53939201417f;
|
|
constexpr float SQRT_210 = 14.4913767462f;
|
|
constexpr float SQRT_273 = 16.5227116410f;
|
|
constexpr float SQRT_429 = 20.7082789866f;
|
|
constexpr float SQRT_858 = 29.2966064066f;
|
|
constexpr float SQRT_13_DIV_32 = SQRT_13 / 32.f;
|
|
constexpr float SQRT_91_DIV_8 = SQRT_91 / 8.f;
|
|
constexpr float SQRT_273_DIV_16 = SQRT_273 / 16.f;
|
|
constexpr float SQRT_429_DIV_8 = SQRT_429 / 8.f;
|
|
constexpr float SQRT_14_DIV_16 = SQRT_14 * 3.0f / 16.0f;
|
|
constexpr float SQRT_70_DIV_32 = SQRT_70 / 32.0f;
|
|
constexpr float SQRT_15_DIV_8 = SQRT_15 / 8.0f;
|
|
|
|
// Cache trig functions.
|
|
struct FTrigCache
|
|
{
|
|
// We only support up to 7th order for now.
|
|
static constexpr int32 MaxOrder = 7;
|
|
|
|
float SinElevation = 0.f;
|
|
float CosElevation = 0.f;
|
|
float SinAzimuthOrder[MaxOrder+1];
|
|
float CosAzimuthOrder[MaxOrder+1];
|
|
|
|
FTrigCache(const float Azimuth, const float Elevation, const int32 Order)
|
|
: SinElevation(FMath::Sin(Elevation))
|
|
, CosElevation(FMath::Cos(Elevation))
|
|
{
|
|
check(Order >= 0 && Order <= MaxOrder);
|
|
|
|
// Cache sin/cos * order
|
|
SinAzimuthOrder[0] = 0.f;
|
|
CosAzimuthOrder[0] = 1.f;
|
|
for (int32 i = 1; i <= Order; ++i)
|
|
{
|
|
SinAzimuthOrder[i] = FMath::Sin(i * Azimuth);
|
|
CosAzimuthOrder[i] = FMath::Cos(i * Azimuth);
|
|
}
|
|
}
|
|
};
|
|
|
|
// Order 0
|
|
static float SHBasisFunction_ACN_0(const FTrigCache& /*Trig*/)
|
|
{
|
|
return 1.0f; // Omnidirectional
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_1(const FTrigCache& T)
|
|
{
|
|
return -SQRT_3 * T.CosElevation * T.SinAzimuthOrder[1];
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_2(const FTrigCache& T)
|
|
{
|
|
return SQRT_3 * T.SinElevation;
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_3(const FTrigCache& T)
|
|
{
|
|
return -SQRT_3 * T.CosElevation * T.CosAzimuthOrder[1];
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Order 2
|
|
//------------------------------------------------------------------------------
|
|
|
|
static float SHBasisFunction_ACN_4(const FTrigCache& T)
|
|
{
|
|
return 0.645497f * T.CosElevation * T.SinAzimuthOrder[2];
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_5(const FTrigCache& T)
|
|
{
|
|
const float S= T.SinElevation;
|
|
const float P21 = 3.f * S* T.CosElevation;
|
|
constexpr float N2_1 = 1.290994f;
|
|
return -N2_1 * P21 * T.SinAzimuthOrder[1];
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_6(const FTrigCache& T)
|
|
{
|
|
const float S= T.SinElevation;
|
|
const float P20 = 0.5f * (3.f * S*S - 1.f);
|
|
return 2.236068f * P20;
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_7(const FTrigCache& T)
|
|
{
|
|
const float S= T.SinElevation;
|
|
const float P21 = 3.f * S* T.CosElevation;
|
|
constexpr float N2_1 = 1.290994f;
|
|
return -N2_1 * P21 * T.CosAzimuthOrder[1];
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_8(const FTrigCache& T)
|
|
{
|
|
const float C = T.CosElevation;
|
|
const float P22 = 3.f * C * C;
|
|
constexpr float N2_2 = 0.645497f;
|
|
return N2_2 * P22 * T.CosAzimuthOrder[2];
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Order 3
|
|
//------------------------------------------------------------------------------
|
|
|
|
static float SHBasisFunction_ACN_9(const FTrigCache& T)
|
|
{
|
|
const float C = T.CosElevation;
|
|
const float P33 = C * C * C;
|
|
constexpr float N3_3 = 2.092034f;
|
|
return -N3_3 * P33 * T.SinAzimuthOrder[3];
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_10(const FTrigCache& T)
|
|
{
|
|
constexpr float N3D_3_2 = 0.0963537f;
|
|
return N3D_3_2 * T.CosElevation * T.SinAzimuthOrder[2];
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_11(const FTrigCache& T)
|
|
{
|
|
const float S= T.SinElevation;
|
|
const float P31 = 3.f * S* T.CosElevation;
|
|
constexpr float N3_1 = 1.145644f;
|
|
return -N3_1 * P31 * T.SinAzimuthOrder[1];
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_12(const FTrigCache& T)
|
|
{
|
|
const float S= T.SinElevation;
|
|
const float P30 = 0.5f * (5.f * S*S*S - 3.f * S);
|
|
return 2.645751f * P30;
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_13(const FTrigCache& T)
|
|
{
|
|
const float S= T.SinElevation;
|
|
const float P31 = 3.f * S* T.CosElevation;
|
|
constexpr float N3_1 = 1.145644f;
|
|
return -N3_1 * P31 * T.CosAzimuthOrder[1];
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_14(const FTrigCache& T)
|
|
{
|
|
const float C = T.CosElevation;
|
|
const float P32 = 3.f * C * C;
|
|
constexpr float N3_2 = 1.207615f;
|
|
return N3_2 * P32 * T.CosAzimuthOrder[2];
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_15(const FTrigCache& T)
|
|
{
|
|
const float C = T.CosElevation;
|
|
const float P33 = C * C * C;
|
|
constexpr float N3_3 = 2.092034f;
|
|
return -N3_3 * P33 * T.CosAzimuthOrder[3];
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Order 4
|
|
//------------------------------------------------------------------------------
|
|
|
|
static float SHBasisFunction_ACN_16(const FTrigCache& T)
|
|
{
|
|
constexpr float N3D_4_4 = 0.0059603f;
|
|
return N3D_4_4 * T.CosElevation * T.SinAzimuthOrder[4];
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_17(const FTrigCache& T)
|
|
{
|
|
const float S = T.SinElevation;
|
|
const float C = T.CosElevation;
|
|
const float P43 = 15.f * S* C * C * C;
|
|
constexpr float N4_3 = 0.4183301f;
|
|
return -N4_3 * P43 * T.SinAzimuthOrder[3];
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_18(const FTrigCache& T)
|
|
{
|
|
constexpr float N3D_4_2 = 0.0630783f;
|
|
return N3D_4_2 * T.CosElevation * T.SinAzimuthOrder[2];
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_19(const FTrigCache& T)
|
|
{
|
|
const float S = T.SinElevation;
|
|
const float C = T.CosElevation;
|
|
const float P41 = 2.5f * S* (7.f * S*S - 3.f) * C;
|
|
constexpr float N4_1 = 0.9486833f;
|
|
return -N4_1 * P41 * T.SinAzimuthOrder[1];
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_20(const FTrigCache& T)
|
|
{
|
|
const float S = T.SinElevation;
|
|
const float s2 = S*S;
|
|
const float P40 = 0.125f * (35.f * s2*s2 - 30.f * s2 + 3.f);
|
|
return 3.0f * P40;
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_21(const FTrigCache& T)
|
|
{
|
|
const float S = T.SinElevation;
|
|
const float C = T.CosElevation;
|
|
const float P41 = 2.5f * S* (7.f * S*S - 3.f) * C;
|
|
constexpr float N4_1 = 0.9486833f;
|
|
return -N4_1 * P41 * T.CosAzimuthOrder[1];
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_22(const FTrigCache& T)
|
|
{
|
|
const float S = T.SinElevation;
|
|
const float S2 = S*S;
|
|
const float P42 = -0.5f * (105.f * S2*S2 - 120.f * S2 + 15.f);
|
|
constexpr float N4_2 = 0.2236068f;
|
|
return N4_2 * P42 * T.CosAzimuthOrder[2];
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_23(const FTrigCache& T)
|
|
{
|
|
const float S = T.SinElevation;
|
|
const float C = T.CosElevation;
|
|
const float P43 = 15.f * S * C * C * C;
|
|
constexpr float N4_3 = 0.4183301f;
|
|
return -N4_3 * P43 * T.CosAzimuthOrder[3];
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_24(const FTrigCache& T)
|
|
{
|
|
const float C = T.CosElevation;
|
|
const float P44 = C * C * C * C;
|
|
constexpr float N4_4 = 2.218528f;
|
|
return N4_4 * P44 * T.CosAzimuthOrder[4];
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_25(const FTrigCache& T)
|
|
{
|
|
const float C = T.CosElevation;
|
|
const float P55 = -945.f * C*C*C*C*C;
|
|
constexpr float N5_5 = 0.0024619f;
|
|
return N5_5 * P55 * T.SinAzimuthOrder[5];
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_26(const FTrigCache& T)
|
|
{
|
|
constexpr float N3D_5_4 = 0.0012290f;
|
|
return N3D_5_4 * T.CosElevation * T.SinAzimuthOrder[4];
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_27(const FTrigCache& T)
|
|
{
|
|
const float S = T.SinElevation;
|
|
const float x2 = S*S;
|
|
const float P53 = -FMath::Pow(1.f - x2, 1.5f) * (3780.f * x2 - 420.f) * 0.125f;
|
|
constexpr float N5_3 = 0.03303437f;
|
|
return N5_3 * P53 * T.SinAzimuthOrder[3];
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_28(const FTrigCache& T)
|
|
{
|
|
constexpr float N3D_5_2 = 0.0413065f;
|
|
return N3D_5_2 * T.CosElevation * T.SinAzimuthOrder[2];
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_29(const FTrigCache& T)
|
|
{
|
|
const float S = T.SinElevation;
|
|
const float x2 = S*S;
|
|
const float P51 = -FMath::Sqrt(1.f - x2) * ((315.f * x2*x2 - 210.f * x2 + 15.f) * 0.125f);
|
|
constexpr float N5_1 = 0.85634918f;
|
|
return N5_1 * P51 * T.SinAzimuthOrder[1];
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_30(const FTrigCache& T)
|
|
{
|
|
const float S = T.SinElevation;
|
|
const float P50 = 0.125f * (63.f * S*S*S*S*S - 70.f * S*S*S + 15.f * S);
|
|
constexpr float N5_0 = 3.31662479f;
|
|
return N5_0 * P50;
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_31(const FTrigCache& T)
|
|
{
|
|
const float S = T.SinElevation;
|
|
const float x2 = S*S;
|
|
const float P51 = -FMath::Sqrt(1.f - x2) * ((315.f * x2*x2 - 210.f*x2 + 15.f) * 0.125f);
|
|
constexpr float N5_1 = 0.85634918f;
|
|
return N5_1 * P51 * T.CosAzimuthOrder[1];
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_32(const FTrigCache& T)
|
|
{
|
|
const float S = T.SinElevation;
|
|
const float x2 = S*S;
|
|
const float P52 = 52.5f * S* (3.f * x2 - 1.f) * (1.f - x2);
|
|
constexpr float N5_2 = 0.161835f;
|
|
return N5_2 * P52 * T.CosAzimuthOrder[2];
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_33(const FTrigCache& T)
|
|
{
|
|
const float S = T.SinElevation;
|
|
const float C = T.CosElevation;
|
|
const float x2 = S*S;
|
|
const float P53 = -0.125f * (3780.f * x2 - 420.f) * (C * C * C);
|
|
constexpr float N5_3 = 0.03303437f;
|
|
return N5_3 * P53 * T.CosAzimuthOrder[3];;
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_34(const FTrigCache& T)
|
|
{
|
|
const float S = T.SinElevation;
|
|
const float S2 = S*S;
|
|
const float P54 = 945.f * S * (1.f - S2) * (1.f - S2);
|
|
constexpr float N5_4 = 0.007786274f;
|
|
return N5_4 * P54 * T.CosAzimuthOrder[4];
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_35(const FTrigCache& T)
|
|
{
|
|
const float C = T.CosElevation;
|
|
const float P55 = -945.f * C * C * C * C * C;
|
|
constexpr float N5_5 = 0.00246216f;
|
|
return N5_5 * P55 * T.CosAzimuthOrder[5];
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Order 6
|
|
//------------------------------------------------------------------------------
|
|
|
|
static float SHBasisFunction_ACN_36(const FTrigCache& T)
|
|
{
|
|
constexpr float N3D_6_6 = 0.0000657f;
|
|
return N3D_6_6 * T.CosElevation * T.SinAzimuthOrder[6];
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_37(const FTrigCache& T)
|
|
{
|
|
const float S = T.SinElevation;
|
|
const float C = T.CosElevation;
|
|
const float P65 = -10395.f * S * C * C * C * C * C;
|
|
constexpr float N6_5 = 0.00080696f;
|
|
return N6_5 * P65 * T.SinAzimuthOrder[5];
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_38(const FTrigCache& T)
|
|
{
|
|
constexpr float N3D_6_4 = 0.0010679f;
|
|
return N3D_6_4 * T.CosElevation * T.SinAzimuthOrder[4];
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_39(const FTrigCache& T)
|
|
{
|
|
const float S = T.SinElevation;
|
|
const float S2 = S*S;
|
|
const float OneMinus_s2 = 1.f - S2;
|
|
const float P63 = ((-1732.5f * S*S*S) + (472.5F * S)) * OneMinus_s2 * T.CosElevation;
|
|
constexpr float N6_3 = 0.0207339f;
|
|
return N6_3 * P63 * T.SinAzimuthOrder[3];
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_40(const FTrigCache& T)
|
|
{
|
|
constexpr float N3D_6_2 = 0.0350935f;
|
|
return N3D_6_2 * T.CosElevation * T.SinAzimuthOrder[2];
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_41(const FTrigCache& T)
|
|
{
|
|
const float S = T.SinElevation;
|
|
const float X2 = S*S;
|
|
const float P61 = -0.0625f * (1386.f * S*X2*X2 -1260.f * S*X2 + 210.f * S) * T.CosElevation;
|
|
constexpr float N6_1 = 0.786800f;
|
|
return N6_1 * P61 * T.SinAzimuthOrder[1];
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_42(const FTrigCache& T)
|
|
{
|
|
const float S = T.SinElevation;
|
|
const float S2 = S*S;
|
|
const float S4 = S2*S2;
|
|
const float S6 = S4*S2;
|
|
const float P60 = 0.0625F * (231.F * S6 - 315.F * S4 + 105.F * S2 - 5.F);
|
|
constexpr float N6_0 = 3.605551f;
|
|
return N6_0 * P60;
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_43(const FTrigCache& T)
|
|
{
|
|
const float S = T.SinElevation;
|
|
const float X2 = S*S;
|
|
const float P61 = -0.0625f * (1386.f * S*X2*X2 -1260.f * S*X2 + 210.f * S) * T.CosElevation;
|
|
constexpr float N6_1 = 0.786800f;
|
|
return N6_1 * P61 * T.CosAzimuthOrder[1];
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_44(const FTrigCache& T)
|
|
{
|
|
const float S = T.SinElevation;
|
|
const float S2 = S * S;
|
|
const float S4 = S2 * S2;
|
|
const float S6 = S4 * S2;
|
|
const float P62 = (-3465.f * S6 + 5355.f * S4 - 1995.f * S2 + 105.f) * 0.125f;
|
|
constexpr float N6_2 = 0.1244032f;
|
|
return N6_2 * P62 * T.CosAzimuthOrder[2];
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_45(const FTrigCache& T)
|
|
{
|
|
const float S = T.SinElevation;
|
|
const float S2 = S * S;
|
|
const float OneMinusS2 = 1.f - S2;
|
|
const float P63 = ((-1732.5f * S* S * S) + (472.5f * S)) * OneMinusS2 * T.CosElevation;
|
|
constexpr float N6_3 = 0.0207339f;
|
|
return N6_3 * P63 * T.CosAzimuthOrder[3];;
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_46(const FTrigCache& T)
|
|
{
|
|
const float S = T.SinElevation;
|
|
const float S2 = S * S;
|
|
const float OneMinusS2 = 1.f - S2;
|
|
const float P64 = 0.5f * (10395.f * S2 - 945.f) * OneMinusS2 * OneMinusS2;
|
|
constexpr float N6_4 = 0.003785f;
|
|
return N6_4 * P64 * T.CosAzimuthOrder[4];
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_47(const FTrigCache& T)
|
|
{
|
|
const float S = T.SinElevation;
|
|
const float C = T.CosElevation;
|
|
const float P65 = -10395.f * S * C * C * C * C * C;
|
|
constexpr float N6_5 = 0.0008070657f;
|
|
return N6_5 * P65 * T.CosAzimuthOrder[5];
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_48(const FTrigCache& T)
|
|
{
|
|
const float S = T.SinElevation;
|
|
const float P66 = 10395.f * FMath::Pow(1.f - S*S, 3);
|
|
constexpr float N6_6 = 0.00023317f;
|
|
return N6_6 * P66 * T.CosAzimuthOrder[6];
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Order 7
|
|
//----------------------------------------------------------------------------//
|
|
|
|
static float SHBasisFunction_ACN_49(const FTrigCache& T)
|
|
{
|
|
const float C = T.CosElevation;
|
|
const float P77 = 135135.f * C * C * C * C * C * C * C;
|
|
constexpr float N7_7 = 1.85505e-05f;
|
|
return -N7_7 * P77 * T.SinAzimuthOrder[7];
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_50(const FTrigCache& T)
|
|
{
|
|
constexpr float N3D_7_6 = 0.0000196f;
|
|
return N3D_7_6 * T.CosElevation * T.SinAzimuthOrder[6];
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_51(const FTrigCache& T)
|
|
{
|
|
const float S = T.SinElevation;
|
|
const float C = T.CosElevation;
|
|
const float P75 = -((67567.5f * S*S - 5197.5f) * C * C * C * C * C);
|
|
constexpr float N7_5 = 0.0003539220f;
|
|
return N7_5 * P75 * T.SinAzimuthOrder[5];
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_52(const FTrigCache& T)
|
|
{
|
|
constexpr float N3D_7_4 = 0.0005990f;
|
|
return N3D_7_4 * T.CosElevation * T.SinAzimuthOrder[4];
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_53(const FTrigCache& T)
|
|
{
|
|
const float S = T.SinElevation;
|
|
const float C = T.CosElevation;
|
|
const float X2 = S * S;
|
|
const float P7 = (90090.f * X2 * X2 - 41580.f * X2 + 1890.f) * 0.0625f;
|
|
const float P73 = C * C * C * P7;
|
|
constexpr float N7_3 = 0.0140849f;
|
|
return -N7_3 * P73 * T.SinAzimuthOrder[3];;
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_54(const FTrigCache& T)
|
|
{
|
|
constexpr float N3D_7_2 = 0.0280973f;
|
|
return N3D_7_2 * T.CosElevation * T.SinAzimuthOrder[2];
|
|
}
|
|
|
|
static constexpr float N7_1_CAL = 0.731924f;
|
|
|
|
static float SHBasisFunction_ACN_55(const FTrigCache& T)
|
|
{
|
|
const float S = T.SinElevation;
|
|
const float C = T.CosElevation;
|
|
const float X2 = S*S;
|
|
const float P7d = (3003.f * X2*X2*X2 -3465.f * X2*X2 + 945.f * X2 - 35.f) * 0.0625f;
|
|
const float P71 = -C * P7d;
|
|
return N7_1_CAL * P71 * T.SinAzimuthOrder[1];
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_56(const FTrigCache& T)
|
|
{
|
|
const float S = T.SinElevation;
|
|
const float S2 = S * S;
|
|
const float S3 = S2 * S;
|
|
const float S5 = S3 * S2;
|
|
const float S7 = S5 * S2;
|
|
const float P70 = 0.0625f * (429.f * S7 - 693.f * S5 + 315.f * S3 - 35.f * S);
|
|
constexpr float N7_0 = 3.872983f;
|
|
return N7_0 * P70;
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_57(const FTrigCache& T)
|
|
{
|
|
const float S = T.SinElevation;
|
|
const float C = T.CosElevation;
|
|
const float X2 = S*S;
|
|
const float P7d = (3003.f * X2*X2*X2 -3465.f * X2*X2 + 945.f * X2 - 35.f) * 0.0625f;
|
|
const float P71 = -C * P7d;
|
|
return N7_1_CAL * P71 * T.CosAzimuthOrder[1];
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_58(const FTrigCache& T)
|
|
{
|
|
const float S = T.SinElevation;
|
|
const float X2 = S*S;
|
|
const float P72 = 0.125f * (945.f * S*X2*X2 -1575.f * S*X2 + 525.f * S) * (1.f - X2);
|
|
constexpr float N7_2 = 1.0159443f;
|
|
return N7_2 * P72 * T.CosAzimuthOrder[2];
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_59(const FTrigCache& T)
|
|
{
|
|
const float S = T.SinElevation;
|
|
const float C = T.CosElevation;
|
|
const float X2 = S*S;
|
|
const float P7 = (90090.f * X2 * X2 - 41580.f * X2 + 1890.f) * 0.0625f;
|
|
const float P73 = C * C * C * P7;
|
|
constexpr float N7_3 = 1.127530f / 80.05332f;
|
|
return -N7_3 * P73 * T.CosAzimuthOrder[3];
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_60(const FTrigCache& T)
|
|
{
|
|
const float S = T.SinElevation;
|
|
const float X2 = S * S;
|
|
const float OneMinusX2 = 1.f - X2;
|
|
const float A = (360360.f * S * X2 - 83160.f * S) * 0.0625f;
|
|
const float P74 = OneMinusX2 * OneMinusX2 * A;
|
|
constexpr float N7_4 = 0.00212334f;
|
|
return N7_4 * P74 * T.CosAzimuthOrder[4];
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_61(const FTrigCache& T)
|
|
{
|
|
const float S = T.SinElevation;
|
|
const float C = T.CosElevation;
|
|
const float P75 = 5197.5f * (1.f - 13.f * S * S) * C * C * C * C * C;
|
|
constexpr float N7_5 = 0.0003539217f;
|
|
return N7_5 * P75 * T.CosAzimuthOrder[5];
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_62(const FTrigCache& T)
|
|
{
|
|
const float S = T.SinElevation;
|
|
const float OneMinusS2 = 1.f - S*S;
|
|
const float P76 = 135135.f * S * OneMinusS2 * OneMinusS2 * OneMinusS2;
|
|
constexpr float N7_6 = 0.829055f / 11944.359359455508f;
|
|
return N7_6 * P76 * T.CosAzimuthOrder[6];
|
|
}
|
|
|
|
static float SHBasisFunction_ACN_63(const FTrigCache& T)
|
|
{
|
|
const float S = T.SinElevation;
|
|
const float OneMinusS2 = 1.f - S*S;
|
|
const float P77 = -135135.f * OneMinusS2 * OneMinusS2 * OneMinusS2 * FMath::Sqrt(OneMinusS2);
|
|
constexpr float N7_7 = 0.221574f / 11944.359359455508f;
|
|
return N7_7 * P77 * T.CosAzimuthOrder[7];
|
|
}
|
|
}
|
|
}
|
|
|
|
void FSphericalHarmonicCalculator::ComputeSoundfieldChannelGains(const int32 Order, const float Azimuth, const float Elevation, float* OutGains)
|
|
{
|
|
ComputeSoundfieldChannelGains(Order, Azimuth, Elevation, MakeArrayView(OutGains, OrderToNumChannels(Order)));
|
|
}
|
|
|
|
void FSphericalHarmonicCalculator::ComputeSoundfieldChannelGains(
|
|
const int32 Order, const float Azimuth, const float Elevation, TArrayView<float> OutGains)
|
|
{
|
|
using namespace Audio::SphericalHarmonicsPrivate;
|
|
check(Order >= 0 && Order <= 7);
|
|
check(OutGains.Num() >= OrderToNumChannels(Order));
|
|
|
|
using namespace Audio;
|
|
const FTrigCache TrigCache(Azimuth, Elevation, Order);
|
|
|
|
switch (Order)
|
|
{
|
|
case 7:
|
|
OutGains[63] = SHBasisFunction_ACN_63(TrigCache);
|
|
OutGains[62] = SHBasisFunction_ACN_62(TrigCache);
|
|
OutGains[61] = SHBasisFunction_ACN_61(TrigCache);
|
|
OutGains[60] = SHBasisFunction_ACN_60(TrigCache);
|
|
OutGains[59] = SHBasisFunction_ACN_59(TrigCache);
|
|
OutGains[58] = SHBasisFunction_ACN_58(TrigCache);
|
|
OutGains[57] = SHBasisFunction_ACN_57(TrigCache);
|
|
OutGains[56] = SHBasisFunction_ACN_56(TrigCache);
|
|
OutGains[55] = SHBasisFunction_ACN_55(TrigCache);
|
|
OutGains[54] = SHBasisFunction_ACN_54(TrigCache);
|
|
OutGains[53] = SHBasisFunction_ACN_53(TrigCache);
|
|
OutGains[52] = SHBasisFunction_ACN_52(TrigCache);
|
|
OutGains[51] = SHBasisFunction_ACN_51(TrigCache);
|
|
OutGains[50] = SHBasisFunction_ACN_50(TrigCache);
|
|
OutGains[49] = SHBasisFunction_ACN_49(TrigCache);
|
|
[[fallthrough]];
|
|
case 6:
|
|
OutGains[48] = SHBasisFunction_ACN_48(TrigCache);
|
|
OutGains[47] = SHBasisFunction_ACN_47(TrigCache);
|
|
OutGains[46] = SHBasisFunction_ACN_46(TrigCache);
|
|
OutGains[45] = SHBasisFunction_ACN_45(TrigCache);
|
|
OutGains[44] = SHBasisFunction_ACN_44(TrigCache);
|
|
OutGains[43] = SHBasisFunction_ACN_43(TrigCache);
|
|
OutGains[42] = SHBasisFunction_ACN_42(TrigCache);
|
|
OutGains[41] = SHBasisFunction_ACN_41(TrigCache);
|
|
OutGains[40] = SHBasisFunction_ACN_40(TrigCache);
|
|
OutGains[39] = SHBasisFunction_ACN_39(TrigCache);
|
|
OutGains[38] = SHBasisFunction_ACN_38(TrigCache);
|
|
OutGains[37] = SHBasisFunction_ACN_37(TrigCache);
|
|
OutGains[36] = SHBasisFunction_ACN_36(TrigCache);
|
|
[[fallthrough]];
|
|
case 5:
|
|
OutGains[35] = SHBasisFunction_ACN_35(TrigCache);
|
|
OutGains[34] = SHBasisFunction_ACN_34(TrigCache);
|
|
OutGains[33] = SHBasisFunction_ACN_33(TrigCache);
|
|
OutGains[32] = SHBasisFunction_ACN_32(TrigCache);
|
|
OutGains[31] = SHBasisFunction_ACN_31(TrigCache);
|
|
OutGains[30] = SHBasisFunction_ACN_30(TrigCache);
|
|
OutGains[29] = SHBasisFunction_ACN_29(TrigCache);
|
|
OutGains[28] = SHBasisFunction_ACN_28(TrigCache);
|
|
OutGains[27] = SHBasisFunction_ACN_27(TrigCache);
|
|
OutGains[26] = SHBasisFunction_ACN_26(TrigCache);
|
|
OutGains[25] = SHBasisFunction_ACN_25(TrigCache);
|
|
[[fallthrough]];
|
|
case 4:
|
|
OutGains[24] = SHBasisFunction_ACN_24(TrigCache);
|
|
OutGains[23] = SHBasisFunction_ACN_23(TrigCache);
|
|
OutGains[22] = SHBasisFunction_ACN_22(TrigCache);
|
|
OutGains[21] = SHBasisFunction_ACN_21(TrigCache);
|
|
OutGains[20] = SHBasisFunction_ACN_20(TrigCache);
|
|
OutGains[19] = SHBasisFunction_ACN_19(TrigCache);
|
|
OutGains[18] = SHBasisFunction_ACN_18(TrigCache);
|
|
OutGains[17] = SHBasisFunction_ACN_17(TrigCache);
|
|
OutGains[16] = SHBasisFunction_ACN_16(TrigCache);
|
|
[[fallthrough]];
|
|
case 3:
|
|
OutGains[15] = SHBasisFunction_ACN_15(TrigCache);
|
|
OutGains[14] = SHBasisFunction_ACN_14(TrigCache);
|
|
OutGains[13] = SHBasisFunction_ACN_13(TrigCache);
|
|
OutGains[12] = SHBasisFunction_ACN_12(TrigCache);
|
|
OutGains[11] = SHBasisFunction_ACN_11(TrigCache);
|
|
OutGains[10] = SHBasisFunction_ACN_10(TrigCache);
|
|
OutGains[9] = SHBasisFunction_ACN_9(TrigCache);
|
|
[[fallthrough]];
|
|
case 2:
|
|
OutGains[8] = SHBasisFunction_ACN_8(TrigCache);
|
|
OutGains[7] = SHBasisFunction_ACN_7(TrigCache);
|
|
OutGains[6] = SHBasisFunction_ACN_6(TrigCache);
|
|
OutGains[5] = SHBasisFunction_ACN_5(TrigCache);
|
|
OutGains[4] = SHBasisFunction_ACN_4(TrigCache);
|
|
[[fallthrough]];
|
|
case 1:
|
|
OutGains[3] = SHBasisFunction_ACN_3(TrigCache);
|
|
OutGains[2] = SHBasisFunction_ACN_2(TrigCache);
|
|
OutGains[1] = SHBasisFunction_ACN_1(TrigCache);
|
|
[[fallthrough]];
|
|
case 0:
|
|
OutGains[0] = SHBasisFunction_ACN_0(TrigCache);
|
|
break;
|
|
default:
|
|
checkNoEntry();
|
|
}
|
|
}
|
|
|
|
|
|
void FSphericalHarmonicCalculator::GenerateFirstOrderRotationMatrixGivenRadians(const float RotXRadians, const float RotYRadians, const float RotZRadians, FMatrix & OutMatrix)
|
|
{
|
|
const float SinX = FMath::Sin(RotXRadians);
|
|
const float SinY = FMath::Sin(RotYRadians);
|
|
const float SinZ = FMath::Sin(RotZRadians);
|
|
|
|
const float CosX = FMath::Cos(RotXRadians);
|
|
const float CosY = FMath::Cos(RotYRadians);
|
|
const float CosZ = FMath::Cos(RotZRadians);
|
|
|
|
|
|
// Build out Rotation Matrix
|
|
OutMatrix.SetIdentity();
|
|
|
|
// row 0:
|
|
/* 1.0f 0.0f 0.0f 0.0f */
|
|
|
|
// row 1:
|
|
/* 0.0f */ OutMatrix.M[1][1] = (CosX * CosZ) + (SinX * SinY * SinZ); OutMatrix.M[1][2] = -SinX * CosY; OutMatrix.M[1][3] = (CosX * SinZ) - (SinX * SinY * CosZ);
|
|
|
|
// row 2:
|
|
/* 0.0f */ OutMatrix.M[2][1] = (SinX * CosZ) - (CosX * SinY * SinZ); OutMatrix.M[2][2] = CosX * CosY; OutMatrix.M[2][3] = (CosX * SinY * CosZ) + (SinX * SinZ);
|
|
|
|
// row 3:
|
|
/* 0.0f */ OutMatrix.M[3][1] = -CosY * SinZ; OutMatrix.M[3][2] = -SinY; OutMatrix.M[3][3] = CosY * CosZ;
|
|
}
|
|
|
|
void FSphericalHarmonicCalculator::GenerateFirstOrderRotationMatrixGivenDegrees(const float RotXDegrees, const float RotYDegrees, const float RotZDegrees, FMatrix & OutMatrix)
|
|
{
|
|
constexpr const float DEG_2_RAD = PI / 180.0f;
|
|
GenerateFirstOrderRotationMatrixGivenRadians(RotXDegrees * DEG_2_RAD, RotYDegrees * DEG_2_RAD, RotZDegrees * DEG_2_RAD, OutMatrix);
|
|
}
|
|
|
|
void FSphericalHarmonicCalculator::NormalizeGains(TArrayView<float> Gains)
|
|
{
|
|
// Normalize. gains.
|
|
float SumSqr = 0.f;
|
|
for (int32 i = 0; i < Gains.Num(); ++i)
|
|
{
|
|
SumSqr+=Gains[i]*Gains[i];
|
|
}
|
|
if (!FMath::IsNearlyZero(SumSqr))
|
|
{
|
|
const float InverseLength = 1.0f / FMath::Sqrt(SumSqr);
|
|
for (int32 i = 0; i < Gains.Num(); ++i)
|
|
{
|
|
Gains[i]*=InverseLength;
|
|
}
|
|
}
|
|
}
|