_ak_vectors_8h

Wwise SDK 2021.1.14

 /*******************************************************************************

 The content of this file includes portions of the AUDIOKINETIC Wwise Technology

 released in source code form as part of the SDK installer package.

 Commercial License Usage

 Licensees holding valid commercial licenses to the AUDIOKINETIC Wwise Technology

 may use this file in accordance with the end user license agreement provided 

 with the software or, alternatively, in accordance with the terms contained in a

 written agreement between you and Audiokinetic Inc.

 Apache License Usage

 Alternatively, this file may be used under the Apache License, Version 2.0 (the 

 "Apache License"); you may not use this file except in compliance with the 

 Apache License. You may obtain a copy of the Apache License at 

 http://www.apache.org/licenses/LICENSE-2.0.

 Unless required by applicable law or agreed to in writing, software distributed

 under the Apache License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES

 OR CONDITIONS OF ANY KIND, either express or implied. See the Apache License for

 the specific language governing permissions and limitations under the License.

   Version: v2021.1.14  Build: 6590

   Copyright (c) 2006-2023 Audiokinetic Inc.

 *******************************************************************************/

 // AkVectors.h

 //

 #pragma once

 #include <AK/SoundEngine/Common/AkTypes.h>

 #include <AK/SoundEngine/Common/AkSimd.h>

 #include <AK/SoundEngine/Common/AkSpeakerVolumes.h>

 #include <AK/SoundEngine/Common/IAkPluginMemAlloc.h>

 #include <AK/Tools/Common/AkArray.h>

 #include <AK/Tools/Common/AkObject.h>

 #include <math.h>

 #include <stdio.h>

 #include <float.h>

 //#define AKVBAP_DEBUG 1

 //#define AKPORTALS_DEBUG

 #define AKVECTORS_PI                (3.1415926535897932384626433832795f)

 #define AKVECTORS_TWOPI             (6.283185307179586476925286766559f)

 #define AKVECTORS_PIOVERTWO         (1.5707963267948966192313216916398f)

 #define AKVECTORS_EPSILON           (1.0e-38f)                                  // epsilon value for fast log(0)

 class Ak4DVector

 {

 public:

     //-----------------------------------------------------------

     // Constructor/Destructor functions

     Ak4DVector()

     {

         v[0] = 0.0f;

         v[1] = 0.0f;

         v[2] = 0.0f;

         v[3] = 0.0f;

     }

     Ak4DVector(const AkVector& b)

     {

         v[0] = b.X;

         v[1] = b.Y;

         v[2] = b.Z;

         v[3] = 1;

     }

     ~Ak4DVector(){}

     //-----------------------------------------------------------

     // Basic vector operators

     Ak4DVector operator=(const Ak4DVector& b)

     {

         v[0] = b.v[0];

         v[1] = b.v[1];

         v[2] = b.v[2];

         v[3] = b.v[3];

         return *this;

     }

     Ak4DVector operator/=(const AkReal32 f)

     {

         v[0] = v[0] / f;

         v[1] = v[1] / f;

         v[2] = v[2] / f;

         v[3] = v[3] / f;

         return *this;

     }

     Ak4DVector operator-(const Ak4DVector& b) const

     {

         Ak4DVector p;

         p.v[0] = v[0] - b.v[0];

         p.v[1] = v[1] - b.v[1];

         p.v[2] = v[2] - b.v[2];

         p.v[3] = v[3] - b.v[3];

         return p;

     }

     AkReal32    v[4];

 };

 struct Ak3DIntVector

 {

 public:

     Ak3DIntVector(){}

     Ak3DIntVector(AkInt32 x, AkInt32 y, AkInt32 z)

     {

         X = x;

         Y = y;

         Z = z;

     }

     ~Ak3DIntVector(){}

     AkInt32     X;  ///< X Position

     AkInt32     Y;  ///< Y Position

     AkInt32     Z;  ///< Z Position

 };

 class Ak3DVector

 {

 public:

     //-----------------------------------------------------------

     // Constructor/Destructor functions

     Ak3DVector() :

         X(0.f),

         Y(0.f),

         Z(0.f)

     {}

     Ak3DVector(

         AkReal32                    x,

         AkReal32                    y,

         AkReal32                    z)

     {

         X = x;

         Y = y;

         Z = z;

     }

     Ak3DVector(const AkVector& b)

     {

         X = b.X;

         Y = b.Y;

         Z = b.Z;

     }

     explicit Ak3DVector(const AKSIMD_V4F32& in_v4f32)

     {

         X = AKSIMD_GETELEMENT_V4F32(in_v4f32, 0);

         Y = AKSIMD_GETELEMENT_V4F32(in_v4f32, 1);

         Z = AKSIMD_GETELEMENT_V4F32(in_v4f32, 2);

     }

     AkForceInline AKSIMD_V4F32 PointV4F32() const

     {

         AKSIMD_V4F32 v4f32;

         AKSIMD_GETELEMENT_V4F32(v4f32, 0) = X;

         AKSIMD_GETELEMENT_V4F32(v4f32, 1) = Y;

         AKSIMD_GETELEMENT_V4F32(v4f32, 2) = Z;

         AKSIMD_GETELEMENT_V4F32(v4f32, 3) = 1.f;

         return v4f32;

     }

     AkForceInline AKSIMD_V4F32 VectorV4F32() const

     {

         AKSIMD_V4F32 v4f32;

         AKSIMD_GETELEMENT_V4F32(v4f32, 0) = X;

         AKSIMD_GETELEMENT_V4F32(v4f32, 1) = Y;

         AKSIMD_GETELEMENT_V4F32(v4f32, 2) = Z;

         AKSIMD_GETELEMENT_V4F32(v4f32, 3) = 0.f;

         return v4f32;

     }

     ~Ak3DVector() {}

     void Zero()

     {

         X = 0.f;

         Y = 0.f;

         Z = 0.f;

     }

     //-----------------------------------------------------------

     // Basic vector operators

     AkForceInline bool operator==(const Ak3DVector& b) const

     {

         return X == b.X && Y == b.Y && Z == b.Z;

     }

     AkForceInline bool operator!=(const Ak3DVector& b) const

     {

         return X != b.X || Y != b.Y || Z != b.Z;

     }

     AkForceInline Ak3DVector operator=(const Ak3DVector& b)

     {

         X = b.X;

         Y = b.Y;

         Z = b.Z;

         return *this;

     }

     AkForceInline Ak3DVector operator=(const AkVector& b)

     {

         X = b.X;

         Y = b.Y;

         Z = b.Z;

         return *this;

     }

     AkForceInline bool operator<(const Ak3DVector& b) const

     {

         return X < b.X && Y < b.Y && Z < b.Z;

     }

     AkForceInline bool operator<=(const Ak3DVector& b) const

     {

         return X <= b.X && Y <= b.Y && Z <= b.Z;

     }

     AkForceInline bool operator>(const Ak3DVector b) const

     {

         return X > b.X && Y > b.Y && Z > b.Z;

     }

     AkForceInline bool operator>=(const Ak3DVector& b) const

     {

         return X >= b.X && Y >= b.Y && Z >= b.Z;

     }

     AkForceInline Ak3DVector operator*=(const AkReal32 f)

     {

         X = X * f;

         Y = Y * f;

         Z = Z * f;

         return *this;

     }

     AkForceInline Ak3DVector operator/=(const AkReal32 f)

     {

         AkReal32 oneoverf = 1.f / f;

         X = X * oneoverf;

         Y = Y * oneoverf;

         Z = Z * oneoverf;

         return *this;

     }

     AkForceInline Ak3DVector operator*(const Ak3DVector v2) const

     {

         Ak3DVector v;

         v.X = X * v2.X;

         v.Y = Y * v2.Y;

         v.Z = Z * v2.Z;

         return v;

     }

     AkForceInline Ak3DVector operator*(const AkReal32 f) const

     {

         Ak3DVector v;

         v.X = X * f;

         v.Y = Y * f;

         v.Z = Z * f;

         return v;

     }

     AkForceInline Ak3DVector operator/(const AkReal32 f) const

     {

         Ak3DVector v;

         AkReal32 oneoverf = 1.f / f;

         v.X = X * oneoverf;

         v.Y = Y * oneoverf;

         v.Z = Z * oneoverf;

         return v;

     }

     AkForceInline Ak3DVector operator+(const AkReal32 f) const

     {

         Ak3DVector v;

         v.X = X + f;

         v.Y = Y + f;

         v.Z = Z + f;

         return v;

     }

     AkForceInline Ak3DVector operator-(const AkReal32 f) const

     {

         Ak3DVector v;

         v.X = X - f;

         v.Y = Y - f;

         v.Z = Z - f;

         return v;

     }

     AkForceInline Ak3DVector operator+(const Ak3DVector& b) const

     {

         Ak3DVector v;

         v.X = X + b.X;

         v.Y = Y + b.Y;

         v.Z = Z + b.Z;

         return v;

     }

     AkForceInline Ak3DVector operator-(const Ak3DVector& b) const

     {

         Ak3DVector v;

         v.X = X - b.X;

         v.Y = Y - b.Y;

         v.Z = Z - b.Z;

         return v;

     }

     AkForceInline operator</span> AkVector()

     {

         AkVector v;

         v.X = X; v.Y = Y; v.Z = Z;

         return v;

     }

     AkForceInline static Ak3DVector Min(const Ak3DVector& A, const Ak3DVector& B)

     {

         Ak3DVector min;

         min.X = AkMin(A.X, B.X);

         min.Y = AkMin(A.Y, B.Y);

         min.Z = AkMin(A.Z, B.Z);

         return min;

     }

     AkForceInline static Ak3DVector Max(const Ak3DVector& A, const Ak3DVector& B)

     {

         Ak3DVector max;

         max.X = AkMax(A.X, B.X);

         max.Y = AkMax(A.Y, B.Y);

         max.Z = AkMax(A.Z, B.Z);

         return max;

     }

     //-----------------------------------------------------------

     // Conversion functions

     AkForceInline Ak3DVector Rotate180X_90Y() const

     {

         Ak3DVector v;

         v.X = -X;

         v.Y = Z;

         v.Z = -Y;

         return v;

     }

     AkForceInline Ak3DVector SphericalToCartesian(

         const AkReal32              azimuth,

         const AkReal32              elevation)

     {

         AkReal32 cosElevation = cosf(elevation);

         X = cosf(azimuth) * cosElevation;

         Y = sinf(azimuth) * cosElevation;

         Z = sinf(elevation);

         return *this;

     }

     // Determinant of 3 column vectors.

     static AkForceInline AkReal32 Determinant(

         const Ak3DVector &          a,

         const Ak3DVector &          b,

         const Ak3DVector &          c)

     {

         return  (a.X*b.Y*c.Z + a.Y*b.Z*c.X + a.Z*b.X*c.Y) -

             (a.Z*b.Y*c.X + a.Y*b.X*c.Z + a.X*b.Z*c.Y);

     }

     // Convert a vector to a different base

     AkForceInline Ak3DVector LinearCombination(

         const Ak3DVector&           A,

         const Ak3DVector&           B,

         const Ak3DVector&           C) const

     {

         Ak3DVector v;

         AkReal32 d = Determinant(A, B, C);

         if (d < AKVECTORS_EPSILON && d > -AKVECTORS_EPSILON)

         {

             v.X = 0.0f; v.Y = 0.0f; v.Z = 0.0f;

             return v;

         }

         // http://mathworld.wolfram.com/MatrixInverse.html

         Ak3DVector invA = Ak3DVector(B.Y*C.Z - B.Z*C.Y, A.Z*C.Y - A.Y*C.Z, A.Y*B.Z - A.Z*B.Y);

         Ak3DVector invB = Ak3DVector(B.Z*C.X - B.X*C.Z, A.X*C.Z - A.Z*C.X, A.Z*B.X - A.X*B.Z);

         Ak3DVector invC = Ak3DVector(B.X*C.Y - B.Y*C.X, A.Y*C.X - A.X*C.Y, A.X*B.Y - A.Y*B.X);

         AkReal32 oneover_d = 1.f / d;

         invA *= oneover_d;

         invB *= oneover_d;

         invC *= oneover_d;

         // Project coordinates using a vector to matrix multiplication

         v.X = X * invA.X + Y * invB.X + Z * invC.X;

         v.Y = X * invA.Y + Y * invB.Y + Z * invC.Y;

         v.Z = X * invA.Z + Y * invB.Z + Z * invC.Z;

         // v /= v.Length();

         return v;

     }

     AkForceInline const Ak3DVector& Normalize()

     {

         AkReal32 l = Length();

         if (l != 0.f)

         {

             X /= l;

             Y /= l;

             Z /= l;

         }

         else

         {

             X = 0.f;

             Y = 0.f;

             Z = 0.f;

         }

         return *this;

     }

     AkForceInline AkReal32 L2_Norm() const

     {

         return sqrtf(X*X + Y*Y + Z*Z);

     }

     AkForceInline AkReal32 DotProduct(const Ak3DVector& v2) const

     {

         return X*v2.X + Y*v2.Y + Z*v2.Z;

     }

     AkForceInline AkReal32 Dot(const Ak3DVector& v2) const

     {

         return DotProduct(v2);

     }

     AkForceInline Ak3DVector Cross(const Ak3DVector& v) const

     {

         Ak3DVector uxv;

         const Ak3DVector& u = *this;

         uxv.X = u.Y*v.Z - u.Z*v.Y;

         uxv.Y = u.Z*v.X - u.X*v.Z;

         uxv.Z = u.X*v.Y - u.Y*v.X;

         return uxv;

     }

     //

     AkForceInline AkReal32 Length() const

     {

         return sqrtf(X*X + Y*Y + Z*Z);

     }

     AkForceInline AkReal32 LengthSquared() const

     {

         return X*X + Y*Y + Z*Z;

     }

     // Usefull in VBAP algorithm, only points that are a positive linear composition matters.

     AkForceInline bool IsAllPositive() const

     {

         const AkReal32 POSITIVE_TEST_EPSILON = 0.00001f;

         return X >= -POSITIVE_TEST_EPSILON &&

             Y >= -POSITIVE_TEST_EPSILON &&

             Z >= -POSITIVE_TEST_EPSILON;

     }

     AkForceInline Ak3DVector Abs() const

     {

         Ak3DVector abs = *this;

         abs.X = (AkReal32)fabs(abs.X);

         abs.Y = (AkReal32)fabs(abs.Y);

         abs.Z = (AkReal32)fabs(abs.Z);

         return abs;

     }

     AkReal32                        X;

     AkReal32                        Y;

     AkReal32                        Z;

 };

 class Ak2DVector

 {

 public:

     //-----------------------------------------------------------

     // Constructor/Destructor functions

     Ak2DVector(){}

     ~Ak2DVector(){}

     Ak2DVector(

         AkReal32                    x,

         AkReal32                    y)

     {

         X = x;

         Y = y;

     }

     //-----------------------------------------------------------

     // Basic vector operators

     AkForceInline Ak2DVector operator=(const Ak2DVector& b)

     {

         X = b.X;

         Y = b.Y;

         return *this;

     }

     AkForceInline Ak2DVector operator=(const AkSphericalCoord& b)

     {

         X = b.theta;

         Y = b.phi;

         return *this;

     }

     Ak2DVector operator-(const Ak2DVector& b) const

     {

         Ak2DVector v;

         v.X = X - b.X;

         v.Y = Y - b.Y;

         return v;

     }

     Ak2DVector operator*=(const AkReal32 f)

     {

         X = X * f;

         Y = Y * f;

         return *this;

     }

     Ak2DVector operator/=(const AkReal32 f)

     {

         AkReal32 oneoverf = 1.f / f;

         X = X * oneoverf;

         Y = Y * oneoverf;

         return *this;

     }

     AkForceInline bool operator==(const Ak2DVector& b) const

     {

         return b.X == X && b.Y == Y;

     }

     AkForceInline bool operator!=(const Ak2DVector& b) const

     {

         return b.X != X && b.Y != Y;

     }

     AkForceInline AkReal32 Length() const

     {

         return sqrtf(X*X+Y*Y);

     }

     //-----------------------------------------------------------

     // Conversion functions

     AkForceInline Ak2DVector CartesianToSpherical( const Ak3DVector& in_Cartesian )

     {

         // (radial, azimuth, elevation)

         AkReal32 r = sqrtf( in_Cartesian.X*in_Cartesian.X + in_Cartesian.Y*in_Cartesian.Y + in_Cartesian.Z*in_Cartesian.Z);

         AKASSERT( r != 0);

         X = atan2f(in_Cartesian.Y, in_Cartesian.X);

         Y = asinf(in_Cartesian.Z / r);

         NormalizeSpherical();

         return *this;

     }

     AkForceInline Ak2DVector LinearCombination(

         const Ak2DVector&           A,

         const Ak2DVector&           B) const

     {

         Ak2DVector v;

         // Project coordinates using a vector to matrix multiplication

         AkReal32 d = (A.X*B.Y - A.Y*B.X);

         if (d < AKVECTORS_EPSILON && d > -AKVECTORS_EPSILON)

         {

             v.X = 0.0f; v.Y = 0.0f;

             return v;

         }

         Ak2DVector invA = Ak2DVector( B.Y, -A.Y );

         Ak2DVector invB = Ak2DVector( -B.X, A.X );

         AkReal32 oneover_d = 1.f / d;

         invA *= oneover_d;

         invB *= oneover_d;

         v.X = X * invA.X + Y * invB.X;

         v.Y = X * invA.Y + Y * invB.Y;

         // v /= v.Length();

         return v;

     }

     AkForceInline Ak2DVector NormalizeSpherical() const

     {

         /*

             Normalise spherical coordinates.

                 X (azimuthal)   -> [-PI, PI],       circle lies on xy plan,         0 is on X axix

                 Y (elevation)   -> [-PI/2, PI/2],   half circle on Z axis,          0 on XY plan, PI/2 straigt up on Z axis.

         */

         Ak2DVector v;

         v.X = X;

         v.Y = Y;

         if (X > AKVECTORS_PI)

             v.X = X - AKVECTORS_TWOPI;

         else if (X < -AKVECTORS_PI)

             v.X = X + AKVECTORS_TWOPI;

         if (Y > AKVECTORS_PIOVERTWO)

             v.Y = Y - AKVECTORS_PI;

         else if (Y < -AKVECTORS_PIOVERTWO)

             v.Y = Y + AKVECTORS_PI;

         AKASSERT(X<AKVECTORS_PI);

         AKASSERT(Y<AKVECTORS_PIOVERTWO);

         return v;

     }

     AkForceInline void NormalizeSpherical()

     {

         /*

             Normalise spherical coordinates.

                 X (azimuthal)   -> [-PI, PI],       circle lies on xy plan,     0 is on X axix

                 Y (elevation)   -> [-PI/2, PI/2],   half circle on Z axis,      0 on XY plan, PI/2 straigt up on Z axis.

         */

         if (X > AKVECTORS_PI)

             X = X - AKVECTORS_TWOPI;

         else if (X < -AKVECTORS_PI)

             X = X + AKVECTORS_TWOPI;

         if (Y > AKVECTORS_PIOVERTWO)

             Y = Y - AKVECTORS_PI;

         else if (Y < -AKVECTORS_PIOVERTWO)

             Y = Y + AKVECTORS_PI;

     }

     // Useful in VBAP algorithm, only points that are a positive linear composition matters.

     AkForceInline bool IsAllPositive() const

     {

         const AkReal32 POSITIVE_TEST_EPSILON = 0.00001f; //0.005f;

         return X >= -POSITIVE_TEST_EPSILON &&

             Y >= -POSITIVE_TEST_EPSILON;

     }

     AkReal32                        X;

     AkReal32                        Y;

 };

 class AkMatrix4x4

 {

     static const int MAX_SIZE = 16;

 public:

     //-----------------------------------------------------------

     // Constructor/Destructor functions

     AkMatrix4x4() {}

     ~AkMatrix4x4() {}

     //-----------------------------------------------------------

     // Basic vector operators

     AkMatrix4x4 operator/=(const AkReal32 f)

     {

         for (int i = 0; i < MAX_SIZE; i++)

             m_Data[i] /= f;

         return *this;

     }

     AkMatrix4x4 operator=(AkReal32 * in_Data)

     {

         for (int i = 0; i < MAX_SIZE; i++)

         {

             m_Data[i] = in_Data[i];

         }

         return *this;

     }

     AkReal32 m_Data[MAX_SIZE];

 };

 class AkMatrix3x3

 {

 public:

     //-----------------------------------------------------------

     // Constructor/Destructor functions

     AkMatrix3x3() {}

     ~AkMatrix3x3() {}

     //-----------------------------------------------------------

     // Basic vector operators

     AkMatrix3x3 operator/=(const AkReal32 f)

     {

         for (int i = 0; i < 3; i++)

         {

             for (int j = 0; j < 3; j++)

             {

                 m_Data[i][j] /= f;

             }

         }

         return *this;

     }

     AkForceInline AkReal32& operator()(const AkUInt32 row, const AkUInt32 column)

     {

         return m_Data[column][row];

     }

     AkForceInline const AkReal32& operator()(const AkUInt32 row, const AkUInt32 column) const

     {

         return m_Data[column][row];

     }

     AkForceInline Ak3DVector operator*(const Ak3DVector& in_rhs)

     {

         Ak3DVector res;

         res.X = in_rhs.X * m_Data[0][0] + in_rhs.Y * m_Data[1][0] + in_rhs.Z * m_Data[2][0];

         res.Y = in_rhs.X * m_Data[0][1] + in_rhs.Y * m_Data[1][1] + in_rhs.Z * m_Data[2][1];

         res.Z = in_rhs.X * m_Data[0][2] + in_rhs.Y * m_Data[1][2] + in_rhs.Z * m_Data[2][2];

         return res;

     }

     AkForceInline AkMatrix3x3& operator+=(const AkMatrix3x3& in_rhs)

     {

         Add(*this, *this, in_rhs);

         return *this;

     }

     static AkForceInline void Add(AkMatrix3x3& out_res, const AkMatrix3x3& in_m0, const AkMatrix3x3& in_m1)

     {

 #define ADD(i,j) out_res(i,j) = in_m0(i,j) + in_m1(i,j)

         ADD(0, 0); ADD(0, 1); ADD(0, 2);

         ADD(1, 0); ADD(1, 1); ADD(1, 2);

         ADD(2, 0); ADD(2, 1); ADD(2, 2);

 #undef ADD

     }

     AkForceInline AkMatrix3x3& operator*=(const AkReal32& in_f)

     {

         m_Data[0][0] *= in_f; m_Data[0][1] *= in_f; m_Data[0][2] *= in_f;

         m_Data[1][0] *= in_f; m_Data[1][1] *= in_f; m_Data[1][2] *= in_f;

         m_Data[2][0] *= in_f; m_Data[2][1] *= in_f; m_Data[2][2] *= in_f;

         return *this;

     }

     static AkForceInline void Diagonal(AkMatrix3x3& out_mat, AkReal32 in_f)

     {

         out_mat(0, 0) = in_f;       out_mat(0, 1) = 0.f;        out_mat(0, 2) = 0.f;

         out_mat(1, 0) = 0.f;        out_mat(1, 1) = in_f;       out_mat(1, 2) = 0.f;

         out_mat(2, 0) = 0.f;        out_mat(2, 1) = 0.f;        out_mat(2, 2) = in_f;

     }

     // Creates the matrix Mu such that Mu*v = u X v

     static AkForceInline  void CrossProductMatrix(AkMatrix3x3& out_mat, const Ak3DVector& in_u)

     {

         out_mat(0, 0) = 0.f;        out_mat(0, 1) = -in_u.Z;        out_mat(0, 2) = in_u.Y;

         out_mat(1, 0) = in_u.Z;     out_mat(1, 1) = 0.f;            out_mat(1, 2) = -in_u.X;

         out_mat(2, 0) = -in_u.Y;    out_mat(2, 1) = in_u.X;         out_mat(2, 2) = 0.f;

     }

     static AkForceInline void OuterProduct(AkMatrix3x3& out_mat, const Ak3DVector& in_v0, const Ak3DVector& in_v1)

     {

         out_mat(0, 0) = in_v0.X*in_v1.X;    out_mat(0, 1) = in_v0.X*in_v1.Y;        out_mat(0, 2) = in_v0.X*in_v1.Z;

         out_mat(1, 0) = in_v0.Y*in_v1.X;    out_mat(1, 1) = in_v0.Y*in_v1.Y;        out_mat(1, 2) = in_v0.Y*in_v1.Z;

         out_mat(2, 0) = in_v0.Z*in_v1.X;    out_mat(2, 1) = in_v0.Z*in_v1.Y;        out_mat(2, 2) = in_v0.Z*in_v1.Z;

     }

     static AkForceInline void Rotation(AkMatrix3x3& out_mat, AkReal32 in_angle, const Ak3DVector& in_axis)

     {

         Rotation(out_mat, sinf(in_angle), cosf(in_angle), in_axis);

     }

     static void Rotation(AkMatrix3x3& out_mat, AkReal32 in_sin, AkReal32 in_cos, const Ak3DVector& in_axis)

     {

         Diagonal(out_mat, in_cos);

         AkMatrix3x3 outer;

         OuterProduct(outer, in_axis, in_axis);

         outer *= (1.f - in_cos);

         out_mat += outer;

         AkMatrix3x3 cross;

         CrossProductMatrix(cross, in_axis*in_sin);

         out_mat += cross;

     }

     // [column][row]

     AkReal32 m_Data[3][3];

 };

 class AkQuaternion

 {

 public:

     // Identity quaternion

     AkQuaternion(): W(1.f), X(0.f), Y(0.f), Z(0.f) {}

     AkQuaternion(AkReal32 in_W, AkReal32 in_X, AkReal32 in_Y, AkReal32 in_Z) : 

             W(in_W), 

             X(in_X), 

             Y(in_Y), 

             Z(in_Z) 

     {}

     AkQuaternion(const Ak3DVector& in_fromVector): 

         W(0.f), 

         X(in_fromVector.X), 

         Y(in_fromVector.Y), 

         Z(in_fromVector.Z) 

     {}

     AkForceInline AkReal32 Length()

     {

         return sqrtf( W*W + X*X + Y*Y + Z*Z );

     }

     AkForceInline const AkQuaternion& Normalize()

     {

         AkReal32 f = 1.0f / Length();

         W *= f;

         X *= f;

         Y *= f;

         Z *= f;

         return *this;

     }

     AkForceInline AkQuaternion Inverse() const

     {

         AkReal32 norm = W*W + X*X + Y*Y + Z*Z;

         if (norm > 0.0)

         {

             AkReal32 invNorm = 1.0f / norm;

             return AkQuaternion(W*invNorm, -X*invNorm, -Y*invNorm, -Z*invNorm);

         }

         else

         {

             return AkQuaternion();

         }

     }

     // Create a quaternion representing the shortest arc rotation between (normalized) vectors v0, v1

     AkQuaternion(const Ak3DVector& in_v0, const Ak3DVector& in_v1)

     {

         AkReal32 dot = in_v0.Dot(in_v1);

         if (dot >= 1.0f - AKVECTORS_EPSILON)

         {

             // No rotation - return unity quaternion.

             AkQuaternion();

         }

         if (dot <= -1.f - AKVECTORS_EPSILON)

         {

             // 180 degree rotation - can use any non-zero length axis.

             Ak3DVector axis = Ak3DVector(0.f, 0.f, 1.f).Cross(in_v0);

             AkReal32 len = axis.Length();

             if (len < AKVECTORS_EPSILON)

             {

                 axis = Ak3DVector(0.f, 1.f, 0.f).Cross(in_v0);

                 len = axis.Length();

             }

             axis.Normalize();

             AkQuaternion(AKVECTORS_PI, axis);

         }

         else

         {

             AkReal32 sqrt = sqrtf((1.f + dot) * 2.f);

             AkReal32 invs = 1.f / sqrt;

             Ak3DVector cross = in_v0.Cross(in_v1);

             X = cross.X * invs;

             Y = cross.Y * invs;

             Z = cross.Z * invs;

             W = sqrt * 0.5f;

             Normalize();

         }

     }

     // Build quaternion from an axis and angle representation.

     AkQuaternion(AkReal32 in_angle, const Ak3DVector& in_axis)

     {

         AkReal32 cosHalfAngle = cosf(in_angle / 2.f);

         W = cosHalfAngle;

         X = cosHalfAngle*in_axis.X;

         Y = cosHalfAngle*in_axis.Y;

         Z = cosHalfAngle*in_axis.Z;

     }

     /// Quaternion multiplication.

     AkForceInline AkQuaternion operator*(const AkQuaternion& Q) const

     {

         return AkQuaternion(

             W*Q.W - X*Q.X - Y*Q.Y - Z*Q.Z,

             W*Q.X + X*Q.W + Y*Q.Z - Z*Q.Y,

             W*Q.Y - X*Q.Z + Y*Q.W + Z*Q.X,

             W*Q.Z + X*Q.Y - Y*Q.X + Z*Q.W);

     }

     AkForceInline Ak3DVector operator* (const Ak3DVector& in_v) const

     {

         /*

         // impl 1

         Ak3DVector uv, uuv;

         Ak3DVector qvec(X, Y, Z);

         uv = qvec.Cross(in_v);

         uuv = qvec.Cross(uv);

         uv *= (2.0f * W);

         uuv *= 2.0f;

         return in_v + uv + uuv;

         */

         // impl 2

         Ak3DVector u(X, Y, Z);

         Ak3DVector res = 

             u * u.Dot(in_v) * 2.f

             + in_v * (W*W - u.Dot(u))

             + u.Cross(in_v) * W * 2.0f;

         return res;

     }

     AkReal32 W;

     AkReal32 X;

     AkReal32 Y;

     AkReal32 Z;

 };

 struct AkIntersectionPoints

 {

     Ak3DVector points[2];

     AkUInt32 count;

 };

 class AkLine

 {

 public:

     AkLine()

     {

         mint = 1.175494351e-38F;

         maxt = 3.402823466e+38F;

     }

     AkLine(

         Ak3DVector                  in_L,

         Ak3DVector                  in_P

         )

     {

         L = in_L;

         P = in_P;

         mint = 1.175494351e-38F;

         maxt = 3.402823466e+38F;

     }

     Ak3DVector PointAt(AkReal32 t) const

     {

         return P + L*t;

     }

     bool Intersect(

         Ak3DVector A,

         Ak3DVector B)

     {

         /*

         a (V1 X V2) = (P2 - P1) X V2

         If the lines intersect at a single point, then the resultant vectors

         on each side of this equation must be parallel, and the left side must

         not be the zero vector. We should check to make sure that this is

         true. Once we have checked this, we can solve for 'a' by taking the

         magnitude of each side and dividing. If the resultant vectors are

         parallel, but in opposite directions, then 'a' is the negative of the

         ratio of magnitudes. Once we have 'a' we can go back to the equation

         for L1 to find the intersection point.

         */

         Ak3DVector V1 = L;

         Ak3DVector V2 = B - A;

         Ak3DVector P1 = P;

         Ak3DVector P2 = A;

         // k(V1 X V2) = (A - P) X V2

         Ak3DVector v1CrossV2 = V1.Cross(V2);

         AkReal32 det = Ak3DVector::Determinant(

             P2 - P1,

             V2,

             v1CrossV2

             );

         AkReal32 t = det / v1CrossV2.LengthSquared();

         det = Ak3DVector::Determinant(

             P2 - P1,

             V1,

             v1CrossV2

             );

         AkReal32 s = det / v1CrossV2.LengthSquared();

         AkReal32 distsqrd = ((P2 + V2*s) - (P1 + V1*t)).LengthSquared();

         if ((AkReal32)fabs(v1CrossV2.L2_Norm()) >= AKVECTORS_EPSILON

             && distsqrd < 0.001

             && s <= 1.0f )

         {

 #ifdef AKPORTALS_DEBUG

             Ak3DVector minPoint = PointAt(t);

             char msg[256];

             sprintf(msg, "L1a=[%0.2f,%0.2f,%0.2f];\n", P.X, P.Y, P.Z); AKPLATFORM::OutputDebugMsg(msg);

             sprintf(msg, "L1b=[%0.2f,%0.2f,%0.2f];\n", V1.X + P.X, V1.Y + P.Y, V1.Z + P.Z); AKPLATFORM::OutputDebugMsg(msg);

             sprintf(msg, "L2a=[%0.2f,%0.2f,%0.2f];\n", A.X, A.Y, A.Z); AKPLATFORM::OutputDebugMsg(msg);

             sprintf(msg, "L2b=[%0.2f,%0.2f,%0.2f];\n", B.X, B.Y, B.Z); AKPLATFORM::OutputDebugMsg(msg);

             sprintf(msg, "%% t=%0.2f Min t=%0.2f, Max t=%0.2f\n", t, mint, maxt); AKPLATFORM::OutputDebugMsg(msg);

             sprintf(msg, "intrPoint=[%0.2f,%0.2f,%0.2f];\n", minPoint.X, minPoint.Y, minPoint.Z); AKPLATFORM::OutputDebugMsg(msg);

             sprintf(msg, "\n"); AKPLATFORM::OutputDebugMsg(msg);

 #endif

             mint = AkMin(mint, t);

             maxt = AkMax(maxt, t);

             return true;

         }

 #ifdef AKPORTALS_DEBUG

     //  char msg[256];

     //  sprintf(msg, "%% DISCARTED t=%0.2f Min t=%0.2f, Max t=%0.2f\n", t, mint, maxt); AKPLATFORM::OutputDebugMsg(msg);

 #endif

         return false;

     }

     Ak3DVector L;

     Ak3DVector P;

     AkReal32 mint;

     AkReal32 maxt;

 };

 class AkPlane

 {

 public:

     AkPlane()

     {

     }

     AkPlane(

         Ak3DVector                  in_p1,

         Ak3DVector                  in_p2,

         Ak3DVector                  in_p4

         )

     {

         SetPlane(

             in_p1,

             in_p2,

             in_p4);

     }

     ~AkPlane()

     {

     }

     void SetPlane(

         Ak3DVector                  in_p1,

         Ak3DVector                  in_p2,

         Ak3DVector                  in_p4

         )

     {

         // Reorder A-B-C to clockwwise if necessary

         AKASSERT(in_p1.X < 100000 && in_p1.X > -100000);

         AKASSERT(in_p1.Y < 100000 && in_p1.Y > -100000);

         AKASSERT(in_p1.Z < 100000 && in_p1.Z > -100000);

         AKASSERT(in_p2.X < 100000 && in_p2.X > -100000);

         AKASSERT(in_p2.Y < 100000 && in_p2.Y > -100000);

         AKASSERT(in_p2.Z < 100000 && in_p2.Z > -100000);

         AKASSERT(in_p4.X < 100000 && in_p4.X > -100000);

         AKASSERT(in_p4.Y < 100000 && in_p4.Y > -100000);

         AKASSERT(in_p4.Z < 100000 && in_p4.Z > -100000);

         p1 = in_p1;

         p2 = in_p2;

         p4 = in_p4;

         SetNormal();

         // Ax + By + Cz + D = 0

         // Find D using the normal and a point

         D = -(N.X*p1.X) - (N.Y*p1.Y) - (N.Z*p1.Z);

     }

 #define EPSILON 0.01f

     bool DoesRayIntersect(

         const Ak3DVector&           in_Origin,

         const Ak3DVector&           in_Destination,

         Ak3DVector&                 out_Intersection

         ) const

     {

         AkReal32 A = N.X;

         AkReal32 B = N.Y;

         AkReal32 C = N.Z;

         Ak3DVector ray = in_Destination - in_Origin;

         AkReal32 rayLength = ray.Length();

         Ak3DVector intersect;

         // If ray is < EPSILON, use on of the point directly for the test and skip the linear projection

         if (rayLength <= EPSILON)

         {

             Ak3DVector temp = in_Origin - p1;

             AkReal32 dot = temp.DotProduct(N);

             if (dot < EPSILON && dot > -EPSILON)

             {

                 intersect = in_Origin;

             }

             else

             {

                 // For debug only, to remove

                 out_Intersection = p1;

                 return false;

             }

         }

         else

         {

             // Normalize ray

             ray.Normalize();

             // 1) if ray len ~= 0, only check if one of the point is on target, ie: assign the intersect point

             // Is ray parallel to the plane?

             if ((A*ray.X + B*ray.Y + C*ray.Z) == 0.0f)

             {

                 // For debug only, to remove

                 AkReal32 t = -(A*in_Origin.X + B*in_Origin.Y + C*in_Origin.Z + D) / (A*ray.X + B*ray.Y + C*ray.Z);

                 intersect = Ak3DVector(in_Origin.X + ray.X*t, in_Origin.Y + ray.Y*t, in_Origin.Z + ray.Z*t);

                 out_Intersection = intersect; // For debugging

                 return false;

             }

             // Distance along the ray where reflector is hit

             AkReal32 t = -(A*in_Origin.X + B*in_Origin.Y + C*in_Origin.Z + D) / (A*ray.X + B*ray.Y + C*ray.Z);

             // Is the ray going towards the plane? Is it long enough?

             if (t < -EPSILON || t >(rayLength + EPSILON))

             {

                 // For debug only, to remove

                 intersect = Ak3DVector(in_Origin.X + ray.X*t, in_Origin.Y + ray.Y*t, in_Origin.Z + ray.Z*t);

                 out_Intersection = intersect; // For debugging

                 return false; // The ray doesn't intersect

             }

             // Find the coordinate of intersection on the plane

             intersect = Ak3DVector(in_Origin.X + ray.X*t, in_Origin.Y + ray.Y*t, in_Origin.Z + ray.Z*t);

         }

         ///////////////////////////////////////

         //

         //      p2____v3____p3

         //      |     .     |

         //      ^   inter   v4

         //      v1          v

         //      |           |

         //      p1__ v2>___p4

         Ak3DVector v1 = p2 - p1;

         Ak3DVector v2 = p4 - p1;

         Ak3DVector vInter1 = intersect - p1;

         Ak3DVector p3 = p4 + v1;

         Ak3DVector v3 = p2 - p3;

         Ak3DVector v4 = p4 - p3;

         Ak3DVector vInter2 = intersect - p3;

         v1.Normalize(); v2.Normalize(); v3.Normalize(); v4.Normalize(); vInter1.Normalize(); vInter2.Normalize();

         // Since it's a square, the angle between the point of intersection and any segment of the pannel should be < 90 degree,

         // therefore the dot product of the two normalized vectors should be > 0

         AkReal32 dot1 = v1.DotProduct(vInter1);

         AkReal32 dot2 = v2.DotProduct(vInter1);

         AkReal32 dot3 = v3.DotProduct(vInter2);

         AkReal32 dot4 = v4.DotProduct(vInter2);

         out_Intersection = intersect;

         return dot1 >= -EPSILON && dot2 >= -EPSILON && dot3 >= -EPSILON && dot4 >= -EPSILON;

     }

     AkReal32 DistPoint_to_Plane(

         Ak3DVector          in_P,

         Ak3DVector&         out_B) const

     {

         AkReal32 distance = (AkReal32)(AkReal32)fabs(N.X * in_P.X + N.Y * in_P.Y + N.Z * in_P.Z + D);

         Ak3DVector pointToPlane = N;

         pointToPlane *= distance;

         out_B = in_P + pointToPlane;

         return (AkReal32)fabs(distance);

     }

     void SetReflection(

         AkReal32*           out_mat) const

     {

         // http://ami.ektf.hu/uploads/papers/finalpdf/AMI_40_from175to186.pd

         /* m_pReflectionMatrix

         reflection on z axis

         P0 (x0, y0, z0), P1 (x1, y1, z1) and P2 (x2, y2, z2),

         normal = (cx, cy, cz)

         d = -CxX0 - CyY0 - CzZ0

         Reflect =   1-2Cx^2     -2CxCy      -2CxCz      -2Cxd

         -2CxCy      1-2Cy^2     -2CyCz      -2Cyd

         -2CxCz      -2CyCz      1-2Cz^2     -2Czd

         0           0           0           1

         */

         AkReal32 d = -(N.X*p1.X) - (N.Y*p1.Y) - (N.Z*p1.Z);

         out_mat[0] = 1 - 2 * N.X*N.X;       out_mat[1] = -2 * N.X*N.Y;              out_mat[2] = -2 * N.X*N.Z;              out_mat[3] = -2 * N.X*d;

         out_mat[0 + 4] = -2 * N.X*N.Y;      out_mat[1 + 4] = 1 - 2 * N.Y*N.Y;       out_mat[2 + 4] = -2 * N.Y*N.Z;          out_mat[3 + 4] = -2 * N.Y*d;

         out_mat[0 + 8] = -2 * N.X*N.Z;      out_mat[1 + 8] = -2 * N.Y*N.Z;          out_mat[2 + 8] = 1 - 2 * N.Z*N.Z;       out_mat[3 + 8] = -2 * N.Z*d;

         out_mat[0 + 12] = 0;                out_mat[1 + 12] = 0;                    out_mat[2 + 12] = 0;                    out_mat[3 + 12] = 1;

     }

     Ak3DVector GetN() const { return N; }

     AkReal32 GetD() const { return D; }

     bool FindIntersectionPoints(

         const AkPlane& in_PlaneB,

         AkIntersectionPoints& out_Intrs) const

     {

         out_Intrs.count = 0;

         // Use vector to solve A

         Ak3DVector point;

         Ak3DVector N1 = N;

         Ak3DVector N2 = in_PlaneB.GetN();

         AkReal32 D1 = D;

         AkReal32 D2 = in_PlaneB.GetD();

         Ak3DVector L = N1.Cross(N2);

         if (L.Length() < 0.001f)

         {

             return false; // The two planes are parallel

         }

         AkUInt8 pivotAxis = 0;

         if ((AkReal32)fabs(L.Y) > (AkReal32)fabs(L.X))

         {

             pivotAxis = 1;

             if ((AkReal32)fabs(L.Z) > (AkReal32)fabs(L.Y))

             {

                 pivotAxis = 2;

             }

         }

         else if ((AkReal32)fabs(L.Z) > (AkReal32)fabs(L.X))

         {

             pivotAxis = 2;

         }

         /*

         Pu = ( N1v*D2 - N2v*D1 ) / Lw

         Pv = ( N2u*D1 - N1u*D2 ) / Lw

         Pz = 0

         */

         switch (pivotAxis)

         {

         case 0:

             AKASSERT((AkReal32)fabs(L.X) > AKVECTORS_EPSILON);

             point.X = 0.f;

             point.Y = (N1.Z*D2 - N2.Z*D1) / L.X;

             point.Z = (N2.Y*D1 - N1.Y*D2) / L.X;

             break;

         case 1:

             AKASSERT((AkReal32)fabs(L.Y) > AKVECTORS_EPSILON);

             point.X = (N1.Z*D2 - N2.Z*D1) / L.Y;

             point.Y = 0.f;

             point.Z = (N2.X*D1 - N1.X*D2) / L.Y;

             break;

         case 2:

             AKASSERT((AkReal32)fabs(L.Z) > AKVECTORS_EPSILON);

             point.X = (N1.Y*D2 - N2.Y*D1) / L.Z;

             point.Y = (N2.X*D1 - N1.X*D2) / L.Z;

             point.Z = 0.f;

             break;

         };

         L.Normalize();

         AkLine intrLine = AkLine(L, point);

         AkLine intrLine2 = AkLine(L, point);

         //in_PlaneB.GetP1()

         // find min max

         AkUInt32 cpt = 0;

         AkUInt32 cpt2 = 0;

         Ak3DVector p3 = GetP2() + (GetP4() - GetP1());

 #ifdef AKPORTALS_DEBUG

         char msg[256];

         sprintf(msg, "P1a=[%0.2f,%0.2f,%0.2f];\n", GetP1().X, GetP1().Y, GetP1().Z); AKPLATFORM::OutputDebugMsg(msg);

         sprintf(msg, "P2a=[%0.2f,%0.2f,%0.2f];\n", GetP2().X, GetP2().Y, GetP2().Z); AKPLATFORM::OutputDebugMsg(msg);

         sprintf(msg, "P4a=[%0.2f,%0.2f,%0.2f];\n", GetP4().X, GetP4().Y, GetP4().Z); AKPLATFORM::OutputDebugMsg(msg);

         sprintf(msg, "P1b=[%0.2f,%0.2f,%0.2f];\n", in_PlaneB.GetP1().X, in_PlaneB.GetP1().Y, in_PlaneB.GetP1().Z); AKPLATFORM::OutputDebugMsg(msg);

         sprintf(msg, "P2b=[%0.2f,%0.2f,%0.2f];\n", in_PlaneB.GetP2().X, in_PlaneB.GetP2().Y, in_PlaneB.GetP2().Z); AKPLATFORM::OutputDebugMsg(msg);

         sprintf(msg, "P4b=[%0.2f,%0.2f,%0.2f];\n", in_PlaneB.GetP4().X, in_PlaneB.GetP4().Y, in_PlaneB.GetP4().Z); AKPLATFORM::OutputDebugMsg(msg);

         sprintf(msg, "line1=[%0.2f,%0.2f,%0.2f];\n", point.X + L.X*1000.f, point.Y + L.Y*1000.f, point.Z + L.Z*1000.f); AKPLATFORM::OutputDebugMsg(msg);

         sprintf(msg, "line2=[%0.2f,%0.2f,%0.2f];\n", point.X - L.X*1000.f, point.Y - L.Y*500.f, point.Z - L.Z*500.f); AKPLATFORM::OutputDebugMsg(msg);

         sprintf(msg, "%% Plane intersec\n"); AKPLATFORM::OutputDebugMsg(msg);

 #endif

         // for the four lines in rectangle

         // Find where the line is crossing with plane A

         if (intrLine.Intersect(GetP1(), GetP2())) cpt++;

         if (intrLine.Intersect(GetP1(), GetP4())) cpt++;

         if (intrLine.Intersect(GetP2(), p3)) cpt++;

         if (intrLine.Intersect(p3, GetP4())) cpt++;

         //AKASSERT(cpt == 2);

 #ifdef AKPORTALS_DEBUG

         sprintf(msg, "%% Portal intersec\n"); AKPLATFORM::OutputDebugMsg(msg);

 #endif

         // Find where the line is crossing with plane B

         p3 = in_PlaneB.GetP2() + (in_PlaneB.GetP4() - in_PlaneB.GetP1());

         if (intrLine2.Intersect(in_PlaneB.GetP1(), in_PlaneB.GetP2())) cpt2++;

         if (intrLine2.Intersect(in_PlaneB.GetP1(), in_PlaneB.GetP4())) cpt2++;

         if (intrLine2.Intersect(in_PlaneB.GetP2(), p3)) cpt2++;

         if (intrLine2.Intersect(p3, in_PlaneB.GetP4())) cpt2++;

         // **AKASSERT(cpt2 == 2 || cpt == 2);

         if (cpt < 2 || cpt2 < 2)

         {

 #ifdef AKPORTALS_DEBUG

             sprintf(msg, "%% NON \n"); AKPLATFORM::OutputDebugMsg(msg);

             sprintf(msg, "%% _______________________\n"); AKPLATFORM::OutputDebugMsg(msg);

 #endif

             return false;

         }

         AkReal32 start = AkMax(intrLine.mint, intrLine2.mint);

         AkReal32 end = AkMin(intrLine.maxt, intrLine2.maxt);

         Ak3DVector minPoint = intrLine.PointAt(start);

         Ak3DVector maxPoint = intrLine.PointAt(end);

 #ifdef AKPORTALS_DEBUG

         sprintf(msg, "P1a=[%0.2f,%0.2f,%0.2f];\n", GetP1().X, GetP1().Y, GetP1().Z); AKPLATFORM::OutputDebugMsg(msg);

         sprintf(msg, "P2a=[%0.2f,%0.2f,%0.2f];\n", GetP2().X, GetP2().Y, GetP2().Z); AKPLATFORM::OutputDebugMsg(msg);

         sprintf(msg, "P4a=[%0.2f,%0.2f,%0.2f];\n", GetP4().X, GetP4().Y, GetP4().Z); AKPLATFORM::OutputDebugMsg(msg);

         sprintf(msg, "P1b=[%0.2f,%0.2f,%0.2f];\n", in_PlaneB.GetP1().X, in_PlaneB.GetP1().Y, in_PlaneB.GetP1().Z); AKPLATFORM::OutputDebugMsg(msg);

         sprintf(msg, "P2b=[%0.2f,%0.2f,%0.2f];\n", in_PlaneB.GetP2().X, in_PlaneB.GetP2().Y, in_PlaneB.GetP2().Z); AKPLATFORM::OutputDebugMsg(msg);

         sprintf(msg, "P4b=[%0.2f,%0.2f,%0.2f];\n", in_PlaneB.GetP4().X, in_PlaneB.GetP4().Y, in_PlaneB.GetP4().Z); AKPLATFORM::OutputDebugMsg(msg);

         sprintf(msg, "line1=[%0.2f,%0.2f,%0.2f];\n", point.X + L.X*1000.f, point.Y + L.Y*1000.f, point.Z + L.Z*1000.f); AKPLATFORM::OutputDebugMsg(msg);

         sprintf(msg, "line2=[%0.2f,%0.2f,%0.2f];\n", point.X - L.X*1000.f, point.Y - L.Y*500.f, point.Z - L.Z*500.f); AKPLATFORM::OutputDebugMsg(msg);

         sprintf(msg, "intr1=[%0.2f,%0.2f,%0.2f];\n", minPoint.X, minPoint.Y, minPoint.Z); AKPLATFORM::OutputDebugMsg(msg);

         sprintf(msg, "intr2=[%0.2f,%0.2f,%0.2f];\n", maxPoint.X, maxPoint.Y, maxPoint.Z); AKPLATFORM::OutputDebugMsg(msg);

         sprintf(msg, "%% _______________________\n"); AKPLATFORM::OutputDebugMsg(msg);

 #endif

         out_Intrs.points[0] = minPoint;

         out_Intrs.points[1] = maxPoint;

         out_Intrs.count = 2;

         return true;

     }

     Ak3DVector GetP1() const { return p1; }

     Ak3DVector GetP2() const { return p2; }

     Ak3DVector GetP4() const { return p4; }

 private:

     bool SetNormal()

     {

         //m_pNormal = (B-A) cross (C-A); normalize

         Ak3DVector a = p2 - p1;

         Ak3DVector b = p4 - p1;

         N = Ak3DVector(a.Y*b.Z - a.Z*b.Y, -(a.X*b.Z - a.Z*b.X), a.X*b.Y - a.Y*b.X);

         AkReal32 len = N.Length();

         AKASSERT(len > 0.f);

         if (len > 0)

         {

             N /= len;

         }

         else

         {

             return false;

         }

         return true;

     };

     /*

     p2__________p3

     |     .     |

     ^   inter   v3

     v1          v

     |           |

     p1__ v2>___p4

     */

     Ak3DVector                      p1;     // Bottom left

     Ak3DVector                      p2;     // Top left

     Ak3DVector                      p4;     // Tottom right

     Ak3DVector                      N;      // Normal vector

     AkReal32                        D;      // Plane equation: Ax + By + Cz = D => N.Xx + N.Yy + N.Zz = D

 };

 struct AkBoundingBox

 {

     AkBoundingBox() :

         m_Min(Ak3DVector(FLT_MAX, FLT_MAX, FLT_MAX)),

         m_Max(Ak3DVector(-FLT_MAX, -FLT_MAX, -FLT_MAX))

     {}

     void Update(

         const Ak3DVector &      in_point

         )

     {

         if (m_Min.X > in_point.X)

             m_Min.X = in_point.X;

         if (m_Min.Y > in_point.Y)

             m_Min.Y = in_point.Y;

         if (m_Min.Z > in_point.Z)

             m_Min.Z = in_point.Z;

         if (m_Max.X < in_point.X)

             m_Max.X = in_point.X;

         if (m_Max.Y < in_point.Y)

             m_Max.Y = in_point.Y;

         if (m_Max.Z < in_point.Z)

             m_Max.Z = in_point.Z;

     }

     AkForceInline bool IsWithin(

         const Ak3DVector &      in_Point

         ) const

     {

         return in_Point >= m_Min && in_Point <= m_Max;

     }

     AkForceInline bool IsWithin(

         const AkBoundingBox &   in_BB

         ) const

     {

         return (m_Min.X <= in_BB.m_Max.X && m_Max.X >= in_BB.m_Min.X) &&

             (m_Min.Y <= in_BB.m_Max.Y && m_Max.Y >= in_BB.m_Min.Y) &&

             (m_Min.Z <= in_BB.m_Max.Z && m_Max.Z >= in_BB.m_Min.Z);

     }

     AkBoundingBox Intersect(

         const AkBoundingBox &   in_BB

     ) const

     {

         AkBoundingBox result;

         result.m_Max.X = AkMin(m_Max.X, in_BB.m_Max.X);

         result.m_Max.Y = AkMin(m_Max.Y, in_BB.m_Max.Y);

         result.m_Max.Z = AkMin(m_Max.Z, in_BB.m_Max.Z);

         result.m_Min.X = AkMax(m_Min.X, in_BB.m_Min.X);

         result.m_Min.Y = AkMax(m_Min.Y, in_BB.m_Min.Y);

         result.m_Min.Z = AkMax(m_Min.Z, in_BB.m_Min.Z);

         return result;

     }

     // returns acos(in_fAngle)

     AkForceInline AkReal32 ACos(

         AkReal32            in_fAngle

         ) const

     {

         AKASSERT((in_fAngle <= 1.0f) && (in_fAngle >= -1.0f));

         return acosf(in_fAngle);

     }

     AkForceInline bool IsEmpty() const

     {

         return (m_Min.X >= m_Max.X) || (m_Min.Y >= m_Max.Y) || (m_Min.Z >= m_Max.Z);

     }

     Ak3DVector                      m_Min;

     Ak3DVector                      m_Max;

 };

 class AkBox

 {

 public:

     AkBox()

     {

     }

     ~AkBox()

     {

     }

     void Init(

         const Ak3DVector &      in_center,

         const Ak3DVector &      in_extent,

         const Ak3DVector &      in_Front,

         const Ak3DVector &      in_Up)

     {

         AKASSERT(fabs(in_Front.Length() - 1.f) < 0.001 && fabs(in_Up.Length() - 1.f) < 0.001);//Must be unit vectors.

         AKASSERT(fabs(in_Front.Dot(in_Up) - 0.f) < 0.001); //Must be orthogonal.

         m_Center = in_center;

         m_Extent = in_extent;

         m_Z = in_Front;

         m_Y = in_Up;

         m_X = m_Z.Cross(m_Y);

     }

     bool IsPointInBox(

         const Ak3DVector &      in_Point

         ) const

     {

         Ak3DVector pt = in_Point - m_Center;

         return  fabs(pt.Dot(m_X)) <= m_Extent.X && fabs(pt.Dot(m_Y)) <= m_Extent.Y && fabs(pt.Dot(m_Z)) <= m_Extent.Z;

     }

     Ak3DVector GetSize() const { return m_Extent*2.f; }

     Ak3DVector GetCenter() const { return m_Center; }

     Ak3DVector GetUx() const { return m_X; }

     Ak3DVector GetUy() const { return m_Y; }

     Ak3DVector GetUz() const { return m_Z; }

     Ak3DVector GetFront() const { return m_Z; }

     Ak3DVector GetUp() const { return m_Y; }

     Ak3DVector GetSide() const { return m_X; }

     AkReal32 GetVolume() const

     {

         Ak3DVector size = GetSize();

         return size.X * size.Y * size.Z;

     }

     bool SeparatingAxisExists(

         const Ak3DVector&       L,

         const AkBox&            B

         ) const

     {

         // Separating Axis Theorem for Oriented Bounding Boxes by Johnny Huynh

         const AkBox& A = *this;

         Ak3DVector T = B.GetCenter() - A.GetCenter();

         AkReal32 WA = A.m_Extent.X;

         AkReal32 HA = A.m_Extent.Y;

         AkReal32 DA = A.m_Extent.Z;

         AkReal32 WB = B.m_Extent.X;

         AkReal32 HB = B.m_Extent.Y;

         AkReal32 DB = B.m_Extent.Z;

         Ak3DVector Ax = A.GetUx();

         Ak3DVector Ay = A.GetUy();

         Ak3DVector Az = A.GetUz();

         Ak3DVector Bx = B.GetUx();

         Ak3DVector By = B.GetUy();

         Ak3DVector Bz = B.GetUz();

         /*

         | T • L | > | (WA*Ax) • L | + | (HA*Ay) • L | + |(DA*Az) • L | +

                     | (WB*Bx) • L | +| (HB*By) • L | +| (DB*Bz) • L |*/

         AkReal32 left = (AkReal32)fabs(T.DotProduct(L));

         AkReal32 dpax = (AkReal32)fabs((Ax*WA).DotProduct(L));

         AkReal32 dpay = (AkReal32)fabs((Ay*HA).DotProduct(L));

         AkReal32 dpaz = (AkReal32)fabs((Az*DA).DotProduct(L));

         AkReal32 dpbx = (AkReal32)fabs((Bx*WB).DotProduct(L));

         AkReal32 dpby = (AkReal32)fabs((By*HB).DotProduct(L));

         AkReal32 dpbz = (AkReal32)fabs((Bz*DB).DotProduct(L));

         AkReal32 right = dpax + dpay + dpaz + dpbx + dpby + dpbz;

         return left > right;

     }

     void UpdateBoundingBox(AkBoundingBox& out_aabb) const

     {

         Ak3DVector x = m_X * m_Extent.X;

         out_aabb.Update(m_Center + x);

         out_aabb.Update(m_Center - x);

         Ak3DVector y = m_Y * m_Extent.Y;

         out_aabb.Update(m_Center + y);

         out_aabb.Update(m_Center - y);

         Ak3DVector Z = m_Z * m_Extent.Z;

         out_aabb.Update(m_Center + Z);

         out_aabb.Update(m_Center - Z);

     }

 private:

     Ak3DVector                      m_Center;

     Ak3DVector                      m_Extent;

     //Orthonormal Axes

     Ak3DVector                      m_X;

     Ak3DVector                      m_Y;

     Ak3DVector                      m_Z;

 };

