Home

Resume

Blog

Teikitu


/* =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-==-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= */
/*  »Project«   Teikitu Gaming System (TgS) (∂)
    »File«      TgS Common - Geometry 3D - Ellipse.i_inc
    »Author«    Andrew Aye (EMail: mailto:andrew.aye@gmail.com, Web: http://www.andrewaye.com)
    »Version«   4.51 / »GUID« A9981407-3EC9-42AF-8B6F-8BE6DD919615                                                                                                        */
/*   -------------------------------------------------------------------------------------------------------------------------------------------------------------------- */
/*  Copyright: © 2002-2017, Andrew Aye.  All Rights Reserved.
    This software is free for non-commercial use.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
      following conditions are met:
        Redistribution of source code must retain this copyright notice, this list of conditions and the following disclaimers.
        Redistribution in binary form must reproduce this copyright notice, this list of conditions and the following disclaimers in the documentation and other materials
          provided with the distribution.
    The name of the author may not be used to endorse or promote products derived from this software without specific prior written permission.
    The intellectual property rights of the algorithms used reside with Andrew Aye.
    You may not use this software, in whole or in part, in support of any commercial product without the express written consent of the author.
    There is no warranty or other guarantee of fitness of this software for any purpose. It is provided solely "as is".                                                   */
/* =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-==-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= */
/* == Common ============================================================================================================================================================ */

/* ---- V(tgGM_EL_Reset) ------------------------------------------------------------------------------------------------------------------------------------------------ */
/* ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- */
TgINLINE TgVOID V(tgGM_EL_Reset)( V(PCU_TgELLIPSE) psEL0 )
{
    psEL0->m.m.vMajor_Axis = V(FS_SETV)( MKL(0.0), MKL(0.0), MKL(0.0) );
    psEL0->m.m.vNormal = V(FS_SETV)( MKL(0.0), MKL(0.0), MKL(0.0) );
    psEL0->m.m.vMinor_Axis = V(FS_SETV)( MKL(0.0), MKL(0.0), MKL(0.0) );
    psEL0->m.m.vOrigin = V(FS_SETP)( MKL(0.0), MKL(0.0), MKL(0.0) );
    psEL0->m_fMajor = MKL(0.0);
    psEL0->m_fMinor = MKL(0.0);
}


/* ---- V(tgGM_EL_Area) ------------------------------------------------------------------------------------------------------------------------------------------------- */
/* ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- */
TgINLINE TYPE V(tgGM_EL_Area)( V(CPCU_TgELLIPSE) psEL1 )
{
    return (F(KTgF_PI) * psEL1->m_fMajor * psEL1->m_fMinor);
}


/* ---- V(tgGM_EL_BA) --------------------------------------------------------------------------------------------------------------------------------------------------- */
/* ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- */
TgINLINE TgVOID V(tgGM_EL_BA)( V(PCU_TgBOXAA) psBA0, V(CPCU_TgELLIPSE) psEL1 )
{
    V(C_TgVEC)                          vX0 = V(F_MUL_SV)( psEL1->m_fMajor, &psEL1->m.m.vMajor_Axis );
    V(C_TgVEC)                          tvX1 = V(F_MUL_SV)( psEL1->m_fMajor, &psEL1->m.m.vMajor_Axis );
    V(C_TgVEC)                          tvX2 = V(F_MUL_SV)( psEL1->m_fMinor, &psEL1->m.m.vMinor_Axis );
    V(C_TgVEC)                          tvX3 = V(F_MUL_SV)( psEL1->m_fMinor, &psEL1->m.m.vMinor_Axis );
    V(C_TgVEC)                          tvX4 = V(F_SUB)( &psEL1->m.m.vOrigin, &vX0 );
    V(C_TgVEC)                          tvX5 = V(F_ADD)( &psEL1->m.m.vOrigin, &tvX1 );
    V(C_TgVEC)                          tvX6 = V(F_SUB)( &psEL1->m.m.vOrigin, &tvX2 );
    V(C_TgVEC)                          tvX7 = V(F_ADD)( &psEL1->m.m.vOrigin, &tvX3 );

    TgGEOM_ASSERT_PARAM(TgTRUE == V(tgGM_EL_Is_Valid)(psEL1));

    V(tgGM_BA_Init_PT)( psBA0, &psEL1->m.m.vOrigin );
    V(tgGM_BA_Union_PT)( psBA0, &tvX4 );
    V(tgGM_BA_Union_PT)( psBA0, &tvX5 );
    V(tgGM_BA_Union_PT)( psBA0, &tvX6 );
    V(tgGM_BA_Union_PT)( psBA0, &tvX7 );
}


