Beispiel #1
0
		Air::U1 MeshEntity::Destroy()
		{
			SAFE_RELEASE_REF(m_pBoundingBoxMaterial);
			SAFE_DELETE(m_pBoxRenderable);
			SAFE_RELEASE_REF(m_pMesh);
			return	true;
		}
			U1 Resource::DestroyHardwareBuff( MeshHDBuffer* pInBuff ){


				SAFE_RELEASE_REF(pInBuff->pVertexDeclare);
				SAFE_RELEASE_REF(pInBuff->pVertexBuff);
				SAFE_RELEASE_REF(pInBuff->pIndexBuff);
				return	true;
			}
Beispiel #3
0
		Air::U1 Section::Destroy()
		{
			if(m_pControl!=NULL)
			{
				OIS::KeyListener*	pKey	=	m_pControl;
				OIS::MouseListener*	pMouse	=	m_pControl;
				Engine::GetGlobalSetting().m_pInputSystem->Remove(pKey);
				Engine::GetGlobalSetting().m_pInputSystem->Remove(pMouse);

			}
			SAFE_RELEASE_REF(m_pControl);
			SAFE_RELEASE_REF(m_pPipeline);
			SAFE_RELEASE_REF(m_pScene);
			return true;
		}
			void Renderer::ReleaseEffect(){
				GlobalSetting&	setting		=	GetGlobalSetting();
				if(m_pImageSet!=NULL){
					m_pImageSet->Destroy();
					delete	m_pImageSet;
					m_pImageSet	=	NULL;
				}
// 				if(m_pMaterial!=NULL){
// 					//这个时候 材质工厂已经释放掉了
// 					RenderSystem::GetSingleton()->DestroyProduct(m_pMaterial);
// 					m_pMaterial	=	NULL;
// 				}
	
				if(m_DrawBuff.m_pVertexDeclare!=NULL){
					m_DrawBuff.m_pVertexDeclare->ReleaseRef();
					m_DrawBuff.m_pVertexDeclare	=	NULL;
				}
	
				SAFE_RELEASE_REF(m_DrawBuff.m_pVertexBuffer[0]);
	
				if(m_pScreenEnt!=NULL){
					//setting.m_pEngine->DestroyProduct(m_pScreenEnt);
					m_pScreenEnt	=	NULL;
				}
			}
Beispiel #5
0
		Air::U1 Actor::Destroy()
		{
			SAFE_RELEASE_REF(m_pHitShape);
			U32 uiSkillCount	=	m_vecSkill.size();
			for(U32 i=0;i<uiSkillCount;i++){
				SAFE_RELEASE_REF(m_vecSkill[i]);
			}
			m_vecSkill.clear();

			SAFE_RELEASE_REF(m_pModel);
			if(m_pNode!=NULL){
				m_pNode->GetParentSceneNode()->RemoveChild(m_pNode,true);
				m_pNode=NULL;
			}
			m_uiLowBodyBoneIndex=0;
			return true;
		}
		Air::U1 TileBaseLight::Release()
		{
			SAFE_DELETE(m_pCSRenderable);
			SAFE_RELEASE_REF(m_pLayerBuffer);
			//StopThread();
			TerminateThread(GetHandle(),-1);
			StopThread();
			return __super::Release();
		}
Beispiel #7
0
		Air::U1 Skill::Destroy()
		{
			SkillTemplate::Info&	stInfo	=	m_pTemplate->GetInfo();
			switch(stInfo.bindType){
			case enSBT_Bone:{
				m_Info.pActor->GetModel()->detachObject(m_pParticle);
							}break;
			case enSBT_Node:{
				m_Info.pActor->GetNode()->detachObject(m_pParticle);
							}break;
			case enSBT_NewNode:{
				m_Info.pActor->GetNode()->detachObject(m_pParticle);
							   }break;
			}
			SAFE_RELEASE_REF(m_pTemplate);
			SAFE_RELEASE_REF(m_pParticle);
			return true;
		}
