C++ IsTemplate函数代码示例

void CFlashUIFunctionNode::ProcessEvent( EFlowEvent event,SActivationInfo* pActInfo )
{
	if (event == eFE_Activate && IsPortActive(pActInfo, eI_Call))
	{
		int          port = GetDynStartPort();
		SUIArguments args;
		for (TUIParams::const_iterator iter = m_funcDesc.InputParams.Params.begin(); iter != m_funcDesc.InputParams.Params.end(); ++iter)
		{
			GetDynInput( args, *iter, pActInfo, port++ );
		}

		TUIData   res;
		const int instanceId = GetPortInt( pActInfo, eI_InstanceID );

		if (IsTemplate() && !UpdateTmplDesc( GetPortString(pActInfo, eI_TemplateInstanceName), pActInfo ))
			return;

		SPerInstanceCall2< const SUIArguments &, TUIData & > caller;
		caller.Execute(m_pElement, instanceId, functor(*this, &CFlashUIFunctionNode::CallFunction), args, res);

		string out;
		res.GetValueWithConversion( out );
		ActivateOutput( pActInfo, eO_RetVal, out  );

		ActivateOutput( pActInfo, eO_OnCall, true );
	}
}

void UEdGraphNode::PostLoad()
{
	Super::PostLoad();

	// Create Guid if not present (and not CDO)
	if(!NodeGuid.IsValid() && !IsTemplate() && GetLinker() && GetLinker()->IsPersistent() && GetLinker()->IsLoading())
	{
		UE_LOG(LogBlueprint, Warning, TEXT("Node '%s' missing NodeGuid."), *GetPathName());

		// Generate new one
		CreateNewGuid();
	}

	// Duplicating a Blueprint needs to have a new Node Guid generated, which was not occuring before this version
	if(GetLinkerUE4Version() < VER_UE4_POST_DUPLICATE_NODE_GUID)
	{
		// Generate new one
		CreateNewGuid();
	}
	// Moving to the new style comments requires conversion to preserve previous state
	if(GetLinkerUE4Version() < VER_UE4_GRAPH_INTERACTIVE_COMMENTBUBBLES)
	{
		bCommentBubbleVisible = !NodeComment.IsEmpty();
	}
}

void CFlashUIGotoAndPlayBaseNode::GetConfiguration( SFlowNodeConfig &config )
{
	static const SInputPortConfig in_config[] = {
		CreateMovieClipsPort(),
		CreateInstanceIdPort(),
		InputPortConfig_Void( "GotoAndPlay", "GotoAndPlay to frame" ),
		InputPortConfig_Void( "GotoAndStop", "GotoAndStop to frame" ),
		InputPortConfig<int>( "FrameId", -1, "Frame Number, -1 = use FrameName"),
		InputPortConfig<string>( "FrameName", "FrameName, only used if FrameId is set to -1" ),
		InputPortConfig_Void( 0 ),
		{0}
	};

	static const SInputPortConfig in_config_tmpl[] = {
		CreateMovieClipsForTmplPort(),
		CreateInstanceIdPort(),
		CreateTmplInstanceNamePort(),
		InputPortConfig_Void( "GotoAndPlay", "GotoAndPlay to frame" ),
		InputPortConfig_Void( "GotoAndStop", "GotoAndStop to frame" ),
		InputPortConfig<int>( "FrameId", -1, "Frame Number, -1 = use FrameName"),
		InputPortConfig<string>( "FrameName", "FrameName, only used if FrameId is set to -1" ),
		InputPortConfig_Void( 0 ),
	};

	static const SOutputPortConfig out_config[] = {
		OutputPortConfig_Void( "OnGotoAndPlay", "On GotoAndPlay" ),
		OutputPortConfig_Void( "OnGotoAndStop", "On GotoAndStop" ),
		{0}
	};

	config.pInputPorts  =  IsTemplate() ? in_config_tmpl : in_config;
	config.pOutputPorts = out_config;
	config.sDescription = "Access to MovieClips";
	config.SetCategory(EFLN_APPROVED);
}

bool AKUIInterface::Cancel()
{
	IKUICancellable* oCancellable = NULL;
	int32 iLastIndex = 0;
	
	for ( int32 i = arCancellables.Num() - 1; i >= 0; --i )
	{
		if ( arCancellables[ i ].Get() == NULL )
			continue;

		oCancellable = Cast<IKUICancellable>( arCancellables[ i ].Get() );
		iLastIndex = i;
		break;
	}

	arCancellables.SetNum( iLastIndex );

	if ( oCancellable != NULL )
	{
		OnCancel( Cast<UObject>( oCancellable ) );

		if ( !IsTemplate() )
			OnCancelBP( Cast<UObject>( oCancellable ) );

		oCancellable->Cancel();
		return true;
	}

	return false;
}