AkMin

#define AkMin(x1, x2)

Definition: AkPlatformFuncs.h:94

AkReal32

float AkReal32

32-bit floating point

Definition: AkTypes.h:70

AkSpeakerVolumes.h

AkPlane::FindIntersectionPoints

bool FindIntersectionPoints(const AkPlane &in_PlaneB, AkIntersectionPoints &out_Intrs) const

Definition: AkVectors.h:1278

AkPlane::DistPoint_to_Plane

AkReal32 DistPoint_to_Plane(Ak3DVector in_P, Ak3DVector &out_B) const

Definition: AkVectors.h:1236

AKVECTORS_TWOPI

#define AKVECTORS_TWOPI

Definition: AkVectors.h:48

AkBox::GetUz

Ak3DVector GetUz() const

Definition: AkVectors.h:1596

Ak3DIntVector::Ak3DIntVector

Ak3DIntVector()

Definition: AkVectors.h:115

Ak3DVector::operator<

AkForceInline bool operator<(const Ak3DVector &b) const

Definition: AkVectors.h:220

Ak3DVector::Cross

AkForceInline Ak3DVector Cross(const Ak3DVector &v) const

Definition: AkVectors.h:472

Ak3DIntVector::Y

AkInt32 Y

Y Position

Definition: AkVectors.h:126

