Пример #1
0
void C3DMarkerSA::SetMatrix ( CMatrix * pMatrix )
{
    CMatrix_Padded * mat = &GetInterface ()->m_mat;
    MemCpyFast ( &mat->vPos, &pMatrix->vPos, sizeof ( CVector ) );
    MemCpyFast ( &mat->vFront, &pMatrix->vFront, sizeof ( CVector ) );
    MemCpyFast ( &mat->vRight, &pMatrix->vRight, sizeof ( CVector ) );
    MemCpyFast ( &mat->vUp, &pMatrix->vUp, sizeof ( CVector ) );
}
Пример #2
0
bool FreePoolHunk(MemPool * Pool,void * Hunk)
{
if ( Pool->NumFreedHunks >= Pool->MaxNumFreedHunks )
  {
  void ** NewFreedHunks;

  if ( (NewFreedHunks = malloc((Pool->MaxNumFreedHunks<<1)*sizeof(void *))) == NULL )
    return(0);

  MemCpyFast(NewFreedHunks,Pool->FreedHunks,Pool->MaxNumFreedHunks);

  free(Pool->FreedHunks);
  
  Pool->FreedHunks = NewFreedHunks;
  Pool->MaxNumFreedHunks <<= 1;
  }

Pool->FreedHunks[Pool->NumFreedHunks] = Hunk;
Pool->NumFreedHunks++;

Pool->NumItemsActive--;

return(1);
}
Пример #3
0
void PostContextSwitch ( void )
{
    // Prevent the game making remote player's weapons get switched by the local player's
    MemPutFast < BYTE > ( 0x60D850, 0x56 );
    MemPutFast < BYTE > ( 0x60D851, 0x57 );
    MemPutFast < BYTE > ( 0x60D852, 0x8B );

    // Prevent it calling ClearWeaponTarget for remote players
    MemPutFast < BYTE > ( 0x609C80, 0x57 );

    // Prevent CCamera::SetNewPlayerWeaponMode being called
    MemPutFast < BYTE > ( 0x50BFB0, 0x66 );
    MemPutFast < BYTE > ( 0x50BFB1, 0x8B );
    MemPutFast < BYTE > ( 0x50BFB2, 0x44 );

    // This is so weapon clicks and similar don't play for us when done remotly
    MemPutFast < BYTE > ( 0x60F273, 0x75 );
    MemPutFast < BYTE > ( 0x60F260, 0x74 );
    MemPutFast < BYTE > ( 0x60F261, 0x13 );

    // Prevent it calling CCamera::ClearPlayerWeaponMode for remote players
    MemPutFast < BYTE > ( 0x50AB10, 0x33 );

    // this is to prevent shooting players following the local camera
    MemPutFast < BYTE > ( 0x687099, 0x75 );

    // Prevent rockets firing oddly
    //*(BYTE *)0x73811C = 0x0F;
    //*(BYTE *)0x73811D = 0x84;

    // Prevent it marking targets of remote players
    MemPutFast < BYTE > ( 0x742BF0, 0x8B );

    // Restore the mouse look state back to the default
    MemPutFast < bool > ( 0xB6EC2E, bMouseLookEnabled );

    // Restore the visual goggle mode back
    MemPutFast < bool > ( 0xC402B9, bInfraredVisionEnabled );
    MemPutFast < bool > ( 0xC402B8, bNightVisionEnabled );

    // Make players cough on fire extinguisher and teargas again
    MemPutFast < unsigned char > ( 0x4C03F0, 0x83 );
    MemPutFast < unsigned char > ( 0x4C03F1, 0xF8 );
    MemPutFast < unsigned char > ( 0x4C03F2, 0x29 );
    MemPutFast < unsigned char > ( 0x4C03F8, 0x74 );
    MemPutFast < unsigned char > ( 0x4C03F9, 0x09 );
    MemPutFast < unsigned char > ( 0x4C03FA, 0x83 );
    MemPutFast < unsigned char > ( 0x4C03FB, 0xF8 );
    MemPutFast < unsigned char > ( 0x4C03FC, 0x2A );
    MemPutFast < unsigned char > ( 0x4C03FD, 0x74 );
    MemPutFast < unsigned char > ( 0x4C03FE, 0x04 );

    // make the CCamera::Using1stPersonWeaponMode function return true
    if ( b1stPersonWeaponModeHackInPlace)
    {
        b1stPersonWeaponModeHackInPlace = false;

        MemPutFast < BYTE > ( 0x50BFF0, 0x66 );
        MemPutFast < BYTE > ( 0x50BFF1, 0x8B );
        MemPutFast < BYTE > ( 0x50BFF2, 0x81 );
    }


    if ( bRadioHackInstalled )
    {
        // For tanks, to prevent our mouse movement affecting remote tanks
        // 006AEA25   0F85 60010000    JNZ gta_sa.006AEB8B
        // ^
        // 006AEA25   90               NOP
        // 006AEA26   E9 60010000      JMP gta_sa.006AEB8B
        MemPutFast < BYTE > ( 0x6AEA25, 0x0F );
        MemPutFast < BYTE > ( 0x6AEA26, 0x85 );

        // Same for firetrucks and SWATs
        // 00729B96   0F85 75010000    JNZ gta_sa.00729D11
        // ^
        // 00729B96   90               NOP
        // 00729B97   E9 75010000      JMP gta_sa.00729D11
        MemPutFast < BYTE > ( 0x729B96, 0x0F );
        MemPutFast < BYTE > ( 0x729B97, 0x85 );
        
        // Prevent the game making remote players vehicle's audio behave like locals (and deleting 
        // radio etc when they are removed) - issue #95
        MemPutFast < BYTE > ( 0x50230C, 0x1 );

        bRadioHackInstalled = FALSE;
    }

    /*
    // ChrML: Force as high stats as we can go before screwing up. Players can't have different
    // stats or guns don't work. We can't have dual guns either due to some screwups.
    // Dual gun screwup: Sync code needs update and the gun pointing up needs to.
    localStatsData.StatTypesFloat [ 69 ] = 500.0f;
    localStatsData.StatTypesFloat [ 70 ] = 999.0f;
    localStatsData.StatTypesFloat [ 71 ] = 999.0f;
    localStatsData.StatTypesFloat [ 72 ] = 999.0f;
    localStatsData.StatTypesFloat [ 73 ] = 500.0f;
    localStatsData.StatTypesFloat [ 74 ] = 999.0f;
    localStatsData.StatTypesFloat [ 75 ] = 500.0f;
    localStatsData.StatTypesFloat [ 76 ] = 999.0f;
    localStatsData.StatTypesFloat [ 77 ] = 999.0f;
    localStatsData.StatTypesFloat [ 78 ] = 999.0f;
    localStatsData.StatTypesFloat [ 79 ] = 999.0f;
    */

    // ChrML: This causes the aiming issues
    // Restore the local player stats    
    MemCpyFast ( (void *)0xb79380, &localStatsData.StatTypesFloat, sizeof(float) * MAX_FLOAT_STATS );
    MemCpyFast ( (void *)0xb79000, &localStatsData.StatTypesInt, sizeof(int) * MAX_INT_STATS );
    MemCpyFast ( (void *)0xb78f10, &localStatsData.StatReactionValue, sizeof(float) * MAX_REACTION_STATS );
}
Пример #4
0
void SwitchContext ( CPed* thePed )
{
    if ( thePed == NULL ) return;

    pContextSwitchedPed = thePed;
    // Are we not already in another context?
    if ( !bNotInLocalContext )
    {
        // Grab the local ped and the local pad
        CPed* pLocalPlayerPed = pGameInterface->GetPools ()->GetPedFromRef ( (DWORD)1 ); // the player
        CPad* pLocalPad = pGameInterface->GetPad ();
        CPadSAInterface* pLocalPadInterface = ( (CPadSA*) pLocalPad )->GetInterface ();

        // We're not switching to local player
        if ( thePed != pLocalPlayerPed )
        {
            // Store the local pad
            pLocalPad->Store (); // store a copy of the local pad internally

            // Grab the remote data storage for the player we're context switching to
            CPlayerPed* thePlayerPed = dynamic_cast < CPlayerPed* > ( thePed );
            if ( thePlayerPed )
            {
                CRemoteDataStorageSA * data = CRemoteDataSA::GetRemoteDataStorage ( thePlayerPed );
                if ( data )
                {
                    // We want the player to be seen as in targeting mode if they are right clicking and with weapons 
                    CWeapon* pWeapon = thePed->GetWeapon(thePed->GetCurrentWeaponSlot());
                    eWeaponType currentWeapon = pWeapon->GetType();
                    CControllerState * cs = data->CurrentControllerState();
                    CWeaponStat * pWeaponStat = NULL;
                    if ( currentWeapon >= WEAPONTYPE_PISTOL && currentWeapon <= WEAPONTYPE_TEC9 )
                    {
                        float fValue = data->m_stats.StatTypesFloat [ pGameInterface->GetStats ()->GetSkillStatIndex ( currentWeapon ) ];
                        pWeaponStat = pGameInterface->GetWeaponStatManager ( )->GetWeaponStatsFromSkillLevel ( currentWeapon, fValue );
                    }
                    else
                        pWeaponStat = pGameInterface->GetWeaponStatManager ( )->GetWeaponStats ( currentWeapon );

                    if ( cs->RightShoulder1 != 0 
                        && ( pWeaponStat && pWeaponStat->IsFlagSet ( WEAPONTYPE_FIRSTPERSON ) ) )
                    {
                        b1stPersonWeaponModeHackInPlace = true;
                        
                        // make the CCamera::Using1stPersonWeaponMode function return true
                        MemPutFast < BYTE > ( 0x50BFF0, 0xB0 );
                        MemPutFast < BYTE > ( 0x50BFF1, 0x01 );
                        MemPutFast < BYTE > ( 0x50BFF2, 0xC3 );
                    }

                    // Change the local player's pad to the remote player's
                    MemCpyFast ( pLocalPadInterface, &data->m_pad, sizeof ( CPadSAInterface ) );

                    // this is to fix the horn/siren
                    pLocalPad->SetHornHistoryValue ( ( cs->ShockButtonL == 255 ) );
                    // disables the impatient actions on remote players (which cause desync)
                    pLocalPad->SetLastTimeTouched ( pGameInterface->GetSystemTime () );

                    // this is to make movement work correctly
                    fLocalPlayerCameraRotation = *(float *)VAR_CameraRotation;
                    MemPutFast < float > ( VAR_CameraRotation, data->m_fCameraRotation );

                    // Change the gravity to the remote player's
                    pGameInterface->SetGravity ( data->m_fGravity );

                    // Disable mouselook for remote players (so the mouse doesn't affect them)
                    // Only disable mouselook if they're not holding a 1st-person weapon
                    // And if they're not under-water
                    bool bDisableMouseLook = true;
                    if ( pWeapon )
                    {
                        eWeaponType weaponType = pWeapon->GetType ();
                        if ( pWeaponStat->IsFlagSet ( WEAPONTYPE_FIRSTPERSON ) )
                        {
                            bDisableMouseLook = false;
                        }
                    }
                    bMouseLookEnabled = *(bool *)0xB6EC2E;
                    if ( bDisableMouseLook ) *(bool *)0xB6EC2E = false;

                    // Disable the goggles
                    bInfraredVisionEnabled = *(bool *)0xC402B9;
                    MemPutFast < bool > ( 0xC402B9, false );
                    bNightVisionEnabled = *(bool *)0xC402B8;
                    MemPutFast < bool > ( 0xC402B8, false );

                    // Remove the code making players cough on fire extinguisher and teargas
                    MemSetFast ( (void*) 0x4C03F0, 0x90, 3 );
                    MemSetFast ( (void*) 0x4C03F8, 0x90, 7 );

                    // Prevent it calling ClearWeaponTarget for remote players
                    MemPutFast < BYTE > ( 0x609C80, 0xC3 );

                    // Prevent rockets firing oddly
                    //*(BYTE *)0x73811C = 0x90;
                    //*(BYTE *)0x73811D = 0xE9;

                    
                    // This is so weapon clicks and similar don't play for us when done remotly
                    MemPutFast < BYTE > ( 0x60F273, 0xEB );
                    MemPutFast < BYTE > ( 0x60F260, 0x90 );
                    MemPutFast < BYTE > ( 0x60F261, 0x90 );
                    

                    // Prevent CCamera::SetNewPlayerWeaponMode being called
                    MemPutFast < BYTE > ( 0x50BFB0, 0xC2 );
                    MemPutFast < BYTE > ( 0x50BFB1, 0x0C );
                    MemPutFast < BYTE > ( 0x50BFB2, 0x00 );

                    // Prevent it calling CCamera::ClearPlayerWeaponMode for remote players
                    MemPutFast < BYTE > ( 0x50AB10, 0xC3 );

                    // Prevent it marking targets of remote players
                    MemPutFast < BYTE > ( 0x742BF0, 0xC3 );

                    // this is to prevent shooting players following the local camera
                    MemPutFast < BYTE > ( 0x687099, 0xEB );

                    // Prevent the game making remote player's weapons get switched by the local player's
                    MemPutFast < BYTE > ( 0x60D850, 0xC2 );
                    MemPutFast < BYTE > ( 0x60D851, 0x04 );
                    MemPutFast < BYTE > ( 0x60D852, 0x00 );

                    // Change the local player's stats to the remote player's
                    if ( data )
                    {
                        MemCpyFast ( (void *)0xb79380, data->m_stats.StatTypesFloat, sizeof(float) * MAX_FLOAT_STATS );
                        MemCpyFast ( (void *)0xb79000, data->m_stats.StatTypesInt, sizeof(int) * MAX_INT_STATS );
                        MemCpyFast ( (void *)0xb78f10, data->m_stats.StatReactionValue, sizeof(float) * MAX_REACTION_STATS );
                    }                 

                    /*
                    // ChrML: Force as high stats as we can go before screwing up. Players can't have different
                    //        stats or guns don't work. We can't have dual guns either due to some screwups.
                    //        Dual gun screwup: Sync code needs update and the gun pointing up needs to.
                    float* pfStats = (float*) 0xb79380;
                    pfStats [ 69 ] = 500.0f;
                    pfStats [ 70 ] = 999.0f;
                    pfStats [ 71 ] = 999.0f;
                    pfStats [ 72 ] = 999.0f;
                    pfStats [ 73 ] = 500.0f;
                    pfStats [ 74 ] = 999.0f;
                    pfStats [ 75 ] = 500.0f;
                    pfStats [ 76 ] = 999.0f;
                    pfStats [ 77 ] = 999.0f;
                    pfStats [ 78 ] = 999.0f;
                    pfStats [ 79 ] = 999.0f;
                    */

                    CPedSA* thePedSA = dynamic_cast < CPedSA* > ( thePed );
                    if ( thePedSA )
                    {
                        CEntitySAInterface * ped = thePedSA->GetInterface();
                        MemPutFast < DWORD > ( 0xB7CD98, (DWORD)ped );
                    }

                    // Remember that we're not in the local player's context any more (for switching back)
                    bNotInLocalContext = true;

                    // Call the pre-context switch handler we might have
                    if ( m_pPreContextSwitchHandler )
                    {
                        CPlayerPed* pPlayerPed = dynamic_cast < CPlayerPed* > ( thePed );
                        if ( pPlayerPed )
                            m_pPreContextSwitchHandler ( pPlayerPed );
                    }
                }
            }
        }
        else
        {
            // Set the local players gravity
            pGameInterface->SetGravity ( fLocalPlayerGravity );

            if ( bCustomCameraRotation )
                MemPutFast < float > ( VAR_CameraRotation, fLocalPlayerCameraRotation );
        }
    }
    pGameInterface->OnPedContextChange ( thePed );
}
Пример #5
0
VOID ReturnContextToLocalPlayer()
{   
    if ( bNotInLocalContext )
    {
        // Grab the remote data storage for the player we context switched to
        CPlayerPed* pContextSwitchedPlayerPed = dynamic_cast < CPlayerPed* > ( pContextSwitchedPed );
        if ( pContextSwitchedPlayerPed )
        {
            CRemoteDataStorageSA * data = CRemoteDataSA::GetRemoteDataStorage ( pContextSwitchedPlayerPed );
            if ( data )
            {
                // Store any changes the game has made to the pad
                CPad* pLocalPad = pGameInterface->GetPad ();
                CPadSAInterface* pLocalPadInterface = ( (CPadSA*) pLocalPad )->GetInterface ();
                MemCpyFast ( &data->m_pad, pLocalPadInterface, sizeof ( CPadSAInterface ) );            
            }
        }

        pGameInterface->GetPad()->Restore();
        
        MemPutFast < float > ( VAR_CameraRotation, fLocalPlayerCameraRotation );

        bNotInLocalContext = false;

        CPed* pLocalPlayerPed = pGameInterface->GetPools ()->GetPedFromRef ( (DWORD)1 ); // the player
        CPedSA* pLocalPlayerPedSA = dynamic_cast < CPedSA* > ( pLocalPlayerPed );
        if ( pLocalPlayerPedSA )
        {
            CEntitySAInterface * ped = pLocalPlayerPedSA->GetInterface();
            MemPutFast < DWORD > ( 0xB7CD98, (DWORD)ped );
        }


        PostContextSwitch();
        pGameInterface->OnPedContextChange ( NULL );

        if ( m_pPostContextSwitchHandler )
        {
            m_pPostContextSwitchHandler ();
        }        
    }
    else
    {
        // Store any changes to the local-players stats?
        if ( !bLocalStatsStatic )
        {
            assert ( 0 );   // bLocalStatsStatic is always true
            MemCpyFast ( &localStatsData.StatTypesFloat, (void *)0xb79380, sizeof(float) * MAX_FLOAT_STATS );
            MemCpyFast ( &localStatsData.StatTypesInt, (void *)0xb79000, sizeof(int) * MAX_INT_STATS );
            MemCpyFast ( &localStatsData.StatReactionValue, (void *)0xb78f10, sizeof(float) * MAX_REACTION_STATS );
        }
    }

    // radio change on startup hack
    //0050237C   90               NOP
    MemSetFast ((void *)0x50237C, 0x90, 5);
    MemSetFast ((void *)0x5023A3, 0x90, 5);

    // We need to set this back, even if its the local player
    pGameInterface->SetGravity ( fGlobalGravity );
}
Пример #6
0
CPlayerPedSA::CPlayerPedSA( ePedModel pedType )
{
    DEBUG_TRACE("CPlayerPedSA::CPlayerPedSA( ePedModel pedType )");
    // based on CPlayerPed::SetupPlayerPed (R*)
    DWORD CPedOperatorNew = FUNC_CPedOperatorNew;
    DWORD CPlayerPedConstructor = FUNC_CPlayerPedConstructor;

    DWORD dwPedPointer = 0;
    _asm
    {
        push    SIZEOF_CPLAYERPED
        call    CPedOperatorNew
        add     esp, 4

        mov     dwPedPointer, eax

        mov     ecx, eax
        push    0 // set to 0 and they'll behave like AI peds
        push    1
        call    CPlayerPedConstructor
    }

    this->SetInterface((CEntitySAInterface *)dwPedPointer);

    this->Init(); // init our interfaces 
    CPoolsSA * pools = (CPoolsSA *)pGame->GetPools ( );
    this->internalID =  pools->GetPedRef ( (DWORD *)this->GetInterface () );
    CWorldSA * world = (CWorldSA *)pGame->GetWorld();
    
    this->SetModelIndex(pedType);
    this->BeingDeleted = FALSE;
    this->DoNotRemoveFromGame = FALSE;
    this->SetType ( PLAYER_PED );

    // Allocate a player data struct and set it as the players
    m_bIsLocal = false;
    m_pData = new CPlayerPedDataSAInterface;

    // Copy the local player data so we're defaulted to something good
    CPlayerPedSA* pLocalPlayerSA = dynamic_cast < CPlayerPedSA* > ( pools->GetPedFromRef ( (DWORD)1 ) );
    if ( pLocalPlayerSA )
        MemCpyFast ( m_pData, ((CPlayerPedSAInterface*)pLocalPlayerSA->GetInterface ())->pPlayerData, sizeof ( CPlayerPedDataSAInterface ) );

    // Replace the player ped data in our ped interface with the one we just created
    GetPlayerPedInterface ()->pPlayerData = m_pData;

    // Set default stuff
    m_pData->m_bRenderWeapon = true;
    m_pData->m_Wanted = pLocalWanted;
    m_pData->m_fSprintEnergy = 1000.0f;

    // Clothes pointers or we'll crash later (TODO: Wrap up with some cloth classes and make it unique per player)
    m_pData->m_pClothes = pLocalClothes;

    // Not sure why was this here (svn blame reports that this line came from the old SVN),
    // but it's causing a bug in what the just streamed-in players that are in the air are
    // processed as if they would be standing on some surface, screwing velocity calculations
    // for players floating in air (using superman script, for example) because GTA:SA will
    // try to apply the floor friction to their velocity.
    //SetIsStanding ( true );

    GetPlayerPedInterface ()->pedFlags.bCanBeShotInVehicle = true;
    GetPlayerPedInterface ()->pedFlags.bTestForShotInVehicle = true;
    // Stop remote players targeting eachother, this also stops the local player targeting them (needs to be fixed)
    GetPlayerPedInterface ()->pedFlags.bNeverEverTargetThisPed = true;
    GetPlayerPedInterface ()->pedFlags.bIsLanding = false;
    GetPlayerPedInterface ()->fRotationSpeed = 7.5;
    m_pInterface->bStreamingDontDelete = true;
    m_pInterface->bDontStream = true;
    world->Add ( m_pInterface, CPlayerPed_Constructor );
}
////////////////////////////////////////////////////////////////
//
// CRenderWareSA::ModelInfoTXDAddTextures
//
// Adds texture into the TXD of a model.
// Returns true if model was affected.
//
////////////////////////////////////////////////////////////////
bool CRenderWareSA::ModelInfoTXDAddTextures ( SReplacementTextures* pReplacementTextures, ushort usModelId )
{
    // Already done for this modelid?
    if ( ListContains ( pReplacementTextures->usedInModelIds, usModelId ) )
        return false;

    // Get valid textures info for this model
    CModelTexturesInfo* pInfo = GetModelTexturesInfo ( usModelId );
    if ( !pInfo )
        return false;

    // Remember which models this set has been applied to
    pReplacementTextures->usedInModelIds.push_back ( usModelId );

    // Already done for this txd?
    if ( ListContains ( pReplacementTextures->usedInTxdIds, pInfo->usTxdId ) )
        return true;    // Return true as model may need restreaming

    //
    // Add section for this txd
    //
    pReplacementTextures->perTxdList.push_back ( SReplacementTextures::SPerTxd () );
    SReplacementTextures::SPerTxd& perTxdInfo = pReplacementTextures->perTxdList.back ();

    perTxdInfo.usTxdId = pInfo->usTxdId;
    perTxdInfo.bTexturesAreCopies = ( pReplacementTextures->usedInTxdIds.size () > 0 );

    // Copy / clone textures
    for ( std::vector < RwTexture* >::iterator iter = pReplacementTextures->textures.begin () ; iter != pReplacementTextures->textures.end () ; iter++ )
    {
        RwTexture* pNewTexture = *iter;

        // Use a copy if not first txd
        if ( perTxdInfo.bTexturesAreCopies )
        {
            // Reuse the given texture's raster
            RwTexture* pCopyTex = RwTextureCreate ( pNewTexture->raster );

            // Copy over additional properties
            MemCpyFast ( &pCopyTex->name, &pNewTexture->name, RW_TEXTURE_NAME_LENGTH );
            MemCpyFast ( &pCopyTex->mask, &pNewTexture->mask, RW_TEXTURE_NAME_LENGTH );
            pCopyTex->flags = pNewTexture->flags;
            
            pNewTexture = pCopyTex;
        }
        perTxdInfo.usingTextures.push_back ( pNewTexture );
    }

    //
    // Add each texture to the target txd
    //
    for ( std::vector < RwTexture* >::iterator iter = perTxdInfo.usingTextures.begin () ; iter != perTxdInfo.usingTextures.end () ; iter++ )
    {
        RwTexture* pNewTexture = *iter;

        // If there is a name clash with an existing texture, replace it
        RwTexture* pExistingTexture = RwTexDictionaryFindNamedTexture ( pInfo->pTxd, pNewTexture->name );
        if ( pExistingTexture )
        {
            RwTexDictionaryRemoveTexture ( pInfo->pTxd, pExistingTexture );
        }

        // Add the texture
        dassert ( !RwTexDictionaryContainsTexture ( pInfo->pTxd, pNewTexture ) );
        RwTexDictionaryAddTexture ( pInfo->pTxd, pNewTexture );
    }

    // Remember which txds this set has been applied to
    pReplacementTextures->usedInTxdIds.push_back ( pInfo->usTxdId );
    dassert ( !ListContains ( pInfo->usedByReplacements, pReplacementTextures ) );
    pInfo->usedByReplacements.push_back ( pReplacementTextures );
    return true;
}
Пример #8
0
VOID CMarkerSA::SetPosition(CVector* vecPosition)
{
    DEBUG_TRACE("VOID CMarkerSA::SetPosition ( CVector * vecPosition )");
    MemCpyFast(&internalInterface->position, vecPosition, sizeof(CVector));
}