bool UGASAbility::IsTickable() const
{
	if (IsTemplate())
		return false;

	return bShouldTick;
}

void AKUIInterface::OnMatchEnd()
{
	KUIBroadcastEvent( FKUIInterfaceEvent, EKUIInterfaceContainerEventList::E_MatchEnd );

	if ( !IsTemplate() )
		OnMatchEndBP();
}

void AKUIInterface::AddElement( uint8 iContainer, UKUIInterfaceElement* oElement )
{
	ctRootContainers[ iContainer ]->AddChild( oElement );

	if ( !IsTemplate() )
		OnElementAddedBP( iContainer, oElement );
}

void CFlashUIVariableBaseNode::GetConfiguration( SFlowNodeConfig &config )
{
	static const SInputPortConfig in_config[] = {
		CreateVariablesPort(),
		CreateInstanceIdPort(),
		InputPortConfig_Void( "Set", "Set value" ),
		InputPortConfig_Void( "Get", "Get value" ),
		InputPortConfig_AnyType( "Value", "Value to set" ),
		InputPortConfig_Void( 0 ),
		{0}
	};

	static const SInputPortConfig in_config_tmpl[] = {
		CreateVariablesForTmplPort(),
		CreateInstanceIdPort(),
		CreateTmplInstanceNamePort(),
		InputPortConfig_Void( "Set", "Set value" ),
		InputPortConfig_Void( "Get", "Get value" ),
		InputPortConfig_AnyType( "Value", "Value to set" ),
		InputPortConfig_Void( 0 ),
	};

	static const SOutputPortConfig out_config[] = {
		OutputPortConfig_Void( "OnSet", "On set value" ),
		OutputPortConfig_AnyType( "Value", "Value" ),
		{0}
	};

	config.pInputPorts  =  IsTemplate() ? in_config_tmpl : in_config;
	config.pOutputPorts = out_config;
	config.sDescription = "Access to Variables";
	config.SetCategory(EFLN_APPROVED);
}

void AKUIInterface::SetFocus( UKUIInterfaceContainer* ctNewFocus )
{
	if ( ctFocused.Get() == ctNewFocus )
		return;

	UKUIInterfaceContainer* const ctOldFocus = ctFocused.Get();

	if ( ctOldFocus != NULL )
	{
		FKUIInterfaceEvent stEventInfo( EKUIInterfaceContainerEventList::E_Blur );
		ctOldFocus->SendEvent( stEventInfo );
	}

	this->ctFocused = ctNewFocus;

	if ( ctNewFocus != NULL )
	{
		FKUIInterfaceEvent stEventInfo( EKUIInterfaceContainerEventList::E_Focus );
		ctNewFocus->SendEvent( stEventInfo );
	}

	FKUIInterfaceContainerElementEvent stEventInfo( EKUIInterfaceContainerEventList::E_FocusChange, ctNewFocus );
	BroadcastEvent( stEventInfo );

	if ( !IsTemplate() )
		OnFocusChangeBP( ctOldFocus, ctNewFocus );
}

FByteBulkData* UBodySetup::GetCookedData(FName Format)
{
	if (IsTemplate())
	{
		return NULL;
	}

	IInterface_CollisionDataProvider* CDP = Cast<IInterface_CollisionDataProvider>(GetOuter());

	// If there is nothing to cook or if we are reading data from a cooked package for an asset with no collision, 
	// we want to return here
	if ((AggGeom.ConvexElems.Num() == 0 && CDP == NULL) || !bHasCookedCollisionData)
	{
		return NULL;
	}

	FFormatContainer* UseCookedData = CookedFormatDataOverride ? CookedFormatDataOverride : &CookedFormatData;

	bool bContainedData = UseCookedData->Contains(Format);
	FByteBulkData* Result = &UseCookedData->GetFormat(Format);
#if WITH_PHYSX
	if (!bContainedData)
	{
		if (FPlatformProperties::RequiresCookedData())
		{
			UE_LOG(LogPhysics, Error, TEXT("Attempt to build physics data for %s when we are unable to. This platform requires cooked packages."), *GetPathName());
		}

		if (AggGeom.ConvexElems.Num() == 0 && (CDP == NULL || CDP->ContainsPhysicsTriMeshData(bMeshCollideAll) == false))
		{
			return NULL;
		}

#if WITH_RUNTIME_PHYSICS_COOKING || WITH_EDITOR
		TArray<uint8> OutData;
		FDerivedDataPhysXCooker* DerivedPhysXData = new FDerivedDataPhysXCooker(Format, this);
		if (DerivedPhysXData->CanBuild())
		{
		#if WITH_EDITOR
			GetDerivedDataCacheRef().GetSynchronous(DerivedPhysXData, OutData);
		#elif WITH_RUNTIME_PHYSICS_COOKING
			DerivedPhysXData->Build(OutData);
		#endif
			if (OutData.Num())
			{
				Result->Lock(LOCK_READ_WRITE);
				FMemory::Memcpy(Result->Realloc(OutData.Num()), OutData.GetData(), OutData.Num());
				Result->Unlock();
			}
		}
		else
#endif
		{
			UE_LOG(LogPhysics, Warning, TEXT("Attempt to build physics data for %s when we are unable to."), *GetPathName());
		}
	}
#endif // WITH_PHYSX
	check(Result);
	return Result->GetBulkDataSize() > 0 ? Result : NULL; // we don't return empty bulk data...but we save it to avoid thrashing the DDC
}