/* ---- V(tgGM_EL_Sweep_BA) --------------------------------------------------------------------------------------------------------------------------------------------- */
/* ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- */
TgINLINE TgVOID V(tgGM_EL_Sweep_BA)( V(PCU_TgBOXAA) psBA0, V(CPCU_TgELLIPSE) psEL1, V(CPCU_TgVEC) pvDT )
{
    TgGEOM_ASSERT_PARAM(TgTRUE == V(F_Is_Vector_Valid)(pvDT));

    V(tgGM_EL_BA)( psBA0, psEL1 );
    V(tgGM_BA_Sweep)( psBA0, pvDT );
}


/* ---- V(tgGM_EL_Project) ---------------------------------------------------------------------------------------------------------------------------------------------- */
/* ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- */
TgINLINE TgVOID V(tgGM_EL_Project)( PCU_TYPE ptyMin, PCU_TYPE ptyMax, V(CPCU_TgELLIPSE) psEL1, V(CPCU_TgVEC) pvDN )
{
    const TYPE                          fAx_A0 = F(tgPM_ABS)( V(F_DOT)(pvDN, &psEL1->m.m.vMajor_Axis) );
    const TYPE                          fAx_A1 = F(tgPM_ABS)( V(F_DOT)(pvDN, &psEL1->m.m.vMinor_Axis) );

    TgGEOM_ASSERT_PARAM(TgTRUE == V(tgGM_EL_Is_Valid)(psEL1) && TgTRUE == V(F_Is_Vector_Valid)(pvDN));

    *ptyMin = *ptyMax = V(F_DOT)( pvDN, &psEL1->m.m.vOrigin );;

    if (F(tgCM_NR0)(fAx_A0) && TgTRUE == F(tgCM_NR0)(fAx_A1))
    {
        return;
    };

    *ptyMin -= fAx_A0 * psEL1->m_fMajor;
    *ptyMin -= fAx_A1 * psEL1->m_fMinor;
    *ptyMax += fAx_A0 * psEL1->m_fMajor;
    *ptyMax += fAx_A1 * psEL1->m_fMinor;
}


/* ---- V(tgGM_EL_Is_Contained) ----------------------------------------------------------------------------------------------------------------------------------------- */
/* ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- */
TgINLINE TgBOOL V(tgGM_EL_Is_Contained)( V(CPCU_TgELLIPSE) psEL1, V(CPCU_TgVEC) pvS0 )
{
    TgGEOM_ASSERT_PARAM(TgTRUE == V(tgGM_EL_Is_Valid)(psEL1) && TgTRUE == V(F_Is_Point_Valid)( pvS0 ));

    if (psEL1->m_fMajor <= F(KTgEPS) || psEL1->m_fMinor <= F(KTgEPS))
    {
        return (TgFALSE);
    }
    else
    {
        V(C_TgVEC)                          vDS = V(F_SUB)( pvS0, &psEL1->m.m.vOrigin );
        const TYPE                          fX = V(F_DOT)(&vDS, &psEL1->m.m.vMajor_Axis) / psEL1->m_fMajor;
        const TYPE                          fY = V(F_DOT)(&vDS, &psEL1->m.m.vMinor_Axis) / psEL1->m_fMinor;

        return (1 >= fX*fX + fY*fY ? TgTRUE : TgFALSE);
    };
}