AkIntersectionPoints::points

Ak3DVector points[2]

Definition: AkVectors.h:980

Ak3DIntVector

Definition: AkVectors.h:113

Ak2DVector::CartesianToSpherical

AkForceInline Ak2DVector CartesianToSpherical(const Ak3DVector &in_Cartesian)

Definition: AkVectors.h:595

Ak2DVector::operator*=

Ak2DVector operator*=(const AkReal32 f)

Definition: AkVectors.h:561

Ak3DVector::operator-

AkForceInline Ak3DVector operator-(const Ak3DVector &b) const

Definition: AkVectors.h:326

AKSIMD_V4F32

float32x4_t AKSIMD_V4F32

Vector of 4 32-bit floats

Definition: AkSimd.h:73

Ak3DVector::X

AkReal32 X

Definition: AkVectors.h:512

Ak3DVector::operator*=

AkForceInline Ak3DVector operator*=(const AkReal32 f)

Definition: AkVectors.h:240

Ak2DVector::operator=

AkForceInline Ak2DVector operator=(const Ak2DVector &b)

Definition: AkVectors.h:535

Ak3DVector::Z

AkReal32 Z

Definition: AkVectors.h:514

Ak3DVector::VectorV4F32

AkForceInline AKSIMD_V4F32 VectorV4F32() const

