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); }