Yardım gr2 kanat ekleme

  • Konuyu açan Konuyu açan classone45
  • Açılış Tarihi Açılış Tarihi
  • Yanıt Yanıt 0
  • Gösterim Gösterim 45
Konu sahibi bu konuda soru soruyor. Sorusu ile ilgili bilgisi olanların yanıtlamasını bekliyor.
C

classone45

Üye
Üye
Mesaj
40
Çözümler
1
Beğeni
3
Puan
414
Ticaret Puanı
0
Linkleri görebilmek için giriş yap veya kayıt ol.


Bu konudakini eklemeye çalıştım kanatlar 5 saniye hareket etti sonra durdu sunucuda ekli olan kanatlarda böyle oldu yürüyünce karakterin ayakları havada kaldı
bu dosya ile alakalıysa yapabilir misiniz anlatımda yazılan arat yeri bende lycan kısmı çıkıyor bende oraya ekledim ama böyle sorun çıktı bu dosya ile alakalıysa yapıp atabilcek var mı ? teşekkür ederim

anlatım:
Genişlet Daralt Kopyala 
=======================================================================================================================

//Ara
void CActorInstance::AttachWeapon(DWORD dwParentPartIndex, DWORD dwPartIndex, CItemData * pItemData)

//Add to the end of
if (CGrannyLODController* pLODController = m_LODControllerVector[dwPartIndex])
{
    if (CGrannyModelInstance* pWeaponModelInstance = pLODController->GetModelInstance())
    {
        CGraphicThing* pItemGraphicThing = pItemData->GetModelThing();
        if (std::shared_ptr<CGrannyMotion> pItemMotion = pItemGraphicThing->GetMotionPointer(0))
        {
            pWeaponModelInstance->SetMotionPointer(pItemMotion);
        }
    }
}

=======================================================================================================================


//ara : CActorInstance::AttachAcce (sizde bu k�s�m CActorInstance::AttachSash olabilir

//kod blo�unun en sonuna ekle specular 8 f yazar
    if (CGrannyLODController* pLODController = m_LODControllerVector[CRaceData::PART_ACCE])
    {
        if (CGrannyModelInstance* pWeaponModelInstance = pLODController->GetModelInstance())
        {
            CGraphicThing* pItemGraphicThing = pItemData->GetModelThing();
            if (std::shared_ptr<CGrannyMotion> pItemMotion = pItemGraphicThing->GetMotionPointer(0))
            {
                pWeaponModelInstance->SetMotionPointer(pItemMotion);
            }
        }
    }
    
=======================================================================================================================

ActorInstanceAttach:
Genişlet Daralt Kopyala 
#include "StdAfx.h"
#include "../EffectLib/EffectManager.h"
#include "../UserInterface/Locale_inc.h"

#include "ActorInstance.h"
#include "ItemData.h"
#include "ItemManager.h"
#include "RaceData.h"
#include "WeaponTrace.h"
#include "GameLibDefines.h"

BOOL USE_WEAPON_SPECULAR = TRUE;

BOOL USE_VIETNAM_CONVERT_WEAPON_VNUM = FALSE;