Definition: AkVectors.h:171

AKVECTORS_PI

#define AKVECTORS_PI

Definition: AkVectors.h:47

AkMax

#define AkMax(x1, x2)

Definition: AkPlatformFuncs.h:93

AkPlane::GetN

Ak3DVector GetN() const

Definition: AkVectors.h:1275

AkLine::PointAt

Ak3DVector PointAt(AkReal32 t) const

Definition: AkVectors.h:1004

Ak3DVector::Ak3DVector

Ak3DVector(const AKSIMD_V4F32 &in_v4f32)

Definition: AkVectors.h:156

AkLine::Intersect

bool Intersect(Ak3DVector A, Ak3DVector B)

Definition: AkVectors.h:1009

AkSphericalCoord::phi

AkReal32 phi

Elevation

Definition: AkTypes.h:494

AkQuaternion::X

AkReal32 X

Definition: AkVectors.h:973

Ak4DVector::operator-

Ak4DVector operator-(const Ak4DVector &b) const

Definition: AkVectors.h:97

AkBox::SeparatingAxisExists

bool SeparatingAxisExists(const Ak3DVector &L, const AkBox &B) const

Definition: AkVectors.h:1608

AkBox::IsPointInBox

bool IsPointInBox(const Ak3DVector &in_Point) const