Beispiel #8
0
		void Actor::SetSkill( U32 uiIndex,Skill* pSkill )
		{
			if(uiIndex>=m_vecSkill.size())
				return;
			Skill* pOldSkill	=	m_vecSkill[uiIndex];
			SAFE_RELEASE_REF(pOldSkill);
			if(pSkill!=NULL){
				pSkill->AddRef();
			}
			m_vecSkill[uiIndex]	=	pSkill;
		}
Beispiel #9
0
		void Actor::SetModelName( CAString& strModelName )
		{
			if(strModelName.empty())
				return;
			SAFE_RELEASE_REF(m_pModel);
			m_Info.strModelName	=	strModelName;
			AnimationModel::Info info;
			info.strTemplate	=	m_Info.strModelName;
			m_pModel	=	EngineSystem::GetSingleton()->CreateProduct<AnimationModel>(m_strProductName,&info);
			m_pModel->SetActionState("stand.CAF");
			m_uiLowBodyBoneIndex	=	m_pModel->GetBoneIndex("BoneWaist");
			m_pNode->CreateChildSceneNode(Float3(0,0,0),Float4(Float3(-1,0,0),1.57))->attachObject(m_pModel);
		}
		void VoxelGenerator::SetParam( U32 uiDepth,float fScale )
		{
			U32 uiOldDepth	=	m_SVOParam.x;
			m_SVOParam.x	=	uiDepth;
			m_SVOParam.y	=	pow(2.0f,m_SVOParam.x);
			m_SVOParam.z	=	pow(2.0f,m_SVOParam.x -1);
			m_SVOParam.w	=	fScale;

			if(uiOldDepth!=uiDepth){
				SAFE_RELEASE_REF(m_pRT);
				RenderTarget::Info rtinfo;
				rtinfo.SetSingleTarget(m_SVOParam.y,m_SVOParam.y,enTFMT_R8G8B8A8_UNORM);

				m_pRT		=	RenderSystem::GetSingleton()->CreateProduct<Render::Target>("SVO_Test",&rtinfo);

			}
		}
		Air::U1 CascadedShadowMap::Release()
		{
			SAFE_RELEASE_REF(m_pShadowDepth);
			SAFE_RELEASE_REF(m_pShadowDepthTemp);
			SAFE_RELEASE_REF(m_pMaskMaterial);
			SAFE_DELETE(m_pQuad);
			SAFE_RELEASE_REF(m_pBlurX);
			SAFE_RELEASE_REF(m_pBlurY);
			U32	uiSize	=	m_vecCSMCamera.size();
			for(U32 i=0;i<uiSize;i++){
				SAFE_RELEASE_REF(m_vecCSMCamera[i]);
			}
			return true;
		}