DWORD Vietnam_ConvertWeaponVnum(DWORD vnum)
{
    DWORD base = vnum / 10 * 10;
    DWORD rest = vnum % 10;
    switch (base)
    {
    case  10:base = 5000;break;
    case  20:base = 5010;break;
    case  30:base = 5020;break;
    case  40:base = 5030;break;
    case  50:base = 5030;break;
    case  60:base = 5040;break;
    case  70:base = 5040;break;
    case  80:base = 5050;break;
    case  90:base = 5050;break;
    case 100:base = 5060;break;
    case 110:base = 5060;break;
    case 120:base = 5070;break;
    case 130:base = 5070;break;
    case 140:base = 5080;break;
    case 150:base = 5080;break;
    case 160:base = 5090;break;
    case 170:base = 5090;break;
    case 180:base = 5100;break;
    case 190:base = 5100;break;
    case 200:base = 5110;break;
    case 210:base = 5110;break;
    case 220:base = 5120;break;
    case 230:base = 5120;break;
    case 240:base = 5130;break;
    case 250:base = 5130;break;
    case 260:base = 5140;break;
    case 270:base = 5140;break;
    case 280:base = 5150;break;
    case 290:base = 5150;break;
    case 1000:base = 5000;break;
    case 1010:base = 5010;break;
    case 1020:base = 5020;break;
    case 1030:base = 5030;break;
    case 1040:base = 5040;break;
    case 1050:base = 5050;break;
    case 1060:base = 5060;break;
    case 1070:base = 5070;break;
    case 1080:base = 5080;break;
    case 1090:base = 5090;break;
    case 1100:base = 5100;break;
    case 1110:base = 5110;break;
    case 1120:base = 5120;break;
    case 1130:base = 5130;break;
    case 1140:base = 5140;break;
    case 1150:base = 5150;break;
    case 1160:base = 5150;break;
    case 1170:base = 5150;break;
    case 3000:base = 5000;break;
    case 3010:base = 5010;break;
    case 3020:base = 5020;break;
    case 3030:base = 5030;break;
    case 3040:base = 5040;break;
    case 3050:base = 5050;break;
    case 3060:base = 5060;break;
    case 3070:base = 5070;break;
    case 3080:base = 5080;break;
    case 3090:base = 5090;break;
    case 3100:base = 5100;break;
    case 3110:base = 5100;break;
    case 3120:base = 5110;break;
    case 3130:base = 5110;break;
    case 3140:base = 5120;break;
    case 3150:base = 5120;break;
    case 3160:base = 5130;break;
    case 3170:base = 5130;break;
    case 3180:base = 5140;break;
    case 3190:base = 5140;break;
    case 3200:base = 5150;break;
    case 3210:base = 5150;break;
    }
    return base + rest;
}


DWORD CActorInstance::AttachSmokeEffect(DWORD eSmoke)
{
    if (!m_pkCurRaceData)
        return 0;

    DWORD dwSmokeEffectID=m_pkCurRaceData->GetSmokeEffectID(eSmoke);

    return AttachEffectByID(0, m_pkCurRaceData->GetSmokeBone().c_str(), dwSmokeEffectID);
}

bool CActorInstance::__IsLeftHandWeapon(DWORD type)
{
    if (CItemData::WEAPON_DAGGER == type || (CItemData::WEAPON_FAN == type && __IsMountingHorse()))
        return true;
    else if (CItemData::WEAPON_BOW == type)
        return true;
#ifdef ENABLE_WOLFMAN_CHARACTER
    else if (CItemData::WEAPON_CLAW == type)
        return true;
#endif
    else
        return false;
}

bool CActorInstance::__IsRightHandWeapon(DWORD type)
{
    if (CItemData::WEAPON_DAGGER == type || (CItemData::WEAPON_FAN == type && __IsMountingHorse()))
        return true;
    else if (CItemData::WEAPON_BOW == type)
        return false;
#ifdef ENABLE_WOLFMAN_CHARACTER
    else if (CItemData::WEAPON_CLAW == type)
        return true;
#endif
    else
        return true;
}

bool CActorInstance::__IsWeaponTrace(DWORD weaponType)
{
    switch(weaponType)
    {
    case CItemData::WEAPON_BELL:
    case CItemData::WEAPON_FAN:
    case CItemData::WEAPON_BOW:
        return false;
    default:
        return true;

    }
}

void CActorInstance::AttachWeapon(DWORD dwItemIndex,DWORD dwParentPartIndex, DWORD dwPartIndex)
{
    if (dwPartIndex>=CRaceData::PART_MAX_NUM)
        return;

    m_adwPartItemID[dwPartIndex]=dwItemIndex;

    if (USE_VIETNAM_CONVERT_WEAPON_VNUM)
        dwItemIndex = Vietnam_ConvertWeaponVnum(dwItemIndex);

    CItemData * pItemData;
    if (!CItemManager::Instance().GetItemDataPointer(dwItemIndex, &pItemData))
    {
        RegisterModelThing(dwPartIndex, NULL);
        SetModelInstance(dwPartIndex, dwPartIndex, 0);

        RegisterModelThing(CRaceData::PART_WEAPON_LEFT, NULL);
        SetModelInstance(CRaceData::PART_WEAPON_LEFT, CRaceData::PART_WEAPON_LEFT, 0);

        RefreshActorInstance();
        return;
    }

    __DestroyWeaponTrace();
    if (__IsRightHandWeapon(pItemData->GetWeaponType()))
        AttachWeapon(dwParentPartIndex, CRaceData::PART_WEAPON, pItemData);
    if (__IsLeftHandWeapon(pItemData->GetWeaponType()))
        AttachWeapon(dwParentPartIndex, CRaceData::PART_WEAPON_LEFT, pItemData);
}

