Commit 1d70aebb authored by vaclav's avatar vaclav
Browse files

comments/formal issues in ivas_orient_trk.c

parent 93c37bbd

lib_rend/ivas_orient_trk.c

+130 −94
Original line number Diff line number Diff line
@@ -60,94 +60,31 @@ 
 *------------------------------------------------------------------------------------------*/



#ifdef FIX_I109_ORIENTATION_TRACKING



/*------------------------------------------------------------------------------------------*

 * Declarations

 * IdentityQuaternion()

 *

 *

 *------------------------------------------------------------------------------------------*/



static IVAS_QUATERNION IdentityQuaternion(

    void );



void QuaternionProduct(

    const IVAS_QUATERNION q1,

    const IVAS_QUATERNION q2,

    IVAS_QUATERNION *const result );



float QuaternionDotProduct(

    const IVAS_QUATERNION q1,

    const IVAS_QUATERNION q2 );



void QuaternionDivision(

    const IVAS_QUATERNION q,

    const float d,

    IVAS_QUATERNION *const result );



void QuaternionNormalize(

    const IVAS_QUATERNION q,

    IVAS_QUATERNION *const result );



void QuaternionSlerp(

    const IVAS_QUATERNION q1,

    const IVAS_QUATERNION q2,

    const float t,

    IVAS_QUATERNION *const result );



void QuaternionConjugate(

    const IVAS_QUATERNION q,

    IVAS_QUATERNION *const result );



float QuaternionAngle(

    const IVAS_QUATERNION q1,

    const IVAS_QUATERNION q2 );



void QuaternionInverse(

    const IVAS_QUATERNION q,

    IVAS_QUATERNION *const result );



#ifdef OTR_REFERENCE_VECTOR_TRACKING

float QuaternionLength(

    const IVAS_QUATERNION q );



IVAS_VECTOR3 VectorSubtract(

    const IVAS_VECTOR3 p1,

    const IVAS_VECTOR3 p2 );



IVAS_VECTOR3 VectorCrossProduct(

    const IVAS_VECTOR3 p1,

    const IVAS_VECTOR3 p2 );



float VectorDotProduct(

    const IVAS_VECTOR3 p1,

    const IVAS_VECTOR3 p2 );



float VectorLength(

    const IVAS_VECTOR3 p );



IVAS_VECTOR3 VectorNormalize(

    const IVAS_VECTOR3 p );



void VectorRotationToQuaternion(

    const IVAS_VECTOR3 p1,

    const IVAS_VECTOR3 p2,

    IVAS_QUATERNION *const result );

#endif /* OTR_REFERENCE_VECTOR_TRACKING */



/*------------------------------------------------------------------------------------------*

 * Quaternion product

 *------------------------------------------------------------------------------------------*/

static IVAS_QUATERNION IdentityQuaternion(

    void )

{

    IVAS_QUATERNION q;



    q.w = 1.0f;

    q.x = q.y = q.z = 0.0f;



    return q;

}





/*------------------------------------------------------------------------------------------*

 * QuaternionProduct()

 *

 * Quaternion product

 *------------------------------------------------------------------------------------------*/

