C++ (Cpp) IParamMap2::Invalidate 예제들

예제 #1

파일: PFTestGoToRotation.cpp 프로젝트: artemeliy/inf4715

void PFTestGoToRotation::UpdatePViewUI(ParamID updateID) const
{
	for(int i=0; i<NumPViewParamMaps(); i++) {
		IParamMap2* map = GetPViewParamMap(i);
		map->Invalidate(updateID);
		Interval currentTimeInterval;
		currentTimeInterval.SetInstant(GetCOREInterface()->GetTime());
		map->Validity() = currentTimeInterval;
	}
}

예제 #2

파일: PFOperatorForceSpaceWarp.cpp 프로젝트: artemeliy/inf4715

//+--------------------------------------------------------------------------+
//|							From ReferenceMaker								 |
//+--------------------------------------------------------------------------+
void PFOperatorForceSpaceWarp::UpdatePViewUI(IParamBlock2* pblock, ParamID updateID)
{
	for(int i=0; i<NumPViewParamMaps(); i++) {
		IParamMap2* map = GetPViewParamMap(i);
		if (pblock != map->GetParamBlock()) continue;
		map->Invalidate(updateID);
		Interval currentTimeInterval;
		currentTimeInterval.SetInstant(GetCOREInterface()->GetTime());
		map->Validity() = currentTimeInterval;
	}
}

예제 #3

void    plAnimStealthNode::SwitchDlg( plAnimStealthNode *toSwitchTo )
{
    IParamMap2 *map = fParamBlock->GetMap();

    fParamBlock->SetMap( nil );
    toSwitchTo->fParamBlock->SetMap( map );

    map->SetParamBlock( toSwitchTo->fParamBlock );
    map->SetThing( (ReferenceTarget *)toSwitchTo );
    map->Invalidate();
    map->UpdateUI( 0 );
}

예제 #4

파일: HLSLShaderMaterial.cpp 프로젝트: ZuqiuMao/HLSLMaterial

RefResult HLSLShaderMaterial::NotifyRefChanged(const Interval& changeInt, RefTargetHandle hTarget, 
   PartID& partID, RefMessage message, BOOL propagate ) 
{
	switch (message) {
		case REFMSG_CHANGE:
			m_iValid.SetEmpty();
			if (hTarget == m_pblock)
			{
				ParamID changing_param = m_pblock->LastNotifyParamID();
				hlslshadermaterial_param_blk.InvalidateUI(changing_param);
				IParamMap2* pMap = m_pblock->GetMap();
				if(pMap != NULL)
					pMap->Invalidate();
			}
			break;

		}
	return REF_SUCCEED;
}

예제 #5

파일: pickmodes.cpp 프로젝트: artemeliy/inf4715

BOOL PickForceMode::Pick(IObjParam* /*ip*/,ViewExp* vpt)
{
	if ( ! vpt || ! vpt->IsAlive())
	{	
		// why are we here?
		DbgAssert(!_T("Doing Pick() on invalid viewport!"));
		return FALSE;
	}

	INode* node = vpt->GetClosestHit();
	if (node)
	{
		dlg->cont->force_pb->Append(jig_force_node, 1, &node);		
		dlg->UpdateForceList();

		IParamMap2* pmap;
		pmap = dlg->cont->force_pb->GetMap();
		if (pmap) pmap->Invalidate(jig_force_node);

		dlg->ip->RedrawViews(dlg->ip->GetTime());
	}
	return FALSE;
}

예제 #6

파일: bhkListObj.cpp 프로젝트: Doommarine23/max_nif_plugin

void bhkListObject::InvalidateUI() 
{
   param_blk.InvalidateUI(pblock2->LastNotifyParamID());
   if (pmapParam) pmapParam->Invalidate();
}

예제 #7

파일: bhkCapsuleObj.cpp 프로젝트: Anchoys1/max_nif_plugin

void bhkCapsuleObject::InvalidateUI() 
{
   if (pmapParam) pmapParam->Invalidate();
}

예제 #8

파일: bhkSphereObj.cpp 프로젝트: blabbatheorange/Nif-Plugin

void bhkSphereObject::InvalidateUI() 
{
   if (pmapParam) pmapParam->Invalidate();
}

예제 #9

파일: blurmgr.cpp 프로젝트: artemeliy/inf4715

RefResult BlurMgr::NotifyRefChanged(Interval changeInt, RefTargetHandle hTarget, PartID& partID, RefMessage message)
{
	ParamID prmID = -1;

	switch (message) {
		case REFMSG_CHANGE:
			if (hTarget == pbMaster)
			{
				pbdMaster.InvalidateUI(pbMaster->LastNotifyParamID());
				return REF_SUCCEED;
			}

			// blur types
			if (hTarget == pbBlurData)
			{
				prmID = pbBlurData->LastNotifyParamID();
				switch (prmID)
				{
					case prmUnifPixRad:
					case prmUnifAlpha:
						m_blurs[idBlurUnif]->notifyPrmChanged(prmID);
						break;
					case prmDirUPixRad:
					case prmDirVPixRad:
					case prmDirUTrail:
					case prmDirVTrail:
					case prmDirRot:
					case prmDirAlpha:
						m_blurs[idBlurDir]->notifyPrmChanged(prmID);
						break;
					case prmRadialPixRad:
					case prmRadialTrail:
					case prmRadialAlpha:
					case prmRadialXOrig:
					case prmRadialYOrig:
					case prmRadialUseNode:
					case prmRadialNode:
						m_blurs[idBlurRadial]->notifyPrmChanged(prmID);
						break;
				}
				IParamMap2 *map = pbBlurData->GetMap();
				if (map)
					map->Invalidate(prmID);
				return REF_SUCCEED;
			}

			// selection types
			if (hTarget == pbSelData)
			{
				prmID = pbSelData->LastNotifyParamID();
				switch (prmID)
				{
					case prmImageActive:
					case prmImageBrighten:
					case prmImageBlend:
						m_sels[idSelImage]->notifyPrmChanged(prmID);
						break;
					case prmIBackActive:
					case prmIBackBrighten:
					case prmIBackBlend:
					case prmIBackFeathRad:
						m_sels[idSelIBack]->notifyPrmChanged(prmID);
						break;
					case prmLumActive:
					case prmLumBrighten:
					case prmLumBlend:
					case prmLumMin:
					case prmLumMax:
					case prmLumFeathRad:
						m_sels[idSelLum]->notifyPrmChanged(prmID);
						break;
					case prmMaskActive:
					case prmMaskMap:
					case prmMaskChannel:
					case prmMaskBrighten:
					case prmMaskBlend:
					case prmMaskMin:
					case prmMaskMax:
					case prmMaskFeathRad:
						m_sels[idSelMask]->notifyPrmChanged(prmID);
						break;
					case prmObjIdsActive:
					case prmObjIdsIds:
					case prmObjIdsBrighten:
					case prmObjIdsBlend:
					case prmObjIdsFeathRad:
					case prmObjIdsLumMin:
					case prmObjIdsLumMax:
						m_sels[idSelObjIds]->notifyPrmChanged(prmID);
						break;
					case prmMatIdsActive:
					case prmMatIdsIds:
					case prmMatIdsBrighten:
					case prmMatIdsBlend:
					case prmMatIdsFeathRad:
					case prmMatIdsLumMin:
					case prmMatIdsLumMax:
						m_sels[idSelMatIds]->notifyPrmChanged(prmID);
						break;
				}
				IParamMap2 *map = pbSelData->GetMap();
				if (map)
					map->Invalidate(prmID);
				return REF_SUCCEED;
			}
	}
	return REF_SUCCEED;
}