Definition: AkVectors.h:1583

Ak4DVector::operator/=

Ak4DVector operator/=(const AkReal32 f)

Definition: AkVectors.h:87

Ak3DVector::operator==

AkForceInline bool operator==(const Ak3DVector &b) const

Definition: AkVectors.h:192

Ak3DVector::Rotate180X_90Y

AkForceInline Ak3DVector Rotate180X_90Y() const

Definition: AkVectors.h:370

AkQuaternion::Inverse

AkForceInline AkQuaternion Inverse() const

Definition: AkVectors.h:878

AkQuaternion::operator*

AkForceInline AkQuaternion operator*(const AkQuaternion &Q) const

Quaternion multiplication.

Definition: AkVectors.h:940

Ak3DVector

Definition: AkVectors.h:131

Ak3DIntVector::Ak3DIntVector

Ak3DIntVector(AkInt32 x, AkInt32 y, AkInt32 z)

Definition: AkVectors.h:116

AkPlane::SetPlane

void SetPlane(Ak3DVector in_p1, Ak3DVector in_p2, Ak3DVector in_p4)

Definition: AkVectors.h:1108

AKPLATFORM::OutputDebugMsg

void OutputDebugMsg(const char *in_pszMsg)

Output a debug message on the console (Ansi string)

Definition: AkPlatformFuncs.h:121