void QuaternionProduct(



static void QuaternionProduct(

    const IVAS_QUATERNION q1,

    const IVAS_QUATERNION q2,

    IVAS_QUATERNION *const r )
@@ -159,21 +96,30 @@ void QuaternionProduct( 
    tmp.z = q1.w * q2.z + q1.x * q2.y - q1.y * q2.x + q1.z * q2.w;



    *r = tmp;



    return;

}



/*------------------------------------------------------------------------------------------*

 * QuaternionDotProduct()

 *

 * Quaternion dot product

 *------------------------------------------------------------------------------------------*/

float QuaternionDotProduct(



static float QuaternionDotProduct(

    const IVAS_QUATERNION q1,

    const IVAS_QUATERNION q2 )

{

    return q1.x * q2.x + q1.y * q2.y + q1.z * q2.z + q1.w * q2.w;

}





/*------------------------------------------------------------------------------------------*

 * QuaternionDivision()

 *

 * Divides a quaternion by a scalar

 *------------------------------------------------------------------------------------------*/



void QuaternionDivision(

    const IVAS_QUATERNION q,

    const float d,
@@ -183,34 +129,49 @@ void QuaternionDivision( 
    r->x = q.x / d;

    r->y = q.y / d;

    r->z = q.z / d;



    return;

}





/*------------------------------------------------------------------------------------------*

 * QuaternionNormalize()

 * 

 * Normalizes a quaternion

 *------------------------------------------------------------------------------------------*/

void QuaternionNormalize(



static void QuaternionNormalize(

    const IVAS_QUATERNION q,

    IVAS_QUATERNION *const r )

{

    QuaternionDivision( q, sqrtf( QuaternionDotProduct( q, q ) ), r );



    return;

}





/*------------------------------------------------------------------------------------------*

 * QuaternionSlerp()

 *

 * Computes a spherical linear interpolation between two quaternions

 *------------------------------------------------------------------------------------------*/

void QuaternionSlerp(



static void QuaternionSlerp(

    const IVAS_QUATERNION q1,

    const IVAS_QUATERNION q2,

    const float t,

    IVAS_QUATERNION *const r )

{

    float angle, denom, s, s2;



    s = QuaternionDotProduct( q1, q2 );



    if ( fabsf( s ) >= 1.0f )

    {

        *r = q2;

        return;

    }



    angle = acosf( s );

    denom = sinf( angle );
@@ -222,12 +183,18 @@ void QuaternionSlerp( 
    r->w = ( q1.w * s + q2.w * s2 ) / denom;



    QuaternionNormalize( *r, r );



    return;

}





/*------------------------------------------------------------------------------------------*

 * QuaternionConjugate()

 *

 * Computes a quaternion conjugate

 *------------------------------------------------------------------------------------------*/

void QuaternionConjugate(



static void QuaternionConjugate(

    const IVAS_QUATERNION q,

    IVAS_QUATERNION *const r )

{
@@ -235,27 +202,39 @@ void QuaternionConjugate( 
    r->x = -q.x;

    r->y = -q.y;

    r->z = -q.z;



    return;

}





/*------------------------------------------------------------------------------------------*

 * QuaternionAngle()

 *

 * Computes an angle between two quaternions

 *------------------------------------------------------------------------------------------*/

float QuaternionAngle(



static float QuaternionAngle(

    const IVAS_QUATERNION q1,

    const IVAS_QUATERNION q2 )

{

    IVAS_QUATERNION q12;

    float angle;



    QuaternionConjugate( q1, &q12 );

    QuaternionProduct( q12, q2, &q12 );

    angle = 2.0f * atan2f( sqrtf( q12.x * q12.x + q12.y * q12.y + q12.z * q12.z ), q12.w );



    return angle;

}





/*------------------------------------------------------------------------------------------*

 * QuaternionInverse()

 *

 * Computes an inverse quaternion

 *------------------------------------------------------------------------------------------*/

void QuaternionInverse(



static void QuaternionInverse(

    const IVAS_QUATERNION q,

    IVAS_QUATERNION *const r )

{
@@ -264,36 +243,39 @@ void QuaternionInverse( 
    dot_product = QuaternionDotProduct( q, q );

    QuaternionConjugate( q, r );

    QuaternionDivision( *r, dot_product, r );

}



#ifdef OTR_REFERENCE_VECTOR_TRACKING

/*------------------------------------------------------------------------------------------*

 * Computes the length of a quaternion

 *------------------------------------------------------------------------------------------*/

float QuaternionLength(

    const IVAS_QUATERNION q )

{

    return sqrtf( q.w * q.w + q.x * q.x + q.y * q.y + q.z * q.z );

    return;

}





#ifdef OTR_REFERENCE_VECTOR_TRACKING

/*------------------------------------------------------------------------------------------*

 * VectorSubtract()

 *

 * Computes the difference of two vectors

 *------------------------------------------------------------------------------------------*/

IVAS_VECTOR3 VectorSubtract(



static IVAS_VECTOR3 VectorSubtract(

    const IVAS_VECTOR3 p1,

    const IVAS_VECTOR3 p2 )

{

    IVAS_VECTOR3 result;



    result.x = p1.x - p2.x;

    result.y = p1.y - p2.y;

    result.z = p1.z - p2.z;



    return result;

}





/*------------------------------------------------------------------------------------------*

 * VectorCrossProduct()

 *

 * Computes the cross product of two vectors

 *------------------------------------------------------------------------------------------*/

IVAS_VECTOR3 VectorCrossProduct(



static IVAS_VECTOR3 VectorCrossProduct(

    const IVAS_VECTOR3 p1,

    const IVAS_VECTOR3 p2 )

{
@@ -301,46 +283,66 @@ IVAS_VECTOR3 VectorCrossProduct( 
    result.x = p1.y * p2.z - p1.z * p2.y;

    result.y = p1.z * p2.x - p1.x * p2.z;

    result.z = p1.x * p2.y - p1.y * p2.x;



    return result;

}





/*------------------------------------------------------------------------------------------*

 * VectorDotProduct(

 *

 * Computes the dot product of two vectors

 *------------------------------------------------------------------------------------------*/

float VectorDotProduct(



static float VectorDotProduct(

    const IVAS_VECTOR3 p1,

    const IVAS_VECTOR3 p2 )

{

    return p1.x * p2.x + p1.y * p2.y + p1.z * p2.z;

}





/*------------------------------------------------------------------------------------------*

 * VectorLength()

 *

 * Computes the length of a vector

 *------------------------------------------------------------------------------------------*/

float VectorLength(



static float VectorLength(

    const IVAS_VECTOR3 p )

{

    return sqrtf( p.x * p.x + p.y * p.y + p.z * p.z );

}





/*------------------------------------------------------------------------------------------*

 * VectorNormalize()

 *

 * Normalizes a vector

 *------------------------------------------------------------------------------------------*/

IVAS_VECTOR3 VectorNormalize(



static IVAS_VECTOR3 VectorNormalize(

    const IVAS_VECTOR3 p )

{

    IVAS_VECTOR3 result;



    const float length = VectorLength( p );



    result.x = p.x / length;

    result.y = p.y / length;

    result.z = p.z / length;



    return result;

}





/*------------------------------------------------------------------------------------------*

 * VectorRotationToQuaternion()

 *

 * Computes a quaternion representing the rotation from vector p1 to vector p2

 *------------------------------------------------------------------------------------------*/

void VectorRotationToQuaternion(



static void VectorRotationToQuaternion(

    const IVAS_VECTOR3 p1,

    const IVAS_VECTOR3 p2,

    IVAS_QUATERNION *const r )
@@ -369,7 +371,10 @@ void VectorRotationToQuaternion( 
        r->z = cross_product.z;

        r->w = 1.0f + dot_product;

    }



    QuaternionNormalize( *r, r );



    return;

}

#endif /* OTR_REFERENCE_VECTOR_TRACKING */

#else
@@ -513,6 +518,12 @@ void ivas_orient_trk_SetTrackingType( 
#endif



#ifdef FIX_I109_ORIENTATION_TRACKING

/*-------------------------------------------------------------------*

 * ivas_orient_trk_SetReferenceRotation()

 *

 *

 *-------------------------------------------------------------------*/



ivas_error ivas_orient_trk_SetReferenceRotation(

    ivas_orient_trk_state_t *pOTR, /* i/o  : orientation tracker handle     */

    IVAS_QUATERNION refRot )       /* i    : reference rotation             */
@@ -535,6 +546,13 @@ ivas_error ivas_orient_trk_SetReferenceRotation( 
    return IVAS_ERR_OK;

}





/*-------------------------------------------------------------------*

 * ivas_orient_trk_GetMainOrientation()

 *

 *

 *-------------------------------------------------------------------*/



ivas_error ivas_orient_trk_GetMainOrientation(

    ivas_orient_trk_state_t *pOTR, /* i/o  : orientation tracker handle     */

    IVAS_QUATERNION *pOrientation  /* i/o  : average/reference orientation  */
@@ -560,9 +578,17 @@ ivas_error ivas_orient_trk_GetMainOrientation( 
            *pOrientation = pOTR->absAvgRot;

            break;

    }



    return IVAS_ERR_OK;

}





/*-------------------------------------------------------------------*

 * ivas_orient_trk_GetTrackedRotation()

 *

 *

 *-------------------------------------------------------------------*/



ivas_error ivas_orient_trk_GetTrackedRotation(

    ivas_orient_trk_state_t *pOTR, /* i/o  : orientation tracker handle    */

    IVAS_QUATERNION *pRotation     /* i/o  : processed rotation            */
@@ -578,7 +604,14 @@ ivas_error ivas_orient_trk_GetTrackedRotation( 
    return IVAS_ERR_OK;

}





#ifdef OTR_REFERENCE_VECTOR_TRACKING

/*-------------------------------------------------------------------*

 * ivas_orient_trk_SetReferenceVector()

 *

 *

 *-------------------------------------------------------------------*/



ivas_error ivas_orient_trk_SetReferenceVector(

    ivas_orient_trk_state_t *pOTR,  /* i/o  : orientation tracker handle    */

    const IVAS_VECTOR3 listenerPos, /* i  : Listener position               */
@@ -604,6 +637,7 @@ ivas_error ivas_orient_trk_SetReferenceVector( 
        case OTR_TRACKING_REF_VEC_LEV:

        {

            IVAS_VECTOR3 listenerPosLevel, refPosLevel;



            /* ignore the height difference between listener position and reference position */

            listenerPosLevel.z = refPosLevel.z = listenerPos.z;

            listenerPosLevel.x = listenerPos.x;
@@ -615,6 +649,7 @@ ivas_error ivas_orient_trk_SetReferenceVector( 
    }



    acousticFrontVectorLength = VectorLength( acousticFrontVector );



    /* if the length is zero, the user has entered insensible listener and reference positions */

    if ( acousticFrontVectorLength < 0.0001f )

    {
@@ -625,6 +660,7 @@ ivas_error ivas_orient_trk_SetReferenceVector( 
    ivasForwardVector.y = 0.0f;

    ivasForwardVector.z = 0.0f;

    VectorRotationToQuaternion( ivasForwardVector, acousticFrontVector, &pOTR->refRot );



    return IVAS_ERR_OK;

}

#endif /* OTR_REFERENCE_VECTOR_TRACKING */