BOOL CActorInstance::GetAttachingBoneName(DWORD dwPartIndex, const char ** c_pszBoneName)
{
    return m_pkCurRaceData->GetAttachingBoneName(dwPartIndex, c_pszBoneName);
}

#define AUTODETECT_LYCAN_RODNPICK_BONE
void CActorInstance::AttachWeapon(DWORD dwParentPartIndex, DWORD dwPartIndex, CItemData * pItemData)
{
//    assert(m_pkCurRaceData);
    if (!pItemData)
        return;

#if defined(ENABLE_WOLFMAN_CHARACTER) && defined(AUTODETECT_LYCAN_RODNPICK_BONE)
    const char * szBoneName;
    if ((GetRace()==8) && (pItemData->GetType()==CItemData::ITEM_TYPE_ROD || pItemData->GetType()==CItemData::ITEM_TYPE_PICK))
    {
        szBoneName = "equip_right";
    }
    else if (!GetAttachingBoneName(dwPartIndex, &szBoneName))
        return;
#else
    const char * szBoneName;
    if (!GetAttachingBoneName(dwPartIndex, &szBoneName))
        return;
#endif

    if (CRaceData::PART_WEAPON_LEFT == dwPartIndex)
    {
        RegisterModelThing(dwPartIndex, pItemData->GetSubModelThing());
    }
    else
    {
        RegisterModelThing(dwPartIndex, pItemData->GetModelThing());
    }

    for (DWORD i = 0; i < pItemData->GetLODModelThingCount(); ++i)
    {
        CGraphicThing * pThing;

        if (!pItemData->GetLODModelThingPointer(i, &pThing))
            continue;

        RegisterLODThing(dwPartIndex, pThing);
    }

    SetModelInstance(dwPartIndex, dwPartIndex, 0);
    AttachModelInstance(dwParentPartIndex, szBoneName, dwPartIndex);

    if (USE_WEAPON_SPECULAR)
    {
        SMaterialData kMaterialData;
        kMaterialData.pImage = NULL;
        kMaterialData.isSpecularEnable = TRUE;
        kMaterialData.fSpecularPower = pItemData->GetSpecularPowerf();
        kMaterialData.bSphereMapIndex = 1;
        SetMaterialData(dwPartIndex, NULL, kMaterialData);
    }

    // Weapon Trace
    if (__IsWeaponTrace(pItemData->GetWeaponType()))
    {
        CWeaponTrace * pWeaponTrace = CWeaponTrace::New();
        pWeaponTrace->SetWeaponInstance(this, dwPartIndex, szBoneName);
        m_WeaponTraceVector.push_back(pWeaponTrace);
    }
}

void CActorInstance::RenderAllAttachingEffect()
{
    for (const auto& it : m_AttachingEffectList)
        CEffectManager::Instance().RenderOne(it.dwEffectIndex);
}

void  CActorInstance::DettachEffect(DWORD dwEID)
{
    std::list<TAttachingEffect>::iterator i = m_AttachingEffectList.begin();

    while (i != m_AttachingEffectList.end())
    {
        TAttachingEffect & rkAttEft = (*i);

        if (rkAttEft.dwEffectIndex == dwEID)
        {
            i = m_AttachingEffectList.erase(i);
            CEffectManager::Instance().DestroyEffectInstance(dwEID);
        }
        else
        {
            ++i;
        }
    }
}