/* ---- V(tgGM_EL_TX) --------------------------------------------------------------------------------------------------------------------------------------------------- */
/* ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- */
TgINLINE TgVOID V(tgGM_EL_TX)( V(PCU_TgELLIPSE) psEL0, M34(CPCU_TgMAT) pxM0 )
{
    TgGEOM_ASSERT_PARAM(TgTRUE != M34(F_NaN)(pxM0));

    psEL0->m.m.vMajor_Axis = M34(F_TX_V)( pxM0, &psEL0->m.m.vMajor_Axis );
    psEL0->m.m.vNormal = M34(F_TX_V)( pxM0, &psEL0->m.m.vNormal );
    psEL0->m.m.vMinor_Axis = M34(F_TX_V)( pxM0, &psEL0->m.m.vMinor_Axis );
    psEL0->m.m.vOrigin = M34(F_TX_P)( pxM0, &psEL0->m.m.vOrigin );
}


/* ---- V(tgGM_EL_Copy_TX) ---------------------------------------------------------------------------------------------------------------------------------------------- */
/* ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- */
TgINLINE TgVOID V(tgGM_EL_Copy_TX)( V(PCU_TgELLIPSE) psEL0, V(CPCU_TgELLIPSE) psEL1, M34(CPCU_TgMAT) pxM0 )
{
    TgGEOM_ASSERT_PARAM(TgTRUE == V(tgGM_EL_Is_Valid)(psEL1) && !M34(F_NaN)(pxM0));

    psEL0->m.m.vOrigin = M34(F_TX_V)( pxM0, &psEL1->m.m.vOrigin );
    psEL0->m.m.vMajor_Axis = M34(F_TX_V)( pxM0, &psEL1->m.m.vMajor_Axis );
    psEL0->m.m.vNormal = M34(F_TX_V)( pxM0, &psEL1->m.m.vNormal );
    psEL0->m.m.vMinor_Axis = M34(F_TX_P)( pxM0, &psEL1->m.m.vMinor_Axis );
    psEL0->m_fMajor = psEL1->m_fMajor;
    psEL0->m_fMinor = psEL1->m_fMinor;
}


/* ---- V(tgGM_EL_Init) ------------------------------------------------------------------------------------------------------------------------------------------------- */
/* ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- */
TgINLINE TgVOID V(tgGM_EL_Init)( V(PCU_TgELLIPSE) psEL0, V(CPCU_TgVEC) pvMJ, V(CPCU_TgVEC) pvNM, V(CPCU_TgVEC) pvMN, V(CPCU_TgVEC) pvOG, const TYPE fMaj, const TYPE fMin)
{
    V(tgGM_EL_Set_Major_Unit)( psEL0, pvMJ );
    V(tgGM_EL_Set_Normal)( psEL0, pvNM );
    V(tgGM_EL_Set_Minor_Unit)( psEL0, pvMN );
    V(tgGM_EL_Set_Origin)( psEL0, pvOG );
    V(tgGM_EL_Set_Major_Radius)( psEL0, fMaj );
    V(tgGM_EL_Set_Minor_Radius)( psEL0, fMin );
}


/* ---- V(tgGM_EL_Init_3D) ---------------------------------------------------------------------------------------------------------------------------------------------- */
/* ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- */
TgINLINE TgVOID V(tgGM_EL_Init_3D)( V(PCU_TgELLIPSE) psEL0, M34(CPCU_TgMAT) pxM0, const TYPE fMaj, const TYPE fMin )
{
    V(tgGM_EL_Set_3D)( psEL0, pxM0 );
    V(tgGM_EL_Set_Major_Radius)( psEL0, fMaj );
    V(tgGM_EL_Set_Minor_Radius)( psEL0, fMin );
}