Ak2DVector::~Ak2DVector

~Ak2DVector()

Definition: AkVectors.h:523

Ak3DVector::DotProduct

AkForceInline AkReal32 DotProduct(const Ak3DVector &v2) const

Definition: AkVectors.h:462

Ak3DVector::Length

AkForceInline AkReal32 Length() const

Definition: AkVectors.h:484

Ak3DVector::Determinant

static AkForceInline AkReal32 Determinant(const Ak3DVector &a, const Ak3DVector &b, const Ak3DVector &c)

Definition: AkVectors.h:394

AkMatrix3x3::Diagonal

static AkForceInline void Diagonal(AkMatrix3x3 &out_mat, AkReal32 in_f)

Definition: AkVectors.h:798

AkUInt8

uint8_t AkUInt8

Unsigned 8-bit integer

Definition: AkTypes.h:57

Ak4DVector

Definition: AkVectors.h:53

Ak3DVector::Zero

void Zero()

Definition: AkVectors.h:182

AkQuaternion::Length

AkForceInline AkReal32 Length()

Definition: AkVectors.h:863

AkMatrix4x4::operator=

AkMatrix4x4 operator=(AkReal32 *in_Data)

Definition: AkVectors.h:720

Ak3DVector::operator=

AkForceInline Ak3DVector operator=(const AkVector &b)