DWORD CActorInstance::AttachEffectByName(DWORD dwParentPartIndex, const char * c_pszBoneName, const char * c_pszEffectName)
{
    std::string str;
    DWORD dwCRC;
    StringPath(c_pszEffectName, str);
    dwCRC = GetCaseCRC32(str.c_str(), str.length());

    return AttachEffectByID(dwParentPartIndex, c_pszBoneName, dwCRC);
}
#ifdef ENABLE_SKILL_COLOR_SYSTEM
DWORD CActorInstance::AttachEffectByID(DWORD dwParentPartIndex, const char* c_pszBoneName, DWORD dwEffectID, const D3DXVECTOR3* c_pv3Position, DWORD* dwSkillColor)
#else
DWORD CActorInstance::AttachEffectByID(DWORD dwParentPartIndex, const char* c_pszBoneName, DWORD dwEffectID, const D3DXVECTOR3* c_pv3Position)
#endif
{
    TAttachingEffect ae;
    ae.iLifeType = EFFECT_LIFE_INFINITE;
    ae.dwEndTime = 0;
    ae.dwModelIndex = dwParentPartIndex;
    ae.dwEffectIndex = CEffectManager::Instance().GetEmptyIndex();
    ae.isAttaching = TRUE;
    if (c_pv3Position)
    {
        D3DXMatrixTranslation(&ae.matTranslation, c_pv3Position->x, c_pv3Position->y, c_pv3Position->z);
    }
    else
    {
        D3DXMatrixIdentity(&ae.matTranslation);
    }
    CEffectManager& rkEftMgr = CEffectManager::Instance();
#ifdef ENABLE_SKILL_COLOR_SYSTEM
    rkEftMgr.CreateEffectInstance(ae.dwEffectIndex, dwEffectID, dwSkillColor);
#else
    rkEftMgr.CreateEffectInstance(ae.dwEffectIndex, dwEffectID);
#endif

    if (c_pszBoneName)
    {
        int iBoneIndex;

        if (!FindBoneIndex(dwParentPartIndex, c_pszBoneName, &iBoneIndex))
        {
            ae.iBoneIndex = -1;
            //Tracef("Cannot get Bone Index\n");
            //assert(false && "Cannot get Bone Index");
        }
        else
        {
            ae.iBoneIndex = iBoneIndex;
        }
    }
    else
    {
        ae.iBoneIndex = -1;
    }

    m_AttachingEffectList.push_back(ae);

    return ae.dwEffectIndex;
}