/* ---- V(tgGM_EL_Copy) ------------------------------------------------------------------------------------------------------------------------------------------------- */
/* ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- */
TgINLINE TgVOID V(tgGM_EL_Copy)( V(PCU_TgELLIPSE) psEL0, V(CPCU_TgELLIPSE) psEL1 )
{
    TgGEOM_ASSERT_PARAM(TgTRUE == V(tgGM_EL_Is_Valid)(psEL1));

    psEL0->m.m.vMajor_Axis = psEL1->m.m.vMajor_Axis;
    psEL0->m.m.vNormal = psEL1->m.m.vNormal;
    psEL0->m.m.vMinor_Axis = psEL1->m.m.vMinor_Axis;
    psEL0->m.m.vOrigin = psEL1->m.m.vOrigin;
    psEL0->m_fMajor = psEL1->m_fMajor;
    psEL0->m_fMinor = psEL1->m_fMinor;
}


/* ---- V(tgGM_EL_Set_Origin) ------------------------------------------------------------------------------------------------------------------------------------------- */
/* ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- */
TgINLINE TgVOID V(tgGM_EL_Set_Origin)( V(PCU_TgELLIPSE) psEL0, V(CPCU_TgVEC) pvOrigin )
{
    TgGEOM_ASSERT_PARAM(TgTRUE == V(F_Is_Point_Valid)(pvOrigin));
    psEL0->m.m.vOrigin = *pvOrigin;
}


/* ---- V(tgGM_EL_Set_Axes_Unit) ---------------------------------------------------------------------------------------------------------------------------------------- */
/* ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- */
TgINLINE TgVOID V(tgGM_EL_Set_Axes_Unit)( V(PCU_TgELLIPSE) psEL0, M34(CPCU_TgMAT) pxM0 )
{
    V(C_TgVEC)                          vS0 = psEL0->m.avData[3];

    TgGEOM_ASSERT_PARAM(TgTRUE != M34(F_NaN)(pxM0));

    M34(F_TR)(&psEL0->m.xData, pxM0);

    psEL0->m.avData[3] = vS0;

    TgGEOM_ASSERT_PARAM(TgTRUE == V(F_Is_Vector_Valid)(psEL0->m.avData + 0) && TgTRUE == F(tgCM_NR1)(V(F_LSQ)(psEL0->m.avData + 0)));
    TgGEOM_ASSERT_PARAM(TgTRUE == V(F_Is_Vector_Valid)(psEL0->m.avData + 1) && TgTRUE == F(tgCM_NR1)(V(F_LSQ)(psEL0->m.avData + 1)));
    TgGEOM_ASSERT_PARAM(TgTRUE == V(F_Is_Vector_Valid)(psEL0->m.avData + 2) && TgTRUE == F(tgCM_NR1)(V(F_LSQ)(psEL0->m.avData + 2)));
}


/* ---- V(tgGM_EL_Set_Major_Unit) --------------------------------------------------------------------------------------------------------------------------------------- */
/* ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- */
TgINLINE TgVOID V(tgGM_EL_Set_Major_Unit)( V(PCU_TgELLIPSE) psEL0, V(CPCU_TgVEC) pvAxis )
{
    TgGEOM_ASSERT_PARAM(TgTRUE == V(F_Is_Vector_Valid)(pvAxis) && TgTRUE == F(tgCM_NR1)(V(F_LSQ)(pvAxis)));
    psEL0->m.m.vMajor_Axis = *pvAxis;
}


/* ---- V(tgGM_EL_Set_Normal) ------------------------------------------------------------------------------------------------------------------------------------------- */
/* ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- */
TgINLINE TgVOID V(tgGM_EL_Set_Normal)( V(PCU_TgELLIPSE) psEL0, V(CPCU_TgVEC) pvNormal )
{
    TgGEOM_ASSERT_PARAM(TgTRUE == V(F_Is_Vector_Valid)(pvNormal) && TgTRUE == F(tgCM_NR1)(V(F_LSQ)(pvNormal)));
    psEL0->m.m.vNormal = *pvNormal;
}