Definition: AkVectors.h:211

AkMatrix3x3::Rotation

static void Rotation(AkMatrix3x3 &out_mat, AkReal32 in_sin, AkReal32 in_cos, const Ak3DVector &in_axis)

Definition: AkVectors.h:825

Ak2DVector::operator==

AkForceInline bool operator==(const Ak2DVector &b) const

Definition: AkVectors.h:578

AkMatrix3x3::operator*

AkForceInline Ak3DVector operator*(const Ak3DVector &in_rhs)

Definition: AkVectors.h:766

Ak3DVector::operator-

AkForceInline Ak3DVector operator-(const AkReal32 f) const

Definition: AkVectors.h:304

Ak3DVector::operator+

AkForceInline Ak3DVector operator+(const Ak3DVector &b) const

Definition: AkVectors.h:315

AkBox::GetUx

Ak3DVector GetUx() const

Definition: AkVectors.h:1594

AkBox::UpdateBoundingBox

void UpdateBoundingBox(AkBoundingBox &out_aabb) const

Definition: AkVectors.h:1650

AkIntersectionPoints::count

AkUInt32 count

Definition: AkVectors.h:981

AkBox::GetCenter

Ak3DVector GetCenter() const

Definition: AkVectors.h:1592

AkPlane::AkPlane

AkPlane()

Definition: AkVectors.h:1088

AkMatrix4x4::AkMatrix4x4

AkMatrix4x4()

Definition: AkVectors.h:707

Ak2DVector::X

AkReal32 X

Definition: AkVectors.h:694

AkLine::maxt

AkReal32 maxt

Definition: AkVectors.h:1082

Ak3DVector::operator>=

AkForceInline bool operator>=(const Ak3DVector &b) const

Definition: AkVectors.h:235

Ak3DVector::~Ak3DVector

~Ak3DVector()

Definition: AkVectors.h:180

AkPlane

Definition: AkVectors.h:1086

AkQuaternion

Definition: AkVectors.h:844

Ak3DVector::Ak3DVector

Ak3DVector()

Definition: AkVectors.h:135

AKVECTORS_PIOVERTWO

#define AKVECTORS_PIOVERTWO

Definition: AkVectors.h:49

Ak2DVector::operator!=

AkForceInline bool operator!=(const Ak2DVector &b) const

Definition: AkVectors.h:583

Ak2DVector::IsAllPositive

AkForceInline bool IsAllPositive() const

Definition: AkVectors.h:687

Ak3DVector::LengthSquared

AkForceInline AkReal32 LengthSquared() const

Definition: AkVectors.h:489

Ak2DVector::Length

AkForceInline AkReal32 Length() const

Definition: AkVectors.h:588

Ak4DVector::Ak4DVector

Ak4DVector()

Definition: AkVectors.h:57

AkBox::GetSide

Ak3DVector GetSide() const

Definition: AkVectors.h:1600

AkLine::AkLine

AkLine()

Definition: AkVectors.h:987

AkVector::Y

AkReal32 Y

Y Position

Definition: AkTypes.h:340

Ak2DVector::Ak2DVector

Ak2DVector(AkReal32 x, AkReal32 y)

Definition: AkVectors.h:525

AkMatrix3x3::operator*=

AkForceInline AkMatrix3x3 & operator*=(const AkReal32 &in_f)

Definition: AkVectors.h:790

AkBox::GetVolume

AkReal32 GetVolume() const

Definition: AkVectors.h:1602

AkPlane::GetD

AkReal32 GetD() const

Definition: AkVectors.h:1276

AkVector::X

AkReal32 X

X Position

Definition: AkTypes.h:339

AkBox::~AkBox

~AkBox()

Definition: AkVectors.h:1562

Ak3DVector::operator*

AkForceInline Ak3DVector operator*(const AkReal32 f) const

Definition: AkVectors.h:270

Ak3DVector::operator>

AkForceInline bool operator>(const Ak3DVector b) const

Definition: AkVectors.h:230

Ak2DVector::operator-

Ak2DVector operator-(const Ak2DVector &b) const

Definition: AkVectors.h:551

AkMatrix4x4::m_Data

AkReal32 m_Data[MAX_SIZE]

Definition: AkVectors.h:730

AkBoundingBox::ACos

AkForceInline AkReal32 ACos(AkReal32 in_fAngle) const

Definition: AkVectors.h:1538

AkBoundingBox::Intersect

AkBoundingBox Intersect(const AkBoundingBox &in_BB) const

Definition: AkVectors.h:1520

AkMatrix3x3::AkMatrix3x3

AkMatrix3x3()

Definition: AkVectors.h:739

Ak2DVector::Ak2DVector

Ak2DVector()

Definition: AkVectors.h:522

AKASSERT

#define AKASSERT(Condition)

Definition: AkAssert.h:76

Ak4DVector::v

AkReal32 v[4]

Definition: AkVectors.h:109

IAkPluginMemAlloc.h

AkSphericalCoord

Spherical coordinates.

Definition: AkTypes.h:493

AkLine::mint

AkReal32 mint

Definition: AkVectors.h:1081

AkPlane::~AkPlane

~AkPlane()

Definition: AkVectors.h:1104

Ak3DVector::Ak3DVector

Ak3DVector(AkReal32 x, AkReal32 y, AkReal32 z)

Definition: AkVectors.h:141

AkIntersectionPoints

Definition: AkVectors.h:979

AkObject.h

AkVector::Z

AkReal32 Z

Z Position

Definition: AkTypes.h:341

AkQuaternion::AkQuaternion

AkQuaternion()

Definition: AkVectors.h:847

AkArray.h

AkMatrix3x3::OuterProduct

static AkForceInline void OuterProduct(AkMatrix3x3 &out_mat, const Ak3DVector &in_v0, const Ak3DVector &in_v1)

Definition: AkVectors.h:813

Ak3DVector::Ak3DVector

Ak3DVector(const AkVector &b)

Definition: AkVectors.h:150

AkMatrix3x3

Definition: AkVectors.h:734

AkBox::GetFront

Ak3DVector GetFront() const

Definition: AkVectors.h:1598

AkBox::GetUy

Ak3DVector GetUy() const

Definition: AkVectors.h:1595

Ak4DVector::operator=

Ak4DVector operator=(const Ak4DVector &b)

Definition: AkVectors.h:77

AkBoundingBox::IsWithin

AkForceInline bool IsWithin(const AkBoundingBox &in_BB) const

Definition: AkVectors.h:1511

Ak2DVector::Y

AkReal32 Y

Definition: AkVectors.h:695

AkMatrix4x4::operator/=

AkMatrix4x4 operator/=(const AkReal32 f)

Definition: AkVectors.h:712

Ak3DVector::operator!=

AkForceInline bool operator!=(const Ak3DVector &b) const

Definition: AkVectors.h:197

AkMatrix3x3::Add

