void ADynamicWeather::LoadWeatherDescriptionsFromFile(
const FString &MapName,
TArray<FWeatherDescription> &Descriptions)
{
// Try to load config file.
FString DefaultFilePath;
if (GetWeatherIniFilePath(GetIniFileName(), DefaultFilePath)) {
UE_LOG(LogCarla, Log, TEXT("Loading weather description from %s"), *DefaultFilePath);
FIniFile ConfigFile(DefaultFilePath);
{ // Override map specific presets.
FString MapOverridesFilePath;
if (GetWeatherIniFilePath(GetIniFileName(MapName), MapOverridesFilePath)) {
UE_LOG(LogCarla, Log, TEXT("Loading weather description from %s"), *MapOverridesFilePath);
ConfigFile.Combine(MapOverridesFilePath);
}
}
// For every section in the config file add a weather description.
for (auto &Item : ConfigFile.GetFConfigFile()) {
Descriptions.AddDefaulted(1u);
Descriptions.Last().ReadFromConfigFile(ConfigFile, Item.Key);
}
}
// If no description was found, append a defaulted one.
if (Descriptions.Num() == 0) {
UE_LOG(LogCarla, Warning, TEXT("No weather description found"));
Descriptions.AddDefaulted(1u);
Descriptions.Last().Name = TEXT("Default");
}
}
EConvertQueryResult AddSweepResults(bool& OutHasValidBlockingHit, const UWorld* World, int32 NumHits, PxSweepHit* Hits, float CheckLength, const PxFilterData& QueryFilter, TArray<FHitResult>& OutHits, const FVector& StartLoc, const FVector& EndLoc, const PxGeometry& Geom, const PxTransform& QueryTM, float MaxDistance, bool bReturnFaceIndex, bool bReturnPhysMat)
{
OutHits.Reserve(OutHits.Num() + NumHits);
EConvertQueryResult ConvertResult = EConvertQueryResult::Valid;
bool bHadBlockingHit = false;
const PxVec3 PDir = U2PVector((EndLoc - StartLoc).GetSafeNormal());
for(int32 i=0; i<NumHits; i++)
{
PxSweepHit& PHit = Hits[i];
checkSlow(PHit.flags & PxHitFlag::eDISTANCE);
if(PHit.distance <= MaxDistance)
{
PHit.faceIndex = FindFaceIndex(PHit, PDir);
FHitResult& NewResult = OutHits[OutHits.AddDefaulted()];
if (ConvertQueryImpactHit(World, PHit, NewResult, CheckLength, QueryFilter, StartLoc, EndLoc, &Geom, QueryTM, bReturnFaceIndex, bReturnPhysMat) == EConvertQueryResult::Valid)
{
bHadBlockingHit |= NewResult.bBlockingHit;
}
else
{
// Reject invalid result (this should be rare). Remove from the results.
OutHits.Pop(/*bAllowShrinking=*/ false);
ConvertResult = EConvertQueryResult::Invalid;
}
}
}
// Sort results from first to last hit
OutHits.Sort( FCompareFHitResultTime() );
OutHasValidBlockingHit = bHadBlockingHit;
return ConvertResult;
}
bool FGameplayCueTranslationManager::GetTranslatedTags(const FName& ParentTag, TArray<FGameplayCueTranslationEditorInfo>& Children)
{
if (const FGameplayCueTranslatorNode* Node = GetTranslationNodeForName(ParentTag))
{
for (const FGameplayCueTranslationLink& Link : Node->Links)
{
for (int32 LinkIdx=0; LinkIdx < Link.NodeLookup.Num(); ++LinkIdx)
{
const FGameplayCueTranslatorNodeIndex& Index = Link.NodeLookup[LinkIdx];
if (Index != INDEX_NONE)
{
FGameplayCueTranslatorNode& ChildNode = TranslationLUT[Index];
// Find the description of the rule this came from
for (FNameSwapData& SwapData : AllNameSwaps)
{
if (SwapData.ClassCDO == Link.RulesCDO)
{
check(SwapData.NameSwaps.IsValidIndex(LinkIdx));
FGameplayCueTranslationEditorInfo& Info = Children[Children.AddDefaulted()];
Info.GameplayTagName = ChildNode.CachedGameplayTagName;
Info.GameplayTag = ChildNode.CachedGameplayTag;
Info.EditorData = SwapData.NameSwaps[LinkIdx].EditorData;
break;
}
}
}
}
}
}
return Children.Num() > 0;
}
void ConvertRaycastResults(const UWorld* World, int32 NumHits, PxRaycastHit* Hits, float CheckLength, const PxFilterData& QueryFilter, TArray<FHitResult>& OutHits, const FVector& StartLoc, const FVector& EndLoc, bool bReturnFaceIndex, bool bReturnPhysMat)
{
OutHits.Reserve(OutHits.Num() + NumHits);
PxTransform PStartTM(U2PVector(StartLoc));
for(int32 i=0; i<NumHits; i++)
{
FHitResult& NewResult = OutHits[OutHits.AddDefaulted()];
const PxRaycastHit& PHit = Hits[i];
ConvertQueryImpactHit(World, PHit, NewResult, CheckLength, QueryFilter, StartLoc, EndLoc, NULL, PStartTM, bReturnFaceIndex, bReturnPhysMat);
}
// Sort results from first to last hit
OutHits.Sort( FCompareFHitResultTime() );
}
bool FWebSocket::SendText(uint8* Data, uint32 Size)
{
TArray<uint8> Buffer;
#if !PLATFORM_HTML5
Buffer.AddDefaulted(LWS_PRE); // Reserve space for WS header data
#endif
// Buffer.Append((uint8*)&Size, sizeof (uint32)); // insert size.
Buffer.Append((uint8*)Data, Size);
CriticalSection.Lock();
OutgoingBuffer.Add(Buffer);
OutgoingBufferType.Add( LWS_WRITE_TEXT );
CriticalSection.Unlock();
return true;
}
bool AddSweepResults(const UWorld* World, int32 NumHits, const PxSweepHit* Hits, float CheckLength, const PxFilterData& QueryFilter, TArray<FHitResult>& OutHits, const FVector& StartLoc, const FVector& EndLoc, const PxGeometry& Geom, const PxTransform& QueryTM, float MaxDistance, bool bReturnPhysMat)
{
OutHits.Reserve(OutHits.Num() + NumHits);
bool bHadBlockingHit = false;
for(int32 i=0; i<NumHits; i++)
{
const PxSweepHit& PHit = Hits[i];
checkSlow(PHit.flags & PxHitFlag::eDISTANCE);
if(PHit.distance <= MaxDistance)
{
FHitResult& NewResult = OutHits[OutHits.AddDefaulted()];
ConvertQueryImpactHit(World, PHit, NewResult, CheckLength, QueryFilter, StartLoc, EndLoc, &Geom, QueryTM, false, bReturnPhysMat);
bHadBlockingHit |= NewResult.bBlockingHit;
}
}
// Sort results from first to last hit
OutHits.Sort( FCompareFHitResultTime() );
return bHadBlockingHit;
}
void UMediaPlayer::GetOverlays(EMediaOverlayType Type, TArray<FMediaPlayerOverlay>& OutOverlays) const
{
FTimespan CurrentTime = GetTime();
if (CurrentTime == FTimespan::Zero())
{
return;
}
for (const FOverlay& Overlay : Overlays)
{
if ((Overlay.Type == Type) && (Overlay.Time <= CurrentTime) && (CurrentTime - Overlay.Time < Overlay.Duration))
{
const int32 OverlayIndex = OutOverlays.AddDefaulted();
FMediaPlayerOverlay& OutOverlay = OutOverlays[OverlayIndex];
{
OutOverlay.HasPosition = Overlay.Position.IsSet();
OutOverlay.Position = OutOverlay.HasPosition ? Overlay.Position.GetValue() : FIntPoint::ZeroValue;
OutOverlay.Text = Overlay.Text;
}
}
}
}
bool FLocTextHelperTest::RunTest(const FString& Parameters)
{
const int32 NumTestEntries = 100;
const FString TestingPath = FPaths::GameAgnosticSavedDir() / TEXT("LocTextHelperTest_") + FGuid::NewGuid().ToString();
TArray<FString> ForeignCultures;
ForeignCultures.Add(TEXT("fr"));
ForeignCultures.Add(TEXT("de"));
FLocTextHelper LocTestHelper(TestingPath, TEXT("Test.manifest"), TEXT("Test.archive"), TEXT("en"), ForeignCultures, nullptr);
LocTestHelper.LoadAll(ELocTextHelperLoadFlags::Create);
TArray<FLocTextHelperTestSourceEntry> TestSources;
TestSources.Reserve(NumTestEntries);
TArray<FLocTextHelperTestTranslationEntry> EnglishTranslations;
EnglishTranslations.Reserve(NumTestEntries);
TArray<FLocTextHelperTestTranslationEntry> FrenchTranslations;
FrenchTranslations.Reserve(NumTestEntries);
TArray<FLocTextHelperTestTranslationEntry> GermanTranslations;
GermanTranslations.Reserve(NumTestEntries);
// Create test data
for (int32 Index = 0; Index < NumTestEntries; ++Index)
{
FLocTextHelperTestSourceEntry& TestSourceEntry = TestSources[TestSources.AddDefaulted()];
TestSourceEntry.Namespace = TEXT("Test");
TestSourceEntry.Key = FString::Printf(TEXT("Test_%d"), Index + 1);
TestSourceEntry.SourceText = FString::Printf(TEXT("Source Text %d"), Index + 1);
FLocTextHelperTestTranslationEntry& TestEnglishEntry = EnglishTranslations[EnglishTranslations.AddDefaulted()];
TestEnglishEntry.Namespace = TestSourceEntry.Namespace;
TestEnglishEntry.Key = TestSourceEntry.Key;
TestEnglishEntry.SourceText = TestSourceEntry.SourceText;
TestEnglishEntry.TranslationText = FString::Printf(TEXT("English Text %d"), Index + 1);
FLocTextHelperTestTranslationEntry& TestFrenchEntry = FrenchTranslations[FrenchTranslations.AddDefaulted()];
TestFrenchEntry.Namespace = TestSourceEntry.Namespace;
TestFrenchEntry.Key = TestSourceEntry.Key;
TestFrenchEntry.SourceText = TestEnglishEntry.TranslationText;
TestFrenchEntry.TranslationText = FString::Printf(TEXT("French Text %d"), Index + 1);
FLocTextHelperTestTranslationEntry& TestGermanEntry = GermanTranslations[GermanTranslations.AddDefaulted()];
TestGermanEntry.Namespace = TestSourceEntry.Namespace;
TestGermanEntry.Key = TestSourceEntry.Key;
TestGermanEntry.SourceText = TestEnglishEntry.TranslationText;
TestGermanEntry.TranslationText = FString::Printf(TEXT("German Text %d"), Index + 1);
}
// Populate database with test data
for (int32 Index = 0; Index < NumTestEntries; ++Index)
{
{
const FLocTextHelperTestSourceEntry& TestSource = TestSources[Index];
FManifestContext Ctx;
Ctx.Key = TestSource.Key;
LocTestHelper.AddSourceText(TestSource.Namespace, FLocItem(TestSource.SourceText), Ctx);
}
{
FLocTextHelperTestTranslationEntry& TestEnglishEntry = EnglishTranslations[Index];
LocTestHelper.AddTranslation(TEXT("en"), TestEnglishEntry.Namespace, TestEnglishEntry.Key, nullptr, FLocItem(TestEnglishEntry.SourceText), FLocItem(TestEnglishEntry.TranslationText), false);
}
{
FLocTextHelperTestTranslationEntry& TestFrenchEntry = FrenchTranslations[Index];
LocTestHelper.AddTranslation(TEXT("fr"), TestFrenchEntry.Namespace, TestFrenchEntry.Key, nullptr, FLocItem(TestFrenchEntry.SourceText), FLocItem(TestFrenchEntry.TranslationText), false);
}
{
FLocTextHelperTestTranslationEntry& TestGermanEntry = GermanTranslations[Index];
LocTestHelper.AddTranslation(TEXT("de"), TestGermanEntry.Namespace, TestGermanEntry.Key, nullptr, FLocItem(TestGermanEntry.SourceText), FLocItem(TestGermanEntry.TranslationText), false);
}
}
// Check that all the test data can be found
for (int32 Index = 0; Index < NumTestEntries; ++Index)
{
const FLocTextHelperTestSourceEntry& TestSourceEntry = TestSources[Index];
const FLocTextHelperTestTranslationEntry& TestEnglishEntry = EnglishTranslations[Index];
const FLocTextHelperTestTranslationEntry& TestFrenchEntry = FrenchTranslations[Index];
const FLocTextHelperTestTranslationEntry& TestGermanEntry = GermanTranslations[Index];
{
TSharedPtr<FManifestEntry> ManifestEntry = LocTestHelper.FindSourceText(TestSourceEntry.Namespace, TestSourceEntry.Key, &TestSourceEntry.SourceText);
if (!ManifestEntry.IsValid())
{
AddError(FString::Printf(TEXT("Failed to find expected source text: '%s', '%s', '%s'."), *TestSourceEntry.Namespace, *TestSourceEntry.Key, *TestSourceEntry.SourceText));
}
}
auto TestTranslationLookup = [this, &LocTestHelper](const FString& InCultureName, const FLocTextHelperTestSourceEntry& InSourceEntry, const FLocTextHelperTestTranslationEntry& InTranslationEntry)
{
TSharedPtr<FArchiveEntry> FoundArchiveEntry = LocTestHelper.FindTranslation(InCultureName, InTranslationEntry.Namespace, InTranslationEntry.Key, nullptr);
if (!FoundArchiveEntry.IsValid() || !FoundArchiveEntry->Translation.Text.Equals(InTranslationEntry.TranslationText, ESearchCase::CaseSensitive))
{
AddError(FString::Printf(TEXT("Failed to find expected translation for '%s': '%s', '%s', '%s', '%s'."), *InCultureName, *InTranslationEntry.Namespace, *InTranslationEntry.Key, *InTranslationEntry.SourceText, *InTranslationEntry.TranslationText));
}
FoundArchiveEntry = LocTestHelper.FindTranslation(InCultureName, InSourceEntry.Namespace, InSourceEntry.Key, nullptr);
if (!FoundArchiveEntry.IsValid() || !FoundArchiveEntry->Translation.Text.Equals(InTranslationEntry.TranslationText, ESearchCase::CaseSensitive))
{
AddError(FString::Printf(TEXT("Failed to find expected translation for '%s': '%s', '%s', '%s', '%s'."), *InCultureName, *InSourceEntry.Namespace, *InSourceEntry.Key, *InSourceEntry.SourceText, *InTranslationEntry.TranslationText));
}
FLocItem FoundSourceText;
FLocItem FoundTranslationText;
LocTestHelper.GetExportText(InCultureName, InTranslationEntry.Namespace, InTranslationEntry.Key, nullptr, ELocTextExportSourceMethod::NativeText, FLocItem(InTranslationEntry.SourceText), FoundSourceText, FoundTranslationText);
if (!FoundTranslationText.Text.Equals(InTranslationEntry.TranslationText, ESearchCase::CaseSensitive) && !FoundSourceText.Text.Equals(InTranslationEntry.SourceText, ESearchCase::CaseSensitive))
{
AddError(FString::Printf(TEXT("Failed to find expected export text for '%s': '%s', '%s', '%s', '%s'."), *InCultureName, *InTranslationEntry.Namespace, *InTranslationEntry.Key, *InTranslationEntry.SourceText, *InTranslationEntry.TranslationText));
}
LocTestHelper.GetExportText(InCultureName, InSourceEntry.Namespace, InSourceEntry.Key, nullptr, ELocTextExportSourceMethod::NativeText, FLocItem(InSourceEntry.SourceText), FoundSourceText, FoundTranslationText);
if (!FoundTranslationText.Text.Equals(InTranslationEntry.TranslationText, ESearchCase::CaseSensitive) && !FoundSourceText.Text.Equals(InSourceEntry.SourceText, ESearchCase::CaseSensitive))
{
AddError(FString::Printf(TEXT("Failed to find expected export text for '%s': '%s', '%s', '%s', '%s'."), *InCultureName, *InTranslationEntry.Namespace, *InTranslationEntry.Key, *InTranslationEntry.SourceText, *InTranslationEntry.TranslationText));
}
};
TestTranslationLookup(TEXT("en"), TestSourceEntry, TestEnglishEntry);
TestTranslationLookup(TEXT("fr"), TestSourceEntry, TestFrenchEntry);
TestTranslationLookup(TEXT("de"), TestSourceEntry, TestGermanEntry);
}
// Check that all the test data can be enumerated
{
int32 EnumeratedCount = 0;
LocTestHelper.EnumerateSourceTexts([&EnumeratedCount](TSharedRef<FManifestEntry> InManifestEntry) -> bool
{
++EnumeratedCount;
return true;
}, true);
if (NumTestEntries != EnumeratedCount)
{
AddError(FString::Printf(TEXT("Failed to enumerate the expected number of source texts. Expected: %d. Actual: %d."), NumTestEntries, EnumeratedCount));
}
}
auto TestTranslationEnumeration = [this, &LocTestHelper, &NumTestEntries](const FString& InCultureName)
{
int32 EnumeratedCount = 0;
LocTestHelper.EnumerateTranslations(InCultureName, [&EnumeratedCount](TSharedRef<FArchiveEntry> InArchiveEntry) -> bool
{
++EnumeratedCount;
return true;
}, true);
if (NumTestEntries != EnumeratedCount)
{
AddError(FString::Printf(TEXT("Failed to enumerate the expected number of translations for '%s'. Expected: %d. Actual: %d."), *InCultureName, NumTestEntries, EnumeratedCount));
}
};
TestTranslationEnumeration(TEXT("en"));
TestTranslationEnumeration(TEXT("fr"));
TestTranslationEnumeration(TEXT("de"));
IFileManager::Get().DeleteDirectory(*TestingPath, true, true);
return true;
}