void CActorInstance::RefreshActorInstance()
{
    if (!m_pkCurRaceData)
    {
        TraceError("void CActorInstance::RefreshActorInstance() - m_pkCurRaceData=NULL");
        return;
    }

    // This is Temporary place before making the weapon detection system
    // Setup Collison Detection Data
    m_BodyPointInstanceList.clear();
    //m_AttackingPointInstanceList.clear();
    m_DefendingPointInstanceList.clear();

    // Base
    for (DWORD i = 0; i < m_pkCurRaceData->GetAttachingDataCount(); ++i)
    {
        const NRaceData::TAttachingData * c_pAttachingData;

        if (!m_pkCurRaceData->GetAttachingDataPointer(i, &c_pAttachingData))
            continue;

        switch (c_pAttachingData->dwType)
        {
            case NRaceData::ATTACHING_DATA_TYPE_COLLISION_DATA:
            {
                const NRaceData::TCollisionData * c_pCollisionData = c_pAttachingData->pCollisionData;

                TCollisionPointInstance PointInstance;
                if (NRaceData::COLLISION_TYPE_ATTACKING == c_pCollisionData->iCollisionType)
                    continue;

                if (!CreateCollisionInstancePiece(CRaceData::PART_MAIN, c_pAttachingData, &PointInstance))
                    continue;

                switch (c_pCollisionData->iCollisionType)
                {
                    case NRaceData::COLLISION_TYPE_ATTACKING:
                        //m_AttackingPointInstanceList.push_back(PointInstance);
                        break;
                    case NRaceData::COLLISION_TYPE_DEFENDING:
                        m_DefendingPointInstanceList.push_back(PointInstance);
                        break;
                    case NRaceData::COLLISION_TYPE_BODY:
                        m_BodyPointInstanceList.push_back(PointInstance);
                        break;
                }
            }
            break;

            case NRaceData::ATTACHING_DATA_TYPE_EFFECT:
//                if (!m_bEffectInitialized)
//                {
//                    DWORD dwCRC;
//                    StringPath(c_pAttachingData->pEffectData->strFileName);
//                    dwCRC = GetCaseCRC32(c_pAttachingData->pEffectData->strFileName.c_str(),c_pAttachingData->pEffectData->strFileName.length());
//
//                    TAttachingEffect ae;
//                    ae.iLifeType = EFFECT_LIFE_INFINITE;
//                    ae.dwEndTime = 0;
//                    ae.dwModelIndex = 0;
//                    ae.dwEffectIndex = CEffectManager::Instance().GetEmptyIndex();
//                    ae.isAttaching = TRUE;
//                    CEffectManager::Instance().CreateEffectInstance(ae.dwEffectIndex, dwCRC);
//
//                    if (c_pAttachingData->isAttaching)
//                    {
//                        int iBoneIndex;
//                        if (!FindBoneIndex(0,c_pAttachingData->strAttachingBoneName.c_str(), &iBoneIndex))
//                        {
//                            Tracef("Cannot get Bone Index\n");
//                            assert(false/*Cannot get Bone Index*/);
//                        }
//
//                        ae.iBoneIndex = iBoneIndex;
//                    }
//                    else
//                    {
//                        ae.iBoneIndex = -1;
//                    }
//
//                    m_AttachingEffectList.push_back(ae);
//                }

                if (c_pAttachingData->isAttaching)
                {
                    AttachEffectByName(0, c_pAttachingData->strAttachingBoneName.c_str(), c_pAttachingData->pEffectData->strFileName.c_str());
                }
                else
                {
                    AttachEffectByName(0, 0, c_pAttachingData->pEffectData->strFileName.c_str());
                }
                break;

            case NRaceData::ATTACHING_DATA_TYPE_OBJECT:
                break;

            default:
                assert(false/*NOT_IMPLEMENTED*/);
                break;
        }
    }

    for (DWORD j = 0; j < CRaceData::PART_MAX_NUM; ++j)
    {
        if (0 == m_adwPartItemID[j])
            continue;

        CItemData * pItemData;
        if (!CItemManager::Instance().GetItemDataPointer(m_adwPartItemID[j], &pItemData))
            return;

        for (DWORD k = 0; k < pItemData->GetAttachingDataCount(); ++k)
        {
            const NRaceData::TAttachingData * c_pAttachingData;

            if (!pItemData->GetAttachingDataPointer(k, &c_pAttachingData))
                continue;

            switch(c_pAttachingData->dwType)
            {
                case NRaceData::ATTACHING_DATA_TYPE_COLLISION_DATA:
                    {
                        const NRaceData::TCollisionData * c_pCollisionData = c_pAttachingData->pCollisionData;

                        TCollisionPointInstance PointInstance;
                        if (NRaceData::COLLISION_TYPE_ATTACKING == c_pCollisionData->iCollisionType)
                            continue;
                        if (!CreateCollisionInstancePiece(j, c_pAttachingData, &PointInstance))
                            continue;

                        switch (c_pCollisionData->iCollisionType)
                        {
                        case NRaceData::COLLISION_TYPE_ATTACKING:
                            //m_AttackingPointInstanceList.push_back(PointInstance);
                            break;
                        case NRaceData::COLLISION_TYPE_DEFENDING:
                            m_DefendingPointInstanceList.push_back(PointInstance);
                            break;
                        case NRaceData::COLLISION_TYPE_BODY:
                            m_BodyPointInstanceList.push_back(PointInstance);
                            break;
                        }
                    }
                    break;

                case NRaceData::ATTACHING_DATA_TYPE_EFFECT:
                    if (!m_bEffectInitialized)
                    {
                        DWORD dwCRC;
                        StringPath(c_pAttachingData->pEffectData->strFileName);
                        dwCRC = GetCaseCRC32(c_pAttachingData->pEffectData->strFileName.c_str(),c_pAttachingData->pEffectData->strFileName.length());

                        TAttachingEffect ae;
                        ae.iLifeType = EFFECT_LIFE_INFINITE;
                        ae.dwEndTime = 0;
                        ae.dwModelIndex = j;
                        ae.dwEffectIndex = CEffectManager::Instance().GetEmptyIndex();
                        ae.isAttaching = TRUE;
                        CEffectManager::Instance().CreateEffectInstance(ae.dwEffectIndex, dwCRC);

                        int iBoneIndex;
                        if (!FindBoneIndex(j,c_pAttachingData->strAttachingBoneName.c_str(), &iBoneIndex))
                        {
                            Tracef("Cannot get Bone Index\n");
                            assert(false/*Cannot get Bone Index*/);
                        }
                        Tracef("Creating %p %d %d\n", this, j,k);

                        ae.iBoneIndex = iBoneIndex;

                        m_AttachingEffectList.push_back(ae);
                    }
                    break;

                case NRaceData::ATTACHING_DATA_TYPE_OBJECT:
                    break;

                default:
                    assert(false/*NOT_IMPLEMENTED*/);
                    break;
            }
        }
    }

    m_bEffectInitialized = true;
}