static AkForceInline void Add(AkMatrix3x3 &out_res, const AkMatrix3x3 &in_m0, const AkMatrix3x3 &in_m1)

Definition: AkVectors.h:781

Ak2DVector

Definition: AkVectors.h:518

AkBoundingBox::IsEmpty

AkForceInline bool IsEmpty() const

Definition: AkVectors.h:1546

AkMatrix3x3::operator/=

AkMatrix3x3 operator/=(const AkReal32 f)

Definition: AkVectors.h:744

Ak3DVector::SphericalToCartesian

AkForceInline Ak3DVector SphericalToCartesian(const AkReal32 azimuth, const AkReal32 elevation)

Definition: AkVectors.h:381

AkMatrix3x3::operator()

AkForceInline AkReal32 & operator()(const AkUInt32 row, const AkUInt32 column)

Definition: AkVectors.h:756

AkQuaternion::W

AkReal32 W

Definition: AkVectors.h:972

AkBoundingBox::Update

void Update(const Ak3DVector &in_point)

Definition: AkVectors.h:1481

AkBox

Definition: AkVectors.h:1556

AkQuaternion::AkQuaternion

AkQuaternion(AkReal32 in_angle, const Ak3DVector &in_axis)

Definition: AkVectors.h:930

AkLine::AkLine

AkLine(Ak3DVector in_L, Ak3DVector in_P)

Definition: AkVectors.h:993

AkMatrix4x4::~AkMatrix4x4

~AkMatrix4x4()

Definition: AkVectors.h:708

AkMatrix3x3::CrossProductMatrix

static AkForceInline void CrossProductMatrix(AkMatrix3x3 &out_mat, const Ak3DVector &in_u)

Definition: AkVectors.h:806

AkPlane::DoesRayIntersect

bool DoesRayIntersect(const Ak3DVector &in_Origin, const Ak3DVector &in_Destination, Ak3DVector &out_Intersection) const

Definition: AkVectors.h:1139

Ak4DVector::~Ak4DVector

~Ak4DVector()

Definition: AkVectors.h:73

AkLine::P

Ak3DVector P

Definition: AkVectors.h:1079

Ak3DVector::IsAllPositive

AkForceInline bool IsAllPositive() const

Definition: AkVectors.h:495

Ak3DVector::L2_Norm

AkForceInline AkReal32 L2_Norm() const

Definition: AkVectors.h:457

AkQuaternion::Z

AkReal32 Z

Definition: AkVectors.h:975

Ak3DVector::PointV4F32

AkForceInline AKSIMD_V4F32 PointV4F32() const

Definition: AkVectors.h:162

AkQuaternion::Normalize

AkForceInline const AkQuaternion & Normalize()

Definition: AkVectors.h:868

Ak2DVector::NormalizeSpherical

AkForceInline Ak2DVector NormalizeSpherical() const

Definition: AkVectors.h:638

AkBoundingBox::m_Min

Ak3DVector m_Min

Definition: AkVectors.h:1551

Ak3DVector::operator/

AkForceInline Ak3DVector operator/(const AkReal32 f) const

Definition: AkVectors.h:281

AkQuaternion::AkQuaternion

AkQuaternion(const Ak3DVector &in_fromVector)

Definition: AkVectors.h:856

ADD

#define ADD(i, j)

Ak2DVector::NormalizeSpherical

AkForceInline void NormalizeSpherical()

Definition: AkVectors.h:667

Ak3DVector::Y

AkReal32 Y

Definition: AkVectors.h:513

AkMatrix3x3::Rotation

static AkForceInline void Rotation(AkMatrix3x3 &out_mat, AkReal32 in_angle, const Ak3DVector &in_axis)

Definition: AkVectors.h:820

AkBox::GetUp

Ak3DVector GetUp() const

Definition: AkVectors.h:1599

AkBoundingBox::AkBoundingBox

AkBoundingBox()

Definition: AkVectors.h:1476

AKVECTORS_EPSILON

#define AKVECTORS_EPSILON

Definition: AkVectors.h:50

Ak3DVector::Max

static AkForceInline Ak3DVector Max(const Ak3DVector &A, const Ak3DVector &B)

Definition: AkVectors.h:357

AkBox::Init

void Init(const Ak3DVector &in_center, const Ak3DVector &in_extent, const Ak3DVector &in_Front, const Ak3DVector &in_Up)

Definition: AkVectors.h:1566

AkTypes.h

AkPolarCoord::theta

AkReal32 theta

Azimuth

Definition: AkTypes.h:488

AkMatrix3x3::operator+=

AkForceInline AkMatrix3x3 & operator+=(const AkMatrix3x3 &in_rhs)

Definition: AkVectors.h:775

AkQuaternion::Y

AkReal32 Y

Definition: AkVectors.h:974

AkPlane::GetP2

Ak3DVector GetP2() const

Definition: AkVectors.h:1431

AkBoundingBox

Definition: AkVectors.h:1475

AkMatrix3x3::operator()

AkForceInline const AkReal32 & operator()(const AkUInt32 row, const AkUInt32 column) const

Definition: AkVectors.h:761

AkMatrix3x3::~AkMatrix3x3

~AkMatrix3x3()

Definition: AkVectors.h:740

AKSIMD_GETELEMENT_V4F32

#define AKSIMD_GETELEMENT_V4F32(__vName, __num__)

Retrieve scalar element from vector.

Definition: AkSimd.h:38

AkMatrix4x4

Definition: AkVectors.h:701

Ak3DVector::operator/=

AkForceInline Ak3DVector operator/=(const AkReal32 f)

Definition: AkVectors.h:249

AkUInt32

uint32_t AkUInt32

Unsigned 32-bit integer

Definition: AkTypes.h:59

Ak3DVector::operator<=

AkForceInline bool operator<=(const Ak3DVector &b) const

Definition: AkVectors.h:225

AkPlane::AkPlane

AkPlane(Ak3DVector in_p1, Ak3DVector in_p2, Ak3DVector in_p4)

Definition: AkVectors.h:1092

AkQuaternion::AkQuaternion

AkQuaternion(const Ak3DVector &in_v0, const Ak3DVector &in_v1)

Definition: AkVectors.h:893

Ak3DIntVector::X

AkInt32 X

X Position

Definition: AkVectors.h:125

Ak3DVector::operator+

AkForceInline Ak3DVector operator+(const AkReal32 f) const

Definition: AkVectors.h:293

EPSILON

#define EPSILON

Definition: AkVectors.h:1138

AkVector

3D vector.

Definition: AkTypes.h:311

AkBox::GetSize

Ak3DVector GetSize() const

Definition: AkVectors.h:1591

Ak3DVector::Dot

AkForceInline AkReal32 Dot(const Ak3DVector &v2) const

Definition: AkVectors.h:467

AkPlane::GetP1

Ak3DVector GetP1() const

Definition: AkVectors.h:1430

Ak3DIntVector::~Ak3DIntVector

~Ak3DIntVector()

Definition: AkVectors.h:123

AkInt32

int32_t AkInt32

Signed 32-bit integer

Definition: AkTypes.h:64

AkPlane::GetP4

Ak3DVector GetP4() const

Definition: AkVectors.h:1432

Ak3DIntVector::Z

AkInt32 Z

Z Position

Definition: AkVectors.h:127

Ak3DVector::Normalize

AkForceInline const Ak3DVector & Normalize()

Definition: AkVectors.h:439

Ak3DVector::operator=

AkForceInline Ak3DVector operator=(const Ak3DVector &b)

Definition: AkVectors.h:202

AkForceInline

#define AkForceInline

Definition: AkTypes.h:60

AkBoundingBox::m_Max

Ak3DVector m_Max

Definition: AkVectors.h:1552

Ak3DVector::Min

static AkForceInline Ak3DVector Min(const Ak3DVector &A, const Ak3DVector &B)

Definition: AkVectors.h:346

AkPlane::SetReflection

void SetReflection(AkReal32 *out_mat) const

Definition: AkVectors.h:1250

Ak4DVector::Ak4DVector

Ak4DVector(const AkVector &b)

Definition: AkVectors.h:65

AkLine::L

Ak3DVector L

Definition: AkVectors.h:1078

AkBoundingBox::IsWithin

AkForceInline bool IsWithin(const Ak3DVector &in_Point) const

Definition: AkVectors.h:1504

Ak2DVector::operator=

AkForceInline Ak2DVector operator=(const AkSphericalCoord &b)

Definition: AkVectors.h:543

Ak2DVector::operator/=

Ak2DVector operator/=(const AkReal32 f)

Definition: AkVectors.h:569

Ak2DVector::LinearCombination

AkForceInline Ak2DVector LinearCombination(const Ak2DVector &A, const Ak2DVector &B) const

Definition: AkVectors.h:609

AkSimd.h

AkQuaternion::AkQuaternion

AkQuaternion(AkReal32 in_W, AkReal32 in_X, AkReal32 in_Y, AkReal32 in_Z)

Definition: AkVectors.h:849

AkBox::AkBox

AkBox()

Definition: AkVectors.h:1558

Ak3DVector::Abs

AkForceInline Ak3DVector Abs() const

Definition: AkVectors.h:503

AkMatrix3x3::m_Data

AkReal32 m_Data[3][3]

Definition: AkVectors.h:840

AkLine

Definition: AkVectors.h:985

Ak3DVector::operator*

AkForceInline Ak3DVector operator*(const Ak3DVector v2) const

Definition: AkVectors.h:259

Ak3DVector::LinearCombination

AkForceInline Ak3DVector LinearCombination(const Ak3DVector &A, const Ak3DVector &B, const Ak3DVector &C) const

Definition: AkVectors.h:404

이 페이지가 도움이 되었나요?

지원이 필요하신가요?

질문이 있으신가요? 문제를 겪고 계신가요? 더 많은 정보가 필요하신가요? 저희에게 문의해주시면 도와드리겠습니다!

지원 페이지를 방문해 주세요

작업하는 프로젝트에 대해 알려주세요. 언제든지 도와드릴 준비가 되어 있습니다.

프로젝트를 등록하세요. 아무런 조건이나 의무 사항 없이 빠른 시작을 도와드리겠습니다.

Wwise를 시작해 보세요

Wwise SDK 2021.1.14

_ak_vectors_8h_source

이 페이지가 도움이 되었나요?

지원이 필요하신가요?

작업하는 프로젝트에 대해 알려주세요. 언제든지 도와드릴 준비가 되어 있습니다.