FString UTimelineTemplate::TimelineVariableNameToTemplateName(FName Name) { return Name.ToString() + TEXT("_Template"); }
void UInternationalizationConditioningCommandlet::FLocalizationFile::CompareToCounterpart( TSharedPtr<FLocalizationFile> Other ) { check(Other.IsValid()); FConfigFile* OtherFile = Other->GetFile(); check(Other.IsValid()); check(LocFile != NULL); // Iterate through all sections in the loc file for ( FConfigFile::TIterator SectionIt(*LocFile); SectionIt; ++SectionIt ) { const FString& LocSectionName = SectionIt.Key(); FConfigSection& MySection = SectionIt.Value(); // Skip the [Language] and [Public] sections if( LocSectionName == TEXT("Language") || LocSectionName == TEXT("Public") ) { continue; } // Find this section in the counterpart loc file FConfigSection* OtherSection = OtherFile->Find(LocSectionName); if ( OtherSection != NULL ) { // Iterate through all keys in this section for ( FConfigSection::TIterator It(MySection); It; ++It ) { const FName Propname = It.Key(); const FString& PropValue = It.Value(); FString EscapedPropValue = PropValue.ReplaceQuotesWithEscapedQuotes(); // Find this key in the counterpart loc file FString* OtherValue = OtherSection->Find(Propname); if ( OtherValue != NULL ) { FString EscapedOtherValue = *OtherValue->ReplaceQuotesWithEscapedQuotes(); // If the counterpart has the same value as we do or is empty, the value is untranslated if( OtherValue->IsEmpty() ) { // If the entry is empty we do nothing for the time being. } else if ( PropValue == *OtherValue ) { new(IdenticalProperties) FLocalizationFileEntry( Other->GetFilename(), LocSectionName, Propname.ToString(), EscapedPropValue, EscapedPropValue ); } else { new(TranslatedProperties) FLocalizationFileEntry( Other->GetFilename(), LocSectionName, Propname.ToString(), EscapedPropValue, EscapedOtherValue ); } } else { // The counterpart didn't contain this key new(UnmatchedProperties) FString(LocSectionName + TEXT(".") + Propname.ToString()); } } } else { // The counterpart didn't contain this section new(UnmatchedSections) FString(FPaths::GetBaseFilename(LocFilename) + TEXT(".") + LocSectionName); } } }
void FAssetViewSortManager::SortList(TArray<TSharedPtr<FAssetViewItem>>& AssetItems, const FName& MajorityAssetType) const { //double SortListStartTime = FPlatformTime::Seconds(); TArray<TUniquePtr<FCompareFAssetItemBase>> SortMethod; for (int32 PriorityIdx = 0; PriorityIdx < EColumnSortPriority::Max; PriorityIdx++) { const bool bAscending(SortMode[PriorityIdx] == EColumnSortMode::Ascending); const FName& Tag(SortColumnId[PriorityIdx]); if (Tag == NAME_None) { break; } if (Tag == NameColumnId) { SortMethod.Add(MakeUnique<FCompareFAssetItemByName>(bAscending, Tag)); } else if (Tag == ClassColumnId) { SortMethod.Add(MakeUnique<FCompareFAssetItemByClass>(bAscending, Tag)); } else if (Tag == PathColumnId) { SortMethod.Add(MakeUnique<FCompareFAssetItemByPath>(bAscending, Tag)); } else { // Since this SortData.Tag is not one of preset columns, sort by asset registry tag UObject::FAssetRegistryTag::ETagType TagType = UObject::FAssetRegistryTag::TT_Alphabetical; if (MajorityAssetType != NAME_None) { UClass* Class = FindObject<UClass>(ANY_PACKAGE, *MajorityAssetType.ToString()); if (Class) { UObject* CDO = Class->GetDefaultObject(); if (CDO) { TArray<UObject::FAssetRegistryTag> TagList; CDO->GetAssetRegistryTags(TagList); for (auto TagIt = TagList.CreateConstIterator(); TagIt; ++TagIt) { if (TagIt->Name == Tag) { TagType = TagIt->Type; break; } } } } } if (TagType == UObject::FAssetRegistryTag::TT_Numerical) { // The property is a Num2er, compare using atof SortMethod.Add(MakeUnique<FCompareFAssetItemByTagNumerical>(bAscending, Tag)); } else if (TagType == UObject::FAssetRegistryTag::TT_Dimensional) { // The property is a series of Num2ers representing dimensions, compare by using atof for each Num2er, delimited by an "x" SortMethod.Add(MakeUnique<FCompareFAssetItemByTagDimensional>(bAscending, Tag)); } else { // Unknown or alphabetical, sort alphabetically either way SortMethod.Add(MakeUnique<FCompareFAssetItemByTag>(bAscending, Tag)); } } } // Sort the list... if (SortMethod.Num() > 0) { TUniquePtr<FCompareFAssetItemBase> PrimarySortMethod = MoveTemp(SortMethod[EColumnSortPriority::Primary]); check(PrimarySortMethod); SortMethod.RemoveAt(0); // Move all the comparisons to the primary sort method PrimarySortMethod->SetNextComparisons(SortMethod); AssetItems.Sort(*(PrimarySortMethod.Get())); // Move the comparisons back for ease of cleanup SortMethod = MoveTemp(PrimarySortMethod->GetNextComparisons()); SortMethod.Insert(MoveTemp(PrimarySortMethod), 0); } // Cleanup the methods we no longer need. for (int32 PriorityIdx = 0; PriorityIdx < SortMethod.Num(); PriorityIdx++) { SortMethod[PriorityIdx].Reset(); } SortMethod.Empty(); //UE_LOG(LogContentBrowser, Warning/*VeryVerbose*/, TEXT("FAssetViewSortManager Sort Time: %0.4f seconds."), FPlatformTime::Seconds() - SortListStartTime); }
/** * Construct this widget. Called by the SNew() Slate macro. * * @param InArgs Declaration used by the SNew() macro to construct this widget * @param Factory The factory this menu entry represents */ void Construct( const FArguments& InArgs, UFactory* Factory ) { const FName ClassThumbnailBrushOverride = Factory->GetNewAssetThumbnailOverride(); const FSlateBrush* ClassThumbnail = nullptr; if (ClassThumbnailBrushOverride.IsNone()) { ClassThumbnail = FClassIconFinder::FindThumbnailForClass(Factory->GetSupportedClass()); } else { // Instead of getting the override thumbnail directly from the editor style here get it from the // ClassIconFinder since it may have additional styles registered which can be searched by passing // it as a default with no class to search for. ClassThumbnail = FClassIconFinder::FindThumbnailForClass(nullptr, ClassThumbnailBrushOverride); } FAssetToolsModule& AssetToolsModule = FAssetToolsModule::GetModule(); TWeakPtr<IAssetTypeActions> AssetTypeActions = AssetToolsModule.Get().GetAssetTypeActionsForClass(Factory->GetSupportedClass()); FLinearColor AssetColor = FLinearColor::White; if ( AssetTypeActions.IsValid() ) { AssetColor = AssetTypeActions.Pin()->GetTypeColor(); } ChildSlot [ SNew( SHorizontalBox ) +SHorizontalBox::Slot() .Padding( 4, 0, 0, 0 ) .VAlign(VAlign_Center) .AutoWidth() [ SNew( SOverlay ) +SOverlay::Slot() [ SNew( SBox ) .WidthOverride( InArgs._Width + 4 ) .HeightOverride( InArgs._Height + 4 ) [ SNew( SBorder ) .BorderImage( FEditorStyle::GetBrush("AssetThumbnail.AssetBackground") ) .BorderBackgroundColor(AssetColor.CopyWithNewOpacity(0.3f)) .Padding( 2.0f ) .VAlign( VAlign_Center ) .HAlign( HAlign_Center ) [ SNew( SImage ) .Image( ClassThumbnail ) ] ] ] +SOverlay::Slot() .HAlign(HAlign_Fill) .VAlign(VAlign_Bottom) [ SNew( SBorder ) .BorderImage( FEditorStyle::GetBrush("WhiteBrush") ) .BorderBackgroundColor( AssetColor ) .Padding( FMargin(0, FMath::Max(FMath::CeilToFloat(InArgs._Width*0.025f), 3.0f), 0, 0) ) ] ] +SHorizontalBox::Slot() .VAlign(VAlign_Center) .Padding(4, 0, 4, 0) [ SNew( SVerticalBox ) +SVerticalBox::Slot() .Padding(0, 0, 0, 1) .AutoHeight() [ SNew(STextBlock) .Font( FEditorStyle::GetFontStyle("LevelViewportContextMenu.AssetLabel.Text.Font") ) .Text( Factory->GetDisplayName() ) ] ] ]; SetToolTip(IDocumentation::Get()->CreateToolTip(Factory->GetToolTip(), nullptr, Factory->GetToolTipDocumentationPage(), Factory->GetToolTipDocumentationExcerpt())); }
void AActor::SetActorLabelInternal( const FString& NewActorLabelDirty, bool bMakeGloballyUniqueFName ) { // Clean up the incoming string a bit FString NewActorLabel = NewActorLabelDirty; NewActorLabel.Trim(); NewActorLabel.TrimTrailing(); // First, update the actor label { // Has anything changed? if( FCString::Strcmp( *NewActorLabel, *GetActorLabel() ) != 0 ) { // Store new label Modify(); ActorLabel = NewActorLabel; } } // Next, update the actor's name { // Generate an object name for the actor's label const FName OldActorName = GetFName(); FName NewActorName = MakeObjectNameFromActorLabel( GetActorLabel(), OldActorName ); // Has anything changed? if( OldActorName != NewActorName ) { // Try to rename the object UObject* NewOuter = NULL; // Outer won't be changing ERenameFlags RenFlags = bMakeGloballyUniqueFName ? (REN_DontCreateRedirectors | REN_ForceGlobalUnique) : REN_DontCreateRedirectors; bool bCanRename = Rename( *NewActorName.ToString(), NewOuter, REN_Test | REN_DoNotDirty | REN_NonTransactional | RenFlags ); if( bCanRename ) { // NOTE: Will assert internally if rename fails const bool bWasRenamed = Rename( *NewActorName.ToString(), NewOuter, RenFlags ); } else { // Unable to rename the object. Use a unique object name variant. NewActorName = MakeUniqueObjectName( bMakeGloballyUniqueFName ? ANY_PACKAGE : GetOuter(), GetClass(), NewActorName ); bCanRename = Rename( *NewActorName.ToString(), NewOuter, REN_Test | REN_DoNotDirty | REN_NonTransactional | RenFlags ); if( bCanRename ) { // NOTE: Will assert internally if rename fails const bool bWasRenamed = Rename( *NewActorName.ToString(), NewOuter, RenFlags ); } else { // Unable to rename the object. Oh well, not a big deal. } } } } FPropertyChangedEvent PropertyEvent( FindField<UProperty>( AActor::StaticClass(), "ActorLabel" ) ); PostEditChangeProperty(PropertyEvent); FCoreDelegates::OnActorLabelChanged.Broadcast(this); }
bool FActorFolders::RenameFolderInWorld(UWorld& World, FName OldPath, FName NewPath) { if (OldPath.IsNone() || OldPath == NewPath || PathIsChildOf(NewPath.ToString(), OldPath.ToString())) { return false; } const FScopedTransaction Transaction(LOCTEXT("UndoAction_RenameFolder", "Rename Folder")); const FString OldPathString = OldPath.ToString(); const FString NewPathString = NewPath.ToString(); TSet<FName> RenamedFolders; // Move any folders we currently hold - old ones will be deleted later UEditorActorFolders& FoldersInWorld = GetOrCreateFoldersForWorld(World); FoldersInWorld.Modify(); auto ExistingFoldersCopy = FoldersInWorld.Folders; for (const auto& Pair : ExistingFoldersCopy) { auto Path = Pair.Key; const FString FolderPath = Path.ToString(); if (OldPath == Path || PathIsChildOf(FolderPath, OldPathString)) { const FName NewFolder = OldPathToNewPath(OldPathString, NewPathString, FolderPath); if (!FoldersInWorld.Folders.Contains(NewFolder)) { // Use the existing properties for the folder if we have them if (FActorFolderProps* ExistingProperties = FoldersInWorld.Folders.Find(Path)) { FoldersInWorld.Folders.Add(NewFolder, *ExistingProperties); } else { // Otherwise use default properties FoldersInWorld.Folders.Add(NewFolder); } OnFolderCreate.Broadcast(World, NewFolder); } RenamedFolders.Add(Path); } } // Now that we have folders created, move any actors that ultimately reside in that folder too for (auto ActorIt = FActorIterator(&World); ActorIt; ++ActorIt) { const FName& OldActorPath = ActorIt->GetFolderPath(); AActor* Actor = *ActorIt; if (OldActorPath.IsNone()) { continue; } if (Actor->GetFolderPath() == OldPath || PathIsChildOf(OldActorPath.ToString(), OldPathString)) { RenamedFolders.Add(OldActorPath); ActorIt->SetFolderPath(OldPathToNewPath(OldPathString, NewPathString, OldActorPath.ToString())); } } // Cleanup any old folders for (const auto& Path : RenamedFolders) { FoldersInWorld.Folders.Remove(Path); OnFolderDelete.Broadcast(World, Path); } return RenamedFolders.Num() != 0; }
/** Build the streamed audio. This function is safe to call from any thread. */ void BuildStreamedAudio() { GetStreamedAudioDerivedDataKeySuffix(SoundWave, AudioFormatName, KeySuffix); DerivedData->Chunks.Empty(); ITargetPlatformManagerModule* TPM = GetTargetPlatformManager(); const IAudioFormat* AudioFormat = NULL; if (TPM) { AudioFormat = TPM->FindAudioFormat(AudioFormatName); } if (AudioFormat) { DerivedData->AudioFormat = AudioFormatName; FByteBulkData* CompressedData = SoundWave.GetCompressedData(AudioFormatName); if (CompressedData) { TArray<uint8> CompressedBuffer; CompressedBuffer.Empty(CompressedData->GetBulkDataSize()); CompressedBuffer.AddUninitialized(CompressedData->GetBulkDataSize()); void* BufferData = CompressedBuffer.GetData(); CompressedData->GetCopy(&BufferData, false); TArray<TArray<uint8>> ChunkBuffers; if (AudioFormat->SplitDataForStreaming(CompressedBuffer, ChunkBuffers)) { for (int32 ChunkIndex = 0; ChunkIndex < ChunkBuffers.Num(); ++ChunkIndex) { FStreamedAudioChunk* NewChunk = new(DerivedData->Chunks) FStreamedAudioChunk(); NewChunk->DataSize = ChunkBuffers[ChunkIndex].Num(); NewChunk->BulkData.Lock(LOCK_READ_WRITE); void* NewChunkData = NewChunk->BulkData.Realloc(ChunkBuffers[ChunkIndex].Num()); FMemory::Memcpy(NewChunkData, ChunkBuffers[ChunkIndex].GetData(), ChunkBuffers[ChunkIndex].Num()); NewChunk->BulkData.Unlock(); } } else { // Could not split so copy compressed data into a single chunk FStreamedAudioChunk* NewChunk = new(DerivedData->Chunks) FStreamedAudioChunk(); NewChunk->DataSize = CompressedBuffer.Num(); NewChunk->BulkData.Lock(LOCK_READ_WRITE); void* NewChunkData = NewChunk->BulkData.Realloc(CompressedBuffer.Num()); FMemory::Memcpy(NewChunkData, CompressedBuffer.GetData(), CompressedBuffer.Num()); NewChunk->BulkData.Unlock(); } DerivedData->NumChunks = DerivedData->Chunks.Num(); // Store it in the cache. PutDerivedDataInCache(DerivedData, KeySuffix); } else { UE_LOG(LogAudio, Warning, TEXT("Failed to retrieve compressed data for format %s and soundwave %s"), *AudioFormatName.GetPlainNameString(), *SoundWave.GetPathName() ); } } if (DerivedData->Chunks.Num()) { bool bInlineChunks = (CacheFlags & EStreamedAudioCacheFlags::InlineChunks) != 0; bSucceeded = !bInlineChunks || DerivedData->TryInlineChunkData(); } else { UE_LOG(LogAudio, Warning, TEXT("Failed to build %s derived data for %s"), *AudioFormatName.GetPlainNameString(), *SoundWave.GetPathName() ); } }
std::string ConvertToString(FName name) { std::string t = TCHAR_TO_UTF8(*name.ToString()); return t; }
void ListGroup(FName Group) { FGroupEnable* Found = HighPerformanceEnable.Find(Group); if (Found) { UE_LOG(LogStatGroupEnableManager, Display, TEXT(" %d default %d %s"), !!Found->CurrentEnable, !!Found->DefaultEnable, *Group.ToString()); } }
void FAnimNode_MMDIK::EvaluateBoneTransforms(USkeletalMeshComponent* SkelComp, const FBoneContainer& RequiredBones, FA2CSPose& MeshBases, TArray<FBoneTransform>& OutBoneTransforms) { FVector EffectorLocation(FVector::ZeroVector); FVector JointTargetLocation(FVector::ZeroVector); TEnumAsByte<enum EBoneControlSpace> EffectorLocationSpace(BCS_BoneSpace); TEnumAsByte<enum EBoneControlSpace> JointTargetLocationSpace(BCS_ParentBoneSpace); FTransform UpperLimbCSTransform; FTransform LowerLimbCSTransform; FTransform EndBoneCSTransform; FTransform JointTargetTransform; const float BlendWeight = FMath::Clamp<float>(1.0f, 0.f, 1.f); check(OutBoneTransforms.Num() == 0); const FStringAssetReference& AssetRef = MMDExtendAssetRef.ToStringReference(); UMMDExtendAsset* MMDExtendAssetPtr = MMDExtendAssetRef.Get(); if (MMDExtendAssetPtr == nullptr) { UE_LOG(LogAnimation, Warning, TEXT("FAnimNode_MMDIK::EvaluateBoneTransforms: MMExtendPtr is nullptr!")); return; } for (int32 indexIK = 0; indexIK < MMDExtendAssetPtr->IkInfoList.Num(); indexIK++) { JointTargetLocationSpace = BCS_ParentBoneSpace; // Get indices of the lower and upper limb bones and check validity. bool bInvalidLimb = false; // IKBoneIndex const FName EffectorSpaceBoneName = MMDExtendAssetPtr->IkInfoList[indexIK].IKBoneName; const int32 EffectorSpaceBoneIndex = MMDExtendAssetPtr->IkInfoList[indexIK].IKBoneIndex; const FName EndBoneName = MMDExtendAssetPtr->IkInfoList[indexIK].TargetBoneName; const int32 EndBoneIndex = MMDExtendAssetPtr->IkInfoList[indexIK].TargetBoneIndex; if (EffectorSpaceBoneName.IsEqual(TEXT("左つま先IK")) || EffectorSpaceBoneName.IsEqual(TEXT("右つま先IK"))) { JointTargetLocationSpace = BCS_BoneSpace; } const int32 LowerLimbIndex = RequiredBones.GetParentBoneIndex(EndBoneIndex); if (LowerLimbIndex == INDEX_NONE) { bInvalidLimb = true; } int32 UpperLimbIndex = INDEX_NONE; if (!bInvalidLimb) { UpperLimbIndex = RequiredBones.GetParentBoneIndex(LowerLimbIndex); if (UpperLimbIndex == INDEX_NONE) { bInvalidLimb = true; } } if (!bInvalidLimb) { int32 JointTargetSpaceBoneIndex = INDEX_NONE; if (MMDExtendAssetPtr->IkInfoList[indexIK].ikLinkList.Num() > 0) { JointTargetSpaceBoneIndex = MMDExtendAssetPtr->IkInfoList[indexIK].ikLinkList[0].BoneIndex; } UpperLimbCSTransform = MeshBases.GetComponentSpaceTransform(UpperLimbIndex); LowerLimbCSTransform = MeshBases.GetComponentSpaceTransform(LowerLimbIndex); EndBoneCSTransform = MeshBases.GetComponentSpaceTransform(EndBoneIndex); FTransform JointTargetTransform(JointTargetLocation); FAnimationRuntime::ConvertBoneSpaceTransformToCS(SkelComp, MeshBases, JointTargetTransform, JointTargetSpaceBoneIndex, JointTargetLocationSpace); const FVector RootPos = UpperLimbCSTransform.GetTranslation(); const FVector InitialJointPos = LowerLimbCSTransform.GetTranslation(); const FVector InitialEndPos = EndBoneCSTransform.GetTranslation(); FTransform EffectorTransform(EffectorLocation); FAnimationRuntime::ConvertBoneSpaceTransformToCS(SkelComp, MeshBases, EffectorTransform, EffectorSpaceBoneIndex, EffectorLocationSpace); FVector DesiredPos = EffectorTransform.GetTranslation(); FVector DesiredDelta = DesiredPos - RootPos; float DesiredLength = DesiredDelta.Size(); // Check to handle case where DesiredPos is the same as RootPos. FVector DesiredDir; if (DesiredLength < (float)KINDA_SMALL_NUMBER) { DesiredLength = (float)KINDA_SMALL_NUMBER; DesiredDir = FVector(1, 0, 0); } else { DesiredDir = DesiredDelta / DesiredLength; } FVector JointTargetPos = JointTargetTransform.GetTranslation(); FVector JointTargetDelta = JointTargetPos - RootPos; float JointTargetLength = JointTargetDelta.Size(); // Same check as above, to cover case when JointTarget position is the same as RootPos. FVector JointPlaneNormal, JointBendDir; if (JointTargetLength < (float)KINDA_SMALL_NUMBER) { JointBendDir = FVector(0, 1, 0); JointPlaneNormal = FVector(0, 0, 1); } else { JointPlaneNormal = DesiredDir ^ JointTargetDelta; // If we are trying to point the limb in the same direction that we are supposed to displace the joint in, // we have to just pick 2 random vector perp to DesiredDir and each other. if (JointPlaneNormal.Size() < (float)KINDA_SMALL_NUMBER) { DesiredDir.FindBestAxisVectors(JointPlaneNormal, JointBendDir); } else { JointPlaneNormal.Normalize(); // Find the final member of the reference frame by removing any component of JointTargetDelta along DesiredDir. // This should never leave a zero vector, because we've checked DesiredDir and JointTargetDelta are not parallel. JointBendDir = JointTargetDelta - ((JointTargetDelta | DesiredDir) * DesiredDir); JointBendDir.Normalize(); } } // Find lengths of upper and lower limb in the ref skeleton. // Use actual sizes instead of ref skeleton, so we take into account translation and scaling from other bone controllers. float LowerLimbLength = (InitialEndPos - InitialJointPos).Size(); float UpperLimbLength = (InitialJointPos - RootPos).Size(); float MaxLimbLength = LowerLimbLength + UpperLimbLength; FVector OutEndPos = DesiredPos; FVector OutJointPos = InitialJointPos; // If we are trying to reach a goal beyond the length of the limb, clamp it to something solvable and extend limb fully. if (DesiredLength > MaxLimbLength) { OutEndPos = RootPos + (MaxLimbLength * DesiredDir); OutJointPos = RootPos + (UpperLimbLength * DesiredDir); } else { // So we have a triangle we know the side lengths of. We can work out the angle between DesiredDir and the direction of the upper limb // using the sin rule: const float TwoAB = 2.f * UpperLimbLength * DesiredLength; const float CosAngle = (TwoAB != 0.f) ? ((UpperLimbLength*UpperLimbLength) + (DesiredLength*DesiredLength) - (LowerLimbLength*LowerLimbLength)) / TwoAB : 0.f; // If CosAngle is less than 0, the upper arm actually points the opposite way to DesiredDir, so we handle that. const bool bReverseUpperBone = (CosAngle < 0.f); // If CosAngle is greater than 1.f, the triangle could not be made - we cannot reach the target. // We just have the two limbs double back on themselves, and EndPos will not equal the desired EffectorLocation. if ((CosAngle > 1.f) || (CosAngle < -1.f)) { // Because we want the effector to be a positive distance down DesiredDir, we go back by the smaller section. if (UpperLimbLength > LowerLimbLength) { OutJointPos = RootPos + (UpperLimbLength * DesiredDir); OutEndPos = OutJointPos - (LowerLimbLength * DesiredDir); } else { OutJointPos = RootPos - (UpperLimbLength * DesiredDir); OutEndPos = OutJointPos + (LowerLimbLength * DesiredDir); } } else { // Angle between upper limb and DesiredDir const float Angle = FMath::Acos(CosAngle); // Now we calculate the distance of the joint from the root -> effector line. // This forms a right-angle triangle, with the upper limb as the hypotenuse. const float JointLineDist = UpperLimbLength * FMath::Sin(Angle); // And the final side of that triangle - distance along DesiredDir of perpendicular. // ProjJointDistSqr can't be neg, because JointLineDist must be <= UpperLimbLength because appSin(Angle) is <= 1. const float ProjJointDistSqr = (UpperLimbLength*UpperLimbLength) - (JointLineDist*JointLineDist); // although this shouldn't be ever negative, sometimes Xbox release produces -0.f, causing ProjJointDist to be NaN // so now I branch it. float ProjJointDist = (ProjJointDistSqr>0.f) ? FMath::Sqrt(ProjJointDistSqr) : 0.f; if (bReverseUpperBone) { ProjJointDist *= -1.f; } // So now we can work out where to put the joint! OutJointPos = RootPos + (ProjJointDist * DesiredDir) + (JointLineDist * JointBendDir); } } // Update transform for upper bone. { // Get difference in direction for old and new joint orientations FVector const OldDir = (InitialJointPos - RootPos).GetSafeNormal(); FVector const NewDir = (OutJointPos - RootPos).GetSafeNormal(); // Find Delta Rotation take takes us from Old to New dir FQuat const DeltaRotation = FQuat::FindBetween(OldDir, NewDir); // Rotate our Joint quaternion by this delta rotation UpperLimbCSTransform.SetRotation(DeltaRotation * UpperLimbCSTransform.GetRotation()); // And put joint where it should be. UpperLimbCSTransform.SetTranslation(RootPos); // Order important. First bone is upper limb. OutBoneTransforms.Add(FBoneTransform(UpperLimbIndex, UpperLimbCSTransform)); } // Update transform for lower bone. { // Get difference in direction for old and new joint orientations FVector const OldDir = (InitialEndPos - InitialJointPos).GetSafeNormal(); FVector const NewDir = (OutEndPos - OutJointPos).GetSafeNormal(); // Find Delta Rotation take takes us from Old to New dir FQuat const DeltaRotation = FQuat::FindBetween(OldDir, NewDir); // Rotate our Joint quaternion by this delta rotation LowerLimbCSTransform.SetRotation(DeltaRotation * LowerLimbCSTransform.GetRotation()); // And put joint where it should be. LowerLimbCSTransform.SetTranslation(OutJointPos); // Order important. Second bone is lower limb. OutBoneTransforms.Add(FBoneTransform(LowerLimbIndex, LowerLimbCSTransform)); } // Update transform for end bone. { // Set correct location for end bone. EndBoneCSTransform.SetTranslation(OutEndPos); // Order important. Third bone is End Bone. OutBoneTransforms.Add(FBoneTransform(EndBoneIndex, EndBoneCSTransform)); } OutBoneTransforms.Sort([](const FBoneTransform& A, const FBoneTransform& B) { return A.BoneIndex < B.BoneIndex; }); if (OutBoneTransforms.Num() > 0) { MeshBases.LocalBlendCSBoneTransforms(OutBoneTransforms, BlendWeight); OutBoneTransforms.Empty(); } } } }
virtual TStatId GetHighPerformanceEnableForStat(FName StatShortName, const char* InGroup, const char* InCategory, bool bDefaultEnable, bool bShouldClearEveryFrame, EStatDataType::Type InStatType, TCHAR const* InDescription, bool bCycleStat, FPlatformMemory::EMemoryCounterRegion MemoryRegion = FPlatformMemory::MCR_Invalid) override { FScopeLock ScopeLock(&SynchronizationObject); FStatNameAndInfo LongName(StatShortName, InGroup, InCategory, InDescription, InStatType, bShouldClearEveryFrame, bCycleStat, MemoryRegion); FName Stat = LongName.GetEncodedName(); FName Group(InGroup); FGroupEnable* Found = HighPerformanceEnable.Find(Group); if (Found) { if (Found->DefaultEnable != bDefaultEnable) { UE_LOG(LogStatGroupEnableManager, Fatal, TEXT("Stat group %s was was defined both on and off by default."), *Group.ToString()); } TStatIdData** StatFound = Found->NamesInThisGroup.Find( Stat ); TStatIdData** StatFoundAlways = Found->AlwaysEnabledNamesInThisGroup.Find( Stat ); if( StatFound ) { if( StatFoundAlways ) { UE_LOG( LogStatGroupEnableManager, Fatal, TEXT( "Stat %s is both always enabled and not always enabled, so it was used for two different things." ), *Stat.ToString() ); } return TStatId( *StatFound ); } else if( StatFoundAlways ) { return TStatId( *StatFoundAlways ); } } else { Found = &HighPerformanceEnable.Add( Group, FGroupEnable( bDefaultEnable || !bShouldClearEveryFrame ) ); // this was set up before we saw the group, so set the enable now if (EnableForNewGroup.Contains(Group)) { Found->CurrentEnable = EnableForNewGroup.FindChecked(Group); EnableForNewGroup.Remove(Group); // by definition, we will never need this again } else if (UseEnableForNewGroups) { Found->CurrentEnable = EnableForNewGroups; } } if (PendingCount < 1) { PendingStatIds = new TStatIdData[NUM_PER_BLOCK]; FMemory::Memzero( PendingStatIds, NUM_PER_BLOCK * sizeof( TStatIdData ) ); PendingCount = NUM_PER_BLOCK; } --PendingCount; TStatIdData* Result = PendingStatIds; const FString StatDescription = InDescription ? InDescription : StatShortName.GetPlainNameString(); // Get the wide stat description. const int32 StatDescLen = StatDescription.Len() + 1; // We are leaking this. @see STAT_StatDescMemory WIDECHAR* StatDescWide = new WIDECHAR[StatDescLen]; TCString<WIDECHAR>::Strcpy( StatDescWide, StatDescLen, StringCast<WIDECHAR>( *StatDescription ).Get() ); Result->WideString = reinterpret_cast<uint64>(StatDescWide); // Get the ansi stat description. // We are leaking this. @see STAT_StatDescMemory ANSICHAR* StatDescAnsi = new ANSICHAR[StatDescLen]; TCString<ANSICHAR>::Strcpy( StatDescAnsi, StatDescLen, StringCast<ANSICHAR>( *StatDescription ).Get() ); Result->AnsiString = reinterpret_cast<uint64>(StatDescAnsi); MemoryCounter.Add( StatDescLen*(sizeof( ANSICHAR ) + sizeof( WIDECHAR )) ); ++PendingStatIds; if( Found->CurrentEnable ) { EnableStat( Stat, Result ); } if( bShouldClearEveryFrame ) { Found->NamesInThisGroup.Add( Stat, Result ); } else { Found->AlwaysEnabledNamesInThisGroup.Add( Stat, Result ); } return TStatId(Result); }
void USkeleton::UpdateRetargetSource( const FName Name ) { FReferencePose * PoseFound = AnimRetargetSources.Find(Name); if (PoseFound) { USkeletalMesh * ReferenceMesh = PoseFound->ReferenceMesh; // reference mesh can be deleted after base pose is created, don't update it if it's not there. if(ReferenceMesh) { const TArray<FTransform>& MeshRefPose = ReferenceMesh->RefSkeleton.GetRefBonePose(); const TArray<FTransform>& SkeletonRefPose = GetReferenceSkeleton().GetRefBonePose(); const TArray<FMeshBoneInfo> & SkeletonBoneInfo = GetReferenceSkeleton().GetRefBoneInfo(); PoseFound->ReferencePose.Empty(SkeletonRefPose.Num()); PoseFound->ReferencePose.AddUninitialized(SkeletonRefPose.Num()); for (int32 SkeletonBoneIndex=0; SkeletonBoneIndex<SkeletonRefPose.Num(); ++SkeletonBoneIndex) { FName SkeletonBoneName = SkeletonBoneInfo[SkeletonBoneIndex].Name; int32 MeshBoneIndex = ReferenceMesh->RefSkeleton.FindBoneIndex(SkeletonBoneName); if (MeshBoneIndex != INDEX_NONE) { PoseFound->ReferencePose[SkeletonBoneIndex] = MeshRefPose[MeshBoneIndex]; } else { PoseFound->ReferencePose[SkeletonBoneIndex] = FTransform::Identity; } } } else { UE_LOG(LogAnimation, Warning, TEXT("Reference Mesh for Retarget Source %s has been removed."), *Name.ToString()); } } }
TSharedPtr<IMediaPlayer> UMediaPlayer::FindPlayerForUrl(const FString& Url, const IMediaOptions& Options) { FName PlayerName = Options.GetDesiredPlayerName(); if (PlayerName == NAME_None) { PlayerName = DesiredPlayerName; } // reuse existing player if desired if (Player.IsValid() && (PlayerName == Player->GetName())) { return Player; } // load media module IMediaModule* MediaModule = FModuleManager::LoadModulePtr<IMediaModule>("Media"); if (MediaModule == nullptr) { UE_LOG(LogMediaAssets, Error, TEXT("Failed to load Media module")); return nullptr; } // try to create desired player if (PlayerName != NAME_None) { IMediaPlayerFactory* Factory = MediaModule->GetPlayerFactory(PlayerName); if (Factory == nullptr) { UE_LOG(LogMediaAssets, Error, TEXT("Could not find desired player %s for %s"), *PlayerName.ToString(), *Url); return nullptr; } TSharedPtr<IMediaPlayer> NewPlayer = Factory->CreatePlayer(); if (!NewPlayer.IsValid()) { UE_LOG(LogMediaAssets, Error, TEXT("Failed to create desired player %s for %s"), *PlayerName.ToString(), *Url); return nullptr; } return NewPlayer; } // try to reuse existing player if (Player.IsValid()) { IMediaPlayerFactory* Factory = MediaModule->GetPlayerFactory(Player->GetName()); if ((Factory != nullptr) && Factory->CanPlayUrl(Url, Options)) { return Player; } } // try to auto-select new player const TArray<IMediaPlayerFactory*>& PlayerFactories = MediaModule->GetPlayerFactories(); const FString RunningPlatformName(FPlatformProperties::IniPlatformName()); for (IMediaPlayerFactory* Factory : PlayerFactories) { if (!Factory->SupportsPlatform(RunningPlatformName) || !Factory->CanPlayUrl(Url, Options)) { continue; } TSharedPtr<IMediaPlayer> NewPlayer = Factory->CreatePlayer(); if (NewPlayer.IsValid()) { return NewPlayer; } } UE_LOG(LogMediaAssets, Error, TEXT("Could not find a native player for %s"), *Url); return nullptr; }
bool SLandscapeEditor::GetIsPropertyVisible(const FPropertyAndParent& PropertyAndParent) const { const UProperty& Property = PropertyAndParent.Property; FEdModeLandscape* LandscapeEdMode = GetEditorMode(); if (LandscapeEdMode != NULL && LandscapeEdMode->CurrentTool != NULL) { if (Property.HasMetaData("ShowForMask")) { const bool bMaskEnabled = LandscapeEdMode->CurrentTool && LandscapeEdMode->CurrentTool->SupportsMask() && LandscapeEdMode->CurrentToolTarget.LandscapeInfo.IsValid() && LandscapeEdMode->CurrentToolTarget.LandscapeInfo->SelectedRegion.Num() > 0; if (bMaskEnabled) { return true; } } if (Property.HasMetaData("ShowForTools")) { const FName CurrentToolName = LandscapeEdMode->CurrentTool->GetToolName(); TArray<FString> ShowForTools; Property.GetMetaData("ShowForTools").ParseIntoArray(&ShowForTools, TEXT(","), true); if (!ShowForTools.Contains(CurrentToolName.ToString())) { return false; } } if (Property.HasMetaData("ShowForBrushes")) { const FName CurrentBrushSetName = LandscapeEdMode->LandscapeBrushSets[LandscapeEdMode->CurrentBrushSetIndex].BrushSetName; // const FName CurrentBrushName = LandscapeEdMode->CurrentBrush->GetBrushName(); TArray<FString> ShowForBrushes; Property.GetMetaData("ShowForBrushes").ParseIntoArray(&ShowForBrushes, TEXT(","), true); if (!ShowForBrushes.Contains(CurrentBrushSetName.ToString())) //&& !ShowForBrushes.Contains(CurrentBrushName.ToString()) { return false; } } if (Property.HasMetaData("ShowForTargetTypes")) { static const TCHAR* TargetTypeNames[] = { TEXT("Heightmap"), TEXT("Weightmap"), TEXT("Visibility") }; TArray<FString> ShowForTargetTypes; Property.GetMetaData("ShowForTargetTypes").ParseIntoArray(&ShowForTargetTypes, TEXT(","), true); const ELandscapeToolTargetType::Type CurrentTargetType = LandscapeEdMode->CurrentToolTarget.TargetType; if (CurrentTargetType == ELandscapeToolTargetType::Invalid || ShowForTargetTypes.FindByKey(TargetTypeNames[CurrentTargetType]) == nullptr) { return false; } } return true; } return false; }
void UOnlineSessionClient::OnDestroyForJoinSessionComplete(FName SessionName, bool bWasSuccessful) { UE_LOG(LogOnline, Verbose, TEXT("OnDestroyForJoinSessionComplete %s bSuccess: %d"), *SessionName.ToString(), bWasSuccessful); IOnlineSessionPtr SessionInt = GetSessionInt(); if (SessionInt.IsValid()) { SessionInt->ClearOnDestroySessionCompleteDelegate_Handle(OnDestroyForJoinSessionCompleteDelegateHandle); } if (bWasSuccessful) { JoinSession(SessionName, CachedSessionResult); } bHandlingDisconnect = false; }
/** UI_COMMAND takes long for the compile to optimize */ PRAGMA_DISABLE_OPTIMIZATION void FLevelViewportCommands::RegisterCommands() { UI_COMMAND( ToggleMaximize, "Maximize Viewport", "Toggles the Maximize state of the current viewport", EUserInterfaceActionType::ToggleButton, FInputChord() ); UI_COMMAND( ToggleGameView, "Game View", "Toggles game view. Game view shows the scene as it appears in game", EUserInterfaceActionType::ToggleButton, FInputChord( EKeys::G ) ); UI_COMMAND( ToggleImmersive, "Immersive Mode", "Switches this viewport between immersive mode and regular mode", EUserInterfaceActionType::ToggleButton, FInputChord( EKeys::F11 ) ); UI_COMMAND( CreateCamera, "Create Camera Here", "Creates a new camera actor at the current location of this viewport's camera", EUserInterfaceActionType::Button, FInputChord() ); UI_COMMAND( HighResScreenshot, "High Resolution Screenshot...", "Opens the control panel for high resolution screenshots", EUserInterfaceActionType::Button, FInputChord() ); UI_COMMAND( UseDefaultShowFlags, "Use Defaults", "Resets all show flags to default", EUserInterfaceActionType::Button, FInputChord() ); UI_COMMAND( PilotSelectedActor, "Pilot Selected Actor", "Move the selected actor around using the viewport controls, and bind the viewport to the actor's location and orientation.", EUserInterfaceActionType::Button, FInputChord( EModifierKey::Control | EModifierKey::Shift, EKeys::P ) ); UI_COMMAND( EjectActorPilot, "Eject from Actor Pilot", "Stop piloting an actor with the current viewport. Unlocks the viewport's position and orientation from the actor the viewport is currently piloting.", EUserInterfaceActionType::Button, FInputChord() ); UI_COMMAND( ToggleActorPilotCameraView, "Actor Pilot Camera View", "Toggles showing the exact camera view when using the viewport to pilot a camera", EUserInterfaceActionType::ToggleButton, FInputChord( EModifierKey::Control | EModifierKey::Shift, EKeys::C ) ); UI_COMMAND( ViewportConfig_OnePane, "Layout One Pane", "Changes the viewport arrangement to one pane", EUserInterfaceActionType::ToggleButton, FInputChord() ); UI_COMMAND( ViewportConfig_TwoPanesH, "Layout Two Panes (horizontal)", "Changes the viewport arrangement to two panes, side-by-side", EUserInterfaceActionType::ToggleButton, FInputChord() ); UI_COMMAND( ViewportConfig_TwoPanesV, "Layout Two Panes (vertical)", "Changes the viewport arrangement to two panes, one above the other", EUserInterfaceActionType::ToggleButton, FInputChord() ); UI_COMMAND( ViewportConfig_ThreePanesLeft, "Layout Three Panes (one left, two right)", "Changes the viewport arrangement to three panes, one on the left, two on the right", EUserInterfaceActionType::ToggleButton, FInputChord() ); UI_COMMAND( ViewportConfig_ThreePanesRight, "Layout Three Panes (one right, two left)", "Changes the viewport arrangement to three panes, one on the right, two on the left", EUserInterfaceActionType::ToggleButton, FInputChord() ); UI_COMMAND( ViewportConfig_ThreePanesTop, "Layout Three Panes (one top, two bottom)", "Changes the viewport arrangement to three panes, one on the top, two on the bottom", EUserInterfaceActionType::ToggleButton, FInputChord() ); UI_COMMAND( ViewportConfig_ThreePanesBottom, "Layout Three Panes (one bottom, two top)", "Changes the viewport arrangement to three panes, one on the bottom, two on the top", EUserInterfaceActionType::ToggleButton, FInputChord() ); UI_COMMAND( ViewportConfig_FourPanesLeft, "Layout Four Panes (one left, three right)", "Changes the viewport arrangement to four panes, one on the left, three on the right", EUserInterfaceActionType::ToggleButton, FInputChord() ); UI_COMMAND( ViewportConfig_FourPanesRight, "Layout Four Panes (one right, three left)", "Changes the viewport arrangement to four panes, one on the right, three on the left", EUserInterfaceActionType::ToggleButton, FInputChord() ); UI_COMMAND( ViewportConfig_FourPanesTop, "Layout Four Panes (one top, three bottom)", "Changes the viewport arrangement to four panes, one on the top, three on the bottom", EUserInterfaceActionType::ToggleButton, FInputChord() ); UI_COMMAND( ViewportConfig_FourPanesBottom, "Layout Four Panes (one bottom, three top)", "Changes the viewport arrangement to four panes, one on the bottom, three on the top", EUserInterfaceActionType::ToggleButton, FInputChord() ); UI_COMMAND( ViewportConfig_FourPanes2x2, "Layout Four Panes (2x2)", "Changes the viewport arrangement to four panes, in a 2x2 grid", EUserInterfaceActionType::ToggleButton, FInputChord() ); UI_COMMAND( ApplyMaterialToActor, "Apply Material", "Attempts to apply a dropped material to this object", EUserInterfaceActionType::Button, FInputChord() ); UI_COMMAND( ToggleCinematicPreview, "Toggles Cinematic Preview", "If enabled, allows Matinee or Sequencer previews to play in this viewport", EUserInterfaceActionType::ToggleButton, FInputChord() ); UI_COMMAND( FindInLevelScriptBlueprint, "Find In Level Script", "Finds references of a selected actor in the level script blueprint", EUserInterfaceActionType::Button, FInputChord(EModifierKey::Control, EKeys::K) ); UI_COMMAND( AdvancedSettings, "Advanced Settings...", "Opens the advanced viewport settings", EUserInterfaceActionType::Button, FInputChord()); // Generate a command for each buffer visualization mode { struct FMaterialIterator { const TSharedRef<class FBindingContext> Parent; FLevelViewportCommands::TBufferVisualizationModeCommandMap& CommandMap; FMaterialIterator(const TSharedRef<class FBindingContext> InParent, FLevelViewportCommands::TBufferVisualizationModeCommandMap& InCommandMap) : Parent(InParent) , CommandMap(InCommandMap) { } void ProcessValue(const FString& InMaterialName, const UMaterial* InMaterial, const FText& InDisplayName) { FName ViewportCommandName = *(FString(TEXT("BufferVisualizationMenu")) + InMaterialName); FBufferVisualizationRecord& Record = CommandMap.Add(ViewportCommandName, FBufferVisualizationRecord()); Record.Name = *InMaterialName; const FText MaterialNameText = FText::FromString( InMaterialName ); Record.Command = FUICommandInfoDecl( Parent, ViewportCommandName, MaterialNameText, MaterialNameText ) .UserInterfaceType( EUserInterfaceActionType::RadioButton ) .DefaultChord( FInputChord() ); } }; BufferVisualizationModeCommands.Empty(); FName ViewportCommandName = *(FString(TEXT("BufferVisualizationOverview"))); FBufferVisualizationRecord& OverviewRecord = BufferVisualizationModeCommands.Add(ViewportCommandName, FBufferVisualizationRecord()); OverviewRecord.Name = NAME_None; OverviewRecord.Command = FUICommandInfoDecl( this->AsShared(), ViewportCommandName, LOCTEXT("BufferVisualization", "Overview"), LOCTEXT("BufferVisualization", "Overview") ) .UserInterfaceType( EUserInterfaceActionType::RadioButton ) .DefaultChord( FInputChord() ); FMaterialIterator It(this->AsShared(), BufferVisualizationModeCommands); GetBufferVisualizationData().IterateOverAvailableMaterials(It); } const TArray<FShowFlagData>& ShowFlagData = GetShowFlagMenuItems(); // Generate a command for each show flag for( int32 ShowFlag = 0; ShowFlag < ShowFlagData.Num(); ++ShowFlag ) { const FShowFlagData& SFData = ShowFlagData[ShowFlag]; FFormatNamedArguments Args; Args.Add( TEXT("ShowFlagName"), SFData.DisplayName ); FText LocalizedName; switch( SFData.Group ) { case SFG_Visualize: LocalizedName = FText::Format( LOCTEXT("VisualizeFlagLabel", "Visualize {ShowFlagName}"), Args ); break; default: LocalizedName = FText::Format( LOCTEXT("ShowFlagLabel", "Show {ShowFlagName}"), Args ); break; } //@todo Slate: The show flags system does not support descriptions currently const FText ShowFlagDesc; TSharedPtr<FUICommandInfo> ShowFlagCommand = FUICommandInfoDecl( this->AsShared(), SFData.ShowFlagName, LocalizedName, ShowFlagDesc ) .UserInterfaceType( EUserInterfaceActionType::ToggleButton ) .DefaultChord( SFData.InputChord ) .Icon(SFData.Group == EShowFlagGroup::SFG_Normal ? FSlateIcon(FEditorStyle::GetStyleSetName(), FEditorStyle::Join( GetContextName(), TCHAR_TO_ANSI( *FString::Printf( TEXT(".%s"), *SFData.ShowFlagName.ToString() ) ) ) ) : FSlateIcon()); ShowFlagCommands.Add( FLevelViewportCommands::FShowMenuCommand( ShowFlagCommand, SFData.DisplayName ) ); } // Generate a command for each volume class { UI_COMMAND( ShowAllVolumes, "Show All Volumes", "Shows all volumes", EUserInterfaceActionType::Button, FInputChord() ); UI_COMMAND( HideAllVolumes, "Hide All Volumes", "Hides all volumes", EUserInterfaceActionType::Button, FInputChord() ); TArray< UClass* > VolumeClasses; UUnrealEdEngine::GetSortedVolumeClasses(&VolumeClasses); for( int32 VolumeClassIndex = 0; VolumeClassIndex < VolumeClasses.Num(); ++VolumeClassIndex ) { //@todo Slate: The show flags system does not support descriptions currently const FText VolumeDesc; const FName VolumeName = VolumeClasses[VolumeClassIndex]->GetFName(); FText DisplayName; FEngineShowFlags::FindShowFlagDisplayName( VolumeName.ToString(), DisplayName ); FFormatNamedArguments Args; Args.Add( TEXT("ShowFlagName"), DisplayName ); const FText LocalizedName = FText::Format( LOCTEXT("ShowFlagLabel_Visualize", "Visualize {ShowFlagName}"), Args ); TSharedPtr<FUICommandInfo> ShowVolumeCommand = FUICommandInfoDecl( this->AsShared(), VolumeName, LocalizedName, VolumeDesc ) .UserInterfaceType( EUserInterfaceActionType::ToggleButton ); ShowVolumeCommands.Add( FLevelViewportCommands::FShowMenuCommand( ShowVolumeCommand, DisplayName ) ); } } // Generate a command for show/hide all layers { UI_COMMAND( ShowAllLayers, "Show All Layers", "Shows all layers", EUserInterfaceActionType::Button, FInputChord() ); UI_COMMAND( HideAllLayers, "Hide All Layers", "Hides all layers", EUserInterfaceActionType::Button, FInputChord() ); } // Generate a command for each sprite category { UI_COMMAND( ShowAllSprites, "Show All Sprites", "Shows all sprites", EUserInterfaceActionType::Button, FInputChord() ); UI_COMMAND( HideAllSprites, "Hide All Sprites", "Hides all sprites", EUserInterfaceActionType::Button, FInputChord() ); // get all the known layers // Get a fresh list as GUnrealEd->SortedSpriteInfo may not yet be built. TArray<FSpriteCategoryInfo> SortedSpriteInfo; UUnrealEdEngine::MakeSortedSpriteInfo(SortedSpriteInfo); FString SpritePrefix = TEXT("ShowSprite_"); for( int32 InfoIndex = 0; InfoIndex < SortedSpriteInfo.Num(); ++InfoIndex ) { const FSpriteCategoryInfo& SpriteInfo = SortedSpriteInfo[InfoIndex]; const FName CommandName = FName( *(SpritePrefix + SpriteInfo.Category.ToString()) ); FFormatNamedArguments Args; Args.Add( TEXT("SpriteName"), SpriteInfo.DisplayName ); const FText LocalizedName = FText::Format( NSLOCTEXT("UICommands", "SpriteShowFlagName", "Show {SpriteName} Sprites"), Args ); TSharedPtr<FUICommandInfo> ShowSpriteCommand = FUICommandInfoDecl( this->AsShared(), CommandName, LocalizedName, SpriteInfo.Description ) .UserInterfaceType( EUserInterfaceActionType::ToggleButton ); ShowSpriteCommands.Add( FLevelViewportCommands::FShowMenuCommand( ShowSpriteCommand, SpriteInfo.DisplayName ) ); } } // Generate a command for each Stat category { UI_COMMAND(HideAllStats, "Hide All Stats", "Hides all Stats", EUserInterfaceActionType::Button, FInputChord()); // Bind a listener here for any additional stat commands that get registered later. UEngine::NewStatDelegate.AddRaw(this, &FLevelViewportCommands::HandleNewStat); #if STATS FStatGroupGameThreadNotifier::Get().NewStatGroupDelegate.BindRaw(this, &FLevelViewportCommands::HandleNewStatGroup); #endif } // Map the bookmark index to default key. // If the max bookmark number ever increases the new bookmarks will not have default keys TArray< FKey > NumberKeyNames; NumberKeyNames.Add( EKeys::Zero ); NumberKeyNames.Add( EKeys::One ); NumberKeyNames.Add( EKeys::Two ); NumberKeyNames.Add( EKeys::Three ); NumberKeyNames.Add( EKeys::Four ); NumberKeyNames.Add( EKeys::Five ); NumberKeyNames.Add( EKeys::Six ); NumberKeyNames.Add( EKeys::Seven ); NumberKeyNames.Add( EKeys::Eight ); NumberKeyNames.Add( EKeys::Nine ); for( int32 BookmarkIndex = 0; BookmarkIndex < AWorldSettings::MAX_BOOKMARK_NUMBER; ++BookmarkIndex ) { TSharedRef< FUICommandInfo > JumpToBookmark = FUICommandInfoDecl( this->AsShared(), //Command class FName( *FString::Printf( TEXT( "JumpToBookmark%i" ), BookmarkIndex ) ), //CommandName FText::Format( NSLOCTEXT("LevelEditorCommands", "JumpToBookmark", "Jump to Bookmark {0}"), FText::AsNumber( BookmarkIndex ) ), //Localized label FText::Format( NSLOCTEXT("LevelEditorCommands", "JumpToBookmark_ToolTip", "Moves the viewport to the location and orientation stored at bookmark {0}"), FText::AsNumber( BookmarkIndex ) ) )//Localized tooltip .UserInterfaceType( EUserInterfaceActionType::Button ) //interface type .DefaultChord( FInputChord( NumberKeyNames.IsValidIndex( BookmarkIndex ) ? NumberKeyNames[BookmarkIndex] : EKeys::Invalid ) ); //default chord JumpToBookmarkCommands.Add( JumpToBookmark ); TSharedRef< FUICommandInfo > SetBookmark = FUICommandInfoDecl( this->AsShared(), //Command class FName( *FString::Printf( TEXT( "SetBookmark%i" ), BookmarkIndex ) ), //CommandName FText::Format( NSLOCTEXT("LevelEditorCommands", "SetBookmark", "Set Bookmark {0}"), FText::AsNumber( BookmarkIndex ) ), //Localized label FText::Format( NSLOCTEXT("LevelEditorCommands", "SetBookmark_ToolTip", "Stores the viewports location and orientation in bookmark {0}"), FText::AsNumber( BookmarkIndex ) ) )//Localized tooltip .UserInterfaceType( EUserInterfaceActionType::Button ) //interface type .DefaultChord( FInputChord( EModifierKey::Control, NumberKeyNames.IsValidIndex( BookmarkIndex ) ? NumberKeyNames[BookmarkIndex] : EKeys::Invalid ) ); //default chord SetBookmarkCommands.Add( SetBookmark ); TSharedRef< FUICommandInfo > ClearBookMark = FUICommandInfoDecl( this->AsShared(), //Command class FName( *FString::Printf( TEXT( "ClearBookmark%i" ), BookmarkIndex ) ), //CommandName FText::Format( NSLOCTEXT("LevelEditorCommands", "ClearBookmark", "Clear Bookmark {0}"), FText::AsNumber( BookmarkIndex ) ), //Localized label FText::Format( NSLOCTEXT("LevelEditorCommands", "ClearBookmark_ToolTip", "Clears the viewports location and orientation in bookmark {0}"), FText::AsNumber( BookmarkIndex ) ) )//Localized tooltip .UserInterfaceType( EUserInterfaceActionType::Button ) //interface type .DefaultChord( FInputChord() ); //default chord ClearBookmarkCommands.Add( ClearBookMark ); } UI_COMMAND( ClearAllBookMarks, "Clear All Bookmarks", "Clears all the bookmarks", EUserInterfaceActionType::Button, FInputChord() ); UI_COMMAND( EnablePreviewMesh, "Hold To Enable Preview Mesh", "When held down a preview mesh appears under the cursor", EUserInterfaceActionType::Button, FInputChord(EKeys::Backslash) ); UI_COMMAND( CyclePreviewMesh, "Cycles Preview Mesh", "Cycles available preview meshes", EUserInterfaceActionType::Button, FInputChord( EModifierKey::Shift, EKeys::Backslash ) ); }
bool GetMovementBaseTransform(const UPrimitiveComponent* MovementBase, const FName BoneName, FVector& OutLocation, FQuat& OutQuat) { if (MovementBase) { if (BoneName != NAME_None) { const USkeletalMeshComponent* SkeletalBase = Cast<USkeletalMeshComponent>(MovementBase); if (SkeletalBase) { const int32 BoneIndex = SkeletalBase->GetBoneIndex(BoneName); if (BoneIndex != INDEX_NONE) { const FTransform BoneTransform = SkeletalBase->GetBoneTransform(BoneIndex); OutLocation = BoneTransform.GetLocation(); OutQuat = BoneTransform.GetRotation(); return true; } UE_LOG(LogCharacter, Warning, TEXT("GetMovementBaseTransform(): Invalid bone '%s' for SkeletalMeshComponent base %s"), *BoneName.ToString(), *GetPathNameSafe(MovementBase)); return false; } // TODO: warn if not a skeletal mesh but providing bone index. } // No bone supplied OutLocation = MovementBase->GetComponentLocation(); OutQuat = MovementBase->GetComponentQuat(); return true; } // NULL MovementBase OutLocation = FVector::ZeroVector; OutQuat = FQuat::Identity; return false; }
void CreatureCore::MakeBluePrintPointCache(FName name_in, int32 approximation_level) { auto cur_creature_manager = GetCreatureManager(); if (!cur_creature_manager) { UE_LOG(LogTemp, Warning, TEXT("ACreatureActor::MakeBluePrintPointCache() - ERROR! Could not generate point cache for %s"), *name_in.ToString()); return; } int32 real_approximation_level = approximation_level; if (real_approximation_level <= 0) { real_approximation_level = 1; } else if (real_approximation_level > 10) { real_approximation_level = 10; } cur_creature_manager->MakePointCache(ConvertToString(name_in), real_approximation_level); }
void AHUD::AddHitBox(FVector2D Position, FVector2D Size, FName Name, bool bConsumesInput, int32 Priority) { if( GetHitBoxWithName(Name) == nullptr ) { bool bAdded = false; for (int32 Index = 0; Index < HitBoxMap.Num(); ++Index) { if (HitBoxMap[Index].GetPriority() < Priority) { HitBoxMap.Insert(FHUDHitBox(Position, Size, Name, bConsumesInput, Priority), Index); bAdded = true; break; } } if (!bAdded) { HitBoxMap.Add(FHUDHitBox(Position, Size, Name, bConsumesInput, Priority)); } } else { UE_LOG(LogHUD, Warning, TEXT("Failed to add hitbox named %s as a hitbox with this name already exists"), *Name.ToString()); } }