Beispiel #12
0
// pRoot의 모든 스킬을 읽는다.
XSkillDat* XESkillMng::LoadSkill( TiXmlElement *pRoot, 
							XSkillDat *pParentDat,
							EFFECT *pParentEffect )
{
	XSkillDat *pSkillDat = NULL;
	EFFECT *pEffect = NULL;
	//////////////////////////////////////////////////////////////////////////
	// 먼저 Attribute(폴더가 아닌것)가 있는지 살펴본다.
	TiXmlAttribute *pAttr = pRoot->FirstAttribute();
	if( pAttr )
	{
		const char *cAttrName = pAttr->Name();
		if( cAttrName )
		{
			// 속성이 하나라도 있으면 skillDat객체를 생성한다.
			// Attribute가 있으면 일단 스킬로 인식하고 Dat객체를 생성한다.
			pSkillDat = CreateSkillDat();
			if( pParentDat )
			{
				ID idSkill = pSkillDat->GetidSkill();
				*pSkillDat = *pParentDat;		// 부모의 데이타를 상속받는다.
				pSkillDat->SetidSkill( idSkill );
				_tstring strIdentifier = U82SZ( pRoot->Value() );
				pSkillDat->SetstrIdentifier( strIdentifier );
			}
			// 디폴트 이펙트버퍼도 하나 받는다.
			pEffect = new EFFECT;		
			if( pParentEffect )
				*pEffect = *pParentEffect;
			// 루프 시작
			do 
			{
				const char *cAttrName = pAttr->Name();
				const char *cParam = pAttr->Value();
				if( cAttrName && cAttrName[ 0 ] != '_' )
				{
					XU8LOG( cAttrName );
					XU8LOG( cParam );
					// 변수명과 값을 파싱해서 pSkillDat에 넣는다.
					ParsingAttr( pAttr, cAttrName, cParam, pSkillDat, pEffect );
				}
			} while (( pAttr = pAttr->Next() ));
		}
	}
	
	// pRoot에 폴더가 있는지 찾는다.
	TiXmlElement *pElemChild = pRoot->FirstChildElement();
	if( pElemChild  )
	{
		do 
		{
			// pRoot하의 모든 폴더를 하나씩 꺼낸다.
			const char *cFolderName = pElemChild->Value();
			if( cFolderName && cFolderName[0] != '_' ) {
				XU8LOG( cFolderName );
				//////////////////////////////////////////////////////////////////////////
				// "효과"블럭은 따로 처리
				if( XSAME( pElemChild->Value(), 96 ) ||
					XSAME( pElemChild->Value(), 226 ) )	{ // 효과/발동효과
					if( pSkillDat == NULL ) {
						pSkillDat = CreateSkillDat();
						if( pParentDat ) {
							ID idSkill = pSkillDat->GetidSkill();
							*pSkillDat = *pParentDat;		// 부모의 데이타를 상속받는다.
							pSkillDat->SetidSkill( idSkill );
							_tstring strIdentifier = U82SZ( pRoot->Value() );
							pSkillDat->SetstrIdentifier( strIdentifier );
						}
					}
					EFFECT *pEffBlock = new EFFECT;
					if( pEffect )
						*pEffBlock = *pEffect;	// 하위상속을 위해 내용 복사.
					else
						*pEffBlock = *pParentEffect;		// 스킬블럭에 디폴트 파라메터가 없으면 부모것을 디폴트로 쓴다.

					int numAttr = LoadEffect( pElemChild, pSkillDat, pEffBlock );
					// 효과블럭안에 아무것도 없었으면 지운다.
					if( numAttr == 0 )
						SAFE_DELETE( pEffBlock );
					if( pEffBlock )
						pSkillDat->AddEffect( pEffBlock );
				} else
				if( XSAME( pElemChild->Value(), 235 ) )	{	// 발동조건
					if( pEffect == nullptr ) {
						pEffect = new EFFECT;
						if( pParentEffect )
							*pEffect = *pParentEffect;
					}
					LoadCond( pElemChild, pEffect );
				} else
					if( cFolderName[0] != '_' )		// 스킬이름이 _로 시작되면 읽지 않는다.
					{
						// 그외 폴더는 일단 스킬로 인식한다.
						XSkillDat* pNewSkillDat = NULL;
						pNewSkillDat = LoadSkill( pElemChild,
							( pSkillDat ) ? pSkillDat : pParentDat,
							( pEffect ) ? pEffect : pParentEffect );
						if( pNewSkillDat ) {
							Add( pNewSkillDat );
						}
					}
			}
		} while (( pElemChild = pElemChild->NextSiblingElement() ));
	}
	if( pSkillDat )	{
		// "효과"블럭이 추가된게 있었으면 디폴트용으로 생성되었던 이펙트 블럭은 필요없으므로 지운다.
		if( pSkillDat->GetNumEffect() > 0 ) {
			SAFE_DELETE( pEffect );
		}
		else
		// 효과폴더가 없고 발동파라메터가 지정되지 않은 폴더는 스킬이 아니라고 보고 지운다.
		if( pSkillDat->GetNumEffect() == 0 ) {
			if( pEffect->invokeParameter == 0 && 
				pEffect->invokeState == 0 &&
				pEffect->strInvokeSkill.empty() && 
				pEffect->idInvokeSkill == 0 &&
				pEffect->invokeAbilityMin.size() == 0 &&
				pEffect->invokeJuncture != 99 )	{	// 발동시점:하드코딩
				SAFE_RELEASE_REF( pSkillDat );
				SAFE_DELETE( pEffect );
			} else
				// "효과"블럭으로 추가된게 없고 발동파라메터는 지정되었으면 디폴트 이펙트를 이펙트로 추가한다.
				pSkillDat->AddEffect( pEffect );
		} else {
			XBREAK(1);
		}
		if( pSkillDat )
		{
			XBREAK( pSkillDat->GetTargetEff().IsHave() && pSkillDat->GetTargetEff().m_Loop == xAL_LOOP );
			if( pSkillDat->m_strShootObj.empty() == false && pSkillDat->m_idShootObj == 0 )
				pSkillDat->m_idShootObj = 1;
			// 파라메터 보정
			for( const auto pEffect : pSkillDat->GetlistEffects() ) {
				// 지속시간이 있는데 발동시점이 지정안되면 디폴트로 persist동작을 하도록 수정.(버프라도 지속시간계속 발동하는게 있고 버프받는최초에만 적용되는게 있다, 버프끝날때 발동되는것도 있고.
				if( pEffect->IsDuration() && pEffect->invokeJuncture == xJC_NONE ) {
						pEffect->invokeJuncture = xJC_PERSIST;
				}
				LCONSOLE( !pEffect->IsDuration() && pEffect->invokeJuncture == xJC_PERSIST
						 , "%s", _T("지속시간이 없는스킬인데 지속발동으로 지정되어 있음.") );
				// 발동시점스킬이 지정되어 있다면 발동시점은 무조건 스킬발동시가 된다.
				if( pEffect->strInvokeTimeSkill.empty() == false ) {
					pEffect->invokeJuncture = xJC_INVOKE_SKILL;	// 이걸하지않으면 지속형 스킬이 되어버림.
				}
				// 발동대상우호가 지정되지 않았으면 시전대상우호를 가져다 쓴다.
				if( pEffect->invokefiltFriendship == xfNONESHIP )
					pEffect->invokefiltFriendship = pEffect->castfiltFriendship;
				// 시전거리는 정해졌는데 시전범위타입이 지정되지 않았으면 디폴트로 원형이 됨
				if( pEffect->castSize.w > 0.f && pEffect->castSize.h > 0.f &&
					pEffect->castTargetRange == xTR_ONE )
					pEffect->castTargetRange = xTR_LINE;
				if( pEffect->castSize.w > 0.f && 
					pEffect->castTargetRange == xTR_ONE )
					pEffect->castTargetRange = xTR_CIRCLE;
				if( pEffect->invokeTarget == xIVT_NONE )
					pEffect->invokeTarget = xIVT_CAST_TARGET;
				if( pEffect->invokeTarget == xIVT_CAST_TARGET_RADIUS 
						|| pEffect->invokeTarget == xIVT_CAST_TARGET_SURROUND ) {
					if( pEffect->IsHaveInvokeSize() == false )
						XALERT("스킬\"%s\":발동범위가 지정되지 않음", pSkillDat->GetstrIdentifier().c_str() );
				}
				// 지속시간스킬이면서 발동스킬이 있는건 에러(매프레임 스킬을 발동시키게 됨)
				XBREAK( pEffect->IsDuration() 
								&& pEffect->secInvokeDOT == 0 
								&& pEffect->invokeJuncture == xJC_PERSIST
								&& !pEffect->strInvokeSkill.empty() );
				XBREAK( pEffect->castTarget == xCST_BASE_TARGET_POS			// 시전대상이 좌표형
								&& pEffect->IsDuration()												// 지속시간형
								&& pEffect->m_PersistEff.IsEmpty() );						// 일때 지속효과 spr이 없으면 안됨.(투명 객체됨)
				AdjustEffectParam( pSkillDat, pEffect );	// virtual
			} // for effect
		}
	} else {
		SAFE_DELETE( pEffect );
	}
	return pSkillDat;
}
		MoveRenderable::~MoveRenderable()
		{
			SAFE_RELEASE_REF(m_DrawBuff.m_pVertexBuffer[0]);
			SAFE_RELEASE_REF(m_DrawBuff.m_pVertexDeclare);
			SAFE_RELEASE_REF(m_DrawBuff.m_pIndexBuff);
		}
				U1 TextureModel::Destroy(){
					SAFE_RELEASE_REF(m_pBoneTexture);
					SAFE_RELEASE_REF(m_pTempBoneTexture);
					return	__super::Destroy();
				}