自学教程：C++ FColor函数代码示例

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

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

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