/* ---- V(tgGM_EL_Set_Minor_Unit) --------------------------------------------------------------------------------------------------------------------------------------- */
/* ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- */
TgINLINE TgVOID V(tgGM_EL_Set_Minor_Unit)( V(PCU_TgELLIPSE) psEL0, V(CPCU_TgVEC) pvAxis )
{
    TgGEOM_ASSERT_PARAM(TgTRUE == V(F_Is_Vector_Valid)(pvAxis) && TgTRUE == F(tgCM_NR1)(V(F_LSQ)(pvAxis)));
    psEL0->m.m.vMinor_Axis = *pvAxis;
}


/* ---- V(tgGM_EL_Set_3D) ----------------------------------------------------------------------------------------------------------------------------------------------- */
/* ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- */
TgINLINE TgVOID V(tgGM_EL_Set_3D)( V(PCU_TgELLIPSE) psEL0, M34(CPCU_TgMAT) pxM0 )
{
    TgGEOM_ASSERT_PARAM(TgTRUE != M34(F_NaN)(pxM0));

    M34(F_TR)(&psEL0->m.xData, pxM0);

    TgGEOM_ASSERT_PARAM(TgTRUE == V(F_Is_Vector_Valid)(psEL0->m.avData + 0) && TgTRUE == F(tgCM_NR1)(V(F_LSQ)(psEL0->m.avData + 0)));
    TgGEOM_ASSERT_PARAM(TgTRUE == V(F_Is_Vector_Valid)(psEL0->m.avData + 1) && TgTRUE == F(tgCM_NR1)(V(F_LSQ)(psEL0->m.avData + 1)));
    TgGEOM_ASSERT_PARAM(TgTRUE == V(F_Is_Vector_Valid)(psEL0->m.avData + 2) && TgTRUE == F(tgCM_NR1)(V(F_LSQ)(psEL0->m.avData + 2)));
    TgGEOM_ASSERT_PARAM(TgTRUE == V(F_Is_Point_Valid)(psEL0->m.avData + 3));
}


/* ---- V(tgGM_EL_Set_Major_Radius) ------------------------------------------------------------------------------------------------------------------------------------- */
/* ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- */
TgINLINE TgVOID V(tgGM_EL_Set_Major_Radius)( V(PCU_TgELLIPSE) psEL0, const TYPE fRadius )
{
    TgGEOM_ASSERT_PARAM(TgTRUE != F(tgPM_NAN)(fRadius) && fRadius > MKL(0.0));
    psEL0->m_fMajor = fRadius;
}


/* ---- V(tgGM_EL_Set_Minor_Radius) ------------------------------------------------------------------------------------------------------------------------------------- */
/* ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- */
TgINLINE TgVOID V(tgGM_EL_Set_Minor_Radius)( V(PCU_TgELLIPSE) psEL0, const TYPE fRadius )
{
    TgGEOM_ASSERT_PARAM(TgTRUE != F(tgPM_NAN)(fRadius) && fRadius > MKL(0.0));
    psEL0->m_fMinor = fRadius;
}


/* ---- V(tgGM_EL_Query_Origin) ----------------------------------------------------------------------------------------------------------------------------------------- */
/* ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- */
TgINLINE V(CP_TgVEC) V(tgGM_EL_Query_Origin)( V(CPCU_TgELLIPSE) psEL1 )
{
    return (&psEL1->m.m.vOrigin);
}


/* ---- V(tgGM_EL_Query_Major_Unit) ------------------------------------------------------------------------------------------------------------------------------------- */
/* ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- */
TgINLINE V(CP_TgVEC) V(tgGM_EL_Query_Major_Unit)( V(CPCU_TgELLIPSE) psEL1 )
{
    return (&psEL1->m.m.vMajor_Axis);
}


