void UAStarAgentComponent::DrawDebugInformation()
{
if (m_path->path.Num() == 0)
return;
for (int i = 0; i < m_path->path.Num() - 1; i++)
{
FVector pos1 = m_path->path[i];
FVector pos2 = m_path->path[i + 1];
DrawDebugPoint(
GetWorld(),
FVector(pos1.X, pos1.Y, pos1.Z),
7,
FColor(255, 255, 0)
);
DrawDebugLine(GetWorld(),
FVector(pos1.X, pos1.Y, pos1.Z), FVector(pos2.X, pos2.Y, pos2.Z),
FColor(255, 255, 0), false, -1, 0, 5.f
);
}
DrawDebugPoint(
GetWorld(),
FVector(m_path->path.Last().X, m_path->path.Last().Y, m_path->path.Last().Z),
7,
FColor(255, 255, 0)
);
}
/*------------------------------------------------------------------------------
FEditorCommonDrawHelper.
------------------------------------------------------------------------------*/
FEditorCommonDrawHelper::FEditorCommonDrawHelper()
: GridWidget(0)
{
bDrawGrid = true;
bDrawPivot = true;
bDrawBaseInfo = true;
AxesLineThickness = 0.f;
GridColorAxis = FColor(70, 70, 70);
GridColorMajor = FColor(40, 40, 40);
GridColorMinor = FColor(20, 20, 20);
PerspectiveGridSize = HALF_WORLD_MAX1;
NumCells = 64;
bDrawWorldBox = false;
bDrawKillZ = false;
PivotColor = FColor(255,0,0);
PivotSize = 0.02f;
BaseBoxColor = FColor(0,255,0);
DepthPriorityGroup=SDPG_World;
GridDepthBias = 0.000001;
}
FMaterialEditorViewportClient::FMaterialEditorViewportClient(TWeakPtr<IMaterialEditor> InMaterialEditor, FPreviewScene& InPreviewScene, const TSharedRef<SMaterialEditorViewport>& InMaterialEditorViewport)
: FEditorViewportClient(nullptr, &InPreviewScene, StaticCastSharedRef<SEditorViewport>(InMaterialEditorViewport))
, MaterialEditorPtr(InMaterialEditor)
{
// Setup defaults for the common draw helper.
DrawHelper.bDrawPivot = false;
DrawHelper.bDrawWorldBox = false;
DrawHelper.bDrawKillZ = false;
DrawHelper.bDrawGrid = false;
DrawHelper.GridColorAxis = FColor(80,80,80);
DrawHelper.GridColorMajor = FColor(72,72,72);
DrawHelper.GridColorMinor = FColor(64,64,64);
DrawHelper.PerspectiveGridSize = HALF_WORLD_MAX1;
SetViewMode(VMI_Lit);
EngineShowFlags.DisableAdvancedFeatures();
EngineShowFlags.SetSnap(0);
OverrideNearClipPlane(1.0f);
bUsingOrbitCamera = true;
// Don't want to display the widget in this viewport
Widget->SetDefaultVisibility(false);
}
/// <summary> Draws one of the paths using one list from each list of lists </summary>
/// <param name="n"> The position, in each list of lists, of the list with the values for this path </param>
void UMovementTracker::DrawNthPath(size_t n)
{
//Checks if there is no mistake in the different lists
if (VectorList[n].Num() == TimeList[n].Num() && TimeList[n].Num() == NameList[n].Num())
{
//previous tells us if the previous point was drawn. It allows us to know if a line needs to be drawn between the points
//but also tells us when the path's beginning was. It allows us to start at that point next update to save on resources.
bool previous = false;
for (size_t i = PathStartArray[n]; i < VectorList[n].Num(); i++)
{
if ((TimeLength <= 0 || TimeList[n][i] >= ElapsedTime - TimeLength) && TimeList[n][i] <= ElapsedTime && NameList[n][i] == GetOwner()->GetName())
{
DrawDebugPoint(World, VectorList[n][i], 20.0f, FColor(255, 0, 0));
if (previous) //Draw the line between the previous point and this one
DrawDebugLine(World, VectorList[n][i - 1], VectorList[n][i], FColor(0, 0, 255), false, -1.0f, (uint8)'\000', 5.0f);
else //Sets the start of next update's sweep
PathStartArray[n] = i;
previous = true;
}
else
{
previous = false;
if (previous) //We are at the end of the path that we want to draw, no need to continue checking the rest of the path
break;
}
}
}
}
/**
* Dump allocation information.
*/
void FBestFitAllocator::DumpAllocs( FOutputDevice& Ar/*=*GLog*/ )
{
// Memory usage stats.
INT UsedSize = 0;
INT FreeSize = 0;
INT NumUsedChunks = 0;
INT NumFreeChunks = 0;
// Fragmentation and allocation size visualization.
INT NumBlocks = MemorySize / AllocationAlignment;
INT Dimension = 1 + NumBlocks / appTrunc(appSqrt(NumBlocks));
TArray<FColor> AllocationVisualization;
AllocationVisualization.AddZeroed( Dimension * Dimension );
INT VisIndex = 0;
// Traverse linked list and gather allocation information.
FMemoryChunk* CurrentChunk = FirstChunk;
while( CurrentChunk )
{
FColor VisColor;
// Free chunk.
if( CurrentChunk->bIsAvailable )
{
NumFreeChunks++;
FreeSize += CurrentChunk->Size;
VisColor = FColor(0,255,0);
}
// Allocated chunk.
else
{
NumUsedChunks++;
UsedSize += CurrentChunk->Size;
// Slightly alternate coloration to also visualize allocation sizes.
if( NumUsedChunks % 2 == 0 )
{
VisColor = FColor(255,0,0);
}
else
{
VisColor = FColor(192,0,0);
}
}
for( INT i=0; i<(CurrentChunk->Size/AllocationAlignment); i++ )
{
AllocationVisualization(VisIndex++) = VisColor;
}
CurrentChunk = CurrentChunk->NextChunk;
}
check(UsedSize == AllocatedMemorySize);
check(FreeSize == AvailableMemorySize);
// Write out bitmap for visualization of fragmentation and allocation patterns.
appCreateBitmap( TEXT("..\\..\\Binaries\\TextureMemory"), Dimension, Dimension, AllocationVisualization.GetTypedData() );
Ar.Logf( TEXT("BestFitAllocator: Allocated %i KByte in %i chunks, leaving %i KByte in %i chunks."), UsedSize / 1024, NumUsedChunks, FreeSize / 1024, NumFreeChunks );
Ar.Logf( TEXT("BestFitAllocator: %5.2f ms in allocator"), TimeSpentInAllocator * 1000 );
}
void UThumbnailManager::SetupCheckerboardTexture()
{
if (CheckerboardTexture)
{
return;
}
CheckerboardTexture = FImageUtils::CreateCheckerboardTexture(FColor(128, 128, 128), FColor(64, 64, 64), 32);
}
void FPaperEditorViewportClient::ModifyCheckerboardTextureColors()
{
const FColor ColorOne = FColor(128, 128, 128);//TextureEditorPtr.Pin()->GetCheckeredBackground_ColorOne();
const FColor ColorTwo = FColor(64, 64, 64);//TextureEditorPtr.Pin()->GetCheckeredBackground_ColorTwo();
const int32 CheckerSize = 32;//TextureEditorPtr.Pin()->GetCheckeredBackground_Size();
DestroyCheckerboardTexture();
SetupCheckerboardTexture(ColorOne, ColorTwo, CheckerSize);
}
UTextureEditorSettings::UTextureEditorSettings( const FObjectInitializer& ObjectInitializer )
: Super(ObjectInitializer)
, Background(TextureEditorBackground_SolidColor)
, BackgroundColor(FColor::Black)
, CheckerColorOne(FColor(128, 128, 128))
, CheckerColorTwo(FColor(64, 64, 64))
, CheckerSize(32)
, FitToViewport(true)
, TextureBorderColor(FColor::White)
, TextureBorderEnabled(true)
{ }
int32 FSequencerTimeSliderController::DrawPlaybackRange(const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FScrubRangeToScreen& RangeToScreen, const FPaintPlaybackRangeArgs& Args) const
{
if (!TimeSliderArgs.PlaybackRange.IsSet())
{
return LayerId;
}
TRange<float> PlaybackRange = TimeSliderArgs.PlaybackRange.Get();
float PlaybackRangeL = RangeToScreen.InputToLocalX(PlaybackRange.GetLowerBoundValue()) - 1;
float PlaybackRangeR = RangeToScreen.InputToLocalX(PlaybackRange.GetUpperBoundValue()) + 1;
FSlateDrawElement::MakeBox(
OutDrawElements,
LayerId+1,
AllottedGeometry.ToPaintGeometry(FVector2D(PlaybackRangeL, 0.f), FVector2D(Args.BrushWidth, AllottedGeometry.Size.Y)),
Args.StartBrush,
MyClippingRect,
ESlateDrawEffect::None,
FColor(32, 128, 32) // 120, 75, 50 (HSV)
);
FSlateDrawElement::MakeBox(
OutDrawElements,
LayerId+1,
AllottedGeometry.ToPaintGeometry(FVector2D(PlaybackRangeR - Args.BrushWidth, 0.f), FVector2D(Args.BrushWidth, AllottedGeometry.Size.Y)),
Args.EndBrush,
MyClippingRect,
ESlateDrawEffect::None,
FColor(128, 32, 32) // 0, 75, 50 (HSV)
);
// Black tint for excluded regions
FSlateDrawElement::MakeBox(
OutDrawElements,
LayerId+1,
AllottedGeometry.ToPaintGeometry(FVector2D(0.f, 0.f), FVector2D(PlaybackRangeL, AllottedGeometry.Size.Y)),
FEditorStyle::GetBrush("WhiteBrush"),
MyClippingRect,
ESlateDrawEffect::None,
FLinearColor::Black.CopyWithNewOpacity(0.2f)
);
FSlateDrawElement::MakeBox(
OutDrawElements,
LayerId+1,
AllottedGeometry.ToPaintGeometry(FVector2D(PlaybackRangeR, 0.f), FVector2D(AllottedGeometry.Size.X - PlaybackRangeR, AllottedGeometry.Size.Y)),
FEditorStyle::GetBrush("WhiteBrush"),
MyClippingRect,
ESlateDrawEffect::None,
FLinearColor::Black.CopyWithNewOpacity(0.2f)
);
return LayerId + 1;
}
FColor UInterpTrackVectorBase::GetKeyColor(int32 SubIndex, int32 KeyIndex, const FColor& CurveColor)
{
check( SubIndex >= 0 && SubIndex < 3);
check( KeyIndex >= 0 && KeyIndex < VectorTrack.Points.Num() );
if(SubIndex == 0)
return FColor(255,0,0);
else if(SubIndex == 1)
return FColor(0,255,0);
else
return FColor(0,0,255);
}
FColor UInterpTrackLinearColorBase::GetSubCurveButtonColor(int32 SubCurveIndex, bool bIsSubCurveHidden) const
{
// Check for array out of bounds because it will crash the program
check(SubCurveIndex >= 0);
check(SubCurveIndex < GetNumSubCurves());
FColor ButtonColor;
switch(SubCurveIndex)
{
case 0:
// Red
ButtonColor = bIsSubCurveHidden ? FColor(32, 0, 0) : FColor(255, 0, 0);
break;
case 1:
// Green
ButtonColor = bIsSubCurveHidden ? FColor(0, 32, 0) : FColor(0, 255, 0);
break;
case 2:
// Blue
ButtonColor = bIsSubCurveHidden ? FColor(0, 0, 32) : FColor(0, 0, 255);
break;
case 3:
// Dark red
ButtonColor = bIsSubCurveHidden ? FColor(0, 0, 0) : FColor(255, 255, 255);
break;
default:
// A bad sub-curve index was given.
check(false);
break;
}
return ButtonColor;
}
static void BatchPxRenderBufferLines(class ULineBatchComponent& LineBatcherToUse, const PxRenderBuffer& DebugData)
{
int32 NumPoints = DebugData.getNbPoints();
if (NumPoints > 0)
{
const PxDebugPoint* Points = DebugData.getPoints();
for (int32 i = 0; i<NumPoints; i++)
{
LineBatcherToUse.DrawPoint(P2UVector(Points->pos), FColor((uint32)Points->color), 2, SDPG_World);
Points++;
}
}
// Build a list of all the lines we want to draw
TArray<FBatchedLine> DebugLines;
// Add all the 'lines' from PhysX
int32 NumLines = DebugData.getNbLines();
if (NumLines > 0)
{
const PxDebugLine* Lines = DebugData.getLines();
for (int32 i = 0; i<NumLines; i++)
{
new(DebugLines)FBatchedLine(P2UVector(Lines->pos0), P2UVector(Lines->pos1), FColor((uint32)Lines->color0), 0.f, 0.0f, SDPG_World);
Lines++;
}
}
// Add all the 'triangles' from PhysX
int32 NumTris = DebugData.getNbTriangles();
if (NumTris > 0)
{
const PxDebugTriangle* Triangles = DebugData.getTriangles();
for (int32 i = 0; i<NumTris; i++)
{
new(DebugLines)FBatchedLine(P2UVector(Triangles->pos0), P2UVector(Triangles->pos1), FColor((uint32)Triangles->color0), 0.f, 0.0f, SDPG_World);
new(DebugLines)FBatchedLine(P2UVector(Triangles->pos1), P2UVector(Triangles->pos2), FColor((uint32)Triangles->color1), 0.f, 0.0f, SDPG_World);
new(DebugLines)FBatchedLine(P2UVector(Triangles->pos2), P2UVector(Triangles->pos0), FColor((uint32)Triangles->color2), 0.f, 0.0f, SDPG_World);
Triangles++;
}
}
// Draw them all in one call.
if (DebugLines.Num() > 0)
{
LineBatcherToUse.DrawLines(DebugLines);
}
}
void AWeapon::DoDamage(FHitResult& ObjectHit)
{
FVector ImpactPoint;
FVector ImpactNormal;
ImpactPoint.X = ObjectHit.ImpactPoint.X;
ImpactPoint.Y = ObjectHit.ImpactPoint.Y;
ImpactPoint.Z = ObjectHit.ImpactPoint.Z;
ImpactNormal.X = ObjectHit.ImpactNormal.X; //Use this data for placing decals if bullets hit walls etc.
ImpactNormal.Y = ObjectHit.ImpactNormal.Y;
ImpactNormal.Z = ObjectHit.ImpactNormal.Z;
const UWorld* World = GetWorld();
if (World)
{
DrawDebugSphere(World, ImpactPoint, 10.0f, 8, FColor(255, 0, 0), false, 3, 0);
APlayerController* PlayerController = Cast<APlayerController>(WeaponOwner->GetController());
if (PlayerController != nullptr)
{
const AActor* HitActor = ObjectHit.GetActor();
if (HitActor != nullptr)
{
if (HitActor->IsA(AEnemy::StaticClass()))
{
AEnemy* Enemy = (AEnemy*)HitActor;
TSubclassOf<UDamageType> const ValidDamageTypeClass = TSubclassOf<UDamageType>(UDamageType::StaticClass());
FDamageEvent DamageEvent(ValidDamageTypeClass);
Enemy->TakeDamage(Config.Damage, DamageEvent, PlayerController, this);
}
}
}
}
}
FSlateColor SAmethystWaitDialog::GetTextColor() const
{
//instead of going from black -> white, go from white -> grey.
float fAlpha = 1.0f - TextColorCurve.GetLerp();
fAlpha = fAlpha * 0.5f + 0.5f;
return FLinearColor(FColor(155, 164, 182, FMath::Clamp((int32)(fAlpha * 255.0f), 0, 255)));
}
AValorMinionSpawner::AValorMinionSpawner(const FObjectInitializer& ObjectInitializer)
: Super(ObjectInitializer)
{
GetCapsuleComponent()->InitCapsuleSize(40.0f, 92.0f);
#if WITH_EDITORONLY_DATA
ArrowComponent = CreateEditorOnlyDefaultSubobject<UArrowComponent>(TEXT("Arrow"));
if (!IsRunningCommandlet())
{
// Structure to hold one-time initialization
struct FConstructorStatics
{
ConstructorHelpers::FObjectFinderOptional<UTexture2D> PlayerStartTextureObject;
FName ID_PlayerStart;
FText NAME_PlayerStart;
FName ID_Navigation;
FText NAME_Navigation;
FConstructorStatics()
: PlayerStartTextureObject(TEXT("/Engine/EditorResources/S_Player"))
, ID_PlayerStart(TEXT("PlayerStart"))
, NAME_PlayerStart(NSLOCTEXT("SpriteCategory", "PlayerStart", "Player Start"))
, ID_Navigation(TEXT("Navigation"))
, NAME_Navigation(NSLOCTEXT("SpriteCategory", "Navigation", "Navigation"))
{
}
};
static FConstructorStatics ConstructorStatics;
if (GetGoodSprite())
{
GetGoodSprite()->Sprite = ConstructorStatics.PlayerStartTextureObject.Get();
GetGoodSprite()->RelativeScale3D = FVector(0.5f, 0.5f, 0.5f);
GetGoodSprite()->SpriteInfo.Category = ConstructorStatics.ID_PlayerStart;
GetGoodSprite()->SpriteInfo.DisplayName = ConstructorStatics.NAME_PlayerStart;
}
if (GetBadSprite())
{
GetBadSprite()->SetVisibility(false);
}
if (ArrowComponent)
{
ArrowComponent->ArrowColor = FColor(150, 200, 255);
ArrowComponent->ArrowSize = 1.0f;
ArrowComponent->bTreatAsASprite = true;
ArrowComponent->SpriteInfo.Category = ConstructorStatics.ID_Navigation;
ArrowComponent->SpriteInfo.DisplayName = ConstructorStatics.NAME_Navigation;
ArrowComponent->SetupAttachment(GetCapsuleComponent());
ArrowComponent->bIsScreenSizeScaled = true;
}
}
#endif // WITH_EDITORONLY_DATA
if (GWorld && GWorld->HasBegunPlay())
{
ensure(SpawnTeam != EValorTeam::Invalid);
}
}
void FEdModeGeometry::RenderEdge( const FSceneView* View, FPrimitiveDrawInterface* PDI )
{
for( int32 ObjectIdx = 0 ; ObjectIdx < GeomObjects.Num() ; ++ObjectIdx )
{
const FGeomObject* GeometryObject = GeomObjects[ObjectIdx];
const FColor WireColor = GeometryObject->GetActualBrush()->GetWireColor();
// Edges
for( int32 EdgeIdx = 0 ; EdgeIdx < GeometryObject->EdgePool.Num() ; ++EdgeIdx )
{
const FGeomEdge* GeometryEdge = &GeometryObject->EdgePool[EdgeIdx];
const FColor Color = GeometryEdge->IsSelected() ? FColor(255,128,64) : WireColor;
PDI->SetHitProxy( new HGeomEdgeProxy(const_cast<FGeomObject*>(GeometryObject),EdgeIdx) );
{
FVector V0 = GeometryObject->VertexPool[ GeometryEdge->VertexIndices[0] ];
FVector V1 = GeometryObject->VertexPool[ GeometryEdge->VertexIndices[1] ];
const FTransform ActorToWorld = GeometryObject->GetActualBrush()->ActorToWorld();
V0 = ActorToWorld.TransformPosition( V0 );
V1 = ActorToWorld.TransformPosition( V1 );
PDI->DrawLine( V0, V1, Color, SDPG_Foreground );
}
PDI->SetHitProxy( NULL );
}
}
}
void UCarditWeapon::Fire()
{
auto Camera = Cast<ACarditCharacter>(GetOwner())->GetCamera();
auto CameraLocation = Camera->GetComponentLocation();
auto EndLocation = Camera->GetComponentLocation() + (Camera->GetComponentRotation().Vector() * MaxRangeInCm);
DrawDebugLine(GetWorld(), CameraLocation, EndLocation, FColor(255, 0, 0), false, 5.f, 0, 2.5f);
FHitResult OutHit;
if (GetWorld()->LineTraceSingleByChannel(
OutHit,
CameraLocation,
EndLocation,
ECC_Visibility
)
)
{
if (Cast<ACarditCharacter>(OutHit.GetActor()))
{
GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, "Character hit");
Cast<ACarditGameMode>(UGameplayStatics::GetGameMode(GetWorld()))->DealDamageOntoCharacter(Cast<ACarditCharacter>(OutHit.GetActor()), DamagePerShot);
}
else
{
UE_LOG(LogTemp, Warning, TEXT("Non-character hit"));
}
}
else
{
UE_LOG(LogTemp, Warning, TEXT("Nothing hit"));
}
}
UArrowComponent::UArrowComponent(const class FPostConstructInitializeProperties& PCIP)
: Super(PCIP)
{
// Structure to hold one-time initialization
struct FConstructorStatics
{
FName ID_Misc;
FText NAME_Misc;
FConstructorStatics()
: ID_Misc(TEXT("Misc"))
, NAME_Misc(NSLOCTEXT( "SpriteCategory", "Misc", "Misc" ))
{
}
};
static FConstructorStatics ConstructorStatics;
BodyInstance.bEnableCollision_DEPRECATED = false;
SetCollisionProfileName(UCollisionProfile::NoCollision_ProfileName);
ArrowColor = FColor(255, 0, 0, 255);
ArrowSize = 1.0f;
bHiddenInGame = true;
bUseEditorCompositing = true;
bGenerateOverlapEvents = false;
#if WITH_EDITORONLY_DATA
SpriteInfo.Category = ConstructorStatics.ID_Misc;
SpriteInfo.DisplayName = ConstructorStatics.NAME_Misc;
bLightAttachment = false;
#endif // WITH_EDITORONLY_DATA
}
void FEdModeGeometry::RenderVertex( const FSceneView* View, FPrimitiveDrawInterface* PDI )
{
for( int32 ObjectIdx = 0 ; ObjectIdx < GeomObjects.Num() ; ++ObjectIdx )
{
const FGeomObject* GeomObject = GeomObjects[ObjectIdx];
check(GeomObject);
// Vertices
FColor Color;
float Scale;
FVector Location;
for( int32 VertIdx = 0 ; VertIdx < GeomObject->VertexPool.Num() ; ++VertIdx )
{
const FGeomVertex* GeomVertex = &GeomObject->VertexPool[VertIdx];
check(GeomVertex);
check(GeomObject->GetActualBrush());
Location = GeomObject->GetActualBrush()->ActorToWorld().TransformPosition( *GeomVertex );
Scale = View->WorldToScreen( Location ).W * ( 4.0f / View->ViewRect.Width() / View->ViewMatrices.ProjMatrix.M[0][0] );
Color = GeomVertex->IsSelected() ? FColor(255,128,64) : GeomObject->GetActualBrush()->GetWireColor();
PDI->SetHitProxy( new HGeomVertexProxy( const_cast<FGeomObject*>(GeomObject), VertIdx) );
PDI->DrawSprite( Location, 4.f * Scale, 4.f * Scale, GEngine->DefaultBSPVertexTexture->Resource, Color, SDPG_Foreground, 0.0, 0.0, 0.0, 0.0 );
PDI->SetHitProxy( NULL );
}
}
}
FColor HSB::hsbFromRgb(const FColor& rgb) {
const auto brightness = max(
max(RGB::red(rgb), RGB::green(rgb)), RGB::blue(rgb));
auto hue = 0.0f, saturation = 0.0f;
if (not near(brightness, 0.0)) {
const auto darkest = min(
min(RGB::red(rgb), RGB::green(rgb)), RGB::blue(rgb));
const auto range = brightness - darkest;
saturation = range / brightness;
if (not near(saturation, 0.0)) {
const float r = (brightness - RGB::red(rgb)) / range;
const float g = (brightness - RGB::green(rgb)) / range;
const float b = (brightness - RGB::blue(rgb)) / range;
if (near(RGB::red(rgb), brightness))
hue = b - g;
else if (near(RGB::green(rgb), brightness))
hue = 2.0f + r - b;
else
hue = 4.0f + g - r;
hue /= 6.0f;
if (hue < 0)
hue += 1.0f;
}
}
return FColor(hue, saturation, brightness, rgb.alpha());
}
void AShaderPluginDemoCharacter::Tick(float DeltaSeconds)
{
Super::Tick(DeltaSeconds);
TotalElapsedTime += DeltaSeconds;
if (PixelShading)
{
EndColorBuildup = FMath::Clamp(EndColorBuildup + DeltaSeconds * EndColorBuildupDirection, 0.0f, 1.0f);
if (EndColorBuildup >= 1.0 || EndColorBuildup <= 0)
{
EndColorBuildupDirection *= -1;
}
FTexture2DRHIRef InputTexture = NULL;
if (ComputeShading)
{
ComputeShading->ExecuteComputeShader(TotalElapsedTime);
InputTexture = ComputeShading->GetTexture(); //This is the output texture from the compute shader that we will pass to the pixel shader.
}
ComputeShaderBlend = FMath::Clamp(ComputeShaderBlend + ComputeShaderBlendScalar * DeltaSeconds, 0.0f, 1.0f);
PixelShading->ExecutePixelShader(RenderTarget, InputTexture, FColor(EndColorBuildup * 255, 0, 0, 255), ComputeShaderBlend);
}
//save screenshot to disk
SaveRenderTargetToDisk(RenderTargetL, "screenshotL1.png",false);
SaveRenderTargetToDisk(RenderTargetR, "screenshotR1.png",false);
}
UUTBetrayalScoreboard::UUTBetrayalScoreboard(const FObjectInitializer& ObjectInitializer)
: Super(ObjectInitializer)
{
// Structure to hold one-time initialization
struct FConstructorStatics
{
ConstructorHelpers::FObjectFinder<UTexture2D> HudTexture;
FConstructorStatics()
: HudTexture(TEXT("Texture2D'/UTBetrayal/Textures/HUDIcons.HUDIcons'"))
{
}
};
static FConstructorStatics ConstructorStatics;
ColumnMedalX = 0.5;
ColumnHeaderScoreX = 0.6;
ColumnHeaderKillsX = 0.72;
AllyColor = FColor(64, 128, 255);
DaggerWidth = 16; //width of dagger icon
DaggerHeight = 28; //height of dagger icon
DaggerSpacing = 12.0f; //spacing between individual daggers
SilverDaggerOffset = 10.0f; //spacing between silver and gold daggers
DaggerXPadding = 6.0f; //spacing between name and dagger icons
DaggerTexCoords = FTextureUVs(262.0f, 53.0f, 16.0f, 28.0f);
GoldLinearColor = FLinearColor(1.0f, 1.0f, 0.0f, 1.0f);
SilverLinearColor = FLinearColor(0.75f, 0.75f, 0.75f, 1.0f);
UT3GHudTexture = ConstructorStatics.HudTexture.Object;
}
bool FLightingPromotionModifyProperties::RunTest(const FString& Parameters)
{
//** SETUP **//
UWorld* World = AutomationEditorCommonUtils::CreateNewMap();
ULevel* CurrentLevel = World->GetCurrentLevel();
// Test Summary
AddLogItem(TEXT("The properties values for a point light are modified.\n- Intensity is set to 1000.\n- Color is set to R=0,G=0,B=255.\n- Attenuation Radius is set to 1024."));
if (!LightingTestHelpers::DoesActorExistInTheLevel(CurrentLevel, TEXT("PointLight"), APointLight::StaticClass()))
{
//** TEST **//
// Add a point light to the level.
APointLight* PointLight = Cast<APointLight>(GEditor->AddActor(World->GetCurrentLevel(), APointLight::StaticClass(), FTransform()));
// Modify the Lights Intensity, Light Color, and Attenuation Radius using it's properties.
LightingTestHelpers::SetPropertyByName(PointLight->PointLightComponent, TEXT("Intensity"), TEXT("1000.f"));
LightingTestHelpers::SetPropertyByName(PointLight->PointLightComponent, TEXT("LightColor"), TEXT("(R=0,G=0,B=255)"));
LightingTestHelpers::SetPropertyByName(PointLight->PointLightComponent, TEXT("AttenuationRadius"), TEXT("1024.f"));
//** VERIFY **//
TestEqual<float>(TEXT("Light brightness property was not modified."), 1000.f, PointLight->PointLightComponent->Intensity);
TestEqual<FColor>(TEXT("Light color property was not modified."), FColor(0,0,255), PointLight->PointLightComponent->LightColor);
TestEqual<float>(TEXT("Light attenuation radius was not modified."), 1024.f, PointLight->PointLightComponent->AttenuationRadius);
return true;
}
AddError(TEXT("A point light already exists in this level which will block the verification of a new point light."));
return false;
}
void UCreatureMeshComponent::DoCreatureMeshUpdate(int render_packet_idx)
{
// Update Mesh
SetBoundsScale(creature_bounds_scale);
SetBoundsOffset(creature_bounds_offset);
SetExtraXForm(GetComponentToWorld());
ForceAnUpdate(render_packet_idx);
// Debug
if (creature_debug_draw) {
FSphere debugSphere = GetDebugBoundsSphere();
DrawDebugSphere(
GetWorld(),
debugSphere.Center,
debugSphere.W,
32,
FColor(255, 0, 0)
);
GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("Sphere pos is: (%f, %f, %f)"), debugSphere.Center.X, debugSphere.Center.Y, debugSphere.Center.Z));
FTransform wTransform = GetComponentToWorld();
GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("Walk pos is: (%f, %f, %f)"), wTransform.GetLocation().X,
wTransform.GetLocation().Y,
wTransform.GetLocation().Z));
}
}
namespace VertexSnappingConstants
{
const float MaxSnappingDistance = 300;
const float MaxSquaredDistanceFromCamera = FMath::Square( 5000 );
const float FadeTime = 0.15f;
const FLinearColor VertexHelperColor = FColor( 17, 105, 238, 255 );
};
void Construct(const FArguments& InArgs,
TSharedPtr<IPropertyHandle> AnchorsHandle,
TSharedPtr<IPropertyHandle> AlignmentHandle,
TSharedPtr<IPropertyHandle> OffsetsHandle,
FText LabelText,
FAnchors Anchors)
{
ResizeCurve = FCurveSequence(0, 0.40f);
ChildSlot
[
SNew(SButton)
.ButtonStyle(FEditorStyle::Get(), "SimpleSharpButton")
.ButtonColorAndOpacity(FLinearColor(FColor(40, 40, 40)))
.OnClicked(this, &SAnchorPreviewWidget::OnAnchorClicked, AnchorsHandle, AlignmentHandle, OffsetsHandle, Anchors)
.ContentPadding(FMargin(2.0f, 2.0f))
[
SNew(SVerticalBox)
+ SVerticalBox::Slot()
.AutoHeight()
[
SNew(SBorder)
.BorderImage(FEditorStyle::GetBrush("UMGEditor.AnchorGrid"))
.Padding(0)
[
SNew(SBox)
.WidthOverride(64)
.HeightOverride(64)
.HAlign(HAlign_Center)
.VAlign(VAlign_Center)
[
SNew(SBox)
.WidthOverride(this, &SAnchorPreviewWidget::GetCurrentWidth)
.HeightOverride(this, &SAnchorPreviewWidget::GetCurrentHeight)
[
SNew(SBorder)
//.BorderImage(FEditorStyle::GetBrush("NoBrush"))
//.BorderImage(FEditorStyle::GetBrush("ToolPanel.GroupBorder"))
//.BorderBackgroundColor
.Padding(1)
[
SNew(SConstraintCanvas)
+ SConstraintCanvas::Slot()
.Anchors(Anchors)
.Offset(FMargin(0, 0, Anchors.IsStretchedHorizontal() ? 0 : 15, Anchors.IsStretchedVertical() ? 0 : 15))
.Alignment(FVector2D(Anchors.IsStretchedHorizontal() ? 0 : Anchors.Minimum.X, Anchors.IsStretchedVertical() ? 0 : Anchors.Minimum.Y))
[
SNew(SImage)
.Image(FEditorStyle::Get().GetBrush("UMGEditor.AnchoredWidget"))
]
]
]
]
]
]
]
];
}
void WorldViewer::addToRender(SceneRenderer &renderer) const {
vector<int> inds;
inds.reserve(8192);
const TileMap &tile_map = m_world->tileMap();
tile_map.findAll(inds, renderer.targetRect(), Flags::all | Flags::visible);
for(int n = 0; n < (int)inds.size(); n++)
tile_map[inds[n]].ptr->addToRender(renderer, (int3)tile_map[inds[n]].bbox.min);
for(int n = 0; n < (int)m_entities.size(); n++) {
const VisEntity &vis_entity = m_entities[n];
if(vis_entity.mode == VisEntity::invisible)
continue;
float blend_value = 1.0f;
if(vis_entity.mode == VisEntity::blending_in)
blend_value = vis_entity.blend_value / blend_time;
else if(vis_entity.mode == VisEntity::blending_out)
blend_value = 1.0f - vis_entity.blend_value / blend_time;
const Entity *entity = vis_entity.mode == VisEntity::shadowed?
vis_entity.shadow.get() : m_world->refEntity(vis_entity.ref);
if(entity && m_occluder_config.isVisible(vis_entity.occluder_id))
entity->addToRender(renderer, (IColor)FColor(1.0f, 1.0f, 1.0f, blend_value));
}
}
APlaneReflectionCapture::APlaneReflectionCapture(const class FPostConstructInitializeProperties& PCIP)
: Super(PCIP.SetDefaultSubobjectClass<UPlaneReflectionCaptureComponent>(TEXT("NewReflectionComponent")))
{
UPlaneReflectionCaptureComponent* PlaneComponent = CastChecked<UPlaneReflectionCaptureComponent>(CaptureComponent);
PlaneComponent->RelativeScale3D = FVector(1, 1000, 1000);
RootComponent = PlaneComponent;
#if WITH_EDITORONLY_DATA
if (SpriteComponent)
{
SpriteComponent->AttachParent = PlaneComponent;
}
#endif //#if WITH_EDITORONLY_DATA
TSubobjectPtr<UDrawSphereComponent> DrawInfluenceRadius = PCIP.CreateDefaultSubobject<UDrawSphereComponent>(this, TEXT("DrawRadius0"));
DrawInfluenceRadius->AttachParent = CaptureComponent;
DrawInfluenceRadius->bDrawOnlyIfSelected = true;
DrawInfluenceRadius->bAbsoluteScale = true;
DrawInfluenceRadius->bUseEditorCompositing = true;
DrawInfluenceRadius->BodyInstance.bEnableCollision_DEPRECATED = false;
DrawInfluenceRadius->SetCollisionProfileName(UCollisionProfile::NoCollision_ProfileName);
PlaneComponent->PreviewInfluenceRadius = DrawInfluenceRadius;
TSubobjectPtr<UBoxComponent> DrawCaptureBox = PCIP.CreateDefaultSubobject<UBoxComponent>(this, TEXT("DrawBox1"));
DrawCaptureBox->AttachParent = CaptureComponent;
DrawCaptureBox->bDrawOnlyIfSelected = true;
DrawCaptureBox->bUseEditorCompositing = true;
DrawCaptureBox->BodyInstance.bEnableCollision_DEPRECATED = false;
DrawCaptureBox->SetCollisionProfileName(UCollisionProfile::NoCollision_ProfileName);
DrawCaptureBox->ShapeColor = FColor(100, 90, 40);
DrawCaptureBox->InitBoxExtent(FVector(1, 1, 1));
PlaneComponent->PreviewCaptureBox = DrawCaptureBox;
}
void APawnWithCamera::DoTrace()
{
FVector Loc = CameraOne->GetActorLocation();
UE_LOG(LogClass, Error, TEXT("Loc is %s"), *Loc.ToString());
FRotator Rot = CameraOne->GetActorRotation();
UE_LOG(LogClass, Error, TEXT("Rot is %s"), *Rot.ToString());
FVector Start = Loc;
UE_LOG(LogClass, Error, TEXT("Start is %s"), *Start.ToString());
FVector End = Loc + (Rot.Vector() * Distance);
UE_LOG(LogClass, Error, TEXT("End is %s"), *End.ToString());
TempActor->SetActorLocation(End);
FCollisionQueryParams TraceParam = FCollisionQueryParams(FName(TEXT("Trace")), true, this);
TraceParam.bTraceComplex = true;
TraceParam.bTraceAsyncScene = true;
TraceParam.bReturnPhysicalMaterial = false;
TraceParam.AddIgnoredActor(this);
FHitResult Hit(ForceInit);
GetWorld()->LineTraceSingle(Hit, Start, End, ECC_Pawn, TraceParam);
DrawDebugLine(GetWorld(), Start, End, FColor(255, 0, 0), false, -1, 0, 12.33f);
if (Hit.bBlockingHit)
{
UE_LOG(LogClass, Error, TEXT("Hit Something"));
}
else
{
UE_LOG(LogClass, Error, TEXT("No Hit"));
}
}
ASphereReflectionCapture::ASphereReflectionCapture(const class FPostConstructInitializeProperties& PCIP)
: Super(PCIP.SetDefaultSubobjectClass<USphereReflectionCaptureComponent>(TEXT("NewReflectionComponent")))
{
USphereReflectionCaptureComponent* SphereComponent = CastChecked<USphereReflectionCaptureComponent>(CaptureComponent);
RootComponent = SphereComponent;
#if WITH_EDITORONLY_DATA
if (SpriteComponent)
{
SpriteComponent->AttachParent = SphereComponent;
}
#endif //WITH_EDITORONLY_DATA
TSubobjectPtr<UDrawSphereComponent> DrawInfluenceRadius = PCIP.CreateDefaultSubobject<UDrawSphereComponent>(this, TEXT("DrawRadius0"));
DrawInfluenceRadius->AttachParent = CaptureComponent;
DrawInfluenceRadius->bDrawOnlyIfSelected = true;
DrawInfluenceRadius->bUseEditorCompositing = true;
DrawInfluenceRadius->BodyInstance.bEnableCollision_DEPRECATED = false;
DrawInfluenceRadius->SetCollisionProfileName(UCollisionProfile::NoCollision_ProfileName);
SphereComponent->PreviewInfluenceRadius = DrawInfluenceRadius;
DrawCaptureRadius = PCIP.CreateDefaultSubobject<UDrawSphereComponent>(this, TEXT("DrawRadius1"));
DrawCaptureRadius->AttachParent = CaptureComponent;
DrawCaptureRadius->bDrawOnlyIfSelected = true;
DrawCaptureRadius->bUseEditorCompositing = true;
DrawCaptureRadius->BodyInstance.bEnableCollision_DEPRECATED = false;
DrawCaptureRadius->SetCollisionProfileName(UCollisionProfile::NoCollision_ProfileName);
DrawCaptureRadius->ShapeColor = FColor(100, 90, 40);
}