void UActorComponent::SetComponentTickEnabled(bool bEnabled)
{
	if (!IsTemplate() && PrimaryComponentTick.bCanEverTick)
	{
		PrimaryComponentTick.SetTickFunctionEnable(bEnabled);
	}
}

UTexture::UTexture(const FObjectInitializer& ObjectInitializer)
	: Super(ObjectInitializer)
{
	SRGB = true;
	Filter = TF_Default;
#if WITH_EDITORONLY_DATA
	AdjustBrightness = 1.0f;
	AdjustBrightnessCurve = 1.0f;
	AdjustVibrance = 0.0f;
	AdjustSaturation = 1.0f;
	AdjustRGBCurve = 1.0f;
	AdjustHue = 0.0f;
	AdjustMinAlpha = 0.0f;
	AdjustMaxAlpha = 1.0f;
	MaxTextureSize = 0; // means no limitation
	MipGenSettings = TMGS_FromTextureGroup;
	CompositeTextureMode = CTM_NormalRoughnessToAlpha;
	CompositePower = 1.0f;
	bUseLegacyGamma = false;
	AlphaCoverageThresholds = FVector4(0, 0, 0, 0);
	PaddingColor = FColor::Black;
	ChromaKeyColor = FColorList::Magenta;
	ChromaKeyThreshold = 1.0f / 255.0f;
	
#endif // #if WITH_EDITORONLY_DATA

	if (FApp::CanEverRender() && !IsTemplate())
	{
		TextureReference.BeginInit_GameThread();
	}
}

void UTexture::PostLoad()
{
	Super::PostLoad();

#if WITH_EDITORONLY_DATA
	if (AssetImportData == nullptr)
	{
		AssetImportData = NewObject<UAssetImportData>(this, TEXT("AssetImportData"));
	}

	if (!SourceFilePath_DEPRECATED.IsEmpty())
	{
		FAssetImportInfo Info;
		Info.Insert(FAssetImportInfo::FSourceFile(SourceFilePath_DEPRECATED));
		AssetImportData->SourceData = MoveTemp(Info);
	}
#endif

	if( !IsTemplate() )
	{
		// Update cached LOD bias.
		UpdateCachedLODBias();

		// The texture will be cached by the cubemap it is contained within on consoles.
		UTextureCube* CubeMap = Cast<UTextureCube>(GetOuter());
		if (CubeMap == NULL)
		{
			// Recreate the texture's resource.
			UpdateResource();
		}
	}
}

void UActorComponent::DoDeferredRenderUpdates_Concurrent()
{
	checkf(!HasAnyFlags(RF_Unreachable), TEXT("%s"), *GetFullName());
	checkf(!IsTemplate(), TEXT("%s"), *GetFullName());
	checkf(!IsPendingKill(), TEXT("%s"), *GetFullName());

	if(!IsRegistered())
	{
		UE_LOG(LogActorComponent, Log, TEXT("UpdateComponent: (%s) Not registered, Aborting."), *GetPathName());
		return;
	}

	if(bRenderStateDirty)
	{
		SCOPE_CYCLE_COUNTER(STAT_PostTickComponentRecreate);
		RecreateRenderState_Concurrent();
		checkf(!bRenderStateDirty, TEXT("Failed to route CreateRenderState_Concurrent (%s)"), *GetFullName());
	}
	else
	{
		SCOPE_CYCLE_COUNTER(STAT_PostTickComponentLW);
		if(bRenderTransformDirty)
		{
			// Update the component's transform if the actor has been moved since it was last updated.
			SendRenderTransform_Concurrent();
		}

		if(bRenderDynamicDataDirty)
		{
			SendRenderDynamicData_Concurrent();
		}
	}
}

void UDataTable::FinishDestroy()
{
    Super::FinishDestroy();
    if(!IsTemplate())
    {
        EmptyTable(); // Free memory when UObject goes away
    }
}