/* ---- V(tgGM_EL_Query_Normal) ----------------------------------------------------------------------------------------------------------------------------------------- */
/* ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- */
TgINLINE V(CP_TgVEC) V(tgGM_EL_Query_Normal)( V(CPCU_TgELLIPSE) psEL1 )
{
    return (&psEL1->m.m.vNormal);
}


/* ---- V(tgGM_EL_Query_Minor_Unit) ------------------------------------------------------------------------------------------------------------------------------------- */
/* ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- */
TgINLINE V(CP_TgVEC) V(tgGM_EL_Query_Minor_Unit)( V(CPCU_TgELLIPSE) psEL1 )
{
    return (&psEL1->m.m.vMinor_Axis);
}


/* ---- V(tgGM_EL_Query_Major_Radius) ----------------------------------------------------------------------------------------------------------------------------------- */
/* ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- */
TgINLINE TYPE V(tgGM_EL_Query_Major_Radius)( V(CPCU_TgELLIPSE) psEL1 )
{
    return (psEL1->m_fMajor);
}


/* ---- V(tgGM_EL_Query_Minor_Radius) ----------------------------------------------------------------------------------------------------------------------------------- */
/* ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- */
TgINLINE TYPE V(tgGM_EL_Query_Minor_Radius)( V(CPCU_TgELLIPSE) psEL1 )
{
    return (psEL1->m_fMinor);
}


#if defined(TgCOMPILE_NATIVE_VECTOR)

/* ---- V(tgGM_EL_M_TX) ------------------------------------------------------------------------------------------------------------------------------------------------- */
/* ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- */
TgINLINE TgVOID V(tgGM_EL_M_TX)( V(PCU_TgELLIPSE) psEL0, M34(CPCU_TgMAT) pxM0 )
{
    TgGEOM_ASSERT_PARAM(TgTRUE != M34(F_NaN)( pxM0 ));

    psEL0->m.m.vMajor_Axis.m_mData = M34(M_TX_V)( pxM0, psEL0->m.m.vMajor_Axis.m_mData );
    psEL0->m.m.vNormal.m_mData = M34(M_TX_V)( pxM0, psEL0->m.m.vNormal.m_mData );
    psEL0->m.m.vMinor_Axis.m_mData = M34(M_TX_V)( pxM0, psEL0->m.m.vMinor_Axis.m_mData );
    psEL0->m.m.vOrigin.m_mData = M34(M_TX_P)( pxM0, psEL0->m.m.vOrigin.m_mData );
}


/* ---- V(tgGM_EL_Copy_M_TX) -------------------------------------------------------------------------------------------------------------------------------------------- */
/* ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- */
TgINLINE TgVOID V(tgGM_EL_Copy_M_TX)( V(PCU_TgELLIPSE) psEL0, V(CPCU_TgELLIPSE) psEL1, M34(CPCU_TgMAT) pxM0 )
{
    TgGEOM_ASSERT_PARAM(TgTRUE == V(tgGM_EL_Is_Valid)( psEL1 ) && TgTRUE != M34(F_NaN)( pxM0 ));

    psEL0->m.m.vMajor_Axis.m_mData = M34(M_TX_V)( pxM0, psEL1->m.m.vMajor_Axis.m_mData );
    psEL0->m.m.vNormal.m_mData = M34(M_TX_V)( pxM0, psEL1->m.m.vNormal.m_mData );
    psEL0->m.m.vMinor_Axis.m_mData = M34(M_TX_V)( pxM0, psEL1->m.m.vMinor_Axis.m_mData );
    psEL0->m.m.vOrigin.m_mData = M34(M_TX_P)( pxM0, psEL1->m.m.vOrigin.m_mData );
    psEL0->m_fMajor = psEL1->m_fMajor;
    psEL0->m_fMinor = psEL1->m_fMinor;
}

/*# defined(TgCOMPILE_NATIVE_VECTOR) */
#endif