void CActorInstance::SetWeaponTraceTexture(const char * szTextureName)
{
    std::vector<CWeaponTrace*>::iterator it;
    for (it = m_WeaponTraceVector.begin(); it != m_WeaponTraceVector.end(); ++it)
    {
        (*it)->SetTexture(szTextureName);
    }
}

void CActorInstance::UseTextureWeaponTrace()
{
    for_each(
            m_WeaponTraceVector.begin(),
            m_WeaponTraceVector.end(),
            std::void_mem_fun(&CWeaponTrace::UseTexture)
            );
}

void CActorInstance::UseAlphaWeaponTrace()
{
    for_each(
            m_WeaponTraceVector.begin(),
            m_WeaponTraceVector.end(),
            std::void_mem_fun(&CWeaponTrace::UseAlpha)
            );
}

void CActorInstance::UpdateAttachingInstances()
{
    CEffectManager& rkEftMgr=CEffectManager::Instance();

    std::list<TAttachingEffect>::iterator it;
    DWORD dwCurrentTime = CTimer::Instance().GetCurrentMillisecond();
    for (it = m_AttachingEffectList.begin(); it!= m_AttachingEffectList.end();)
    {
        if (EFFECT_LIFE_WITH_MOTION == it->iLifeType)
        {
            ++it;
            continue;
        }

        if ((EFFECT_LIFE_NORMAL == it->iLifeType && it->dwEndTime < dwCurrentTime) ||
            !rkEftMgr.IsAliveEffect(it->dwEffectIndex))
        {
            rkEftMgr.DestroyEffectInstance(it->dwEffectIndex);
            it = m_AttachingEffectList.erase(it);
        }
        else
        {
            if (it->isAttaching)
            {
                rkEftMgr.SelectEffectInstance(it->dwEffectIndex);

                if (it->iBoneIndex == -1)
                {
                    D3DXMATRIX matTransform;
                    matTransform = it->matTranslation;
                    matTransform *= m_worldMatrix;
                    rkEftMgr.SetEffectInstanceGlobalMatrix(matTransform);
                }
                else
                {
                    D3DXMATRIX * pBoneMat;
                    if (GetBoneMatrix(it->dwModelIndex, it->iBoneIndex, &pBoneMat))
                    {
                        D3DXMATRIX matTransform;
                        matTransform = *pBoneMat;
                        matTransform *= it->matTranslation;
                        matTransform *= m_worldMatrix;
                        rkEftMgr.SetEffectInstanceGlobalMatrix(matTransform);
                    }
                    else
                    {
                        //TraceError("GetBoneMatrix(modelIndex(%d), boneIndex(%d)).NOT_FOUND_BONE",
                        //    it->dwModelIndex, it->iBoneIndex);
                    }
                }
            }

            ++it;
        }
    }
}

#if defined(ENABLE_GRAPHIC_ON_OFF) || defined(ENABLE_EFFECT_CAMERA_VIEW_FIX)
void CActorInstance::SetActiveAllAttachingEffect()
{
    std::list<TAttachingEffect>::iterator it;
    for (it = m_AttachingEffectList.begin(); it != m_AttachingEffectList.end(); ++it)
    {
        CEffectManager::Instance().ActiveEffectInstance(it->dwEffectIndex);
    }
}

void CActorInstance::SetDeactiveAllAttachingEffect()
{
    std::list<TAttachingEffect>::iterator it;
    for (it = m_AttachingEffectList.begin(); it != m_AttachingEffectList.end(); ++it)
    {
        CEffectManager::Instance().DeactiveEffectInstance(it->dwEffectIndex);
    }
}
#endif

void CActorInstance::ShowAllAttachingEffect()
{
    std::list<TAttachingEffect>::iterator it;
    for(it = m_AttachingEffectList.begin(); it!= m_AttachingEffectList.end();++it)
    {
        CEffectManager::Instance().SelectEffectInstance(it->dwEffectIndex);
        CEffectManager::Instance().ShowEffect();
        CEffectManager::Instance().ReleaseAlwaysHidden();//@DsProject7
    }
}

void CActorInstance::HideAllAttachingEffect()
{
    std::list<TAttachingEffect>::iterator it;
    for(it = m_AttachingEffectList.begin(); it!= m_AttachingEffectList.end();++it)
    {
        CEffectManager::Instance().SelectEffectInstance(it->dwEffectIndex);
        CEffectManager::Instance().HideEffect();
        CEffectManager::Instance().ApplyAlwaysHidden();//@DsProject7
    }
}

void CActorInstance::__ClearAttachingEffect()
{
    m_bEffectInitialized = false;

    std::list<TAttachingEffect>::iterator it;
    for(it = m_AttachingEffectList.begin(); it!= m_AttachingEffectList.end();++it)
    {
        CEffectManager::Instance().DestroyEffectInstance(it->dwEffectIndex);
    }
    m_AttachingEffectList.clear();
}


#ifdef ENABLE_ACCE_SYSTEM
void CActorInstance::AttachAcce(CItemData * pItemData, float fSpecular)
{
    if (!pItemData)
    {
        RegisterModelThing(CRaceData::PART_ACCE, NULL);
        SetModelInstance(CRaceData::PART_ACCE, CRaceData::PART_ACCE, 0);
        RefreshActorInstance();
        return;
    }

    RegisterModelThing(CRaceData::PART_ACCE, pItemData->GetModelThing());
    SetModelInstance(CRaceData::PART_ACCE, CRaceData::PART_ACCE, 0);
    AttachModelInstance(CRaceData::PART_MAIN, "Bip01 Spine2", CRaceData::PART_ACCE);

    if (fSpecular > 0.0f)
    {
        SMaterialData kMaterialData;
        kMaterialData.pImage = NULL;
        kMaterialData.isSpecularEnable = TRUE;
        kMaterialData.fSpecularPower = fSpecular;
        kMaterialData.bSphereMapIndex = 1;
        SetMaterialData(CRaceData::PART_ACCE, NULL, kMaterialData);
    }
}
#endif

void CActorInstance::ChangePart(DWORD dwPartIndex, DWORD dwItemIndex)
{
    m_adwPartItemID[dwPartIndex] = dwItemIndex;
}
 

Benzer konular

S
  • Çözüldü
Çözüldü Başlık Gözükmüyor msm ve item proto paylaşıldı
Yanıt
8
Gösterim
504
SemihSEL
S
Stiglitz
  • Kilitli
  • Çözüldü
Çözüldü Kanser eden bir pack olayı
Yanıt
5
Gösterim
1K
Whistle
Whistle
B
Yardım Gr2 dosyasi metin2 kanat sorunu
Yanıt
0
Gösterim
328
bady
B
Kaiser
  • Kilitli
  • Çözüldü
Çözüldü Kanat Ekleme Hakkında
Yanıt
1
Gösterim
1K
Kaiser
Kaiser
TheAdmin33
Yardım Kanat sistemi
Yanıt
12
Gösterim
643
TheAdmin33
TheAdmin33
Üst